,..\n * where each

is of the form\n * : : : \n * where\n * is a delay in seconds\n * is the event type(s) (error, transaction, etc) being rate limited and is of the form\n * ;;...\n * is what's being limited (org, project, or key) - ignored by SDK\n * is an arbitrary string like \"org_quota\" - ignored by SDK\n */\n for (var limit of rateLimitHeader.trim().split(',')) {\n const [retryAfter, categories] = limit.split(':', 2);\n var headerDelay = parseInt(retryAfter, 10);\n var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n if (!categories) {\n updatedRateLimits.all = now + delay;\n } else {\n for (var category of categories.split(';')) {\n updatedRateLimits[category] = now + delay;\n }\n }\n }\n } else if (retryAfterHeader) {\n updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n } else if (statusCode === 429) {\n updatedRateLimits.all = now + 60 * 1000;\n }\n\n return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","import { makePromiseBuffer, forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, serializeEnvelope, logger, updateRateLimits, SentryError } from '@sentry/utils';\n\nvar DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nfunction createTransport(\n options,\n makeRequest,\n buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n) {\n let rateLimits = {};\n\n var flush = (timeout) => buffer.drain(timeout);\n\n function send(envelope) {\n var filteredEnvelopeItems = [];\n\n // Drop rate limited items from envelope\n forEachEnvelopeItem(envelope, (item, type) => {\n var envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n } else {\n filteredEnvelopeItems.push(item);\n }\n });\n\n // Skip sending if envelope is empty after filtering out rate limited events\n if (filteredEnvelopeItems.length === 0) {\n return resolvedSyncPromise();\n }\n\n var filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n // Creates client report for each item in an envelope\n var recordEnvelopeLoss = (reason) => {\n forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n });\n };\n\n var requestTask = () =>\n makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n response => {\n // We don't want to throw on NOK responses, but we want to at least log them\n if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n }\n\n rateLimits = updateRateLimits(rateLimits, response);\n },\n error => {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);\n recordEnvelopeLoss('network_error');\n },\n );\n\n return buffer.add(requestTask).then(\n result => result,\n error => {\n if (error instanceof SentryError) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Skipped sending event due to full buffer');\n recordEnvelopeLoss('queue_overflow');\n return resolvedSyncPromise();\n } else {\n throw error;\n }\n },\n );\n }\n\n return {\n send,\n flush,\n };\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { createTransport } from '@sentry/core';\nimport { getNativeFetchImplementation } from './utils.js';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n options,\n nativeFetch = getNativeFetchImplementation(),\n) {\n function makeRequest(request) {\n var requestOptions = {\n body: request.body,\n method: 'POST',\n referrerPolicy: 'origin',\n headers: options.headers,\n ...options.fetchOptions,\n };\n\n return nativeFetch(options.url, requestOptions).then(response => ({\n statusCode: response.status,\n headers: {\n 'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n 'retry-after': response.headers.get('Retry-After'),\n },\n }));\n }\n\n return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nvar XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nfunction makeXHRTransport(options) {\n function makeRequest(request) {\n return new SyncPromise((resolve, reject) => {\n var xhr = new XMLHttpRequest();\n\n xhr.onerror = reject;\n\n xhr.onreadystatechange = () => {\n if (xhr.readyState === XHR_READYSTATE_DONE) {\n resolve({\n statusCode: xhr.status,\n headers: {\n 'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n 'retry-after': xhr.getResponseHeader('Retry-After'),\n },\n });\n }\n };\n\n xhr.open('POST', options.url);\n\n for (var header in options.headers) {\n if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n xhr.setRequestHeader(header, options.headers[header]);\n }\n }\n\n xhr.send(request.body);\n });\n }\n\n return createTransport(options, makeRequest);\n}\n\nexport { makeXHRTransport };\n//# sourceMappingURL=xhr.js.map\n","import { Integrations, getIntegrationsToSetup, initAndBind, getCurrentHub, getReportDialogEndpoint } from '@sentry/core';\nimport { getGlobalObject, stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { wrap as wrap$1 } from './helpers.js';\nimport './integrations/index.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport './transports/index.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\nvar defaultIntegrations = [\n new Integrations.InboundFilters(),\n new Integrations.FunctionToString(),\n new TryCatch(),\n new Breadcrumbs(),\n new GlobalHandlers(),\n new LinkedErrors(),\n new Dedupe(),\n new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n * dsn: '__DSN__',\n * // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n * scope.setExtra({ battery: 0.7 });\n * scope.setTag({ user_mode: 'admin' });\n * scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n * message: 'My Breadcrumb',\n * // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n * message: 'Manual',\n * stacktrace: [\n * // ...\n * ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nfunction init(options = {}) {\n if (options.defaultIntegrations === undefined) {\n options.defaultIntegrations = defaultIntegrations;\n }\n if (options.release === undefined) {\n var window = getGlobalObject();\n // This supports the variable that sentry-webpack-plugin injects\n if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {\n options.release = window.SENTRY_RELEASE.id;\n }\n }\n if (options.autoSessionTracking === undefined) {\n options.autoSessionTracking = true;\n }\n if (options.sendClientReports === undefined) {\n options.sendClientReports = true;\n }\n\n var clientOptions = {\n ...options,\n stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n integrations: getIntegrationsToSetup(options),\n transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n };\n\n initAndBind(BrowserClient, clientOptions);\n\n if (options.autoSessionTracking) {\n startSessionTracking();\n }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nfunction showReportDialog(options = {}, hub = getCurrentHub()) {\n // doesn't work without a document (React Native)\n var global = getGlobalObject();\n if (!global.document) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n return;\n }\n\n const { client, scope } = hub.getStackTop();\n var dsn = options.dsn || (client && client.getDsn());\n if (!dsn) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n return;\n }\n\n if (scope) {\n options.user = {\n ...scope.getUser(),\n ...options.user,\n };\n }\n\n if (!options.eventId) {\n options.eventId = hub.lastEventId();\n }\n\n var script = global.document.createElement('script');\n script.async = true;\n script.src = getReportDialogEndpoint(dsn, options);\n\n if (options.onLoad) {\n script.onload = options.onLoad;\n }\n\n var injectionPoint = global.document.head || global.document.body;\n if (injectionPoint) {\n injectionPoint.appendChild(script);\n } else {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nfunction lastEventId() {\n return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n callback();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nfunction flush(timeout) {\n var client = getCurrentHub().getClient();\n if (client) {\n return client.flush(timeout);\n }\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n return resolvedSyncPromise(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nfunction close(timeout) {\n var client = getCurrentHub().getClient();\n if (client) {\n return client.close(timeout);\n }\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\nfunction wrap(fn) {\n return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n hub.startSession({ ignoreDuration: true });\n hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n var window = getGlobalObject();\n var document = window.document;\n\n if (typeof document === 'undefined') {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n return;\n }\n\n var hub = getCurrentHub();\n\n // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n // pinned at the same version in package.json, but there are edge cases where it's possible. See\n // https://github.com/getsentry/sentry-javascript/issues/3207 and\n // https://github.com/getsentry/sentry-javascript/issues/3234 and\n // https://github.com/getsentry/sentry-javascript/issues/3278.\n if (!hub.captureSession) {\n return;\n }\n\n // The session duration for browser sessions does not track a meaningful\n // concept that can be used as a metric.\n // Automatically captured sessions are akin to page views, and thus we\n // discard their duration.\n startSessionOnHub(hub);\n\n // We want to create a session for every navigation as well\n addInstrumentationHandler('history', ({ from, to }) => {\n // Don't create an additional session for the initial route or if the location did not change\n if (!(from === undefined || from === to)) {\n startSessionOnHub(getCurrentHub());\n }\n });\n}\n\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\n/** A class object that can instantiate Client objects. */\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nfunction initAndBind(\n clientClass,\n options,\n) {\n if (options.debug === true) {\n if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n logger.enable();\n } else {\n // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n }\n }\n var hub = getCurrentHub();\n var scope = hub.getScope();\n if (scope) {\n scope.update(options.initialScope);\n }\n\n var client = new clientClass(options);\n hub.bindClient(client);\n}\n\nexport { initAndBind };\n//# sourceMappingURL=sdk.js.map\n","var SDK_VERSION = '7.7.0';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { getCurrentHub } from './hub.js';\n\n// Note: All functions in this file are typed with a return value of `ReturnType`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\nfunction captureException(exception, captureContext) {\n return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(\n message,\n captureContext,\n) {\n // This is necessary to provide explicit scopes upgrade, without changing the original\n // arity of the `captureMessage(message, level)` method.\n var level = typeof captureContext === 'string' ? captureContext : undefined;\n var context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event, hint) {\n return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\nfunction setContext(name, context) {\n getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n * pushScope();\n * callback();\n * popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(\n context,\n customSamplingContext,\n) {\n return getCurrentHub().startTransaction(\n {\n metadata: { source: 'custom' },\n ...context,\n },\n customSamplingContext,\n );\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, getGlobalObject, getGlobalSingleton, isNodeEnv } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nvar API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\nclass Hub {\n /** Is a {@link Layer}[] containing the client and scope */\n __init() {this._stack = [{}];}\n\n /** Contains the last event id of a captured event. */\n \n\n /**\n * Creates a new instance of the hub, will push one {@link Layer} into the\n * internal stack on creation.\n *\n * @param client bound to the hub.\n * @param scope bound to the hub.\n * @param version number, higher number means higher priority.\n */\n constructor(client, scope = new Scope(), _version = API_VERSION) {;this._version = _version;Hub.prototype.__init.call(this);\n this.getStackTop().scope = scope;\n if (client) {\n this.bindClient(client);\n }\n }\n\n /**\n * @inheritDoc\n */\n isOlderThan(version) {\n return this._version < version;\n }\n\n /**\n * @inheritDoc\n */\n bindClient(client) {\n var top = this.getStackTop();\n top.client = client;\n if (client && client.setupIntegrations) {\n client.setupIntegrations();\n }\n }\n\n /**\n * @inheritDoc\n */\n pushScope() {\n // We want to clone the content of prev scope\n var scope = Scope.clone(this.getScope());\n this.getStack().push({\n client: this.getClient(),\n scope,\n });\n return scope;\n }\n\n /**\n * @inheritDoc\n */\n popScope() {\n if (this.getStack().length <= 1) return false;\n return !!this.getStack().pop();\n }\n\n /**\n * @inheritDoc\n */\n withScope(callback) {\n var scope = this.pushScope();\n try {\n callback(scope);\n } finally {\n this.popScope();\n }\n }\n\n /**\n * @inheritDoc\n */\n getClient() {\n return this.getStackTop().client ;\n }\n\n /** Returns the scope of the top stack. */\n getScope() {\n return this.getStackTop().scope;\n }\n\n /** Returns the scope stack for domains or the process. */\n getStack() {\n return this._stack;\n }\n\n /** Returns the topmost scope layer in the order domain > local > process. */\n getStackTop() {\n return this._stack[this._stack.length - 1];\n }\n\n /**\n * @inheritDoc\n */\n captureException(exception, hint) {\n var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n var syntheticException = new Error('Sentry syntheticException');\n this._withClient((client, scope) => {\n client.captureException(\n exception,\n {\n originalException: exception,\n syntheticException,\n ...hint,\n event_id: eventId,\n },\n scope,\n );\n });\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n captureMessage(\n message,\n level,\n hint,\n ) {\n var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n var syntheticException = new Error(message);\n this._withClient((client, scope) => {\n client.captureMessage(\n message,\n level,\n {\n originalException: message,\n syntheticException,\n ...hint,\n event_id: eventId,\n },\n scope,\n );\n });\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n captureEvent(event, hint) {\n var eventId = hint && hint.event_id ? hint.event_id : uuid4();\n if (event.type !== 'transaction') {\n this._lastEventId = eventId;\n }\n\n this._withClient((client, scope) => {\n client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n });\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n lastEventId() {\n return this._lastEventId;\n }\n\n /**\n * @inheritDoc\n */\n addBreadcrumb(breadcrumb, hint) {\n const { scope, client } = this.getStackTop();\n\n if (!scope || !client) return;\n\n const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n (client.getOptions && client.getOptions()) || {};\n\n if (maxBreadcrumbs <= 0) return;\n\n var timestamp = dateTimestampInSeconds();\n var mergedBreadcrumb = { timestamp, ...breadcrumb };\n var finalBreadcrumb = beforeBreadcrumb\n ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n : mergedBreadcrumb;\n\n if (finalBreadcrumb === null) return;\n\n scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n }\n\n /**\n * @inheritDoc\n */\n setUser(user) {\n var scope = this.getScope();\n if (scope) scope.setUser(user);\n }\n\n /**\n * @inheritDoc\n */\n setTags(tags) {\n var scope = this.getScope();\n if (scope) scope.setTags(tags);\n }\n\n /**\n * @inheritDoc\n */\n setExtras(extras) {\n var scope = this.getScope();\n if (scope) scope.setExtras(extras);\n }\n\n /**\n * @inheritDoc\n */\n setTag(key, value) {\n var scope = this.getScope();\n if (scope) scope.setTag(key, value);\n }\n\n /**\n * @inheritDoc\n */\n setExtra(key, extra) {\n var scope = this.getScope();\n if (scope) scope.setExtra(key, extra);\n }\n\n /**\n * @inheritDoc\n */\n setContext(name, context) {\n var scope = this.getScope();\n if (scope) scope.setContext(name, context);\n }\n\n /**\n * @inheritDoc\n */\n configureScope(callback) {\n const { scope, client } = this.getStackTop();\n if (scope && client) {\n callback(scope);\n }\n }\n\n /**\n * @inheritDoc\n */\n run(callback) {\n var oldHub = makeMain(this);\n try {\n callback(this);\n } finally {\n makeMain(oldHub);\n }\n }\n\n /**\n * @inheritDoc\n */\n getIntegration(integration) {\n var client = this.getClient();\n if (!client) return null;\n try {\n return client.getIntegration(integration);\n } catch (_oO) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n return null;\n }\n }\n\n /**\n * @inheritDoc\n */\n startTransaction(context, customSamplingContext) {\n return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n }\n\n /**\n * @inheritDoc\n */\n traceHeaders() {\n return this._callExtensionMethod('traceHeaders');\n }\n\n /**\n * @inheritDoc\n */\n captureSession(endSession = false) {\n // both send the update and pull the session from the scope\n if (endSession) {\n return this.endSession();\n }\n\n // only send the update\n this._sendSessionUpdate();\n }\n\n /**\n * @inheritDoc\n */\n endSession() {\n var layer = this.getStackTop();\n var scope = layer && layer.scope;\n var session = scope && scope.getSession();\n if (session) {\n closeSession(session);\n }\n this._sendSessionUpdate();\n\n // the session is over; take it off of the scope\n if (scope) {\n scope.setSession();\n }\n }\n\n /**\n * @inheritDoc\n */\n startSession(context) {\n const { scope, client } = this.getStackTop();\n const { release, environment } = (client && client.getOptions()) || {};\n\n // Will fetch userAgent if called from browser sdk\n var global = getGlobalObject();\n const { userAgent } = global.navigator || {};\n\n var session = makeSession({\n release,\n environment,\n ...(scope && { user: scope.getUser() }),\n ...(userAgent && { userAgent }),\n ...context,\n });\n\n if (scope) {\n // End existing session if there's one\n var currentSession = scope.getSession && scope.getSession();\n if (currentSession && currentSession.status === 'ok') {\n updateSession(currentSession, { status: 'exited' });\n }\n this.endSession();\n\n // Afterwards we set the new session on the scope\n scope.setSession(session);\n }\n\n return session;\n }\n\n /**\n * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n * when Tracing is used.\n */\n shouldSendDefaultPii() {\n var client = this.getClient();\n var options = client && client.getOptions();\n return Boolean(options && options.sendDefaultPii);\n }\n\n /**\n * Sends the current Session on the scope\n */\n _sendSessionUpdate() {\n const { scope, client } = this.getStackTop();\n if (!scope) return;\n\n var session = scope.getSession();\n if (session) {\n if (client && client.captureSession) {\n client.captureSession(session);\n }\n }\n }\n\n /**\n * Internal helper function to call a method on the top client if it exists.\n *\n * @param method The method to call on the client.\n * @param args Arguments to pass to the client function.\n */\n _withClient(callback) {\n const { scope, client } = this.getStackTop();\n if (client) {\n callback(client, scope);\n }\n }\n\n /**\n * Calls global extension method and binding current instance to the function call\n */\n // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n _callExtensionMethod(method, ...args) {\n var carrier = getMainCarrier();\n var sentry = carrier.__SENTRY__;\n if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n return sentry.extensions[method].apply(this, args);\n }\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nfunction getMainCarrier() {\n var carrier = getGlobalObject();\n carrier.__SENTRY__ = carrier.__SENTRY__ || {\n extensions: {},\n hub: undefined,\n };\n return carrier;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nfunction makeMain(hub) {\n var registry = getMainCarrier();\n var oldHub = getHubFromCarrier(registry);\n setHubOnCarrier(registry, hub);\n return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nfunction getCurrentHub() {\n // Get main carrier (global for every environment)\n var registry = getMainCarrier();\n\n // If there's no hub, or its an old API, assign a new one\n if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n setHubOnCarrier(registry, new Hub());\n }\n\n // Prefer domains over global if they are there (applicable only to Node environment)\n if (isNodeEnv()) {\n return getHubFromActiveDomain(registry);\n }\n // Return hub that lives on a global object\n return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n try {\n var sentry = getMainCarrier().__SENTRY__;\n var activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n // If there's no active domain, just return global hub\n if (!activeDomain) {\n return getHubFromCarrier(registry);\n }\n\n // If there's no hub on current domain, or it's an old API, assign a new one\n if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n }\n\n // Return hub that lives on a domain\n return getHubFromCarrier(activeDomain);\n } catch (_Oo) {\n // Return hub that lives on a global object\n return getHubFromCarrier(registry);\n }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nfunction getHubFromCarrier(carrier) {\n return getGlobalSingleton('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nfunction setHubOnCarrier(carrier, hub) {\n if (!carrier) return false;\n var __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n __SENTRY__.hub = hub;\n return true;\n}\n\nexport { API_VERSION, Hub, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, setHubOnCarrier };\n//# sourceMappingURL=hub.js.map\n","import { isPlainObject, dateTimestampInSeconds, getGlobalSingleton, SyncPromise, logger, isThenable } from '@sentry/utils';\nimport { updateSession } from './session.js';\n\n/**\n * Absolute maximum number of breadcrumbs added to an event.\n * The `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nclass Scope {\n /** Flag if notifying is happening. */\n \n\n /** Callback for client to receive scope changes. */\n \n\n /** Callback list that will be called after {@link applyToEvent}. */\n \n\n /** Array of breadcrumbs. */\n \n\n /** User */\n \n\n /** Tags */\n \n\n /** Extra */\n \n\n /** Contexts */\n \n\n /** Attachments */\n \n\n /**\n * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n * sent to Sentry\n */\n \n\n /** Fingerprint */\n \n\n /** Severity */\n \n\n /** Transaction Name */\n \n\n /** Span */\n \n\n /** Session */\n \n\n /** Request Mode Session Status */\n \n\n constructor() {\n this._notifyingListeners = false;\n this._scopeListeners = [];\n this._eventProcessors = [];\n this._breadcrumbs = [];\n this._attachments = [];\n this._user = {};\n this._tags = {};\n this._extra = {};\n this._contexts = {};\n this._sdkProcessingMetadata = {};\n }\n\n /**\n * Inherit values from the parent scope.\n * @param scope to clone.\n */\n static clone(scope) {\n var newScope = new Scope();\n if (scope) {\n newScope._breadcrumbs = [...scope._breadcrumbs];\n newScope._tags = { ...scope._tags };\n newScope._extra = { ...scope._extra };\n newScope._contexts = { ...scope._contexts };\n newScope._user = scope._user;\n newScope._level = scope._level;\n newScope._span = scope._span;\n newScope._session = scope._session;\n newScope._transactionName = scope._transactionName;\n newScope._fingerprint = scope._fingerprint;\n newScope._eventProcessors = [...scope._eventProcessors];\n newScope._requestSession = scope._requestSession;\n newScope._attachments = [...scope._attachments];\n }\n return newScope;\n }\n\n /**\n * Add internal on change listener. Used for sub SDKs that need to store the scope.\n * @hidden\n */\n addScopeListener(callback) {\n this._scopeListeners.push(callback);\n }\n\n /**\n * @inheritDoc\n */\n addEventProcessor(callback) {\n this._eventProcessors.push(callback);\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setUser(user) {\n this._user = user || {};\n if (this._session) {\n updateSession(this._session, { user });\n }\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n getUser() {\n return this._user;\n }\n\n /**\n * @inheritDoc\n */\n getRequestSession() {\n return this._requestSession;\n }\n\n /**\n * @inheritDoc\n */\n setRequestSession(requestSession) {\n this._requestSession = requestSession;\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setTags(tags) {\n this._tags = {\n ...this._tags,\n ...tags,\n };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setTag(key, value) {\n this._tags = { ...this._tags, [key]: value };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setExtras(extras) {\n this._extra = {\n ...this._extra,\n ...extras,\n };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setExtra(key, extra) {\n this._extra = { ...this._extra, [key]: extra };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setFingerprint(fingerprint) {\n this._fingerprint = fingerprint;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setLevel(\n level,\n ) {\n this._level = level;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setTransactionName(name) {\n this._transactionName = name;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setContext(key, context) {\n if (context === null) {\n delete this._contexts[key];\n } else {\n this._contexts = { ...this._contexts, [key]: context };\n }\n\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setSpan(span) {\n this._span = span;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n getSpan() {\n return this._span;\n }\n\n /**\n * @inheritDoc\n */\n getTransaction() {\n // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n // have a pointer to the currently-active transaction.\n var span = this.getSpan();\n return span && span.transaction;\n }\n\n /**\n * @inheritDoc\n */\n setSession(session) {\n if (!session) {\n delete this._session;\n } else {\n this._session = session;\n }\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n getSession() {\n return this._session;\n }\n\n /**\n * @inheritDoc\n */\n update(captureContext) {\n if (!captureContext) {\n return this;\n }\n\n if (typeof captureContext === 'function') {\n var updatedScope = (captureContext )(this);\n return updatedScope instanceof Scope ? updatedScope : this;\n }\n\n if (captureContext instanceof Scope) {\n this._tags = { ...this._tags, ...captureContext._tags };\n this._extra = { ...this._extra, ...captureContext._extra };\n this._contexts = { ...this._contexts, ...captureContext._contexts };\n if (captureContext._user && Object.keys(captureContext._user).length) {\n this._user = captureContext._user;\n }\n if (captureContext._level) {\n this._level = captureContext._level;\n }\n if (captureContext._fingerprint) {\n this._fingerprint = captureContext._fingerprint;\n }\n if (captureContext._requestSession) {\n this._requestSession = captureContext._requestSession;\n }\n } else if (isPlainObject(captureContext)) {\n captureContext = captureContext ;\n this._tags = { ...this._tags, ...captureContext.tags };\n this._extra = { ...this._extra, ...captureContext.extra };\n this._contexts = { ...this._contexts, ...captureContext.contexts };\n if (captureContext.user) {\n this._user = captureContext.user;\n }\n if (captureContext.level) {\n this._level = captureContext.level;\n }\n if (captureContext.fingerprint) {\n this._fingerprint = captureContext.fingerprint;\n }\n if (captureContext.requestSession) {\n this._requestSession = captureContext.requestSession;\n }\n }\n\n return this;\n }\n\n /**\n * @inheritDoc\n */\n clear() {\n this._breadcrumbs = [];\n this._tags = {};\n this._extra = {};\n this._user = {};\n this._contexts = {};\n this._level = undefined;\n this._transactionName = undefined;\n this._fingerprint = undefined;\n this._requestSession = undefined;\n this._span = undefined;\n this._session = undefined;\n this._notifyScopeListeners();\n this._attachments = [];\n return this;\n }\n\n /**\n * @inheritDoc\n */\n addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n var maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;\n\n // No data has been changed, so don't notify scope listeners\n if (maxCrumbs <= 0) {\n return this;\n }\n\n var mergedBreadcrumb = {\n timestamp: dateTimestampInSeconds(),\n ...breadcrumb,\n };\n this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n this._notifyScopeListeners();\n\n return this;\n }\n\n /**\n * @inheritDoc\n */\n clearBreadcrumbs() {\n this._breadcrumbs = [];\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n addAttachment(attachment) {\n this._attachments.push(attachment);\n return this;\n }\n\n /**\n * @inheritDoc\n */\n getAttachments() {\n return this._attachments;\n }\n\n /**\n * @inheritDoc\n */\n clearAttachments() {\n this._attachments = [];\n return this;\n }\n\n /**\n * Applies the current context and fingerprint to the event.\n * Note that breadcrumbs will be added by the client.\n * Also if the event has already breadcrumbs on it, we do not merge them.\n * @param event Event\n * @param hint May contain additional information about the original exception.\n * @hidden\n */\n applyToEvent(event, hint = {}) {\n if (this._extra && Object.keys(this._extra).length) {\n event.extra = { ...this._extra, ...event.extra };\n }\n if (this._tags && Object.keys(this._tags).length) {\n event.tags = { ...this._tags, ...event.tags };\n }\n if (this._user && Object.keys(this._user).length) {\n event.user = { ...this._user, ...event.user };\n }\n if (this._contexts && Object.keys(this._contexts).length) {\n event.contexts = { ...this._contexts, ...event.contexts };\n }\n if (this._level) {\n event.level = this._level;\n }\n if (this._transactionName) {\n event.transaction = this._transactionName;\n }\n\n // We want to set the trace context for normal events only if there isn't already\n // a trace context on the event. There is a product feature in place where we link\n // errors with transaction and it relies on that.\n if (this._span) {\n event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n var transactionName = this._span.transaction && this._span.transaction.name;\n if (transactionName) {\n event.tags = { transaction: transactionName, ...event.tags };\n }\n }\n\n this._applyFingerprint(event);\n\n event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n }\n\n /**\n * Add data which will be accessible during event processing but won't get sent to Sentry\n */\n setSDKProcessingMetadata(newData) {\n this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n return this;\n }\n\n /**\n * This will be called after {@link applyToEvent} is finished.\n */\n _notifyEventProcessors(\n processors,\n event,\n hint,\n index = 0,\n ) {\n return new SyncPromise((resolve, reject) => {\n var processor = processors[index];\n if (event === null || typeof processor !== 'function') {\n resolve(event);\n } else {\n var result = processor({ ...event }, hint) ;\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n processor.id &&\n result === null &&\n logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n if (isThenable(result)) {\n void result\n .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n .then(null, reject);\n } else {\n void this._notifyEventProcessors(processors, result, hint, index + 1)\n .then(resolve)\n .then(null, reject);\n }\n }\n });\n }\n\n /**\n * This will be called on every set call.\n */\n _notifyScopeListeners() {\n // We need this check for this._notifyingListeners to be able to work on scope during updates\n // If this check is not here we'll produce endless recursion when something is done with the scope\n // during the callback.\n if (!this._notifyingListeners) {\n this._notifyingListeners = true;\n this._scopeListeners.forEach(callback => {\n callback(this);\n });\n this._notifyingListeners = false;\n }\n }\n\n /**\n * Applies fingerprint from the scope to the event if there's one,\n * uses message if there's one instead or get rid of empty fingerprint\n */\n _applyFingerprint(event) {\n // Make sure it's an array first and we actually have something in place\n event.fingerprint = event.fingerprint\n ? Array.isArray(event.fingerprint)\n ? event.fingerprint\n : [event.fingerprint]\n : [];\n\n // If we have something on the scope, then merge it with event\n if (this._fingerprint) {\n event.fingerprint = event.fingerprint.concat(this._fingerprint);\n }\n\n // If we have no data at all, remove empty array default\n if (event.fingerprint && !event.fingerprint.length) {\n delete event.fingerprint;\n }\n }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n return getGlobalSingleton('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nfunction addGlobalEventProcessor(callback) {\n getGlobalEventProcessors().push(callback);\n}\n\nexport { Scope, addGlobalEventProcessor };\n//# sourceMappingURL=scope.js.map\n","import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nfunction makeSession(context) {\n // Both timestamp and started are in seconds since the UNIX epoch.\n var startingTime = timestampInSeconds();\n\n var session = {\n sid: uuid4(),\n init: true,\n timestamp: startingTime,\n started: startingTime,\n duration: 0,\n status: 'ok',\n errors: 0,\n ignoreDuration: false,\n toJSON: () => sessionToJSON(session),\n };\n\n if (context) {\n updateSession(session, context);\n }\n\n return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\nfunction updateSession(session, context = {}) {\n if (context.user) {\n if (!session.ipAddress && context.user.ip_address) {\n session.ipAddress = context.user.ip_address;\n }\n\n if (!session.did && !context.did) {\n session.did = context.user.id || context.user.email || context.user.username;\n }\n }\n\n session.timestamp = context.timestamp || timestampInSeconds();\n\n if (context.ignoreDuration) {\n session.ignoreDuration = context.ignoreDuration;\n }\n if (context.sid) {\n // Good enough uuid validation. — Kamil\n session.sid = context.sid.length === 32 ? context.sid : uuid4();\n }\n if (context.init !== undefined) {\n session.init = context.init;\n }\n if (!session.did && context.did) {\n session.did = `${context.did}`;\n }\n if (typeof context.started === 'number') {\n session.started = context.started;\n }\n if (session.ignoreDuration) {\n session.duration = undefined;\n } else if (typeof context.duration === 'number') {\n session.duration = context.duration;\n } else {\n var duration = session.timestamp - session.started;\n session.duration = duration >= 0 ? duration : 0;\n }\n if (context.release) {\n session.release = context.release;\n }\n if (context.environment) {\n session.environment = context.environment;\n }\n if (!session.ipAddress && context.ipAddress) {\n session.ipAddress = context.ipAddress;\n }\n if (!session.userAgent && context.userAgent) {\n session.userAgent = context.userAgent;\n }\n if (typeof context.errors === 'number') {\n session.errors = context.errors;\n }\n if (context.status) {\n session.status = context.status;\n }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n * this function will keep the previously set status, unless it was `'ok'` in which case\n * it is changed to `'exited'`.\n */\nfunction closeSession(session, status) {\n let context = {};\n if (status) {\n context = { status };\n } else if (session.status === 'ok') {\n context = { status: 'exited' };\n }\n\n updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session) {\n return dropUndefinedKeys({\n sid: `${session.sid}`,\n init: session.init,\n // Make sure that sec is converted to ms for date constructor\n started: new Date(session.started * 1000).toISOString(),\n timestamp: new Date(session.timestamp * 1000).toISOString(),\n status: session.status,\n errors: session.errors,\n did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n duration: session.duration,\n attrs: {\n release: session.release,\n environment: session.environment,\n ip_address: session.ipAddress,\n user_agent: session.userAgent,\n },\n });\n}\n\nexport { closeSession, makeSession, updateSession };\n//# sourceMappingURL=session.js.map\n","import { addInstrumentationHandler, logger } from '@sentry/utils';\nimport { getActiveTransaction } from './utils.js';\n\n/**\n * Configures global error listeners\n */\nfunction registerErrorInstrumentation() {\n addInstrumentationHandler('error', errorCallback);\n addInstrumentationHandler('unhandledrejection', errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\nfunction errorCallback() {\n var activeTransaction = getActiveTransaction();\n if (activeTransaction) {\n var status = 'internal_error';\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);\n activeTransaction.setStatus(status);\n }\n}\n\nexport { registerErrorInstrumentation };\n//# sourceMappingURL=errors.js.map\n","import { getMainCarrier } from '@sentry/hub';\nimport { logger, isNaN, dynamicRequire, loadModule, isNodeEnv } from '@sentry/utils';\nimport { registerErrorInstrumentation } from './errors.js';\nimport { IdleTransaction } from './idletransaction.js';\nimport { Transaction } from './transaction.js';\nimport { hasTracingEnabled } from './utils.js';\n\n/** Returns all trace headers that are currently on the top scope. */\nfunction traceHeaders() {\n var scope = this.getScope();\n if (scope) {\n var span = scope.getSpan();\n if (span) {\n return {\n 'sentry-trace': span.toTraceparent(),\n };\n }\n }\n return {};\n}\n\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param transaction: The transaction needing a sampling decision\n * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\nfunction sample(\n transaction,\n options,\n samplingContext,\n) {\n // nothing to do if tracing is not enabled\n if (!hasTracingEnabled(options)) {\n transaction.sampled = false;\n return transaction;\n }\n\n // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n if (transaction.sampled !== undefined) {\n transaction.setMetadata({\n transactionSampling: { method: 'explicitly_set' },\n });\n return transaction;\n }\n\n // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` 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 transaction.setMetadata({\n transactionSampling: {\n method: 'client_sampler',\n // cast to number in case it's a boolean\n rate: Number(sampleRate),\n },\n });\n } else if (samplingContext.parentSampled !== undefined) {\n sampleRate = samplingContext.parentSampled;\n transaction.setMetadata({\n transactionSampling: { method: 'inheritance' },\n });\n } else {\n sampleRate = options.tracesSampleRate;\n transaction.setMetadata({\n transactionSampling: {\n method: 'client_rate',\n // cast to number in case it's a boolean\n rate: Number(sampleRate),\n },\n });\n }\n\n // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n // only valid values are booleans or numbers between 0 and 1.)\n if (!isValidSampleRate(sampleRate)) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n transaction.sampled = false;\n return transaction;\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 (!sampleRate) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\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 transaction.sampled = false;\n return transaction;\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 transaction.sampled = Math.random() < (sampleRate );\n\n // if we're not going to keep it, we're done\n if (!transaction.sampled) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\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 transaction;\n }\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);\n return transaction;\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nfunction isValidSampleRate(rate) {\n // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\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 rate,\n )} of type ${JSON.stringify(typeof rate)}.`,\n );\n return false;\n }\n\n // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n if (rate < 0 || rate > 1) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);\n return false;\n }\n return true;\n}\n\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\nfunction _startTransaction(\n \n transactionContext,\n customSamplingContext,\n) {\n var client = this.getClient();\n var options = (client && client.getOptions()) || {};\n\n let transaction = new Transaction(transactionContext, this);\n transaction = sample(transaction, options, {\n parentSampled: transactionContext.parentSampled,\n transactionContext,\n ...customSamplingContext,\n });\n if (transaction.sampled) {\n transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));\n }\n return transaction;\n}\n\n/**\n * Create new idle transaction.\n */\nfunction startIdleTransaction(\n hub,\n transactionContext,\n idleTimeout,\n finalTimeout,\n onScope,\n customSamplingContext,\n) {\n var client = hub.getClient();\n var options = (client && client.getOptions()) || {};\n\n let transaction = new IdleTransaction(transactionContext, hub, idleTimeout, finalTimeout, onScope);\n transaction = sample(transaction, options, {\n parentSampled: transactionContext.parentSampled,\n transactionContext,\n ...customSamplingContext,\n });\n if (transaction.sampled) {\n transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));\n }\n return transaction;\n}\n\n/**\n * @private\n */\nfunction _addTracingExtensions() {\n var carrier = getMainCarrier();\n if (!carrier.__SENTRY__) {\n return;\n }\n carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n if (!carrier.__SENTRY__.extensions.startTransaction) {\n carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n }\n if (!carrier.__SENTRY__.extensions.traceHeaders) {\n carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n }\n}\n\n/**\n * @private\n */\nfunction _autoloadDatabaseIntegrations() {\n var carrier = getMainCarrier();\n if (!carrier.__SENTRY__) {\n return;\n }\n\n var packageToIntegrationMapping = {\n mongodb() {\n var integration = dynamicRequire(module, './integrations/node/mongo') \n\n;\n return new integration.Mongo();\n },\n mongoose() {\n var integration = dynamicRequire(module, './integrations/node/mongo') \n\n;\n return new integration.Mongo({ mongoose: true });\n },\n mysql() {\n var integration = dynamicRequire(module, './integrations/node/mysql') \n\n;\n return new integration.Mysql();\n },\n pg() {\n var integration = dynamicRequire(module, './integrations/node/postgres') \n\n;\n return new integration.Postgres();\n },\n };\n\n var mappedPackages = Object.keys(packageToIntegrationMapping)\n .filter(moduleName => !!loadModule(moduleName))\n .map(pkg => {\n try {\n return packageToIntegrationMapping[pkg]();\n } catch (e) {\n return undefined;\n }\n })\n .filter(p => p) ;\n\n if (mappedPackages.length > 0) {\n carrier.__SENTRY__.integrations = [...(carrier.__SENTRY__.integrations || []), ...mappedPackages];\n }\n}\n\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\nfunction addExtensionMethods() {\n _addTracingExtensions();\n\n // Detect and automatically load specified integrations.\n if (isNodeEnv()) {\n _autoloadDatabaseIntegrations();\n }\n\n // If an error happens globally, we should make sure transaction status is set to error.\n registerErrorInstrumentation();\n}\n\nexport { _addTracingExtensions, addExtensionMethods, startIdleTransaction };\n//# sourceMappingURL=hubextensions.js.map\n","import { timestampWithMs, logger } from '@sentry/utils';\nimport { SpanRecorder } from './span.js';\nimport { Transaction } from './transaction.js';\n\nvar DEFAULT_IDLE_TIMEOUT = 1000;\nvar DEFAULT_FINAL_TIMEOUT = 30000;\nvar HEARTBEAT_INTERVAL = 5000;\n\n/**\n * @inheritDoc\n */\nclass IdleTransactionSpanRecorder extends SpanRecorder {\n constructor(\n _pushActivity,\n _popActivity,\n transactionSpanId,\n maxlen,\n ) {\n super(maxlen);this._pushActivity = _pushActivity;this._popActivity = _popActivity;this.transactionSpanId = transactionSpanId;;\n }\n\n /**\n * @inheritDoc\n */\n add(span) {\n // We should make sure we do not push and pop activities for\n // the transaction that this span recorder belongs to.\n if (span.spanId !== this.transactionSpanId) {\n // We patch span.finish() to pop an activity after setting an endTimestamp.\n span.finish = (endTimestamp) => {\n span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n this._popActivity(span.spanId);\n };\n\n // We should only push new activities if the span does not have an end timestamp.\n if (span.endTimestamp === undefined) {\n this._pushActivity(span.spanId);\n }\n }\n\n super.add(span);\n }\n}\n\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\nclass IdleTransaction extends Transaction {\n // Activities store a list of active spans\n __init() {this.activities = {};}\n\n // Track state of activities in previous heartbeat\n \n\n // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n __init2() {this._heartbeatCounter = 0;}\n\n // We should not use heartbeat if we finished a transaction\n __init3() {this._finished = false;}\n\n __init4() {this._beforeFinishCallbacks = [];}\n\n /**\n * Timer that tracks Transaction idleTimeout\n */\n \n\n constructor(\n transactionContext,\n _idleHub,\n /**\n * The time to wait in ms until the idle transaction will be finished. This timer is started each time\n * there are no active spans on this transaction.\n */\n _idleTimeout = DEFAULT_IDLE_TIMEOUT,\n /**\n * The final value in ms that a transaction cannot exceed\n */\n _finalTimeout = DEFAULT_FINAL_TIMEOUT,\n // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends\n _onScope = false,\n ) {\n super(transactionContext, _idleHub);this._idleHub = _idleHub;this._idleTimeout = _idleTimeout;this._finalTimeout = _finalTimeout;this._onScope = _onScope;IdleTransaction.prototype.__init.call(this);IdleTransaction.prototype.__init2.call(this);IdleTransaction.prototype.__init3.call(this);IdleTransaction.prototype.__init4.call(this);;\n\n if (_onScope) {\n // There should only be one active transaction on the scope\n clearActiveTransaction(_idleHub);\n\n // We set the transaction here on the scope so error events pick up the trace\n // context and attach it to the error.\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanId}`);\n _idleHub.configureScope(scope => scope.setSpan(this));\n }\n\n this._startIdleTimeout();\n setTimeout(() => {\n if (!this._finished) {\n this.setStatus('deadline_exceeded');\n this.finish();\n }\n }, this._finalTimeout);\n }\n\n /** {@inheritDoc} */\n finish(endTimestamp = timestampWithMs()) {\n this._finished = true;\n this.activities = {};\n\n if (this.spanRecorder) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n for (var callback of this._beforeFinishCallbacks) {\n callback(this, endTimestamp);\n }\n\n this.spanRecorder.spans = this.spanRecorder.spans.filter((span) => {\n // If we are dealing with the transaction itself, we just return it\n if (span.spanId === this.spanId) {\n return true;\n }\n\n // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n if (!span.endTimestamp) {\n span.endTimestamp = endTimestamp;\n span.setStatus('cancelled');\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n }\n\n var keepSpan = span.startTimestamp < endTimestamp;\n if (!keepSpan) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log(\n '[Tracing] discarding Span since it happened after Transaction was finished',\n JSON.stringify(span, undefined, 2),\n );\n }\n return keepSpan;\n });\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] flushing IdleTransaction');\n } else {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] No active IdleTransaction');\n }\n\n // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n if (this._onScope) {\n clearActiveTransaction(this._idleHub);\n }\n\n return super.finish(endTimestamp);\n }\n\n /**\n * Register a callback function that gets excecuted before the transaction finishes.\n * Useful for cleanup or if you want to add any additional spans based on current context.\n *\n * This is exposed because users have no other way of running something before an idle transaction\n * finishes.\n */\n registerBeforeFinishCallback(callback) {\n this._beforeFinishCallbacks.push(callback);\n }\n\n /**\n * @inheritDoc\n */\n initSpanRecorder(maxlen) {\n if (!this.spanRecorder) {\n var pushActivity = (id) => {\n if (this._finished) {\n return;\n }\n this._pushActivity(id);\n };\n var popActivity = (id) => {\n if (this._finished) {\n return;\n }\n this._popActivity(id);\n };\n\n this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);\n\n // Start heartbeat so that transactions do not run forever.\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Starting heartbeat');\n this._pingHeartbeat();\n }\n this.spanRecorder.add(this);\n }\n\n /**\n * Cancels the existing idletimeout, if there is one\n */\n _cancelIdleTimeout() {\n if (this._idleTimeoutID) {\n clearTimeout(this._idleTimeoutID);\n this._idleTimeoutID = undefined;\n }\n }\n\n /**\n * Creates an idletimeout\n */\n _startIdleTimeout(endTimestamp) {\n this._cancelIdleTimeout();\n this._idleTimeoutID = setTimeout(() => {\n if (!this._finished && Object.keys(this.activities).length === 0) {\n this.finish(endTimestamp);\n }\n }, this._idleTimeout);\n }\n\n /**\n * Start tracking a specific activity.\n * @param spanId The span id that represents the activity\n */\n _pushActivity(spanId) {\n this._cancelIdleTimeout();\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] pushActivity: ${spanId}`);\n this.activities[spanId] = true;\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n }\n\n /**\n * Remove an activity from usage\n * @param spanId The span id that represents the activity\n */\n _popActivity(spanId) {\n if (this.activities[spanId]) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] popActivity ${spanId}`);\n delete this.activities[spanId];\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n }\n\n if (Object.keys(this.activities).length === 0) {\n // We need to add the timeout here to have the real endtimestamp of the transaction\n // Remember timestampWithMs is in seconds, timeout is in ms\n var endTimestamp = timestampWithMs() + this._idleTimeout / 1000;\n this._startIdleTimeout(endTimestamp);\n }\n }\n\n /**\n * Checks when entries of this.activities are not changing for 3 beats.\n * If this occurs we finish the transaction.\n */\n _beat() {\n // We should not be running heartbeat if the idle transaction is finished.\n if (this._finished) {\n return;\n }\n\n var heartbeatString = Object.keys(this.activities).join('');\n\n if (heartbeatString === this._prevHeartbeatString) {\n this._heartbeatCounter += 1;\n } else {\n this._heartbeatCounter = 1;\n }\n\n this._prevHeartbeatString = heartbeatString;\n\n if (this._heartbeatCounter >= 3) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n this.setStatus('deadline_exceeded');\n this.finish();\n } else {\n this._pingHeartbeat();\n }\n }\n\n /**\n * Pings the heartbeat\n */\n _pingHeartbeat() {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);\n setTimeout(() => {\n this._beat();\n }, HEARTBEAT_INTERVAL);\n }\n}\n\n/**\n * Reset transaction on scope to `undefined`\n */\nfunction clearActiveTransaction(hub) {\n var scope = hub.getScope();\n if (scope) {\n var transaction = scope.getTransaction();\n if (transaction) {\n scope.setSpan(undefined);\n }\n }\n}\n\nexport { DEFAULT_FINAL_TIMEOUT, DEFAULT_IDLE_TIMEOUT, HEARTBEAT_INTERVAL, IdleTransaction, IdleTransactionSpanRecorder };\n//# sourceMappingURL=idletransaction.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { uuid4, timestampWithMs, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\nclass SpanRecorder {\n __init() {this.spans = [];}\n\n constructor(maxlen = 1000) {;SpanRecorder.prototype.__init.call(this);\n this._maxlen = maxlen;\n }\n\n /**\n * This is just so that we don't run out of memory while recording a lot\n * of spans. At some point we just stop and flush out the start of the\n * trace tree (i.e.the first n spans with the smallest\n * start_timestamp).\n */\n add(span) {\n if (this.spans.length > this._maxlen) {\n span.spanRecorder = undefined;\n } else {\n this.spans.push(span);\n }\n }\n}\n\n/**\n * Span contains all data about a span\n */\nclass Span {\n /**\n * @inheritDoc\n */\n __init2() {this.traceId = uuid4();}\n\n /**\n * @inheritDoc\n */\n __init3() {this.spanId = uuid4().substring(16);}\n\n /**\n * @inheritDoc\n */\n \n\n /**\n * Internal keeper of the status\n */\n \n\n /**\n * @inheritDoc\n */\n \n\n /**\n * Timestamp in seconds when the span was created.\n */\n __init4() {this.startTimestamp = timestampWithMs();}\n\n /**\n * Timestamp in seconds when the span ended.\n */\n \n\n /**\n * @inheritDoc\n */\n \n\n /**\n * @inheritDoc\n */\n \n\n /**\n * @inheritDoc\n */\n __init5() {this.tags = {};}\n\n /**\n * @inheritDoc\n */\n __init6() {this.data = {};}\n\n /**\n * List of spans that were finalized\n */\n \n\n /**\n * @inheritDoc\n */\n \n\n /**\n * You should never call the constructor manually, always use `Sentry.startTransaction()`\n * or call `startChild()` on an existing span.\n * @internal\n * @hideconstructor\n * @hidden\n */\n constructor(spanContext) {;Span.prototype.__init2.call(this);Span.prototype.__init3.call(this);Span.prototype.__init4.call(this);Span.prototype.__init5.call(this);Span.prototype.__init6.call(this);\n if (!spanContext) {\n return this;\n }\n if (spanContext.traceId) {\n this.traceId = spanContext.traceId;\n }\n if (spanContext.spanId) {\n this.spanId = spanContext.spanId;\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.op) {\n this.op = spanContext.op;\n }\n if (spanContext.description) {\n this.description = spanContext.description;\n }\n if (spanContext.data) {\n this.data = spanContext.data;\n }\n if (spanContext.tags) {\n this.tags = spanContext.tags;\n }\n if (spanContext.status) {\n this.status = spanContext.status;\n }\n if (spanContext.startTimestamp) {\n this.startTimestamp = spanContext.startTimestamp;\n }\n if (spanContext.endTimestamp) {\n this.endTimestamp = spanContext.endTimestamp;\n }\n }\n\n /**\n * @inheritDoc\n */\n startChild(\n spanContext,\n ) {\n var childSpan = new Span({\n ...spanContext,\n parentSpanId: this.spanId,\n sampled: this.sampled,\n traceId: this.traceId,\n });\n\n childSpan.spanRecorder = this.spanRecorder;\n if (childSpan.spanRecorder) {\n childSpan.spanRecorder.add(childSpan);\n }\n\n childSpan.transaction = this.transaction;\n\n return childSpan;\n }\n\n /**\n * @inheritDoc\n */\n setTag(key, value) {\n this.tags = { ...this.tags, [key]: value };\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setData(key, value) {\n this.data = { ...this.data, [key]: value };\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setStatus(value) {\n this.status = value;\n return this;\n }\n\n /**\n * @inheritDoc\n */\n setHttpStatus(httpStatus) {\n this.setTag('http.status_code', String(httpStatus));\n var spanStatus = spanStatusfromHttpCode(httpStatus);\n if (spanStatus !== 'unknown_error') {\n this.setStatus(spanStatus);\n }\n return this;\n }\n\n /**\n * @inheritDoc\n */\n isSuccess() {\n return this.status === 'ok';\n }\n\n /**\n * @inheritDoc\n */\n finish(endTimestamp) {\n this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n }\n\n /**\n * @inheritDoc\n */\n toTraceparent() {\n let sampledString = '';\n if (this.sampled !== undefined) {\n sampledString = this.sampled ? '-1' : '-0';\n }\n return `${this.traceId}-${this.spanId}${sampledString}`;\n }\n\n /**\n * @inheritDoc\n */\n toContext() {\n return dropUndefinedKeys({\n data: this.data,\n description: this.description,\n endTimestamp: this.endTimestamp,\n op: this.op,\n parentSpanId: this.parentSpanId,\n sampled: this.sampled,\n spanId: this.spanId,\n startTimestamp: this.startTimestamp,\n status: this.status,\n tags: this.tags,\n traceId: this.traceId,\n });\n }\n\n /**\n * @inheritDoc\n */\n updateWithContext(spanContext) {\n this.data = _nullishCoalesce(spanContext.data, () => ( {}));\n this.description = spanContext.description;\n this.endTimestamp = spanContext.endTimestamp;\n this.op = spanContext.op;\n this.parentSpanId = spanContext.parentSpanId;\n this.sampled = spanContext.sampled;\n this.spanId = _nullishCoalesce(spanContext.spanId, () => ( this.spanId));\n this.startTimestamp = _nullishCoalesce(spanContext.startTimestamp, () => ( this.startTimestamp));\n this.status = spanContext.status;\n this.tags = _nullishCoalesce(spanContext.tags, () => ( {}));\n this.traceId = _nullishCoalesce(spanContext.traceId, () => ( this.traceId));\n\n return this;\n }\n\n /**\n * @inheritDoc\n */\n getTraceContext()\n\n {\n return dropUndefinedKeys({\n data: Object.keys(this.data).length > 0 ? this.data : undefined,\n description: this.description,\n op: this.op,\n parent_span_id: this.parentSpanId,\n span_id: this.spanId,\n status: this.status,\n tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n trace_id: this.traceId,\n });\n }\n\n /**\n * @inheritDoc\n */\n toJSON()\n\n {\n return dropUndefinedKeys({\n data: Object.keys(this.data).length > 0 ? this.data : undefined,\n description: this.description,\n op: this.op,\n parent_span_id: this.parentSpanId,\n span_id: this.spanId,\n start_timestamp: this.startTimestamp,\n status: this.status,\n tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n timestamp: this.endTimestamp,\n trace_id: this.traceId,\n });\n }\n}\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nfunction spanStatusfromHttpCode(httpStatus) {\n if (httpStatus < 400 && httpStatus >= 100) {\n return 'ok';\n }\n\n if (httpStatus >= 400 && httpStatus < 500) {\n switch (httpStatus) {\n case 401:\n return 'unauthenticated';\n case 403:\n return 'permission_denied';\n case 404:\n return 'not_found';\n case 409:\n return 'already_exists';\n case 413:\n return 'failed_precondition';\n case 429:\n return 'resource_exhausted';\n default:\n return 'invalid_argument';\n }\n }\n\n if (httpStatus >= 500 && httpStatus < 600) {\n switch (httpStatus) {\n case 501:\n return 'unimplemented';\n case 503:\n return 'unavailable';\n case 504:\n return 'deadline_exceeded';\n default:\n return 'internal_error';\n }\n }\n\n return 'unknown_error';\n}\n\nexport { Span, SpanRecorder, spanStatusfromHttpCode };\n//# sourceMappingURL=span.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { getCurrentHub } from '@sentry/hub';\nimport { logger, dropUndefinedKeys, isBaggageMutable, createBaggage, getSentryBaggageItems } from '@sentry/utils';\nimport { Span, SpanRecorder } from './span.js';\n\n/** JSDoc */\nclass Transaction extends Span {\n \n\n /**\n * The reference to the current hub.\n */\n \n\n __init() {this._measurements = {};}\n\n /**\n * This constructor should never be called manually. Those instrumenting tracing should use\n * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n * @internal\n * @hideconstructor\n * @hidden\n */\n constructor(transactionContext, hub) {\n super(transactionContext);Transaction.prototype.__init.call(this);;\n\n this._hub = hub || getCurrentHub();\n\n this._name = transactionContext.name || '';\n\n this.metadata = transactionContext.metadata || {};\n this._trimEnd = transactionContext.trimEnd;\n\n // this is because transactions are also spans, and spans have a transaction pointer\n this.transaction = this;\n }\n\n /** Getter for `name` property */\n get name() {\n return this._name;\n }\n\n /** Setter for `name` property, which also sets `source` */\n set name(newName) {\n this._name = newName;\n this.metadata.source = 'custom';\n }\n\n /**\n * JSDoc\n */\n setName(name, source = 'custom') {\n this.name = name;\n this.metadata.source = source;\n }\n\n /**\n * Attaches SpanRecorder to the span itself\n * @param maxlen maximum number of spans that can be recorded\n */\n initSpanRecorder(maxlen = 1000) {\n if (!this.spanRecorder) {\n this.spanRecorder = new SpanRecorder(maxlen);\n }\n this.spanRecorder.add(this);\n }\n\n /**\n * @inheritDoc\n */\n setMeasurement(name, value, unit = '') {\n this._measurements[name] = { value, unit };\n }\n\n /**\n * @inheritDoc\n */\n setMetadata(newMetadata) {\n this.metadata = { ...this.metadata, ...newMetadata };\n }\n\n /**\n * @inheritDoc\n */\n finish(endTimestamp) {\n // This transaction is already finished, so we should not flush it again.\n if (this.endTimestamp !== undefined) {\n return undefined;\n }\n\n if (!this.name) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Transaction has no name, falling back to ``.');\n this.name = '';\n }\n\n // just sets the end timestamp\n super.finish(endTimestamp);\n\n if (this.sampled !== true) {\n // At this point if `sampled !== true` we want to discard the transaction.\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n var client = this._hub.getClient();\n if (client) {\n client.recordDroppedEvent('sample_rate', 'transaction');\n }\n\n return undefined;\n }\n\n var finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(s => s !== this && s.endTimestamp) : [];\n\n if (this._trimEnd && finishedSpans.length > 0) {\n this.endTimestamp = finishedSpans.reduce((prev, current) => {\n if (prev.endTimestamp && current.endTimestamp) {\n return prev.endTimestamp > current.endTimestamp ? prev : current;\n }\n return prev;\n }).endTimestamp;\n }\n\n var metadata = this.metadata;\n\n var transaction = {\n contexts: {\n trace: this.getTraceContext(),\n },\n spans: finishedSpans,\n start_timestamp: this.startTimestamp,\n tags: this.tags,\n timestamp: this.endTimestamp,\n transaction: this.name,\n type: 'transaction',\n sdkProcessingMetadata: {\n ...metadata,\n baggage: this.getBaggage(),\n },\n ...(metadata.source && {\n transaction_info: {\n source: metadata.source,\n },\n }),\n };\n\n var hasMeasurements = Object.keys(this._measurements).length > 0;\n\n if (hasMeasurements) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log(\n '[Measurements] Adding measurements to transaction',\n JSON.stringify(this._measurements, undefined, 2),\n );\n transaction.measurements = this._measurements;\n }\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);\n\n return this._hub.captureEvent(transaction);\n }\n\n /**\n * @inheritDoc\n */\n toContext() {\n var spanContext = super.toContext();\n\n return dropUndefinedKeys({\n ...spanContext,\n name: this.name,\n trimEnd: this._trimEnd,\n });\n }\n\n /**\n * @inheritDoc\n */\n updateWithContext(transactionContext) {\n super.updateWithContext(transactionContext);\n\n this.name = _nullishCoalesce(transactionContext.name, () => ( ''));\n\n this._trimEnd = transactionContext.trimEnd;\n\n return this;\n }\n\n /**\n * @inheritdoc\n *\n * @experimental\n */\n getBaggage() {\n var existingBaggage = this.metadata.baggage;\n\n // Only add Sentry baggage items to baggage, if baggage does not exist yet or it is still\n // empty and mutable\n var finalBaggage =\n !existingBaggage || isBaggageMutable(existingBaggage)\n ? this._populateBaggageWithSentryValues(existingBaggage)\n : existingBaggage;\n\n // Update the baggage stored on the transaction.\n this.metadata.baggage = finalBaggage;\n\n return finalBaggage;\n }\n\n /**\n * Collects and adds data to the passed baggage object.\n *\n * Note: This function does not explicitly check if the passed baggage object is allowed\n * to be modified. Implicitly, `setBaggageValue` will not make modification to the object\n * if it was already set immutable.\n *\n * After adding the data, the baggage object is set immutable to prevent further modifications.\n *\n * @param baggage\n *\n * @returns modified and immutable baggage object\n */\n _populateBaggageWithSentryValues(baggage = createBaggage({})) {\n var hub = this._hub || getCurrentHub();\n var client = hub && hub.getClient();\n\n if (!client) return baggage;\n\n const { environment, release } = client.getOptions() || {};\n const { publicKey: public_key } = client.getDsn() || {};\n\n var rate = this.metadata && this.metadata.transactionSampling && this.metadata.transactionSampling.rate;\n var sample_rate =\n rate !== undefined\n ? rate.toLocaleString('fullwide', { useGrouping: false, maximumFractionDigits: 16 })\n : undefined;\n\n var scope = hub.getScope();\n const { segment: user_segment } = (scope && scope.getUser()) || {};\n\n var source = this.metadata.source;\n var transaction = source && source !== 'url' ? this.name : undefined;\n\n return createBaggage(\n dropUndefinedKeys({\n environment,\n release,\n transaction,\n user_segment,\n public_key,\n trace_id: this.traceId,\n sample_rate,\n ...getSentryBaggageItems(baggage), // keep user-added values\n } ),\n '',\n false, // set baggage immutable\n );\n }\n}\n\nexport { Transaction };\n//# sourceMappingURL=transaction.js.map\n","import { getCurrentHub } from '@sentry/hub';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nfunction hasTracingEnabled(\n maybeOptions,\n) {\n var client = getCurrentHub().getClient();\n var options = maybeOptions || (client && client.getOptions());\n return !!options && ('tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\n/** Grabs active transaction off scope, if any */\nfunction getActiveTransaction(maybeHub) {\n var hub = maybeHub || getCurrentHub();\n var scope = hub.getScope();\n return scope && (scope.getTransaction() );\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time) {\n return time / 1000;\n}\n\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\nfunction secToMs(time) {\n return time * 1000;\n}\n\nexport { getActiveTransaction, hasTracingEnabled, msToSec, secToMs };\n//# sourceMappingURL=utils.js.map\n","import { isString } from './is.js';\nimport { logger } from './logger.js';\n\nvar BAGGAGE_HEADER_NAME = 'baggage';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nvar MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/** Create an instance of Baggage */\nfunction createBaggage(initItems, baggageString = '', mutable = true) {\n return [{ ...initItems }, baggageString, mutable];\n}\n\n/** Get a value from baggage */\nfunction getBaggageValue(baggage, key) {\n return baggage[0][key];\n}\n\n/** Add a value to baggage */\nfunction setBaggageValue(baggage, key, value) {\n if (isBaggageMutable(baggage)) {\n baggage[0][key] = value;\n }\n}\n\n/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */\nfunction isSentryBaggageEmpty(baggage) {\n return Object.keys(baggage[0]).length === 0;\n}\n\n/** Returns Sentry specific baggage values */\nfunction getSentryBaggageItems(baggage) {\n return baggage[0];\n}\n\n/**\n * Returns 3rd party baggage string of @param baggage\n * @param baggage\n */\nfunction getThirdPartyBaggage(baggage) {\n return baggage[1];\n}\n\n/**\n * Checks if baggage is mutable\n * @param baggage\n * @returns true if baggage is mutable, else false\n */\nfunction isBaggageMutable(baggage) {\n return baggage[2];\n}\n\n/**\n * Sets the passed baggage immutable\n * @param baggage\n */\nfunction setBaggageImmutable(baggage) {\n baggage[2] = false;\n}\n\n/** Serialize a baggage object */\nfunction serializeBaggage(baggage) {\n return Object.keys(baggage[0]).reduce((prev, key) => {\n var val = baggage[0][key] ;\n var baggageEntry = `${SENTRY_BAGGAGE_KEY_PREFIX}${encodeURIComponent(key)}=${encodeURIComponent(val)}`;\n var newVal = prev === '' ? baggageEntry : `${prev},${baggageEntry}`;\n if (newVal.length > MAX_BAGGAGE_STRING_LENGTH) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(`Not adding key: ${key} with val: ${val} to baggage due to exceeding baggage size limits.`);\n return prev;\n } else {\n return newVal;\n }\n }, baggage[1]);\n}\n\n/**\n * Parse a baggage header from a string or a string array and return a Baggage object\n *\n * If @param includeThirdPartyEntries is set to true, third party baggage entries are added to the Baggage object\n * (This is necessary for merging potentially pre-existing baggage headers in outgoing requests with\n * our `sentry-` values)\n */\nfunction parseBaggageHeader(\n inputBaggageValue,\n includeThirdPartyEntries = false,\n) {\n // Adding this check here because we got reports of this function failing due to the input value\n // not being a string. This debug log might help us determine what's going on here.\n if ((!Array.isArray(inputBaggageValue) && !isString(inputBaggageValue)) || typeof inputBaggageValue === 'number') {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(\n '[parseBaggageHeader] Received input value of incompatible type: ',\n typeof inputBaggageValue,\n inputBaggageValue,\n );\n\n // Gonna early-return an empty baggage object so that we don't fail later on\n return createBaggage({}, '');\n }\n\n var baggageEntries = (isString(inputBaggageValue) ? inputBaggageValue : inputBaggageValue.join(','))\n .split(',')\n .map(entry => entry.trim())\n .filter(entry => entry !== '' && (includeThirdPartyEntries || SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(entry)));\n\n return baggageEntries.reduce(\n ([baggageObj, baggageString], curr) => {\n const [key, val] = curr.split('=');\n if (SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(key)) {\n var baggageKey = decodeURIComponent(key.split('-')[1]);\n return [\n {\n ...baggageObj,\n [baggageKey]: decodeURIComponent(val),\n },\n baggageString,\n true,\n ];\n } else {\n return [baggageObj, baggageString === '' ? curr : `${baggageString},${curr}`, true];\n }\n },\n [{}, '', true],\n );\n}\n\n/**\n * Merges the baggage header we saved from the incoming request (or meta tag) with\n * a possibly created or modified baggage header by a third party that's been added\n * to the outgoing request header.\n *\n * In case @param headerBaggageString exists, we can safely add the the 3rd party part of @param headerBaggage\n * with our @param incomingBaggage. This is possible because if we modified anything beforehand,\n * it would only affect parts of the sentry baggage (@see Baggage interface).\n *\n * @param incomingBaggage the baggage header of the incoming request that might contain sentry entries\n * @param thirdPartyBaggageHeader possibly existing baggage header string or string[] added from a third\n * party to the request headers\n *\n * @return a merged and serialized baggage string to be propagated with the outgoing request\n */\nfunction mergeAndSerializeBaggage(incomingBaggage, thirdPartyBaggageHeader) {\n if (!incomingBaggage && !thirdPartyBaggageHeader) {\n return '';\n }\n\n var headerBaggage = (thirdPartyBaggageHeader && parseBaggageHeader(thirdPartyBaggageHeader, true)) || undefined;\n var thirdPartyHeaderBaggage = headerBaggage && getThirdPartyBaggage(headerBaggage);\n\n var finalBaggage = createBaggage((incomingBaggage && incomingBaggage[0]) || {}, thirdPartyHeaderBaggage || '');\n return serializeBaggage(finalBaggage);\n}\n\n/**\n * Helper function that takes a raw baggage string (if available) and the processed sentry-trace header\n * data (if available), parses the baggage string and creates a Baggage object\n * If there is no baggage string, it will create an empty Baggage object.\n * In a second step, this functions determines if the created Baggage object should be set immutable\n * to prevent mutation of the Sentry data.\n *\n * Extracted this logic to a function because it's duplicated in a lot of places.\n *\n * @param rawBaggageValue\n * @param sentryTraceHeader\n */\nfunction parseBaggageSetMutability(\n rawBaggageValue,\n sentryTraceHeader,\n) {\n var baggage = parseBaggageHeader(rawBaggageValue || '');\n\n // Because we are always creating a Baggage object by calling `parseBaggageHeader` above\n // (either a filled one or an empty one, even if we didn't get a `baggage` header),\n // we only need to check if we have a sentry-trace header or not. As soon as we have it,\n // we set baggage immutable. In case we don't get a sentry-trace header, we can assume that\n // this SDK is the head of the trace and thus we still permit mutation at this time.\n // There is one exception though, which is that we get a baggage-header with `sentry-`\n // items but NO sentry-trace header. In this case we also set the baggage immutable for now\n // but if smoething like this would ever happen, we should revisit this and determine\n // what this would actually mean for the trace (i.e. is this SDK the head?, what happened\n // before that we don't have a sentry-trace header?, etc)\n (sentryTraceHeader || !isSentryBaggageEmpty(baggage)) && setBaggageImmutable(baggage);\n\n return baggage;\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, createBaggage, getBaggageValue, getSentryBaggageItems, getThirdPartyBaggage, isBaggageMutable, isSentryBaggageEmpty, mergeAndSerializeBaggage, parseBaggageHeader, parseBaggageSetMutability, serializeBaggage, setBaggageImmutable, setBaggageValue };\n//# sourceMappingURL=baggage.js.map\n","import { getGlobalObject } from './global.js';\nimport { isString } from './is.js';\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(elem, keyAttrs) {\n \n\n // try/catch both:\n // - accessing event.target (see getsentry/raven-js#838, #768)\n // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n // - can throw an exception in some circumstances.\n try {\n let currentElem = elem ;\n var MAX_TRAVERSE_HEIGHT = 5;\n var MAX_OUTPUT_LEN = 80;\n var out = [];\n let height = 0;\n let len = 0;\n var separator = ' > ';\n var sepLength = separator.length;\n let nextStr;\n\n while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n nextStr = _htmlElementAsString(currentElem, keyAttrs);\n // bail out if\n // - nextStr is the 'html' element\n // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n // (ignore this limit if we are on the first iteration)\n if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n break;\n }\n\n out.push(nextStr);\n\n len += nextStr.length;\n currentElem = currentElem.parentNode;\n }\n\n return out.reverse().join(separator);\n } catch (_oO) {\n return '';\n }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n var elem = el \n\n;\n\n var out = [];\n let className;\n let classes;\n let key;\n let attr;\n let i;\n\n if (!elem || !elem.tagName) {\n return '';\n }\n\n out.push(elem.tagName.toLowerCase());\n\n // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n var keyAttrPairs =\n keyAttrs && keyAttrs.length\n ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n : null;\n\n if (keyAttrPairs && keyAttrPairs.length) {\n keyAttrPairs.forEach(keyAttrPair => {\n out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n });\n } else {\n if (elem.id) {\n out.push(`#${elem.id}`);\n }\n\n className = elem.className;\n if (className && isString(className)) {\n classes = className.split(/\\s+/);\n for (i = 0; i < classes.length; i++) {\n out.push(`.${classes[i]}`);\n }\n }\n }\n var allowedAttrs = ['type', 'name', 'title', 'alt'];\n for (i = 0; i < allowedAttrs.length; i++) {\n key = allowedAttrs[i];\n attr = elem.getAttribute(key);\n if (attr) {\n out.push(`[${key}=\"${attr}\"]`);\n }\n }\n return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nfunction getLocationHref() {\n var global = getGlobalObject();\n try {\n return global.document.location.href;\n } catch (oO) {\n return '';\n }\n}\n\nexport { getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","/**\n * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nfunction _nullishCoalesce(lhs, rhsFn) {\n // by checking for loose equality to `null`, we catch both `null` and `undefined`\n return lhs != null ? lhs : rhsFn();\n}\n\n// Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n// if (lhs != null) {\n// return lhs;\n// } else {\n// return rhsFn();\n// }\n// }\n\nexport { _nullishCoalesce };\n//# sourceMappingURL=_nullishCoalesce.js.map\n","import { isNodeEnv } from './node.js';\n\n/** Internal */\n\nvar fallbackGlobalObject = {};\n\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nfunction getGlobalObject() {\n return (\n isNodeEnv()\n ? global\n : typeof window !== 'undefined' ? window : typeof self !== 'undefined'\n ? self\n : fallbackGlobalObject\n ) ;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `getGlobalObject`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n var global = (obj || getGlobalObject()) ;\n var __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});\n var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n return singleton;\n}\n\nexport { getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=global.js.map\n","import { getGlobalObject } from './global.js';\nimport { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\n\nvar global = getGlobalObject();\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n * - Console API\n * - Fetch API\n * - XHR API\n * - History API\n * - DOM API (click/typing)\n * - Error API\n * - UnhandledRejection API\n */\n\nvar handlers = {};\nvar instrumented = {};\n\n/** Instruments given API */\nfunction instrument(type) {\n if (instrumented[type]) {\n return;\n }\n\n instrumented[type] = true;\n\n switch (type) {\n case 'console':\n instrumentConsole();\n break;\n case 'dom':\n instrumentDOM();\n break;\n case 'xhr':\n instrumentXHR();\n break;\n case 'fetch':\n instrumentFetch();\n break;\n case 'history':\n instrumentHistory();\n break;\n case 'error':\n instrumentError();\n break;\n case 'unhandledrejection':\n instrumentUnhandledRejection();\n break;\n default:\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n return;\n }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addInstrumentationHandler(type, callback) {\n handlers[type] = handlers[type] || [];\n (handlers[type] ).push(callback);\n instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n if (!type || !handlers[type]) {\n return;\n }\n\n for (var handler of handlers[type] || []) {\n try {\n handler(data);\n } catch (e) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.error(\n `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n e,\n );\n }\n }\n}\n\n/** JSDoc */\nfunction instrumentConsole() {\n if (!('console' in global)) {\n return;\n }\n\n CONSOLE_LEVELS.forEach(function (level) {\n if (!(level in global.console)) {\n return;\n }\n\n fill(global.console, level, function (originalConsoleMethod) {\n return function (...args) {\n triggerHandlers('console', { args, level });\n\n // this fails for some browsers. :(\n if (originalConsoleMethod) {\n originalConsoleMethod.apply(global.console, args);\n }\n };\n });\n });\n}\n\n/** JSDoc */\nfunction instrumentFetch() {\n if (!supportsNativeFetch()) {\n return;\n }\n\n fill(global, 'fetch', function (originalFetch) {\n return function (...args) {\n var handlerData = {\n args,\n fetchData: {\n method: getFetchMethod(args),\n url: getFetchUrl(args),\n },\n startTimestamp: Date.now(),\n };\n\n triggerHandlers('fetch', {\n ...handlerData,\n });\n\n return originalFetch.apply(global, args).then(\n (response) => {\n triggerHandlers('fetch', {\n ...handlerData,\n endTimestamp: Date.now(),\n response,\n });\n return response;\n },\n (error) => {\n triggerHandlers('fetch', {\n ...handlerData,\n endTimestamp: Date.now(),\n error,\n });\n // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n // it means the sentry.javascript SDK caught an error invoking your application code.\n // This is expected behavior and NOT indicative of a bug with sentry.javascript.\n throw error;\n },\n );\n };\n });\n}\n\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs = []) {\n if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n return String(fetchArgs[0].method).toUpperCase();\n }\n if (fetchArgs[1] && fetchArgs[1].method) {\n return String(fetchArgs[1].method).toUpperCase();\n }\n return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs = []) {\n if (typeof fetchArgs[0] === 'string') {\n return fetchArgs[0];\n }\n if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n return fetchArgs[0].url;\n }\n return String(fetchArgs[0]);\n}\n\n/** JSDoc */\nfunction instrumentXHR() {\n if (!('XMLHttpRequest' in global)) {\n return;\n }\n\n var xhrproto = XMLHttpRequest.prototype;\n\n fill(xhrproto, 'open', function (originalOpen) {\n return function ( ...args) {\n var xhr = this;\n var url = args[1];\n var xhrInfo = (xhr.__sentry_xhr__ = {\n method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n url: args[1],\n });\n\n // if Sentry key appears in URL, don't capture it as a request\n if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n xhr.__sentry_own_request__ = true;\n }\n\n var onreadystatechangeHandler = function () {\n if (xhr.readyState === 4) {\n try {\n // touching statusCode in some platforms throws\n // an exception\n xhrInfo.status_code = xhr.status;\n } catch (e) {\n /* do nothing */\n }\n\n triggerHandlers('xhr', {\n args,\n endTimestamp: Date.now(),\n startTimestamp: Date.now(),\n xhr,\n });\n }\n };\n\n if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n fill(xhr, 'onreadystatechange', function (original) {\n return function (...readyStateArgs) {\n onreadystatechangeHandler();\n return original.apply(xhr, readyStateArgs);\n };\n });\n } else {\n xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n }\n\n return originalOpen.apply(xhr, args);\n };\n });\n\n fill(xhrproto, 'send', function (originalSend) {\n return function ( ...args) {\n if (this.__sentry_xhr__ && args[0] !== undefined) {\n this.__sentry_xhr__.body = args[0];\n }\n\n triggerHandlers('xhr', {\n args,\n startTimestamp: Date.now(),\n xhr: this,\n });\n\n return originalSend.apply(this, args);\n };\n });\n}\n\nlet lastHref;\n\n/** JSDoc */\nfunction instrumentHistory() {\n if (!supportsHistory()) {\n return;\n }\n\n var oldOnPopState = global.onpopstate;\n global.onpopstate = function ( ...args) {\n var to = global.location.href;\n // keep track of the current URL state, as we always receive only the updated state\n var from = lastHref;\n lastHref = to;\n triggerHandlers('history', {\n from,\n to,\n });\n if (oldOnPopState) {\n // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n // https://github.com/getsentry/sentry-javascript/issues/3344\n // https://github.com/bugsnag/bugsnag-js/issues/469\n try {\n return oldOnPopState.apply(this, args);\n } catch (_oO) {\n // no-empty\n }\n }\n };\n\n /** @hidden */\n function historyReplacementFunction(originalHistoryFunction) {\n return function ( ...args) {\n var url = args.length > 2 ? args[2] : undefined;\n if (url) {\n // coerce to string (this is what pushState does)\n var from = lastHref;\n var to = String(url);\n // keep track of the current URL state, as we always receive only the updated state\n lastHref = to;\n triggerHandlers('history', {\n from,\n to,\n });\n }\n return originalHistoryFunction.apply(this, args);\n };\n }\n\n fill(global.history, 'pushState', historyReplacementFunction);\n fill(global.history, 'replaceState', historyReplacementFunction);\n}\n\nvar debounceDuration = 1000;\nlet debounceTimerID;\nlet lastCapturedEvent;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n // If there was no previous event, it should always be swapped for the new one.\n if (!previous) {\n return true;\n }\n\n // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n if (previous.type !== current.type) {\n return true;\n }\n\n try {\n // If both events have the same type, it's still possible that actions were performed on different targets.\n // e.g. 2 clicks on different buttons.\n if (previous.target !== current.target) {\n return true;\n }\n } catch (e) {\n // just accessing `target` property can throw an exception in some rare circumstances\n // see: https://github.com/getsentry/sentry-javascript/issues/838\n }\n\n // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n // to which an event listener was attached), we treat them as the same action, as we want to capture\n // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event) {\n // We are only interested in filtering `keypress` events for now.\n if (event.type !== 'keypress') {\n return false;\n }\n\n try {\n var target = event.target ;\n\n if (!target || !target.tagName) {\n return true;\n }\n\n // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n // e.g.tabbing through elements, hotkeys, etc.\n if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n return false;\n }\n } catch (e) {\n // just accessing `target` property can throw an exception in some rare circumstances\n // see: https://github.com/getsentry/sentry-javascript/issues/838\n }\n\n return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler, globalListener = false) {\n return (event) => {\n // It's possible this handler might trigger multiple times for the same\n // event (e.g. event propagation through node ancestors).\n // Ignore if we've already captured that event.\n if (!event || lastCapturedEvent === event) {\n return;\n }\n\n // We always want to skip _some_ events.\n if (shouldSkipDOMEvent(event)) {\n return;\n }\n\n var name = event.type === 'keypress' ? 'input' : event.type;\n\n // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n if (debounceTimerID === undefined) {\n handler({\n event: event,\n name,\n global: globalListener,\n });\n lastCapturedEvent = event;\n }\n // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n handler({\n event: event,\n name,\n global: globalListener,\n });\n lastCapturedEvent = event;\n }\n\n // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n clearTimeout(debounceTimerID);\n debounceTimerID = global.setTimeout(() => {\n debounceTimerID = undefined;\n }, debounceDuration);\n };\n}\n\n/** JSDoc */\nfunction instrumentDOM() {\n if (!('document' in global)) {\n return;\n }\n\n // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n var triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n global.document.addEventListener('click', globalDOMEventHandler, false);\n global.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n // guaranteed to fire at least once.)\n ['EventTarget', 'Node'].forEach((target) => {\n var proto = (global )[target] && (global )[target].prototype;\n if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n return;\n }\n\n fill(proto, 'addEventListener', function (originalAddEventListener) {\n return function (\n \n type,\n listener,\n options,\n ) {\n if (type === 'click' || type == 'keypress') {\n try {\n var el = this ;\n var handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n var handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n if (!handlerForType.handler) {\n var handler = makeDOMEventHandler(triggerDOMHandler);\n handlerForType.handler = handler;\n originalAddEventListener.call(this, type, handler, options);\n }\n\n handlerForType.refCount += 1;\n } catch (e) {\n // Accessing dom properties is always fragile.\n // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n }\n }\n\n return originalAddEventListener.call(this, type, listener, options);\n };\n });\n\n fill(\n proto,\n 'removeEventListener',\n function (originalRemoveEventListener) {\n return function (\n \n type,\n listener,\n options,\n ) {\n if (type === 'click' || type == 'keypress') {\n try {\n var el = this ;\n var handlers = el.__sentry_instrumentation_handlers__ || {};\n var handlerForType = handlers[type];\n\n if (handlerForType) {\n handlerForType.refCount -= 1;\n // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n if (handlerForType.refCount <= 0) {\n originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n handlerForType.handler = undefined;\n delete handlers[type]; }\n\n // If there are no longer any custom handlers of any type on this element, cleanup everything.\n if (Object.keys(handlers).length === 0) {\n delete el.__sentry_instrumentation_handlers__;\n }\n }\n } catch (e) {\n // Accessing dom properties is always fragile.\n // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n }\n }\n\n return originalRemoveEventListener.call(this, type, listener, options);\n };\n },\n );\n });\n}\n\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n _oldOnErrorHandler = global.onerror;\n\n global.onerror = function (msg, url, line, column, error) {\n triggerHandlers('error', {\n column,\n error,\n line,\n msg,\n url,\n });\n\n if (_oldOnErrorHandler) {\n return _oldOnErrorHandler.apply(this, arguments);\n }\n\n return false;\n };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n\n global.onunhandledrejection = function (e) {\n triggerHandlers('unhandledrejection', e);\n\n if (_oldOnUnhandledRejectionHandler) {\n return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n }\n\n return true;\n };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","var objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n switch (objectToString.call(wat)) {\n case '[object Error]':\n case '[object Exception]':\n case '[object DOMException]':\n return true;\n default:\n return isInstanceOf(wat, Error);\n }\n}\n\nfunction isBuiltin(wat, ty) {\n return objectToString.call(wat) === `[object ${ty}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n try {\n return wat instanceof base;\n } catch (_e) {\n return false;\n }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","import { getGlobalObject, getGlobalSingleton } from './global.js';\n\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n\nvar CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n var global = getGlobalObject();\n\n if (!('console' in global)) {\n return callback();\n }\n\n var originalConsole = global.console ;\n var wrappedLevels = {};\n\n // Restore all wrapped console methods\n CONSOLE_LEVELS.forEach(level => {\n // TODO(v7): Remove this check as it's only needed for Node 6\n var originalWrappedFunc =\n originalConsole[level] && (originalConsole[level] ).__sentry_original__;\n if (level in global.console && originalWrappedFunc) {\n wrappedLevels[level] = originalConsole[level] ;\n originalConsole[level] = originalWrappedFunc ;\n }\n });\n\n try {\n return callback();\n } finally {\n // Revert restoration to wrapped state\n Object.keys(wrappedLevels).forEach(level => {\n originalConsole[level] = wrappedLevels[level ];\n });\n }\n}\n\nfunction makeLogger() {\n let enabled = false;\n var logger = {\n enable: () => {\n enabled = true;\n },\n disable: () => {\n enabled = false;\n },\n };\n\n if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n CONSOLE_LEVELS.forEach(name => {\n logger[name] = (...args) => {\n if (enabled) {\n consoleSandbox(() => {\n global.console[name](`${PREFIX}[${name}]:`, ...args);\n });\n }\n };\n });\n } else {\n CONSOLE_LEVELS.forEach(name => {\n logger[name] = () => undefined;\n });\n }\n\n return logger ;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger;\nif ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n logger = getGlobalSingleton('logger', makeLogger);\n} else {\n logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };\n//# sourceMappingURL=logger.js.map\n","import { getGlobalObject } from './global.js';\nimport { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\n\n/**\n * Extended Window interface that allows for Crypto API usage in IE browsers\n */\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n var global = getGlobalObject() ;\n var crypto = global.crypto || global.msCrypto;\n\n if (!(crypto === void 0) && crypto.getRandomValues) {\n // Use window.crypto API if available\n var arr = new Uint16Array(8);\n crypto.getRandomValues(arr);\n\n // set 4 in byte 7\n arr[3] = (arr[3] & 0xfff) | 0x4000;\n // set 2 most significant bits of byte 9 to '10'\n arr[4] = (arr[4] & 0x3fff) | 0x8000;\n\n var pad = (num) => {\n let v = num.toString(16);\n while (v.length < 4) {\n v = `0${v}`;\n }\n return v;\n };\n\n return (\n pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7])\n );\n }\n // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, c => {\n var r = (Math.random() * 16) | 0;\n var v = c === 'x' ? r : (r & 0x3) | 0x8;\n return v.toString(16);\n });\n}\n\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url)\n\n {\n if (!url) {\n return {};\n }\n\n var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n if (!match) {\n return {};\n }\n\n // coerce to undefined values to empty string so we don't get 'undefined'\n var query = match[6] || '';\n var fragment = match[8] || '';\n return {\n host: match[4],\n path: match[5],\n protocol: match[2],\n relative: match[5] + query + fragment, // everything minus origin\n };\n}\n\nfunction getFirstException(event) {\n return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n const { message, event_id: eventId } = event;\n if (message) {\n return message;\n }\n\n var firstException = getFirstException(event);\n if (firstException) {\n if (firstException.type && firstException.value) {\n return `${firstException.type}: ${firstException.value}`;\n }\n return firstException.type || firstException.value || eventId || '';\n }\n return eventId || '';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n var exception = (event.exception = event.exception || {});\n var values = (exception.values = exception.values || []);\n var firstException = (values[0] = values[0] || {});\n if (!firstException.value) {\n firstException.value = value || '';\n }\n if (!firstException.type) {\n firstException.type = type || 'Error';\n }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nfunction addExceptionMechanism(event, newMechanism) {\n var firstException = getFirstException(event);\n if (!firstException) {\n return;\n }\n\n var defaultMechanism = { type: 'generic', handled: true };\n var currentMechanism = firstException.mechanism;\n firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n if (newMechanism && 'data' in newMechanism) {\n var mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n firstException.mechanism.data = mergedData;\n }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP =\n /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n var match = input.match(SEMVER_REGEXP) || [];\n var major = parseInt(match[1], 10);\n var minor = parseInt(match[2], 10);\n var patch = parseInt(match[3], 10);\n return {\n buildmetadata: match[5],\n major: isNaN(major) ? undefined : major,\n minor: isNaN(minor) ? undefined : minor,\n patch: isNaN(patch) ? undefined : patch,\n prerelease: match[4],\n };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n var lineno = frame.lineno || 0;\n var maxLines = lines.length;\n var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n\n frame.pre_context = lines\n .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n .map((line) => snipLine(line, 0));\n\n frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n frame.post_context = lines\n .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n .map((line) => snipLine(line, 0));\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nfunction checkOrSetAlreadyCaught(exception) {\n if (exception && (exception ).__sentry_captured__) {\n return true;\n }\n\n try {\n // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n // `ExtraErrorData` integration\n addNonEnumerableProperty(exception , '__sentry_captured__', true);\n } catch (err) {\n // `exception` is a primitive, so we can't mark it seen\n }\n\n return false;\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, checkOrSetAlreadyCaught, getEventDescription, parseSemver, parseUrl, stripUrlQueryAndFragment, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n // explicitly check for browser bundles as those can be optimized statically\n // by terser/rollup.\n return (\n !isBrowserBundle() &&\n Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\nfunction dynamicRequire(mod, request) {\n return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n let mod;\n\n try {\n mod = dynamicRequire(module, moduleName);\n } catch (e) {\n // no-empty\n }\n\n try {\n const { cwd } = dynamicRequire(module, 'process');\n mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n } catch (e) {\n // no-empty\n }\n\n return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser. We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\nexport { isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, )` or `origMethod.apply(this, [])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n if (!(name in source)) {\n return;\n }\n\n var original = source[name] ;\n var wrapped = replacementFactory(original) ;\n\n // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n if (typeof wrapped === 'function') {\n try {\n markFunctionWrapped(wrapped, original);\n } catch (_Oo) {\n // This can throw if multiple fill happens on a global object like XMLHttpRequest\n // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n }\n }\n\n source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n Object.defineProperty(obj, name, {\n // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n value: value,\n writable: true,\n configurable: true,\n });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n var proto = original.prototype || {};\n wrapped.prototype = original.prototype = proto;\n addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available. See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nfunction getOriginalFunction(func) {\n return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n return Object.keys(object)\n .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n * an Error.\n */\nfunction convertToPlainObject(\n value,\n)\n\n {\n if (isError(value)) {\n return {\n message: value.message,\n name: value.name,\n stack: value.stack,\n ...getOwnProperties(value),\n };\n } else if (isEvent(value)) {\n var newObj\n\n = {\n type: value.type,\n target: serializeEventTarget(value.target),\n currentTarget: serializeEventTarget(value.currentTarget),\n ...getOwnProperties(value),\n };\n\n if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n newObj.detail = value.detail;\n }\n\n return newObj;\n } else {\n return value;\n }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target) {\n try {\n return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n } catch (_oO) {\n return '';\n }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj) {\n if (typeof obj === 'object' && obj !== null) {\n var extractedProps = {};\n for (var property in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, property)) {\n extractedProps[property] = (obj )[property];\n }\n }\n return extractedProps;\n } else {\n return {};\n }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nfunction extractExceptionKeysForMessage(exception, maxLength = 40) {\n var keys = Object.keys(convertToPlainObject(exception));\n keys.sort();\n\n if (!keys.length) {\n return '[object has no keys]';\n }\n\n if (keys[0].length >= maxLength) {\n return truncate(keys[0], maxLength);\n }\n\n for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n var serialized = keys.slice(0, includedKeys).join(', ');\n if (serialized.length > maxLength) {\n continue;\n }\n if (includedKeys === keys.length) {\n return serialized;\n }\n return truncate(serialized, maxLength);\n }\n\n return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nfunction dropUndefinedKeys(inputValue) {\n // This map keeps track of what already visited nodes map to.\n // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n // references as the input object.\n var memoizationMap = new Map();\n\n // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\n if (isPlainObject(inputValue)) {\n // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n var memoVal = memoizationMap.get(inputValue);\n if (memoVal !== undefined) {\n return memoVal ;\n }\n\n var returnValue = {};\n // Store the mapping of this value in case we visit it again, in case of circular data\n memoizationMap.set(inputValue, returnValue);\n\n for (var key of Object.keys(inputValue)) {\n if (typeof inputValue[key] !== 'undefined') {\n returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n }\n }\n\n return returnValue ;\n }\n\n if (Array.isArray(inputValue)) {\n // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n var memoVal = memoizationMap.get(inputValue);\n if (memoVal !== undefined) {\n return memoVal ;\n }\n\n var returnValue = [];\n // Store the mapping of this value in case we visit it again, in case of circular data\n memoizationMap.set(inputValue, returnValue);\n\n inputValue.forEach((item) => {\n returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n });\n\n return returnValue ;\n }\n\n return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nfunction objectify(wat) {\n let objectified;\n switch (true) {\n case wat === undefined || wat === null:\n objectified = new String(wat);\n break;\n\n // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n // an object in order to wrap it.\n case typeof wat === 'symbol' || typeof wat === 'bigint':\n objectified = Object(wat);\n break;\n\n // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n case isPrimitive(wat):\n objectified = new (wat ).constructor(wat);\n break;\n\n // by process of elimination, at this point we know that `wat` must already be an object\n default:\n objectified = wat;\n break;\n }\n return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };\n//# sourceMappingURL=object.js.map\n","import { _optionalChain } from './buildPolyfills';\n\nvar STACKTRACE_LIMIT = 50;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n var sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n return (stack, skipFirst = 0) => {\n var frames = [];\n\n for (var line of stack.split('\\n').slice(skipFirst)) {\n for (var parser of sortedParsers) {\n var frame = parser(line);\n\n if (frame) {\n frames.push(frame);\n break;\n }\n }\n }\n\n return stripSentryFramesAndReverse(frames);\n };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n if (Array.isArray(stackParser)) {\n return createStackParser(...stackParser);\n }\n return stackParser;\n}\n\n/**\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n if (!stack.length) {\n return [];\n }\n\n let localStack = stack;\n\n var firstFrameFunction = localStack[0].function || '';\n var lastFrameFunction = localStack[localStack.length - 1].function || '';\n\n // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n localStack = localStack.slice(1);\n }\n\n // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n localStack = localStack.slice(0, -1);\n }\n\n // The frame where the crash happened, should be the last entry in the array\n return localStack\n .slice(0, STACKTRACE_LIMIT)\n .map(frame => ({\n ...frame,\n filename: frame.filename || localStack[0].filename,\n function: frame.function || '?',\n }))\n .reverse();\n}\n\nvar defaultFunctionName = '';\n\n/**\n * Safely extract function name from itself\n */\nfunction getFunctionName(fn) {\n try {\n if (!fn || typeof fn !== 'function') {\n return defaultFunctionName;\n }\n return fn.name || defaultFunctionName;\n } catch (e) {\n // Just accessing custom props in some Selenium environments\n // can cause a \"Permission denied\" exception (see raven-js#495).\n return defaultFunctionName;\n }\n}\n\nfunction node(getModule) {\n var FILENAME_MATCH = /^\\s*[-]{4,}$/;\n var FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\$)?(?:(.+?):(\\d+)(?::(\\d+))?|([^)]+))\$?/;\n\n return (line) => {\n if (line.match(FILENAME_MATCH)) {\n return {\n filename: line,\n };\n }\n\n var lineMatch = line.match(FULL_MATCH);\n if (!lineMatch) {\n return undefined;\n }\n\n let object;\n let method;\n let functionName;\n let typeName;\n let methodName;\n\n if (lineMatch[1]) {\n functionName = lineMatch[1];\n\n let methodStart = functionName.lastIndexOf('.');\n if (functionName[methodStart - 1] === '.') {\n methodStart--;\n }\n\n if (methodStart > 0) {\n object = functionName.substr(0, methodStart);\n method = functionName.substr(methodStart + 1);\n var objectEnd = object.indexOf('.Module');\n if (objectEnd > 0) {\n functionName = functionName.substr(objectEnd + 1);\n object = object.substr(0, objectEnd);\n }\n }\n typeName = undefined;\n }\n\n if (method) {\n typeName = object;\n methodName = method;\n }\n\n if (method === '') {\n methodName = undefined;\n functionName = undefined;\n }\n\n if (functionName === undefined) {\n methodName = methodName || '';\n functionName = typeName ? `${typeName}.${methodName}` : methodName;\n }\n\n var filename = _optionalChain([lineMatch, 'access', _ => _[2], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3('file://')]) ? lineMatch[2].substr(7) : lineMatch[2];\n var isNative = lineMatch[5] === 'native';\n var isInternal =\n isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n // in_app is all that's not an internal Node function or a module within node_modules\n // note that isNative appears to return true even for node core libraries\n // see https://github.com/getsentry/raven-node/issues/176\n var in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n return {\n filename,\n module: _optionalChain([getModule, 'optionalCall', _4 => _4(filename)]),\n function: functionName,\n lineno: parseInt(lineMatch[3], 10) || undefined,\n colno: parseInt(lineMatch[4], 10) || undefined,\n in_app,\n };\n };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nfunction nodeStackLineParser(getModule) {\n return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n if (typeof str !== 'string' || max === 0) {\n return str;\n }\n return str.length <= max ? str : `${str.substr(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n let newLine = line;\n var lineLength = newLine.length;\n if (lineLength <= 150) {\n return newLine;\n }\n if (colno > lineLength) {\n colno = lineLength;\n }\n\n let start = Math.max(colno - 60, 0);\n if (start < 5) {\n start = 0;\n }\n\n let end = Math.min(start + 140, lineLength);\n if (end > lineLength - 5) {\n end = lineLength;\n }\n if (end === lineLength) {\n start = Math.max(end - 140, 0);\n }\n\n newLine = newLine.slice(start, end);\n if (start > 0) {\n newLine = `'{snip} ${newLine}`;\n }\n if (end < lineLength) {\n newLine += ' {snip}';\n }\n\n return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nfunction safeJoin(input, delimiter) {\n if (!Array.isArray(input)) {\n return '';\n }\n\n var output = [];\n for (let i = 0; i < input.length; i++) {\n var value = input[i];\n try {\n output.push(String(value));\n } catch (e) {\n output.push('[value cannot be serialized]');\n }\n }\n\n return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nfunction isMatchingPattern(value, pattern) {\n if (!isString(value)) {\n return false;\n }\n\n if (isRegExp(pattern)) {\n return pattern.test(value);\n }\n if (typeof pattern === 'string') {\n return value.indexOf(pattern) !== -1;\n }\n return false;\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nfunction escapeStringForRegex(regexString) {\n // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, truncate };\n//# sourceMappingURL=string.js.map\n","import { getGlobalObject } from './global.js';\nimport { logger } from './logger.js';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n try {\n new ErrorEvent('');\n return true;\n } catch (e) {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n try {\n // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n // 1 argument required, but only 0 present.\n // @ts-ignore It really needs 1 argument, not 0.\n new DOMError('');\n return true;\n } catch (e) {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n try {\n new DOMException('');\n return true;\n } catch (e) {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n if (!('fetch' in getGlobalObject())) {\n return false;\n }\n\n try {\n new Headers();\n new Request('');\n new Response();\n return true;\n } catch (e) {\n return false;\n }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n return func && /^function fetch\$\$\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n if (!supportsFetch()) {\n return false;\n }\n\n var global = getGlobalObject();\n\n // Fast path to avoid DOM I/O\n if (isNativeFetch(global.fetch)) {\n return true;\n }\n\n // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n // so create a \"pure\" iframe to see if that has native fetch\n let result = false;\n var doc = global.document;\n if (doc && typeof (doc.createElement ) === 'function') {\n try {\n var sandbox = doc.createElement('iframe');\n sandbox.hidden = true;\n doc.head.appendChild(sandbox);\n if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n result = isNativeFetch(sandbox.contentWindow.fetch);\n }\n doc.head.removeChild(sandbox);\n } catch (err) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n }\n }\n\n return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n return 'ReportingObserver' in getGlobalObject();\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReferrerPolicy() {\n // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n // (see https://caniuse.com/#feat=referrer-policy),\n // it doesn't. And it throws an exception instead of ignoring this parameter...\n // REF: https://github.com/getsentry/raven-js/issues/1233\n\n if (!supportsFetch()) {\n return false;\n }\n\n try {\n new Request('_', {\n referrerPolicy: 'origin' ,\n });\n return true;\n } catch (e) {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsHistory() {\n // NOTE: in Chrome App environment, touching history.pushState, *even inside\n // a try/catch block*, will cause Chrome to output an error to console.error\n // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n var global = getGlobalObject();\n var chrome = (global ).chrome;\n var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n\n return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { isThenable } from './is.js';\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n /** Pending */\n var PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n /** Resolved / OK */\n var RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n /** Rejected / Error */\n var REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n return new SyncPromise(resolve => {\n resolve(value);\n });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n return new SyncPromise((_, reject) => {\n reject(reason);\n });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n __init() {this._state = States.PENDING;}\n __init2() {this._handlers = [];}\n \n\n constructor(\n executor,\n ) {;SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);SyncPromise.prototype.__init5.call(this);SyncPromise.prototype.__init6.call(this);\n try {\n executor(this._resolve, this._reject);\n } catch (e) {\n this._reject(e);\n }\n }\n\n /** JSDoc */\n then(\n onfulfilled,\n onrejected,\n ) {\n return new SyncPromise((resolve, reject) => {\n this._handlers.push([\n false,\n result => {\n if (!onfulfilled) {\n // TODO: ¯\\_(ツ)_/¯\n // TODO: FIXME\n resolve(result );\n } else {\n try {\n resolve(onfulfilled(result));\n } catch (e) {\n reject(e);\n }\n }\n },\n reason => {\n if (!onrejected) {\n reject(reason);\n } else {\n try {\n resolve(onrejected(reason));\n } catch (e) {\n reject(e);\n }\n }\n },\n ]);\n this._executeHandlers();\n });\n }\n\n /** JSDoc */\n catch(\n onrejected,\n ) {\n return this.then(val => val, onrejected);\n }\n\n /** JSDoc */\n finally(onfinally) {\n return new SyncPromise((resolve, reject) => {\n let val;\n let isRejected;\n\n return this.then(\n value => {\n isRejected = false;\n val = value;\n if (onfinally) {\n onfinally();\n }\n },\n reason => {\n isRejected = true;\n val = reason;\n if (onfinally) {\n onfinally();\n }\n },\n ).then(() => {\n if (isRejected) {\n reject(val);\n return;\n }\n\n resolve(val );\n });\n });\n }\n\n /** JSDoc */\n __init3() {this._resolve = (value) => {\n this._setResult(States.RESOLVED, value);\n };}\n\n /** JSDoc */\n __init4() {this._reject = (reason) => {\n this._setResult(States.REJECTED, reason);\n };}\n\n /** JSDoc */\n __init5() {this._setResult = (state, value) => {\n if (this._state !== States.PENDING) {\n return;\n }\n\n if (isThenable(value)) {\n void (value ).then(this._resolve, this._reject);\n return;\n }\n\n this._state = state;\n this._value = value;\n\n this._executeHandlers();\n };}\n\n /** JSDoc */\n __init6() {this._executeHandlers = () => {\n if (this._state === States.PENDING) {\n return;\n }\n\n var cachedHandlers = this._handlers.slice();\n this._handlers = [];\n\n cachedHandlers.forEach(handler => {\n if (handler[0]) {\n return;\n }\n\n if (this._state === States.RESOLVED) {\n handler[1](this._value );\n }\n\n if (this._state === States.REJECTED) {\n handler[2](this._value);\n }\n\n handler[0] = true;\n });\n };}\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { getGlobalObject } from './global.js';\nimport { dynamicRequire, isNodeEnv } from './node.js';\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n const { performance } = getGlobalObject();\n if (!performance || !performance.now) {\n return undefined;\n }\n\n // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n //\n // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n // performance.now() gives a date arbitrarily in the past.\n //\n // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n // undefined.\n //\n // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n // interact with data coming out of performance entries.\n //\n // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n // observed skews that can be as long as days, weeks or months.\n //\n // See https://github.com/getsentry/sentry-javascript/issues/2590.\n //\n // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n // transactions of long-lived web pages.\n var timeOrigin = Date.now() - performance.now();\n\n return {\n now: () => performance.now(),\n timeOrigin,\n };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n try {\n var perfHooks = dynamicRequire(module, 'perf_hooks') ;\n return perfHooks.performance;\n } catch (_) {\n return undefined;\n }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nvar timestampSource =\n platformPerformance === undefined\n ? dateTimestampSource\n : {\n nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nvar dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nvar timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nvar timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nvar usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nlet _browserPerformanceTimeOriginMode;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nvar browserPerformanceTimeOrigin = (() => {\n // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n // data as reliable if they are within a reasonable threshold of the current time.\n\n const { performance } = getGlobalObject();\n if (!performance || !performance.now) {\n _browserPerformanceTimeOriginMode = 'none';\n return undefined;\n }\n\n var threshold = 3600 * 1000;\n var performanceNow = performance.now();\n var dateNow = Date.now();\n\n // if timeOrigin isn't available set delta to threshold so it isn't used\n var timeOriginDelta = performance.timeOrigin\n ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n : threshold;\n var timeOriginIsReliable = timeOriginDelta < threshold;\n\n // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n // Date API.\n var navigationStart = performance.timing && performance.timing.navigationStart;\n var hasNavigationStart = typeof navigationStart === 'number';\n // if navigationStart isn't available set delta to threshold so it isn't used\n var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n var navigationStartIsReliable = navigationStartDelta < threshold;\n\n if (timeOriginIsReliable || navigationStartIsReliable) {\n // Use the more reliable time origin\n if (timeOriginDelta <= navigationStartDelta) {\n _browserPerformanceTimeOriginMode = 'timeOrigin';\n return performance.timeOrigin;\n } else {\n _browserPerformanceTimeOriginMode = 'navigationStart';\n return navigationStart;\n }\n }\n\n // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n _browserPerformanceTimeOriginMode = 'dateNow';\n return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };\n//# sourceMappingURL=time.js.map\n","var _global = (typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}); _global.SENTRY_RELEASE={id:\"8231acad724b47551c47a20dd01e44e1c0389aa9\"};","/**\n * https://github.com/gre/bezier-easing\n * BezierEasing - use bezier curve for transition easing function\n * by Gaëtan Renaudeau 2014 - 2015 – MIT License\n */\n\n// These values are established by empiricism with tests (tradeoff: performance VS precision)\nvar NEWTON_ITERATIONS = 4;\nvar NEWTON_MIN_SLOPE = 0.001;\nvar SUBDIVISION_PRECISION = 0.0000001;\nvar SUBDIVISION_MAX_ITERATIONS = 10;\n\nvar kSplineTableSize = 11;\nvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\n\nvar float32ArraySupported = typeof Float32Array === 'function';\n\nfunction A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }\nfunction B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }\nfunction C (aA1) { return 3.0 * aA1; }\n\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nfunction calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }\n\n// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.\nfunction getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }\n\nfunction binarySubdivide (aX, aA, aB, mX1, mX2) {\n var currentX, currentT, i = 0;\n do {\n currentT = aA + (aB - aA) / 2.0;\n currentX = calcBezier(currentT, mX1, mX2) - aX;\n if (currentX > 0.0) {\n aB = currentT;\n } else {\n aA = currentT;\n }\n } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n return currentT;\n}\n\nfunction newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {\n for (var i = 0; i < NEWTON_ITERATIONS; ++i) {\n var currentSlope = getSlope(aGuessT, mX1, mX2);\n if (currentSlope === 0.0) {\n return aGuessT;\n }\n var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n aGuessT -= currentX / currentSlope;\n }\n return aGuessT;\n}\n\nfunction LinearEasing (x) {\n return x;\n}\n\nmodule.exports = function bezier (mX1, mY1, mX2, mY2) {\n if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {\n throw new Error('bezier x values must be in [0, 1] range');\n }\n\n if (mX1 === mY1 && mX2 === mY2) {\n return LinearEasing;\n }\n\n // Precompute samples table\n var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\n for (var i = 0; i < kSplineTableSize; ++i) {\n sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n }\n\n function getTForX (aX) {\n var intervalStart = 0.0;\n var currentSample = 1;\n var lastSample = kSplineTableSize - 1;\n\n for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n intervalStart += kSampleStepSize;\n }\n --currentSample;\n\n // Interpolate to provide an initial guess for t\n var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n var guessForT = intervalStart + dist * kSampleStepSize;\n\n var initialSlope = getSlope(guessForT, mX1, mX2);\n if (initialSlope >= NEWTON_MIN_SLOPE) {\n return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n } else if (initialSlope === 0.0) {\n return guessForT;\n } else {\n return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n }\n }\n\n return function BezierEasing (x) {\n // Because JavaScript number are imprecise, we should guarantee the extremes are right.\n if (x === 0) {\n return 0;\n }\n if (x === 1) {\n return 1;\n }\n return calcBezier(getTForX(x), mY1, mY2);\n };\n};\n","\n (window.__NEXT_P = window.__NEXT_P || []).push([\n \"/_app\",\n function () {\n return require(\"private-next-pages/_app.js\");\n }\n ]);\n if(module.hot) {\n module.hot.dispose(function () {\n window.__NEXT_P.push([\"/_app\"])\n });\n }\n ","import { createContext, useReducer } from 'react';\n\nconst initialState = {\n environment: undefined,\n dynamicGridParam: {}, // store for multiple dynamic grids params grouped by dynamic grid's queryTagsKey\n};\n\nconst reducer = (state, action) => {\n switch (action.type) {\n case 'SET_ENVIRONMENT':\n return {\n ...state,\n environment: action.payload,\n };\n //set a dynamic grid params based on its queryTagsKey (ex. dynamicGridParam.recipe_grid )\n case 'SET_DYNAMIC_GRID_PARAMS':\n return {\n ...state,\n dynamicGridParam: {\n ...state.dynamicGridParam,\n [action.payload.queryTagsKey]: {\n ...state.dynamicGridParam[action.payload.queryTagsKey],\n ...(action.payload.queryTagIds && {\n queryTagIds: action.payload.queryTagIds,\n }),\n ...(action.payload.paginationNo && {\n paginationNo: action.payload.paginationNo,\n }),\n ...(action.payload.paginationLimit && {\n paginationLimit: action.payload.paginationLimit,\n }),\n ...(action.payload.isFiltering !== undefined && {\n isFiltering: action.payload.isFiltering,\n }),\n ...(action.payload.filterParams !== undefined && {\n filterParams: action.payload.filterParams,\n }),\n offset: action.payload.offset,\n },\n },\n };\n }\n};\n\nconst StateContext = createContext(initialState);\nconst DispatchContext = createContext(() => {});\n\nconst ContextProvider = ({ children }) => {\n const [state, dispatch] = useReducer(reducer, initialState);\n\n return (\n \n {children}\n \n );\n};\n\nexport { StateContext, DispatchContext, ContextProvider };\n","import { useRouter } from 'next/router';\nimport { useEffect, useState } from 'react';\nimport { ParallaxProvider } from 'react-scroll-parallax';\nimport Head from 'next/head';\n\nimport { ContextProvider } from '@/context/index';\n\nimport 'swiper/css';\nimport 'swiper/css/autoplay';\nimport 'swiper/css/effect-fade';\nimport 'swiper/css/navigation';\nimport 'swiper/css/pagination';\nimport '../styles/globals.css';\n\nfunction MyApp({ Component, pageProps }) {\n const router = useRouter();\n const [key, setKey] = useState('home');\n useEffect(() => {\n if (router.asPath) {\n const k = router.asPath.split('?')[0];\n setKey(k[1]);\n }\n\n if (window?.history?.scrollRestoration) {\n window.history.scrollRestoration = 'manual';\n }\n }, [router.asPath]);\n\n return (\n <>\n \n \n \n\n \n \n \n \n \n \n );\n}\n\nexport default MyApp;\n","var TRACEPARENT_REGEXP = new RegExp(\n '^[ \\\\t]*' + // whitespace\n '([0-9a-f]{32})?' + // trace_id\n '-?([0-9a-f]{16})?' + // span_id\n '-?([01])?' + // sampled\n '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nfunction extractTraceparentData(traceparent) {\n var matches = traceparent.match(TRACEPARENT_REGEXP);\n if (matches) {\n let parentSampled;\n if (matches[3] === '1') {\n parentSampled = true;\n } else if (matches[3] === '0') {\n parentSampled = false;\n }\n return {\n traceId: matches[1],\n parentSampled,\n parentSpanId: matches[2],\n };\n }\n return undefined;\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData };\n//# sourceMappingURL=tracing.js.map\n","import { getGlobalObject, logger } from '@sentry/utils';\nimport { getActiveTransaction } from '../utils.js';\n\nvar global = getGlobalObject();\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nfunction registerBackgroundTabDetection() {\n if (global && global.document) {\n global.document.addEventListener('visibilitychange', () => {\n var activeTransaction = getActiveTransaction() ;\n if (global.document.hidden && activeTransaction) {\n var statusType = 'cancelled';\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log(\n `[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${activeTransaction.op}`,\n );\n // We should not set status if it is already set, this prevent important statuses like\n // error or data loss from being overwritten on transaction.\n if (!activeTransaction.status) {\n activeTransaction.setStatus(statusType);\n }\n activeTransaction.setTag('visibilitychange', 'document.hidden');\n activeTransaction.finish();\n }\n });\n } else {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n }\n}\n\nexport { registerBackgroundTabDetection };\n//# sourceMappingURL=backgroundtab.js.map\n","var bindReporter = (\n callback,\n metric,\n reportAllChanges,\n) => {\n let prevValue;\n return (forceReport) => {\n if (metric.value >= 0) {\n if (forceReport || reportAllChanges) {\n metric.delta = metric.value - (prevValue || 0);\n\n // Report the metric if there's a non-zero delta or if no previous\n // value exists (which can happen in the case of the document becoming\n // hidden when the metric value is 0).\n // See: https://github.com/GoogleChrome/web-vitals/issues/14\n if (metric.delta || prevValue === undefined) {\n prevValue = metric.value;\n callback(metric);\n }\n }\n }\n };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { generateUniqueID } from './generateUniqueID.js';\n\nvar initMetric = (name, value) => {\n return {\n name,\n value: _nullishCoalesce(value, () => ( -1)),\n delta: 0,\n entries: [],\n id: generateUniqueID(),\n };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\n","/*\n * Copyright 2020 Google LLC\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\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nvar generateUniqueID = () => {\n return `v2-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","/*\n * Copyright 2020 Google LLC\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\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nvar observe = (type, callback) => {\n try {\n if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n // More extensive feature detect needed for Firefox due to:\n // https://github.com/GoogleChrome/web-vitals/issues/142\n if (type === 'first-input' && !('PerformanceEventTiming' in self)) {\n return;\n }\n\n var po = new PerformanceObserver(l => l.getEntries().map(callback));\n\n po.observe({ type, buffered: true });\n return po;\n }\n } catch (e) {\n // Do nothing.\n }\n return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","import { getGlobalObject } from '@sentry/utils';\n\n/*\n * Copyright 2020 Google LLC\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\nvar onHidden = (cb, once) => {\n var onHiddenOrPageHide = (event) => {\n if (event.type === 'pagehide' || getGlobalObject().document.visibilityState === 'hidden') {\n cb(event);\n if (once) {\n removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n removeEventListener('pagehide', onHiddenOrPageHide, true);\n }\n }\n };\n addEventListener('visibilitychange', onHiddenOrPageHide, true);\n // Some browsers have buggy implementations of visibilitychange,\n // so we use pagehide in addition, just to be safe.\n addEventListener('pagehide', onHiddenOrPageHide, true);\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\n","import { getGlobalObject } from '@sentry/utils';\nimport { onHidden } from './onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\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\nlet firstHiddenTime = -1;\n\nvar initHiddenTime = () => {\n return getGlobalObject().document.visibilityState === 'hidden' ? 0 : Infinity;\n};\n\nvar trackChanges = () => {\n // Update the time if/when the document becomes hidden.\n onHidden(({ timeStamp }) => {\n firstHiddenTime = timeStamp;\n }, true);\n};\n\nvar getVisibilityWatcher = (\n\n) => {\n if (firstHiddenTime < 0) {\n // If the document is hidden when this code runs, assume it was hidden\n // since navigation start. This isn't a perfect heuristic, but it's the\n // best we can do until an API is available to support querying past\n // visibilityState.\n firstHiddenTime = initHiddenTime();\n trackChanges();\n }\n return {\n get firstHiddenTime() {\n return firstHiddenTime;\n },\n };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\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\n// https://wicg.github.io/largest-contentful-paint/#sec-largest-contentful-paint-interface\n\nvar reportedMetricIDs = {};\n\nvar getLCP = (onReport, reportAllChanges) => {\n var visibilityWatcher = getVisibilityWatcher();\n var metric = initMetric('LCP');\n let report;\n\n var entryHandler = (entry) => {\n // The startTime attribute returns the value of the renderTime if it is not 0,\n // and the value of the loadTime otherwise.\n var value = entry.startTime;\n\n // If the page was hidden prior to paint time of the entry,\n // ignore it and mark the metric as final, otherwise add the entry.\n if (value < visibilityWatcher.firstHiddenTime) {\n metric.value = value;\n metric.entries.push(entry);\n }\n\n if (report) {\n report();\n }\n };\n\n var po = observe('largest-contentful-paint', entryHandler);\n\n if (po) {\n report = bindReporter(onReport, metric, reportAllChanges);\n\n var stopListening = () => {\n if (!reportedMetricIDs[metric.id]) {\n po.takeRecords().map(entryHandler );\n po.disconnect();\n reportedMetricIDs[metric.id] = true;\n report(true);\n }\n };\n\n // Stop listening after input. Note: while scrolling is an input that\n // stop LCP observation, it's unreliable since it can be programmatically\n // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n ['keydown', 'click'].forEach(type => {\n addEventListener(type, stopListening, { once: true, capture: true });\n });\n\n onHidden(stopListening, true);\n }\n};\n\nexport { getLCP };\n//# sourceMappingURL=getLCP.js.map\n","/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value) {\n return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nfunction _startChild(transaction, { startTimestamp, ...ctx }) {\n if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n transaction.startTimestamp = startTimestamp;\n }\n\n return transaction.startChild({\n startTimestamp,\n ...ctx,\n });\n}\n\nexport { _startChild, isMeasurementValue };\n//# sourceMappingURL=utils.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { getGlobalObject, browserPerformanceTimeOrigin, logger, htmlTreeAsString } from '@sentry/utils';\nimport { msToSec } from '../../utils.js';\nimport { getCLS } from '../web-vitals/getCLS.js';\nimport { getFID } from '../web-vitals/getFID.js';\nimport { getLCP } from '../web-vitals/getLCP.js';\nimport { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher.js';\nimport { _startChild, isMeasurementValue } from './utils.js';\n\nvar global = getGlobalObject();\n\nfunction getBrowserPerformanceAPI() {\n return global && global.addEventListener && global.performance;\n}\n\nlet _performanceCursor = 0;\n\nlet _measurements = {};\nlet _lcpEntry;\nlet _clsEntry;\n\n/**\n * Start tracking web vitals\n */\nfunction startTrackingWebVitals(reportAllChanges = false) {\n var performance = getBrowserPerformanceAPI();\n if (performance && browserPerformanceTimeOrigin) {\n if (performance.mark) {\n global.performance.mark('sentry-tracing-init');\n }\n _trackCLS();\n _trackLCP(reportAllChanges);\n _trackFID();\n }\n}\n\n/** Starts tracking the Cumulative Layout Shift on the current page. */\nfunction _trackCLS() {\n // See:\n // https://web.dev/evolving-cls/\n // https://web.dev/cls-web-tooling/\n getCLS(metric => {\n var entry = metric.entries.pop();\n if (!entry) {\n return;\n }\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS');\n _measurements['cls'] = { value: metric.value, unit: '' };\n _clsEntry = entry ;\n });\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP(reportAllChanges) {\n getLCP(metric => {\n var entry = metric.entries.pop();\n if (!entry) {\n return;\n }\n\n var timeOrigin = msToSec(browserPerformanceTimeOrigin );\n var startTime = msToSec(entry.startTime);\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP');\n _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n _measurements['mark.lcp'] = { value: timeOrigin + startTime, unit: 'second' };\n _lcpEntry = entry ;\n }, reportAllChanges);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n getFID(metric => {\n var entry = metric.entries.pop();\n if (!entry) {\n return;\n }\n\n var timeOrigin = msToSec(browserPerformanceTimeOrigin );\n var startTime = msToSec(entry.startTime);\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FID');\n _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n });\n}\n\n/** Add performance related spans to a transaction */\nfunction addPerformanceEntries(transaction) {\n var performance = getBrowserPerformanceAPI();\n if (!performance || !global.performance.getEntries || !browserPerformanceTimeOrigin) {\n // Gatekeeper if performance API not available\n return;\n }\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n var timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n var performanceEntries = performance.getEntries();\n\n let responseStartTimestamp;\n let requestStartTimestamp;\n\n performanceEntries.slice(_performanceCursor).forEach((entry) => {\n var startTime = msToSec(entry.startTime);\n var duration = msToSec(entry.duration);\n\n if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n return;\n }\n\n switch (entry.entryType) {\n case 'navigation': {\n _addNavigationSpans(transaction, entry, timeOrigin);\n responseStartTimestamp = timeOrigin + msToSec(entry.responseStart);\n requestStartTimestamp = timeOrigin + msToSec(entry.requestStart);\n break;\n }\n case 'mark':\n case 'paint':\n case 'measure': {\n var startTimestamp = _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n\n // capture web vitals\n var firstHidden = getVisibilityWatcher();\n // Only report if the page wasn't hidden prior to the web vital.\n var shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n if (entry.name === 'first-paint' && shouldRecord) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FP');\n _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n _measurements['mark.fp'] = { value: startTimestamp, unit: 'second' };\n }\n if (entry.name === 'first-contentful-paint' && shouldRecord) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FCP');\n _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n _measurements['mark.fcp'] = { value: startTimestamp, unit: 'second' };\n }\n break;\n }\n case 'resource': {\n var resourceName = (entry.name ).replace(global.location.origin, '');\n _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);\n break;\n }\n default:\n // Ignore other entry types.\n }\n });\n\n _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n _trackNavigator(transaction);\n\n // Measurements are only available for pageload transactions\n if (transaction.op === 'pageload') {\n // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the\n // start of the response in milliseconds\n if (typeof responseStartTimestamp === 'number') {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding TTFB');\n _measurements['ttfb'] = {\n value: (responseStartTimestamp - transaction.startTimestamp) * 1000,\n unit: 'millisecond',\n };\n\n if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {\n // Capture the time spent making the request and receiving the first byte of the response.\n // This is the time between the start of the request and the start of the response in milliseconds.\n _measurements['ttfb.requestTime'] = {\n value: (responseStartTimestamp - requestStartTimestamp) * 1000,\n unit: 'millisecond',\n };\n }\n }\n\n ['fcp', 'fp', 'lcp'].forEach(name => {\n if (!_measurements[name] || timeOrigin >= transaction.startTimestamp) {\n return;\n }\n // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n // to be adjusted to be relative to transaction.startTimestamp.\n var oldValue = _measurements[name].value;\n var measurementTimestamp = timeOrigin + msToSec(oldValue);\n\n // normalizedValue should be in milliseconds\n var normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);\n var delta = normalizedValue - oldValue;\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);\n _measurements[name].value = normalizedValue;\n });\n\n if (_measurements['mark.fid'] && _measurements['fid']) {\n // create span for FID\n _startChild(transaction, {\n description: 'first input delay',\n endTimestamp: _measurements['mark.fid'].value + msToSec(_measurements['fid'].value),\n op: 'web.vitals',\n startTimestamp: _measurements['mark.fid'].value,\n });\n }\n\n // If FCP is not recorded we should not record the cls value\n // according to the new definition of CLS.\n if (!('fcp' in _measurements)) {\n delete _measurements.cls;\n }\n\n Object.keys(_measurements).forEach(measurementName => {\n transaction.setMeasurement(\n measurementName,\n _measurements[measurementName].value,\n _measurements[measurementName].unit,\n );\n });\n\n _tagMetricInfo(transaction);\n }\n\n _lcpEntry = undefined;\n _clsEntry = undefined;\n _measurements = {};\n}\n\n/** Create measure related spans */\nfunction _addMeasureSpans(\n transaction,\n entry,\n startTime,\n duration,\n timeOrigin,\n) {\n var measureStartTimestamp = timeOrigin + startTime;\n var measureEndTimestamp = measureStartTimestamp + duration;\n\n _startChild(transaction, {\n description: entry.name ,\n endTimestamp: measureEndTimestamp,\n op: entry.entryType ,\n startTimestamp: measureStartTimestamp,\n });\n\n return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\nfunction _addNavigationSpans(transaction, entry, timeOrigin) {\n ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {\n _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n });\n _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n _addRequest(transaction, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n transaction,\n entry,\n event,\n timeOrigin,\n description,\n eventEnd,\n) {\n var end = eventEnd ? (entry[eventEnd] ) : (entry[`${event}End`] );\n var start = entry[`${event}Start`] ;\n if (!start || !end) {\n return;\n }\n _startChild(transaction, {\n op: 'browser',\n description: _nullishCoalesce(description, () => ( event)),\n startTimestamp: timeOrigin + msToSec(start),\n endTimestamp: timeOrigin + msToSec(end),\n });\n}\n\n/** Create request and response related spans */\nfunction _addRequest(transaction, entry, timeOrigin) {\n _startChild(transaction, {\n op: 'browser',\n description: 'request',\n startTimestamp: timeOrigin + msToSec(entry.requestStart ),\n endTimestamp: timeOrigin + msToSec(entry.responseEnd ),\n });\n\n _startChild(transaction, {\n op: 'browser',\n description: 'response',\n startTimestamp: timeOrigin + msToSec(entry.responseStart ),\n endTimestamp: timeOrigin + msToSec(entry.responseEnd ),\n });\n}\n\n/** Create resource-related spans */\nfunction _addResourceSpans(\n transaction,\n entry,\n resourceName,\n startTime,\n duration,\n timeOrigin,\n) {\n // we already instrument based on fetch and xhr, so we don't need to\n // duplicate spans here.\n if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n return;\n }\n\n var data = {};\n if ('transferSize' in entry) {\n data['Transfer Size'] = entry.transferSize;\n }\n if ('encodedBodySize' in entry) {\n data['Encoded Body Size'] = entry.encodedBodySize;\n }\n if ('decodedBodySize' in entry) {\n data['Decoded Body Size'] = entry.decodedBodySize;\n }\n\n var startTimestamp = timeOrigin + startTime;\n var endTimestamp = startTimestamp + duration;\n\n _startChild(transaction, {\n description: resourceName,\n endTimestamp,\n op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource',\n startTimestamp,\n data,\n });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(transaction) {\n var navigator = global.navigator ;\n if (!navigator) {\n return;\n }\n\n // track network connectivity\n var connection = navigator.connection;\n if (connection) {\n if (connection.effectiveType) {\n transaction.setTag('effectiveConnectionType', connection.effectiveType);\n }\n\n if (connection.type) {\n transaction.setTag('connectionType', connection.type);\n }\n\n if (isMeasurementValue(connection.rtt)) {\n _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n }\n\n if (isMeasurementValue(connection.downlink)) {\n _measurements['connection.downlink'] = { value: connection.downlink, unit: '' }; // unit is empty string for now, while relay doesn't support download speed units\n }\n }\n\n if (isMeasurementValue(navigator.deviceMemory)) {\n transaction.setTag('deviceMemory', `${navigator.deviceMemory} GB`);\n }\n\n if (isMeasurementValue(navigator.hardwareConcurrency)) {\n transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n }\n}\n\n/** Add LCP / CLS data to transaction to allow debugging */\nfunction _tagMetricInfo(transaction) {\n if (_lcpEntry) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP Data');\n\n // Capture Properties of the LCP element that contributes to the LCP.\n\n if (_lcpEntry.element) {\n transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));\n }\n\n if (_lcpEntry.id) {\n transaction.setTag('lcp.id', _lcpEntry.id);\n }\n\n if (_lcpEntry.url) {\n // Trim URL to the first 200 characters.\n transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n }\n\n transaction.setTag('lcp.size', _lcpEntry.size);\n }\n\n // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n if (_clsEntry && _clsEntry.sources) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS Data');\n _clsEntry.sources.forEach((source, index) =>\n transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n );\n }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingWebVitals };\n//# sourceMappingURL=index.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\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\n// https://wicg.github.io/layout-instability/#sec-layout-shift\n\nvar getCLS = (onReport, reportAllChanges) => {\n var metric = initMetric('CLS', 0);\n let report;\n\n let sessionValue = 0;\n let sessionEntries = [];\n\n var entryHandler = (entry) => {\n // Only count layout shifts without recent user input.\n // TODO: Figure out why entry can be undefined\n if (entry && !entry.hadRecentInput) {\n var firstSessionEntry = sessionEntries[0];\n var lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n // If the entry occurred less than 1 second after the previous entry and\n // less than 5 seconds after the first entry in the session, include the\n // entry in the current session. Otherwise, start a new session.\n if (\n sessionValue &&\n sessionEntries.length !== 0 &&\n entry.startTime - lastSessionEntry.startTime < 1000 &&\n entry.startTime - firstSessionEntry.startTime < 5000\n ) {\n sessionValue += entry.value;\n sessionEntries.push(entry);\n } else {\n sessionValue = entry.value;\n sessionEntries = [entry];\n }\n\n // If the current session value is larger than the current CLS value,\n // update CLS and the entries contributing to it.\n if (sessionValue > metric.value) {\n metric.value = sessionValue;\n metric.entries = sessionEntries;\n if (report) {\n report();\n }\n }\n }\n };\n\n var po = observe('layout-shift', entryHandler );\n if (po) {\n report = bindReporter(onReport, metric, reportAllChanges);\n\n onHidden(() => {\n po.takeRecords().map(entryHandler );\n report(true);\n });\n }\n};\n\nexport { getCLS };\n//# sourceMappingURL=getCLS.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\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\nvar getFID = (onReport, reportAllChanges) => {\n var visibilityWatcher = getVisibilityWatcher();\n var metric = initMetric('FID');\n let report;\n\n var entryHandler = (entry) => {\n // Only report if the page wasn't hidden prior to the first input.\n if (report && entry.startTime < visibilityWatcher.firstHiddenTime) {\n metric.value = entry.processingStart - entry.startTime;\n metric.entries.push(entry);\n report(true);\n }\n };\n\n var po = observe('first-input', entryHandler );\n if (po) {\n report = bindReporter(onReport, metric, reportAllChanges);\n onHidden(() => {\n po.takeRecords().map(entryHandler );\n po.disconnect();\n }, true);\n }\n};\n\nexport { getFID };\n//# sourceMappingURL=getFID.js.map\n","import { isMatchingPattern, addInstrumentationHandler, isInstanceOf, BAGGAGE_HEADER_NAME, mergeAndSerializeBaggage } from '@sentry/utils';\nimport { hasTracingEnabled, getActiveTransaction } from '../utils.js';\n\nvar DEFAULT_TRACING_ORIGINS = ['localhost', /^\\//];\n\n/** Options for Request Instrumentation */\n\nvar defaultRequestInstrumentationOptions = {\n traceFetch: true,\n traceXHR: true,\n tracingOrigins: DEFAULT_TRACING_ORIGINS,\n};\n\n/** Registers span creators for xhr and fetch requests */\nfunction instrumentOutgoingRequests(_options) {\n const { traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest } = {\n ...defaultRequestInstrumentationOptions,\n ..._options,\n };\n\n // We should cache url -> decision so that we don't have to compute\n // regexp everytime we create a request.\n var urlMap = {};\n\n var defaultShouldCreateSpan = (url) => {\n if (urlMap[url]) {\n return urlMap[url];\n }\n var origins = tracingOrigins;\n urlMap[url] =\n origins.some((origin) => isMatchingPattern(url, origin)) &&\n !isMatchingPattern(url, 'sentry_key');\n return urlMap[url];\n };\n\n // We want that our users don't have to re-implement shouldCreateSpanForRequest themselves\n // That's why we filter out already unwanted Spans from tracingOrigins\n let shouldCreateSpan = defaultShouldCreateSpan;\n if (typeof shouldCreateSpanForRequest === 'function') {\n shouldCreateSpan = (url) => {\n return defaultShouldCreateSpan(url) && shouldCreateSpanForRequest(url);\n };\n }\n\n var spans = {};\n\n if (traceFetch) {\n addInstrumentationHandler('fetch', (handlerData) => {\n fetchCallback(handlerData, shouldCreateSpan, spans);\n });\n }\n\n if (traceXHR) {\n addInstrumentationHandler('xhr', (handlerData) => {\n xhrCallback(handlerData, shouldCreateSpan, spans);\n });\n }\n}\n\n/**\n * Create and track fetch request spans\n */\nfunction fetchCallback(\n handlerData,\n shouldCreateSpan,\n spans,\n) {\n if (!hasTracingEnabled() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n return;\n }\n\n if (handlerData.endTimestamp) {\n var spanId = handlerData.fetchData.__span;\n if (!spanId) return;\n\n var span = spans[spanId];\n if (span) {\n if (handlerData.response) {\n // TODO (kmclb) remove this once types PR goes through\n span.setHttpStatus(handlerData.response.status);\n } else if (handlerData.error) {\n span.setStatus('internal_error');\n }\n span.finish();\n\n delete spans[spanId];\n }\n return;\n }\n\n var activeTransaction = getActiveTransaction();\n if (activeTransaction) {\n var span = activeTransaction.startChild({\n data: {\n ...handlerData.fetchData,\n type: 'fetch',\n },\n description: `${handlerData.fetchData.method} ${handlerData.fetchData.url}`,\n op: 'http.client',\n });\n\n handlerData.fetchData.__span = span.spanId;\n spans[span.spanId] = span;\n\n var request = (handlerData.args[0] = handlerData.args[0] );\n var options = (handlerData.args[1] = (handlerData.args[1] ) || {});\n options.headers = addTracingHeaders(request, activeTransaction.getBaggage(), span, options);\n }\n}\n\nfunction addTracingHeaders(\n request,\n incomingBaggage,\n span,\n options,\n) {\n let headers = options.headers;\n\n if (isInstanceOf(request, Request)) {\n headers = (request ).headers;\n }\n\n if (headers) {\n if (typeof headers.append === 'function') {\n headers.append('sentry-trace', span.toTraceparent());\n headers.append(BAGGAGE_HEADER_NAME, mergeAndSerializeBaggage(incomingBaggage, headers.get(BAGGAGE_HEADER_NAME)));\n } else if (Array.isArray(headers)) {\n const [, headerBaggageString] = headers.find(([key, _]) => key === BAGGAGE_HEADER_NAME);\n headers = [\n ...headers,\n ['sentry-trace', span.toTraceparent()],\n [BAGGAGE_HEADER_NAME, mergeAndSerializeBaggage(incomingBaggage, headerBaggageString)],\n ];\n } else {\n headers = {\n ...headers,\n 'sentry-trace': span.toTraceparent(),\n baggage: mergeAndSerializeBaggage(incomingBaggage, headers.baggage),\n };\n }\n } else {\n headers = { 'sentry-trace': span.toTraceparent(), baggage: mergeAndSerializeBaggage(incomingBaggage) };\n }\n return headers;\n}\n\n/**\n * Create and track xhr request spans\n */\nfunction xhrCallback(\n handlerData,\n shouldCreateSpan,\n spans,\n) {\n if (\n !hasTracingEnabled() ||\n (handlerData.xhr && handlerData.xhr.__sentry_own_request__) ||\n !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))\n ) {\n return;\n }\n\n var xhr = handlerData.xhr.__sentry_xhr__;\n\n // check first if the request has finished and is tracked by an existing span which should now end\n if (handlerData.endTimestamp) {\n var spanId = handlerData.xhr.__sentry_xhr_span_id__;\n if (!spanId) return;\n\n var span = spans[spanId];\n if (span) {\n span.setHttpStatus(xhr.status_code);\n span.finish();\n\n delete spans[spanId];\n }\n return;\n }\n\n // if not, create a new span to track it\n var activeTransaction = getActiveTransaction();\n if (activeTransaction) {\n var span = activeTransaction.startChild({\n data: {\n ...xhr.data,\n type: 'xhr',\n method: xhr.method,\n url: xhr.url,\n },\n description: `${xhr.method} ${xhr.url}`,\n op: 'http.client',\n });\n\n handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;\n spans[handlerData.xhr.__sentry_xhr_span_id__] = span;\n\n if (handlerData.xhr.setRequestHeader) {\n try {\n handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());\n\n var headerBaggageString =\n handlerData.xhr.getRequestHeader && handlerData.xhr.getRequestHeader(BAGGAGE_HEADER_NAME);\n\n handlerData.xhr.setRequestHeader(\n BAGGAGE_HEADER_NAME,\n mergeAndSerializeBaggage(activeTransaction.getBaggage(), headerBaggageString),\n );\n } catch (_) {\n // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n }\n }\n }\n}\n\nexport { DEFAULT_TRACING_ORIGINS, defaultRequestInstrumentationOptions, fetchCallback, instrumentOutgoingRequests, xhrCallback };\n//# sourceMappingURL=request.js.map\n","import { getGlobalObject, logger, addInstrumentationHandler } from '@sentry/utils';\n\nvar global = getGlobalObject();\n\n/**\n * Default function implementing pageload and navigation transactions\n */\nfunction instrumentRoutingWithDefaults(\n customStartTransaction,\n startTransactionOnPageLoad = true,\n startTransactionOnLocationChange = true,\n) {\n if (!global || !global.location) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Could not initialize routing instrumentation due to invalid location');\n return;\n }\n\n let startingUrl = global.location.href;\n\n let activeTransaction;\n if (startTransactionOnPageLoad) {\n activeTransaction = customStartTransaction({\n name: global.location.pathname,\n op: 'pageload',\n metadata: { source: 'url' },\n });\n }\n\n if (startTransactionOnLocationChange) {\n addInstrumentationHandler('history', ({ to, from }) => {\n /**\n * This early return is there to account for some cases where a navigation transaction starts right after\n * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n * create an uneccessary navigation transaction.\n *\n * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n * only be caused in certain development environments where the usage of a hot module reloader is causing\n * errors.\n */\n if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n startingUrl = undefined;\n return;\n }\n\n if (from !== to) {\n startingUrl = undefined;\n if (activeTransaction) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);\n // If there's an open transaction on the scope, we need to finish it before creating an new one.\n activeTransaction.finish();\n }\n activeTransaction = customStartTransaction({\n name: global.location.pathname,\n op: 'navigation',\n metadata: { source: 'url' },\n });\n }\n });\n }\n}\n\nexport { instrumentRoutingWithDefaults };\n//# sourceMappingURL=router.js.map\n","import { logger, getGlobalObject, extractTraceparentData, parseBaggageSetMutability } from '@sentry/utils';\nimport { startIdleTransaction } from '../hubextensions.js';\nimport { DEFAULT_IDLE_TIMEOUT, DEFAULT_FINAL_TIMEOUT } from '../idletransaction.js';\nimport '../utils.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { startTrackingWebVitals, addPerformanceEntries } from './metrics/index.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\nimport { instrumentRoutingWithDefaults } from './router.js';\n\nvar BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\n/** Options for Browser Tracing integration */\n\nvar DEFAULT_BROWSER_TRACING_OPTIONS = {\n idleTimeout: DEFAULT_IDLE_TIMEOUT,\n finalTimeout: DEFAULT_FINAL_TIMEOUT,\n markBackgroundTransactions: true,\n routingInstrumentation: instrumentRoutingWithDefaults,\n startTransactionOnLocationChange: true,\n startTransactionOnPageLoad: true,\n ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library. This integration uses {@see IdleTransaction} to create transactions.\n */\nclass BrowserTracing {\n // This class currently doesn't have a static `id` field like the other integration classes, because it prevented\n // @sentry/tracing from being treeshaken. Tree shakers do not like static fields, because they behave like side effects.\n // TODO: Come up with a better plan, than using static fields on integration classes, and use that plan on all\n // integrations.\n\n /** Browser Tracing integration options */\n \n\n /**\n * @inheritDoc\n */\n __init() {this.name = BROWSER_TRACING_INTEGRATION_ID;}\n\n constructor(_options) {;BrowserTracing.prototype.__init.call(this);\n let tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins;\n // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances\n if (_options) {\n if (_options.tracingOrigins && Array.isArray(_options.tracingOrigins) && _options.tracingOrigins.length !== 0) {\n tracingOrigins = _options.tracingOrigins;\n } else {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && (this._emitOptionsWarning = true);\n }\n }\n\n this.options = {\n ...DEFAULT_BROWSER_TRACING_OPTIONS,\n ..._options,\n tracingOrigins,\n };\n\n const { _metricOptions } = this.options;\n startTrackingWebVitals(_metricOptions && _metricOptions._reportAllChanges);\n }\n\n /**\n * @inheritDoc\n */\n setupOnce(_, getCurrentHub) {\n this._getCurrentHub = getCurrentHub;\n\n if (this._emitOptionsWarning) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(\n '[Tracing] You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.',\n );\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(\n `[Tracing] We added a reasonable default for you: ${defaultRequestInstrumentationOptions.tracingOrigins}`,\n );\n }\n\n const {\n routingInstrumentation: instrumentRouting,\n startTransactionOnLocationChange,\n startTransactionOnPageLoad,\n markBackgroundTransactions,\n traceFetch,\n traceXHR,\n tracingOrigins,\n shouldCreateSpanForRequest,\n } = this.options;\n\n instrumentRouting(\n (context) => this._createRouteTransaction(context),\n startTransactionOnPageLoad,\n startTransactionOnLocationChange,\n );\n\n if (markBackgroundTransactions) {\n registerBackgroundTabDetection();\n }\n\n instrumentOutgoingRequests({ traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest });\n }\n\n /** Create routing idle transaction. */\n _createRouteTransaction(context) {\n if (!this._getCurrentHub) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(`[Tracing] Did not create ${context.op} transaction because _getCurrentHub is invalid.`);\n return undefined;\n }\n\n const { beforeNavigate, idleTimeout, finalTimeout } = this.options;\n\n var parentContextFromHeader = context.op === 'pageload' ? extractTraceDataFromMetaTags() : undefined;\n\n var expandedContext = {\n ...context,\n ...parentContextFromHeader,\n ...(parentContextFromHeader && {\n metadata: {\n ...context.metadata,\n ...parentContextFromHeader.metadata,\n },\n }),\n trimEnd: true,\n };\n var modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;\n\n // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n // from being sent to Sentry).\n var finalContext = modifiedContext === undefined ? { ...expandedContext, sampled: false } : modifiedContext;\n\n // If `beforeNavigate` set a custom name, record that fact\n finalContext.metadata =\n finalContext.name !== expandedContext.name\n ? { ...finalContext.metadata, source: 'custom' }\n : finalContext.metadata;\n\n if (finalContext.sampled === false) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);\n }\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);\n\n var hub = this._getCurrentHub();\n const { location } = getGlobalObject() ;\n\n var idleTransaction = startIdleTransaction(\n hub,\n finalContext,\n idleTimeout,\n finalTimeout,\n true,\n { location }, // for use in the tracesSampler\n );\n idleTransaction.registerBeforeFinishCallback(transaction => {\n addPerformanceEntries(transaction);\n transaction.setTag(\n 'sentry_reportAllChanges',\n Boolean(this.options._metricOptions && this.options._metricOptions._reportAllChanges),\n );\n });\n\n return idleTransaction ;\n }\n}\n\n/**\n * Gets transaction context data from `sentry-trace` and `baggage` tags.\n * @returns Transaction context data or undefined neither tag exists or has valid data\n */\nfunction extractTraceDataFromMetaTags() {\n var sentrytraceValue = getMetaContent('sentry-trace');\n var baggageValue = getMetaContent('baggage');\n\n var sentrytraceData = sentrytraceValue ? extractTraceparentData(sentrytraceValue) : undefined;\n var baggage = parseBaggageSetMutability(baggageValue, sentrytraceValue);\n\n // TODO more extensive checks for baggage validity/emptyness?\n if (sentrytraceData || baggage) {\n return {\n ...(sentrytraceData && sentrytraceData),\n ...(baggage && { metadata: { baggage } }),\n };\n }\n\n return undefined;\n}\n\n/** Returns the value of a meta tag */\nfunction getMetaContent(metaName) {\n var globalObject = getGlobalObject();\n\n // DOM/querySelector is not available in all environments\n if (globalObject.document && globalObject.document.querySelector) {\n var el = globalObject.document.querySelector(`meta[name=${metaName}]`);\n return el ? el.getAttribute('content') : null;\n } else {\n return null;\n }\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing, extractTraceDataFromMetaTags, getMetaContent };\n//# sourceMappingURL=browsertracing.js.map\n","import { addExtensionMethods } from './hubextensions.js';\nexport { addExtensionMethods, startIdleTransaction } from './hubextensions.js';\nimport * as index from './integrations/index.js';\nexport { index as Integrations };\nimport './browser/index.js';\nexport { Span, spanStatusfromHttpCode } from './span.js';\nexport { SpanStatus } from './spanstatus.js';\nexport { Transaction } from './transaction.js';\nexport { IdleTransaction } from './idletransaction.js';\nexport { getActiveTransaction, hasTracingEnabled } from './utils.js';\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing } from './browser/browsertracing.js';\nexport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './browser/request.js';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n\n;\n;\n\n// Treeshakable guard to remove all code related to tracing\n\n// Guard for tree\nif (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n // We are patching the global object with our hub extension methods\n addExtensionMethods();\n}\n//# sourceMappingURL=index.js.map\n","import { getGlobalObject, stripUrlQueryAndFragment, fill } from '@sentry/utils';\nimport Router from 'next/router';\n\nvar global = getGlobalObject();\n\nvar DEFAULT_TAGS = {\n 'routing.instrumentation': 'next-router',\n} ;\n\nlet activeTransaction = undefined;\nlet prevTransactionName = undefined;\nlet startTransaction = undefined;\n\n/**\n * Creates routing instrumention for Next Router. Only supported for\n * client side routing. Works for Next >= 10.\n *\n * Leverages the SingletonRouter from the `next/router` to\n * generate pageload/navigation transactions and parameterize\n * transaction names.\n */\nfunction nextRouterInstrumentation(\n startTransactionCb,\n startTransactionOnPageLoad = true,\n startTransactionOnLocationChange = true,\n) {\n startTransaction = startTransactionCb;\n Router.ready(() => {\n // We can only start the pageload transaction when we have access to the parameterized\n // route name. Setting the transaction name after the transaction is started could lead\n // to possible race conditions with the router, so this approach was taken.\n if (startTransactionOnPageLoad) {\n var pathIsRoute = Router.route !== null;\n\n prevTransactionName = pathIsRoute ? stripUrlQueryAndFragment(Router.route) : global.location.pathname;\n activeTransaction = startTransactionCb({\n name: prevTransactionName,\n op: 'pageload',\n tags: DEFAULT_TAGS,\n metadata: {\n source: pathIsRoute ? 'route' : 'url',\n },\n });\n }\n\n // Spans that aren't attached to any transaction are lost; so if transactions aren't\n // created (besides potentially the onpageload transaction), no need to wrap the router.\n if (!startTransactionOnLocationChange) return;\n\n // `withRouter` uses `useRouter` underneath:\n // https://github.com/vercel/next.js/blob/de42719619ae69fbd88e445100f15701f6e1e100/packages/next/client/with-router.tsx#L21\n // Router events also use the router:\n // https://github.com/vercel/next.js/blob/de42719619ae69fbd88e445100f15701f6e1e100/packages/next/client/router.ts#L92\n // `Router.changeState` handles the router state changes, so it may be enough to only wrap it\n // (instead of wrapping all of the Router's functions).\n var routerPrototype = Object.getPrototypeOf(Router.router);\n fill(routerPrototype, 'changeState', changeStateWrapper);\n });\n}\n\n/**\n * Wraps Router.changeState()\n * https://github.com/vercel/next.js/blob/da97a18dafc7799e63aa7985adc95f213c2bf5f3/packages/next/next-server/lib/router/router.ts#L1204\n * Start a navigation transaction every time the router changes state.\n */\nfunction changeStateWrapper(originalChangeStateWrapper) {\n var wrapper = function (\n \n method,\n // The parameterized url, ex. posts/[id]/[comment]\n url,\n // The actual url, ex. posts/85/my-comment\n as,\n options,\n // At the moment there are no additional arguments (meaning the rest parameter is empty).\n // This is meant to protect from future additions to Next.js API, especially since this is an\n // internal API.\n ...args\n ) {\n var newTransactionName = stripUrlQueryAndFragment(url);\n // do not start a transaction if it's from the same page\n if (startTransaction !== undefined && prevTransactionName !== newTransactionName) {\n if (activeTransaction) {\n activeTransaction.finish();\n }\n var tags = {\n ...DEFAULT_TAGS,\n method,\n ...options,\n };\n if (prevTransactionName) {\n tags.from = prevTransactionName;\n }\n prevTransactionName = newTransactionName;\n activeTransaction = startTransaction({\n name: prevTransactionName,\n op: 'navigation',\n tags,\n metadata: { source: 'route' },\n });\n }\n return originalChangeStateWrapper.call(this, method, url, as, options, ...args);\n };\n return wrapper;\n}\n\nexport { nextRouterInstrumentation };\n//# sourceMappingURL=client.js.map\n","/**\n * Recursively traverses an object to update an existing nested key.\n * Note: The provided key path must include existing properties,\n * the function will not create objects while traversing.\n *\n * @param obj An object to update\n * @param value The value to update the nested key with\n * @param keyPath The path to the key to update ex. fizz.buzz.foo\n */\nfunction setNestedKey(obj, keyPath, value) {\n // Ex. foo.bar.zoop will extract foo and bar.zoop\n var match = keyPath.match(/([a-z]+)\\.(.*)/i);\n if (match === null) {\n obj[keyPath] = value;\n } else {\n setNestedKey(obj[match[1]], match[2], value);\n }\n}\n\n/**\n * Retrieves the patched integrations with the provided integration.\n *\n * The integration must be present in the final user integrations, and they are compared\n * by integration name. If the user has defined one, there's nothing to patch; if not,\n * the provided integration is added.\n *\n * @param integration The integration to patch, if necessary.\n * @param userIntegrations Integrations defined by the user.\n * @param options options to update for a particular integration\n * @returns Final integrations, patched if necessary.\n */\nfunction addIntegration(\n integration,\n userIntegrations,\n options = {},\n) {\n if (Array.isArray(userIntegrations)) {\n return addIntegrationToArray(integration, userIntegrations, options);\n } else {\n return addIntegrationToFunction(integration, userIntegrations, options);\n }\n}\n\nfunction addIntegrationToArray(\n integration,\n userIntegrations,\n options,\n) {\n let includesName = false;\n for (let x = 0; x < userIntegrations.length; x++) {\n if (userIntegrations[x].name === integration.name) {\n includesName = true;\n }\n\n var op = options[userIntegrations[x].name];\n if (op) {\n setNestedKey(userIntegrations[x], op.keyPath, op.value);\n }\n }\n\n if (includesName) {\n return userIntegrations;\n }\n return [...userIntegrations, integration];\n}\n\nfunction addIntegrationToFunction(\n integration,\n userIntegrationsFunc,\n options,\n) {\n var wrapper = defaultIntegrations => {\n var userFinalIntegrations = userIntegrationsFunc(defaultIntegrations);\n return addIntegrationToArray(integration, userFinalIntegrations, options);\n };\n return wrapper;\n}\n\nexport { addIntegration };\n//# sourceMappingURL=userIntegrations.js.map\n","import { init as init$1, configureScope } from '@sentry/react';\nexport * from '@sentry/react';\nexport { Integrations } from '@sentry/react';\nimport { BrowserTracing, defaultRequestInstrumentationOptions } from '@sentry/tracing';\nexport { BrowserTracing } from '@sentry/tracing';\nimport { nextRouterInstrumentation } from './performance/client.js';\nexport { nextRouterInstrumentation } from './performance/client.js';\nimport { buildMetadata } from './utils/metadata.js';\nimport { addIntegration } from './utils/userIntegrations.js';\nexport { captureUnderscoreErrorException } from './utils/_error.js';\n\n// Treeshakable guard to remove all code related to tracing\n\n/** Inits the Sentry NextJS SDK on the browser with the React SDK. */\nfunction init(options) {\n buildMetadata(options, ['nextjs', 'react']);\n options.environment = options.environment || process.env.NODE_ENV;\n\n let integrations = options.integrations;\n\n // Guard below evaluates to true unless __SENTRY_TRACING__ is text-replaced with \"false\"\n if (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n // Only add BrowserTracing if a tracesSampleRate or tracesSampler is set\n if (options.tracesSampleRate !== undefined || options.tracesSampler !== undefined) {\n integrations = createClientIntegrations(options.integrations);\n }\n }\n\n init$1({\n ...options,\n integrations,\n });\n\n configureScope(scope => {\n scope.setTag('runtime', 'browser');\n var filterTransactions = event =>\n event.type === 'transaction' && event.transaction === '/404' ? null : event;\n filterTransactions.id = 'NextClient404Filter';\n scope.addEventProcessor(filterTransactions);\n });\n}\n\nfunction createClientIntegrations(integrations) {\n var defaultBrowserTracingIntegration = new BrowserTracing({\n tracingOrigins: [...defaultRequestInstrumentationOptions.tracingOrigins, /^(api\\/)/],\n routingInstrumentation: nextRouterInstrumentation,\n });\n\n if (integrations) {\n return addIntegration(defaultBrowserTracingIntegration, integrations, {\n BrowserTracing: { keyPath: 'options.routingInstrumentation', value: nextRouterInstrumentation },\n });\n } else {\n return [defaultBrowserTracingIntegration];\n }\n}\n\nexport { init };\n//# sourceMappingURL=index.client.js.map\n","import { SDK_VERSION } from '@sentry/core';\n\nvar PACKAGE_NAME_PREFIX = 'npm:@sentry/';\n\n/**\n * A builder for the SDK metadata in the options for the SDK initialization.\n * @param options sdk options object that gets mutated\n * @param names list of package names\n */\nfunction buildMetadata(options, names) {\n options._metadata = options._metadata || {};\n options._metadata.sdk =\n options._metadata.sdk ||\n ({\n name: 'sentry.javascript.nextjs',\n packages: names.map(name => ({\n name: `${PACKAGE_NAME_PREFIX}${name}`,\n version: SDK_VERSION,\n })),\n version: SDK_VERSION,\n } );\n}\n\nexport { buildMetadata };\n//# sourceMappingURL=metadata.js.map\n","import { SDK_VERSION, init as init$1 } from '@sentry/browser';\n\n/**\n * Inits the React SDK\n */\nfunction init(options) {\n options._metadata = options._metadata || {};\n options._metadata.sdk = options._metadata.sdk || {\n name: 'sentry.javascript.react',\n packages: [\n {\n name: 'npm:@sentry/react',\n version: SDK_VERSION,\n },\n ],\n version: SDK_VERSION,\n };\n init$1(options);\n}\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n","// This file configures the initialization of Sentry on the browser.\n// The config you add here will be used whenever a page is visited.\n// https://docs.sentry.io/platforms/javascript/guides/nextjs/\n\nimport * as Sentry from '@sentry/nextjs';\n\nconst SENTRY_DSN = process.env.SENTRY_DSN || process.env.NEXT_PUBLIC_SENTRY_DSN;\n\nSentry.init({\n dsn: SENTRY_DSN || 'https://ee557f44152b4c54940205c27aae727c@o1302711.ingest.sentry.io/6540720',\n // Adjust this value in production, or use tracesSampler for greater control\n tracesSampleRate: 1.0,\n environment: process.env.NEXT_PUBLIC_APP_ENV + '-nextjs-client',\n // ...\n // Note: if you want to override the automatic release value, do not set a\n // `release` value here - use the environment variable `SENTRY_RELEASE`, so\n // that it will also get attached to your source maps\n});\n","module.exports = require('./dist/shared/lib/head')\n","module.exports = require('./dist/client/router')\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","import bezier from 'bezier-easing';\n\nvar Limits = function Limits(properties) {\n this.startX = properties.startX;\n this.startY = properties.startY;\n this.endX = properties.endX;\n this.endY = properties.endY; // Used to calculate the progress of the element\n\n this.totalX = this.endX - this.startX;\n this.totalY = this.endY - this.startY; // Used to scale translate effects\n\n this.startMultiplierX = properties.startMultiplierX || 1;\n this.endMultiplierX = properties.endMultiplierX || 1;\n this.startMultiplierY = properties.startMultiplierY || 1;\n this.endMultiplierY = properties.endMultiplierY || 1;\n};\n\nfunction _extends() {\n _extends = Object.assign || function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n\n return target;\n };\n\n return _extends.apply(this, arguments);\n}\n\nvar ValidCSSEffects;\n\n(function (ValidCSSEffects) {\n ValidCSSEffects[\"speed\"] = \"speed\";\n ValidCSSEffects[\"translateX\"] = \"translateX\";\n ValidCSSEffects[\"translateY\"] = \"translateY\";\n ValidCSSEffects[\"rotate\"] = \"rotate\";\n ValidCSSEffects[\"rotateX\"] = \"rotateX\";\n ValidCSSEffects[\"rotateY\"] = \"rotateY\";\n ValidCSSEffects[\"rotateZ\"] = \"rotateZ\";\n ValidCSSEffects[\"scale\"] = \"scale\";\n ValidCSSEffects[\"scaleX\"] = \"scaleX\";\n ValidCSSEffects[\"scaleY\"] = \"scaleY\";\n ValidCSSEffects[\"scaleZ\"] = \"scaleZ\";\n ValidCSSEffects[\"opacity\"] = \"opacity\";\n})(ValidCSSEffects || (ValidCSSEffects = {}));\n\nvar Units;\n\n(function (Units) {\n Units[\"px\"] = \"px\";\n Units[\"%\"] = \"%\";\n Units[\"vh\"] = \"vh\";\n Units[\"vw\"] = \"vw\";\n})(Units || (Units = {}));\n\nvar RotationUnits;\n\n(function (RotationUnits) {\n RotationUnits[\"deg\"] = \"deg\";\n RotationUnits[\"turn\"] = \"turn\";\n RotationUnits[\"rad\"] = \"rad\";\n})(RotationUnits || (RotationUnits = {}));\n\nvar ScaleUnits;\n\n(function (ScaleUnits) {\n ScaleUnits[\"\"] = \"\";\n})(ScaleUnits || (ScaleUnits = {}));\n\nvar ScrollAxis;\n\n(function (ScrollAxis) {\n ScrollAxis[\"vertical\"] = \"vertical\";\n ScrollAxis[\"horizontal\"] = \"horizontal\";\n})(ScrollAxis || (ScrollAxis = {}));\n\nvar EasingPreset;\n\n(function (EasingPreset) {\n EasingPreset[\"ease\"] = \"ease\";\n EasingPreset[\"easeIn\"] = \"easeIn\";\n EasingPreset[\"easeOut\"] = \"easeOut\";\n EasingPreset[\"easeInOut\"] = \"easeInOut\";\n EasingPreset[\"easeInQuad\"] = \"easeInQuad\";\n EasingPreset[\"easeInCubic\"] = \"easeInCubic\";\n EasingPreset[\"easeInQuart\"] = \"easeInQuart\";\n EasingPreset[\"easeInQuint\"] = \"easeInQuint\";\n EasingPreset[\"easeInSine\"] = \"easeInSine\";\n EasingPreset[\"easeInExpo\"] = \"easeInExpo\";\n EasingPreset[\"easeInCirc\"] = \"easeInCirc\";\n EasingPreset[\"easeOutQuad\"] = \"easeOutQuad\";\n EasingPreset[\"easeOutCubic\"] = \"easeOutCubic\";\n EasingPreset[\"easeOutQuart\"] = \"easeOutQuart\";\n EasingPreset[\"easeOutQuint\"] = \"easeOutQuint\";\n EasingPreset[\"easeOutSine\"] = \"easeOutSine\";\n EasingPreset[\"easeOutExpo\"] = \"easeOutExpo\";\n EasingPreset[\"easeOutCirc\"] = \"easeOutCirc\";\n EasingPreset[\"easeInOutQuad\"] = \"easeInOutQuad\";\n EasingPreset[\"easeInOutCubic\"] = \"easeInOutCubic\";\n EasingPreset[\"easeInOutQuart\"] = \"easeInOutQuart\";\n EasingPreset[\"easeInOutQuint\"] = \"easeInOutQuint\";\n EasingPreset[\"easeInOutSine\"] = \"easeInOutSine\";\n EasingPreset[\"easeInOutExpo\"] = \"easeInOutExpo\";\n EasingPreset[\"easeInOutCirc\"] = \"easeInOutCirc\";\n EasingPreset[\"easeInBack\"] = \"easeInBack\";\n EasingPreset[\"easeOutBack\"] = \"easeOutBack\";\n EasingPreset[\"easeInOutBack\"] = \"easeInOutBack\";\n})(EasingPreset || (EasingPreset = {}));\n\n/**\r\n * Creates a unique id to distinguish parallax elements.\r\n */\nvar id = 0;\nfunction createId() {\n ++id;\n return id;\n}\n\nvar Rect = /*#__PURE__*/function () {\n function Rect(options) {\n var rect = options.el.getBoundingClientRect(); // rect is based on viewport -- must adjust for relative scroll container\n\n if (options.view.scrollContainer) {\n var scrollRect = options.view.scrollContainer.getBoundingClientRect();\n rect = _extends({}, rect, {\n top: rect.top - scrollRect.top,\n right: rect.right - scrollRect.left,\n bottom: rect.bottom - scrollRect.top,\n left: rect.left - scrollRect.left\n });\n }\n\n this.height = options.el.offsetHeight;\n this.width = options.el.offsetWidth;\n this.left = rect.left;\n this.right = rect.right;\n this.top = rect.top;\n this.bottom = rect.bottom;\n\n if (options.rootMargin) {\n this._setRectWithRootMargin(options.rootMargin);\n }\n }\n /**\r\n * Apply root margin to all properties\r\n */\n\n\n var _proto = Rect.prototype;\n\n _proto._setRectWithRootMargin = function _setRectWithRootMargin(rootMargin) {\n var totalRootY = rootMargin.top + rootMargin.bottom;\n var totalRootX = rootMargin.left + rootMargin.right;\n this.top -= rootMargin.top;\n this.right += rootMargin.right;\n this.bottom += rootMargin.bottom;\n this.left -= rootMargin.left;\n this.height += totalRootY;\n this.width += totalRootX;\n };\n\n return Rect;\n}();\n\nvar VALID_UNITS = [ScaleUnits[''], Units.px, Units['%'], Units['vh'], Units['vw'], RotationUnits.deg, RotationUnits.turn, RotationUnits.rad];\n/**\r\n * Determines the unit of a string and parses the value\r\n */\n\nfunction parseValueAndUnit(str, defaultUnit) {\n if (defaultUnit === void 0) {\n defaultUnit = Units['%'];\n }\n\n var out = {\n value: 0,\n unit: defaultUnit\n };\n if (typeof str === 'undefined') return out;\n var isValid = typeof str === 'number' || typeof str === 'string';\n\n if (!isValid) {\n throw new Error('Invalid value provided. Must provide a value as a string or number');\n }\n\n str = String(str);\n out.value = parseFloat(str); // @ts-ignore\n\n out.unit = str.match(/[\\d.\\-+]*\\s*(.*)/)[1] || defaultUnit; // @ts-expect-error\n\n var isValidUnit = VALID_UNITS.includes(out.unit);\n\n if (!isValidUnit) {\n throw new Error('Invalid unit provided.');\n }\n\n return out;\n}\n\nvar easingPresets = {\n ease: [0.25, 0.1, 0.25, 1.0],\n easeIn: [0.42, 0.0, 1.0, 1.0],\n easeOut: [0.0, 0.0, 0.58, 1.0],\n easeInOut: [0.42, 0.0, 0.58, 1.0],\n\n /* Ease IN curves */\n easeInQuad: [0.55, 0.085, 0.68, 0.53],\n easeInCubic: [0.55, 0.055, 0.675, 0.19],\n easeInQuart: [0.895, 0.03, 0.685, 0.22],\n easeInQuint: [0.755, 0.05, 0.855, 0.06],\n easeInSine: [0.47, 0.0, 0.745, 0.715],\n easeInExpo: [0.95, 0.05, 0.795, 0.035],\n easeInCirc: [0.6, 0.04, 0.98, 0.335],\n\n /* Ease Out Curves */\n easeOutQuad: [0.25, 0.46, 0.45, 0.94],\n easeOutCubic: [0.215, 0.61, 0.355, 1.0],\n easeOutQuart: [0.165, 0.84, 0.44, 1.0],\n easeOutQuint: [0.23, 1.0, 0.32, 1.0],\n easeOutSine: [0.39, 0.575, 0.565, 1.0],\n easeOutExpo: [0.19, 1.0, 0.22, 1.0],\n easeOutCirc: [0.075, 0.82, 0.165, 1.0],\n\n /* Ease IN Out Curves */\n easeInOutQuad: [0.455, 0.03, 0.515, 0.955],\n easeInOutCubic: [0.645, 0.045, 0.355, 1.0],\n easeInOutQuart: [0.77, 0.0, 0.175, 1.0],\n easeInOutQuint: [0.86, 0.0, 0.07, 1.0],\n easeInOutSine: [0.445, 0.05, 0.55, 0.95],\n easeInOutExpo: [1.0, 0.0, 0.0, 1.0],\n easeInOutCirc: [0.785, 0.135, 0.15, 0.86],\n\n /* Ease Bounce Curves */\n easeInBack: [0.6, -0.28, 0.735, 0.045],\n easeOutBack: [0.175, 0.885, 0.32, 1.275],\n easeInOutBack: [0.68, -0.55, 0.265, 1.55]\n};\n\nfunction createEasingFunction(easing) {\n if (Array.isArray(easing)) {\n return bezier(easing[0], easing[1], easing[2], easing[3]);\n }\n\n if (typeof easing === 'string' && typeof easingPresets[easing] !== 'undefined') {\n var params = easingPresets[easing];\n return bezier(params[0], params[1], params[2], params[3]);\n }\n\n return;\n}\n\nvar PARALLAX_EFFECTS = /*#__PURE__*/Object.values(ValidCSSEffects);\nvar MAP_EFFECT_TO_DEFAULT_UNIT = {\n speed: 'px',\n translateX: '%',\n translateY: '%',\n rotate: 'deg',\n rotateX: 'deg',\n rotateY: 'deg',\n rotateZ: 'deg',\n scale: '',\n scaleX: '',\n scaleY: '',\n scaleZ: '',\n opacity: ''\n};\n/**\r\n * Takes a parallax element effects and parses the properties to get the start and end values and units.\r\n */\n\nfunction parseElementTransitionEffects(props, scrollAxis) {\n var parsedEffects = {};\n PARALLAX_EFFECTS.forEach(function (key) {\n var defaultValue = MAP_EFFECT_TO_DEFAULT_UNIT[key]; // If the provided type is a number, this must be the speed prop\n // in which case we need to construct the proper translate config\n\n if (typeof (props == null ? void 0 : props[key]) === 'number') {\n var value = props == null ? void 0 : props[key];\n var startSpeed = (value || 0) * 10 + \"px\";\n var endSpeed = (value || 0) * -10 + \"px\";\n var startParsed = parseValueAndUnit(startSpeed);\n var endParsed = parseValueAndUnit(endSpeed);\n var speedConfig = {\n start: startParsed.value,\n end: endParsed.value,\n unit: startParsed.unit\n }; // Manually set translate y value\n\n if (scrollAxis === ScrollAxis.vertical) {\n parsedEffects.translateY = speedConfig;\n } // Manually set translate y value\n\n\n if (scrollAxis === ScrollAxis.horizontal) {\n parsedEffects.translateX = speedConfig;\n }\n } // The rest are standard effect being parsed\n\n\n if (Array.isArray(props == null ? void 0 : props[key])) {\n var _value = props == null ? void 0 : props[key];\n\n if (typeof _value[0] !== 'undefined' && typeof _value[1] !== 'undefined') {\n var _startParsed = parseValueAndUnit(_value == null ? void 0 : _value[0], defaultValue);\n\n var _endParsed = parseValueAndUnit(_value == null ? void 0 : _value[1], defaultValue);\n\n var easing = createEasingFunction(_value == null ? void 0 : _value[2]);\n parsedEffects[key] = {\n start: _startParsed.value,\n end: _endParsed.value,\n unit: _startParsed.unit,\n easing: easing\n };\n\n if (_startParsed.unit !== _endParsed.unit) {\n throw new Error('Must provide matching units for the min and max offset values of each axis.');\n }\n }\n }\n });\n return parsedEffects;\n}\n\n/**\r\n * Returns the percent (0 - 100) moved based on position in the viewport\r\n */\nfunction getProgressAmount(\n/*\r\n * The start value from cache\r\n */\nstart,\n/*\r\n * total dist the element has to move to be 100% complete (view width/height + element width/height)\r\n */\ntotalDist,\n/*\r\n * Current scroll value\r\n */\ncurrentScroll,\n/*\r\n * an optional easing function to apply\r\n */\neasing) {\n // adjust cached value\n var startAdjustedScroll = currentScroll - start; // Amount the element has moved based on current and total distance to move\n\n var amount = startAdjustedScroll / totalDist; // Apply bezier easing if provided\n\n if (easing) {\n amount = easing(amount);\n }\n\n return amount;\n}\n\n/**\r\n * Takes two values (start, end) and returns whether the current scroll is within range\r\n * @param {number} start - start of scroll (x/y)\r\n * @param {number} end - end of scroll (x/y)\r\n * @param {number} scroll - current scroll (x/y)\r\n * @return {boolean} isInView\r\n */\nfunction isElementInView(start, end, scroll) {\n var isInView = scroll >= start && scroll <= end;\n return isInView;\n}\n\n// Scale between AKA normalize\nfunction scaleBetween(value, newMin, newMax, oldMin, oldMax) {\n return (newMax - newMin) * (value - oldMin) / (oldMax - oldMin) + newMin;\n}\n\n/**\r\n * Scales a start and end value of an effect based on percent moved and easing function\r\n */\n\nfunction scaleEffectByProgress(effect, progress) {\n var value = scaleBetween(typeof effect.easing === 'function' ? effect.easing(progress) : progress, (effect == null ? void 0 : effect.start) || 0, (effect == null ? void 0 : effect.end) || 0, 0, 1);\n return {\n value: value,\n unit: effect == null ? void 0 : effect.unit\n };\n}\n\nvar TRANSFORM_EFFECTS = /*#__PURE__*/Object.values(ValidCSSEffects).filter(function (v) {\n return v !== 'opacity';\n});\nfunction setWillChangeStyles(el, effects) {\n var keys = Object.keys(effects);\n var hasOpacity = keys.includes('opacity');\n var willChange = \"transform\" + (hasOpacity ? ',opacity' : '');\n el.style.willChange = willChange;\n}\nfunction setElementStyles(effects, progress, el) {\n if (!el) return;\n var transform = getTransformStyles(effects, progress);\n var opacity = getOpacityStyles(effects, progress);\n el.style.transform = transform;\n el.style.opacity = opacity;\n}\nfunction getOpacityStyles(effects, progress) {\n var scaledOpacity = effects['opacity'] && scaleEffectByProgress(effects['opacity'], progress);\n\n if (typeof scaledOpacity === 'undefined' || typeof scaledOpacity.value === 'undefined' || typeof scaledOpacity.unit === 'undefined') {\n return '';\n }\n\n var styleStr = \"\" + scaledOpacity.value;\n return styleStr;\n}\nfunction getTransformStyles(effects, progress) {\n var transform = TRANSFORM_EFFECTS.reduce(function (acc, key) {\n var scaledEffect = // @ts-expect-error\n effects[key] && scaleEffectByProgress(effects[key], progress);\n\n if (typeof scaledEffect === 'undefined' || typeof scaledEffect.value === 'undefined' || typeof scaledEffect.unit === 'undefined') {\n return acc;\n }\n\n var styleStr = key + \"(\" + scaledEffect.value + scaledEffect.unit + \")\";\n return acc + styleStr;\n }, '');\n return transform;\n}\n/**\r\n * Takes a parallax element and removes parallax offset styles.\r\n * @param {object} element\r\n */\n\nfunction resetStyles(element) {\n var el = element.el;\n if (!el) return;\n el.style.transform = '';\n el.style.opacity = '';\n}\n\nfunction createLimitsForRelativeElements(rect, view, scroll, shouldAlwaysCompleteAnimation) {\n var startY = rect.top - view.height;\n var startX = rect.left - view.width;\n var endY = rect.bottom;\n var endX = rect.right; // add scroll\n\n startX += scroll.x;\n endX += scroll.x;\n startY += scroll.y;\n endY += scroll.y;\n\n if (shouldAlwaysCompleteAnimation) {\n if (scroll.y + rect.top < view.height) {\n startY = 0;\n }\n\n if (scroll.x + rect.left < view.width) {\n startX = 0;\n }\n\n if (endY > view.scrollHeight - view.height) {\n endY = view.scrollHeight - view.height;\n }\n\n if (endX > view.scrollWidth - view.width) {\n endX = view.scrollWidth - view.width;\n }\n }\n\n var limits = new Limits({\n startX: startX,\n startY: startY,\n endX: endX,\n endY: endY\n });\n return limits;\n}\n\nfunction getTranslateScalar(startTranslatePx, endTranslatePx, totalDist) {\n var slow = endTranslatePx > startTranslatePx; // calculating necessary scale to increase translations\n\n var totalAbsOff = (Math.abs(startTranslatePx) + Math.abs(endTranslatePx)) * (slow ? -1 : 1);\n var totalDistTrue = totalDist + totalAbsOff; // Determine multiple to scale by, only values greater than 1\n\n var scale = Math.max(totalDist / totalDistTrue, 1);\n return scale;\n}\n\n/**\r\n * Return the start and end pixel values for an elements translations\r\n */\nfunction getStartEndValueInPx(translate, elementSize) {\n var start = translate.start,\n end = translate.end,\n unit = translate.unit;\n\n if (unit === '%') {\n var scale = elementSize / 100;\n start = start * scale;\n end = end * scale;\n }\n\n if (unit === 'vw') {\n var startScale = start / 100;\n var endScale = end / 100;\n start = window.innerWidth * startScale;\n end = window.innerWidth * endScale;\n }\n\n if (unit === 'vh') {\n var _startScale = start / 100;\n\n var _endScale = end / 100;\n\n start = window.innerHeight * _startScale;\n end = window.innerHeight * _endScale;\n }\n\n return {\n start: start,\n end: end\n };\n}\n\nvar DEFAULT_VALUE = {\n start: 0,\n end: 0,\n unit: ''\n};\nfunction createLimitsWithTranslationsForRelativeElements(rect, view, effects, scroll, scrollAxis, shouldAlwaysCompleteAnimation) {\n // get start and end accounting for percent effects\n var translateX = effects.translateX || DEFAULT_VALUE;\n var translateY = effects.translateY || DEFAULT_VALUE;\n\n var _getStartEndValueInPx = getStartEndValueInPx(translateX, rect.width),\n startTranslateXPx = _getStartEndValueInPx.start,\n endTranslateXPx = _getStartEndValueInPx.end;\n\n var _getStartEndValueInPx2 = getStartEndValueInPx(translateY, rect.height),\n startTranslateYPx = _getStartEndValueInPx2.start,\n endTranslateYPx = _getStartEndValueInPx2.end; // default starting values\n\n\n var startY = rect.top - view.height;\n var startX = rect.left - view.width;\n var endY = rect.bottom;\n var endX = rect.right;\n var startMultiplierY = 1;\n var endMultiplierY = 1;\n\n if (scrollAxis === ScrollAxis.vertical) {\n startMultiplierY = getTranslateScalar(startTranslateYPx, endTranslateYPx, view.height + rect.height);\n endMultiplierY = startMultiplierY;\n }\n\n var startMultiplierX = 1;\n var endMultiplierX = 1;\n\n if (scrollAxis === ScrollAxis.horizontal) {\n startMultiplierX = getTranslateScalar(startTranslateXPx, endTranslateXPx, view.width + rect.width);\n endMultiplierX = startMultiplierX;\n } // Apply the scale to initial values\n\n\n if (startTranslateYPx < 0) {\n startY = startY + startTranslateYPx * startMultiplierY;\n }\n\n if (endTranslateYPx > 0) {\n endY = endY + endTranslateYPx * endMultiplierY;\n }\n\n if (startTranslateXPx < 0) {\n startX = startX + startTranslateXPx * startMultiplierX;\n }\n\n if (endTranslateXPx > 0) {\n endX = endX + endTranslateXPx * endMultiplierX;\n } // add scroll\n\n\n startX += scroll.x;\n endX += scroll.x;\n startY += scroll.y;\n endY += scroll.y; // NOTE: please refactor and isolate this :(\n\n if (shouldAlwaysCompleteAnimation) {\n var topBeginsInView = scroll.y + rect.top < view.height;\n var leftBeginsInView = scroll.x + rect.left < view.width;\n var bottomEndsInView = scroll.y + rect.bottom > view.scrollHeight - view.height;\n var rightEndsInView = scroll.x + rect.right > view.scrollWidth - view.height;\n\n if (topBeginsInView && bottomEndsInView) {\n startMultiplierY = 1;\n endMultiplierY = 1;\n startY = 0;\n endY = view.scrollHeight - view.height;\n }\n\n if (leftBeginsInView && rightEndsInView) {\n startMultiplierX = 1;\n endMultiplierX = 1;\n startX = 0;\n endX = view.scrollWidth - view.width;\n }\n\n if (!topBeginsInView && bottomEndsInView) {\n startY = rect.top - view.height + scroll.y;\n endY = view.scrollHeight - view.height;\n var totalDist = endY - startY;\n startMultiplierY = getTranslateScalar(startTranslateYPx, endTranslateYPx, totalDist);\n endMultiplierY = 1;\n\n if (startTranslateYPx < 0) {\n startY = startY + startTranslateYPx * startMultiplierY;\n }\n }\n\n if (!leftBeginsInView && rightEndsInView) {\n startX = rect.left - view.width + scroll.x;\n endX = view.scrollWidth - view.width;\n\n var _totalDist = endX - startX;\n\n startMultiplierX = getTranslateScalar(startTranslateXPx, endTranslateXPx, _totalDist);\n endMultiplierX = 1;\n\n if (startTranslateXPx < 0) {\n startX = startX + startTranslateXPx * startMultiplierX;\n }\n }\n\n if (topBeginsInView && !bottomEndsInView) {\n startY = 0;\n endY = rect.bottom + scroll.y;\n\n var _totalDist2 = endY - startY;\n\n startMultiplierY = 1;\n endMultiplierY = getTranslateScalar(startTranslateYPx, endTranslateYPx, _totalDist2);\n\n if (endTranslateYPx > 0) {\n endY = endY + endTranslateYPx * endMultiplierY;\n }\n }\n\n if (leftBeginsInView && !rightEndsInView) {\n startX = 0;\n endX = rect.right + scroll.x;\n\n var _totalDist3 = endX - startX;\n\n startMultiplierX = 1;\n endMultiplierX = getTranslateScalar(startTranslateXPx, endTranslateXPx, _totalDist3);\n\n if (endTranslateXPx > 0) {\n endX = endX + endTranslateXPx * endMultiplierX;\n }\n }\n }\n\n var limits = new Limits({\n startX: startX,\n startY: startY,\n endX: endX,\n endY: endY,\n startMultiplierX: startMultiplierX,\n endMultiplierX: endMultiplierX,\n startMultiplierY: startMultiplierY,\n endMultiplierY: endMultiplierY\n });\n return limits;\n}\n\nfunction scaleTranslateEffectsForSlowerScroll(effects, limits) {\n var effectsCopy = _extends({}, effects);\n\n if (effectsCopy.translateX) {\n effectsCopy.translateX = _extends({}, effects.translateX, {\n start: effectsCopy.translateX.start * limits.startMultiplierX,\n end: effectsCopy.translateX.end * limits.endMultiplierX\n });\n }\n\n if (effectsCopy.translateY) {\n effectsCopy.translateY = _extends({}, effects.translateY, {\n start: effectsCopy.translateY.start * limits.startMultiplierY,\n end: effectsCopy.translateY.end * limits.endMultiplierY\n });\n }\n\n return effectsCopy;\n}\n\nfunction getShouldScaleTranslateEffects(props, effects, scrollAxis) {\n if (props.rootMargin || props.targetElement || props.shouldDisableScalingTranslations) {\n return false;\n }\n\n if (!!effects.translateX && scrollAxis === ScrollAxis.horizontal || !!effects.translateY && scrollAxis === ScrollAxis.vertical) {\n return true;\n }\n\n return false;\n}\n\nvar clamp = function clamp(num, min, max) {\n return Math.min(Math.max(num, min), max);\n};\n\nvar Element = /*#__PURE__*/function () {\n function Element(options) {\n this.el = options.el;\n this.props = options.props;\n this.scrollAxis = options.scrollAxis;\n this.id = createId();\n this.effects = parseElementTransitionEffects(this.props, this.scrollAxis);\n this.isInView = null;\n this.progress = 0;\n\n this._setElementEasing(options.props.easing);\n\n setWillChangeStyles(options.el, this.effects);\n }\n\n var _proto = Element.prototype;\n\n _proto.updateProps = function updateProps(nextProps) {\n this.props = _extends({}, this.props, nextProps);\n this.effects = parseElementTransitionEffects(nextProps, this.scrollAxis);\n\n this._setElementEasing(nextProps.easing);\n\n return this;\n };\n\n _proto.setCachedAttributes = function setCachedAttributes(view, scroll) {\n // NOTE: Must reset styles before getting the rect, as it might impact the natural position\n resetStyles(this);\n this.rect = new Rect({\n el: this.props.targetElement || this.el,\n rootMargin: this.props.rootMargin,\n view: view\n });\n var shouldScaleTranslateEffects = getShouldScaleTranslateEffects(this.props, this.effects, this.scrollAxis);\n\n if (typeof this.props.startScroll === 'number' && typeof this.props.endScroll === 'number') {\n this.limits = new Limits({\n startX: this.props.startScroll,\n startY: this.props.startScroll,\n endX: this.props.endScroll,\n endY: this.props.endScroll\n }); // Undo the reset -- place it back at current position with styles\n\n this._setElementStyles();\n\n return this;\n }\n\n if (shouldScaleTranslateEffects) {\n this.limits = createLimitsWithTranslationsForRelativeElements(this.rect, view, this.effects, scroll, this.scrollAxis, this.props.shouldAlwaysCompleteAnimation);\n this.scaledEffects = scaleTranslateEffectsForSlowerScroll(this.effects, this.limits);\n } else {\n this.limits = createLimitsForRelativeElements(this.rect, view, scroll, this.props.shouldAlwaysCompleteAnimation);\n } // Undo the reset -- place it back at current position with styles\n\n\n this._setElementStyles();\n\n return this;\n };\n\n _proto._updateElementIsInView = function _updateElementIsInView(nextIsInView) {\n // NOTE: Check if this is the first change to make sure onExit isn't called\n var isFirstChange = this.isInView === null;\n\n if (nextIsInView !== this.isInView) {\n if (nextIsInView) {\n this.props.onEnter && this.props.onEnter(this);\n } else if (!isFirstChange) {\n this._setFinalProgress();\n\n this._setElementStyles();\n\n this.props.onExit && this.props.onExit(this);\n }\n }\n\n this.isInView = nextIsInView;\n };\n\n _proto._setFinalProgress = function _setFinalProgress() {\n var finalProgress = clamp(Math.round(this.progress), 0, 1);\n\n this._updateElementProgress(finalProgress);\n };\n\n _proto._setElementStyles = function _setElementStyles() {\n if (this.props.disabled) return;\n var effects = this.scaledEffects || this.effects;\n setElementStyles(effects, this.progress, this.el);\n };\n\n _proto._updateElementProgress = function _updateElementProgress(nextProgress) {\n this.progress = nextProgress;\n this.props.onProgressChange && this.props.onProgressChange(this.progress);\n this.props.onChange && this.props.onChange(this);\n };\n\n _proto._setElementEasing = function _setElementEasing(easing) {\n this.easing = createEasingFunction(easing);\n };\n\n _proto.updatePosition = function updatePosition(scroll) {\n if (!this.limits) return this;\n var isVertical = this.scrollAxis === ScrollAxis.vertical;\n var isFirstChange = this.isInView === null; // based on scroll axis\n\n var start = isVertical ? this.limits.startY : this.limits.startX;\n var end = isVertical ? this.limits.endY : this.limits.endX;\n var total = isVertical ? this.limits.totalY : this.limits.totalX;\n var s = isVertical ? scroll.y : scroll.x; // check if in view\n\n var nextIsInView = isElementInView(start, end, s);\n\n this._updateElementIsInView(nextIsInView); // set the progress if in view or this is the first change\n\n\n if (nextIsInView) {\n var nextProgress = getProgressAmount(start, total, s, this.easing);\n\n this._updateElementProgress(nextProgress);\n\n this._setElementStyles();\n } else if (isFirstChange) {\n // NOTE: this._updateElementProgress -- dont use this because it will trigger onChange\n this.progress = clamp(Math.round(getProgressAmount(start, total, s, this.easing)), 0, 1);\n\n this._setElementStyles();\n }\n\n return this;\n };\n\n return Element;\n}();\n\nvar View = /*#__PURE__*/function () {\n function View(config) {\n this.scrollContainer = config.scrollContainer;\n this.width = config.width;\n this.height = config.height;\n this.scrollHeight = config.scrollHeight;\n this.scrollWidth = config.scrollWidth;\n }\n\n var _proto = View.prototype;\n\n _proto.hasChanged = function hasChanged(params) {\n if (params.width !== this.width || params.height !== this.height || params.scrollWidth !== this.scrollWidth || params.scrollHeight !== this.scrollHeight) {\n return true;\n }\n\n return false;\n };\n\n _proto.setSize = function setSize(params) {\n this.width = params.width;\n this.height = params.height;\n this.scrollHeight = params.scrollHeight;\n this.scrollWidth = params.scrollWidth;\n return this;\n };\n\n return View;\n}();\n\nvar Scroll = /*#__PURE__*/function () {\n function Scroll(x, y) {\n this.x = x;\n this.y = y;\n this.dx = 0;\n this.dy = 0;\n }\n\n var _proto = Scroll.prototype;\n\n _proto.setScroll = function setScroll(x, y) {\n this.dx = x - this.x;\n this.dy = y - this.y;\n this.x = x;\n this.y = y;\n return this;\n };\n\n return Scroll;\n}();\n\nfunction testForPassiveScroll() {\n var supportsPassiveOption = false;\n\n try {\n var opts = Object.defineProperty({}, 'passive', {\n get: function get() {\n supportsPassiveOption = true;\n return true;\n }\n }); // @ts-expect-error\n\n window.addEventListener('test', null, opts); // @ts-expect-error\n\n window.removeEventListener('test', null, opts);\n } catch (e) {}\n\n return supportsPassiveOption;\n}\n\n/**\r\n * -------------------------------------------------------\r\n * Parallax Controller\r\n * -------------------------------------------------------\r\n *\r\n * The global controller for setting up and managing a scroll view of elements.\r\n *\r\n */\n\nvar ParallaxController = /*#__PURE__*/function () {\n function ParallaxController(_ref) {\n var _ref$scrollAxis = _ref.scrollAxis,\n scrollAxis = _ref$scrollAxis === void 0 ? ScrollAxis.vertical : _ref$scrollAxis,\n scrollContainer = _ref.scrollContainer;\n this.scrollAxis = scrollAxis; // All parallax elements to be updated\n\n this.elements = [];\n this._hasScrollContainer = !!scrollContainer;\n this.viewEl = scrollContainer != null ? scrollContainer : window; // Scroll and View\n\n var _this$_getScrollPosit = this._getScrollPosition(),\n x = _this$_getScrollPosit[0],\n y = _this$_getScrollPosit[1];\n\n this.scroll = new Scroll(x, y);\n this.view = new View({\n width: 0,\n height: 0,\n scrollWidth: 0,\n scrollHeight: 0,\n scrollContainer: this._hasScrollContainer ? scrollContainer : undefined\n }); // Ticking\n\n this._ticking = false; // Passive support\n\n this._supportsPassive = testForPassiveScroll(); // Bind methods to class\n\n this._bindAllMethods();\n\n this._addListeners(this.viewEl);\n\n this._addResizeObserver();\n\n this._setViewSize();\n }\n /**\r\n * Static method to instantiate the ParallaxController.\r\n * @returns {Class} ParallaxController\r\n */\n\n\n ParallaxController.init = function init(options) {\n var hasWindow = typeof window !== 'undefined';\n\n if (!hasWindow) {\n throw new Error('Looks like ParallaxController.init() was called on the server. This method must be called on the client.');\n }\n\n return new ParallaxController(options);\n };\n\n var _proto = ParallaxController.prototype;\n\n _proto._bindAllMethods = function _bindAllMethods() {\n var _this = this;\n\n ['_addListeners', '_removeListeners', '_getScrollPosition', '_handleScroll', '_handleUpdateCache', '_updateAllElements', '_updateElementPosition', '_setViewSize', '_addResizeObserver', '_checkIfViewHasChanged', '_getViewParams', 'getElements', 'createElement', 'removeElementById', 'resetElementStyles', 'updateElementPropsById', 'update', 'updateScrollContainer', 'destroy'].forEach(function (method) {\n // @ts-expect-error\n _this[method] = _this[method].bind(_this);\n });\n };\n\n _proto._addListeners = function _addListeners(el) {\n el.addEventListener('scroll', this._handleScroll, this._supportsPassive ? {\n passive: true\n } : false);\n window.addEventListener('resize', this._handleUpdateCache, false);\n window.addEventListener('blur', this._handleUpdateCache, false);\n window.addEventListener('focus', this._handleUpdateCache, false);\n window.addEventListener('load', this._handleUpdateCache, false);\n };\n\n _proto._removeListeners = function _removeListeners(el) {\n var _this$_resizeObserver;\n\n el.removeEventListener('scroll', this._handleScroll, false);\n window.removeEventListener('resize', this._handleUpdateCache, false);\n window.removeEventListener('blur', this._handleUpdateCache, false);\n window.removeEventListener('focus', this._handleUpdateCache, false);\n window.removeEventListener('load', this._handleUpdateCache, false);\n (_this$_resizeObserver = this._resizeObserver) == null ? void 0 : _this$_resizeObserver.disconnect();\n };\n\n _proto._addResizeObserver = function _addResizeObserver() {\n var _this2 = this;\n\n try {\n var observedEl = this._hasScrollContainer ? this.viewEl : document.documentElement;\n this._resizeObserver = new ResizeObserver(function () {\n return _this2.update();\n });\n\n this._resizeObserver.observe(observedEl);\n } catch (e) {\n console.warn('Failed to create the resize observer in the ParallaxContoller');\n }\n };\n\n _proto._getScrollPosition = function _getScrollPosition() {\n // Save current scroll\n // Supports IE 9 and up.\n var nx = this._hasScrollContainer ? // @ts-expect-error\n this.viewEl.scrollLeft : window.pageXOffset;\n var ny = this._hasScrollContainer ? // @ts-expect-error\n this.viewEl.scrollTop : window.pageYOffset;\n return [nx, ny];\n }\n /**\r\n * Window scroll handler sets scroll position\r\n * and then calls '_updateAllElements()'.\r\n */\n ;\n\n _proto._handleScroll = function _handleScroll() {\n var _this$_getScrollPosit2 = this._getScrollPosition(),\n nx = _this$_getScrollPosit2[0],\n ny = _this$_getScrollPosit2[1];\n\n this.scroll.setScroll(nx, ny); // Only called if the last animation request has been\n // completed and there are parallax elements to update\n\n if (!this._ticking && this.elements.length > 0) {\n this._ticking = true; // @ts-ignore\n\n window.requestAnimationFrame(this._updateAllElements);\n }\n }\n /**\r\n * Window resize handler. Sets the new window inner height\r\n * then updates parallax element attributes and positions.\r\n */\n ;\n\n _proto._handleUpdateCache = function _handleUpdateCache() {\n this._setViewSize();\n\n this._updateAllElements({\n updateCache: true\n });\n }\n /**\r\n * Update element positions.\r\n * Determines if the element is in view based on the cached\r\n * attributes, if so set the elements parallax styles.\r\n */\n ;\n\n _proto._updateAllElements = function _updateAllElements(_temp) {\n var _this3 = this;\n\n var _ref2 = _temp === void 0 ? {} : _temp,\n updateCache = _ref2.updateCache;\n\n if (this.elements) {\n this.elements.forEach(function (element) {\n if (updateCache) {\n element.setCachedAttributes(_this3.view, _this3.scroll);\n }\n\n _this3._updateElementPosition(element);\n });\n } // reset ticking so more animations can be called\n\n\n this._ticking = false;\n }\n /**\r\n * Update element positions.\r\n * Determines if the element is in view based on the cached\r\n * attributes, if so set the elements parallax styles.\r\n */\n ;\n\n _proto._updateElementPosition = function _updateElementPosition(element) {\n if (element.props.disabled) return;\n element.updatePosition(this.scroll);\n }\n /**\r\n * Gets the params to set in the View from the scroll container or the window\r\n */\n ;\n\n _proto._getViewParams = function _getViewParams() {\n if (this._hasScrollContainer) {\n // @ts-expect-error\n var _width = this.viewEl.offsetWidth; // @ts-expect-error\n\n var _height = this.viewEl.offsetHeight; // @ts-expect-error\n\n var _scrollHeight = this.viewEl.scrollHeight; // @ts-expect-error\n\n var _scrollWidth = this.viewEl.scrollWidth;\n return this.view.setSize({\n width: _width,\n height: _height,\n scrollHeight: _scrollHeight,\n scrollWidth: _scrollWidth\n });\n }\n\n var html = document.documentElement;\n var width = window.innerWidth || html.clientWidth;\n var height = window.innerHeight || html.clientHeight;\n var scrollHeight = html.scrollHeight;\n var scrollWidth = html.scrollWidth;\n return {\n width: width,\n height: height,\n scrollHeight: scrollHeight,\n scrollWidth: scrollWidth\n };\n }\n /**\r\n * Cache the view attributes\r\n */\n ;\n\n _proto._setViewSize = function _setViewSize() {\n return this.view.setSize(this._getViewParams());\n }\n /**\r\n * Checks if any of the cached attributes of the view have changed.\r\n * @returns boolean\r\n */\n ;\n\n _proto._checkIfViewHasChanged = function _checkIfViewHasChanged() {\n return this.view.hasChanged(this._getViewParams());\n }\n /**\r\n * -------------------------------------------------------\r\n * Public methods\r\n * -------------------------------------------------------\r\n */\n\n /**\r\n * Returns all the parallax elements in the controller\r\n */\n ;\n\n _proto.getElements = function getElements() {\n return this.elements;\n }\n /**\r\n * Creates and returns new parallax element with provided options to be managed by the controller.\r\n */\n ;\n\n _proto.createElement = function createElement(options) {\n var newElement = new Element(_extends({}, options, {\n scrollAxis: this.scrollAxis\n }));\n newElement.setCachedAttributes(this.view, this.scroll);\n this.elements = this.elements ? [].concat(this.elements, [newElement]) : [newElement];\n\n this._updateElementPosition(newElement); // NOTE: This checks if the view has changed then update the controller and all elements if it has\n // This shouldn't always be necessary with a resize observer watching the view element\n // but there seems to be cases where the resize observer does not catch and update.\n\n\n if (this._checkIfViewHasChanged()) {\n this.update();\n }\n\n return newElement;\n }\n /**\r\n * Remove an element by id\r\n */\n ;\n\n _proto.removeElementById = function removeElementById(id) {\n if (!this.elements) return;\n this.elements = this.elements.filter(function (el) {\n return el.id !== id;\n });\n }\n /**\r\n * Updates an existing parallax element object with new options.\r\n */\n ;\n\n _proto.updateElementPropsById = function updateElementPropsById(id, props) {\n if (this.elements) {\n this.elements = this.elements.map(function (el) {\n if (el.id === id) {\n return el.updateProps(props);\n }\n\n return el;\n });\n }\n\n this.update();\n }\n /**\r\n * Remove a target elements parallax styles\r\n */\n ;\n\n _proto.resetElementStyles = function resetElementStyles(element) {\n resetStyles(element);\n }\n /**\r\n * Updates all cached attributes on parallax elements.\r\n */\n ;\n\n _proto.update = function update() {\n // Save the latest scroll position because window.scroll\n // may be called and the handle scroll event may not be called.\n var _this$_getScrollPosit3 = this._getScrollPosition(),\n nx = _this$_getScrollPosit3[0],\n ny = _this$_getScrollPosit3[1];\n\n this.scroll.setScroll(nx, ny);\n\n this._setViewSize();\n\n this._updateAllElements({\n updateCache: true\n });\n }\n /**\r\n * Updates the scroll container of the parallax controller\r\n */\n ;\n\n _proto.updateScrollContainer = function updateScrollContainer(el) {\n // remove existing listeners with current el first\n this._removeListeners(this.viewEl);\n\n this.viewEl = el;\n this._hasScrollContainer = !!el;\n this.view = new View({\n width: 0,\n height: 0,\n scrollWidth: 0,\n scrollHeight: 0,\n scrollContainer: el\n });\n\n this._setViewSize();\n\n this._addListeners(this.viewEl);\n\n this._updateAllElements({\n updateCache: true\n });\n }\n /**\r\n * Removes all listeners and resets all styles on managed elements.\r\n */\n ;\n\n _proto.destroy = function destroy() {\n this._removeListeners(this.viewEl);\n\n if (this.elements) {\n this.elements.forEach(function (element) {\n return resetStyles(element);\n });\n } // @ts-expect-error\n\n\n this.elements = undefined;\n };\n\n return ParallaxController;\n}();\n\nexport { EasingPreset, Element, Limits, ParallaxController, Rect, RotationUnits, ScaleUnits, Scroll, ScrollAxis, Units, ValidCSSEffects, View, createId, getProgressAmount, isElementInView, parseElementTransitionEffects, parseValueAndUnit, resetStyles, scaleBetween, scaleEffectByProgress, setElementStyles, testForPassiveScroll };\n//# sourceMappingURL=parallax-controller.esm.js.map\n","import { ParallaxController, parseValueAndUnit, ScrollAxis } from 'parallax-controller';\nexport { EasingPreset } from 'parallax-controller';\nimport React, { useEffect, useContext, useRef, useState, Component } from 'react';\n\nfunction _extends() {\n _extends = Object.assign || function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n\n return target;\n };\n\n return _extends.apply(this, arguments);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n subClass.prototype = Object.create(superClass.prototype);\n subClass.prototype.constructor = subClass;\n\n _setPrototypeOf(subClass, superClass);\n}\n\nfunction _setPrototypeOf(o, p) {\n _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n o.__proto__ = p;\n return o;\n };\n\n return _setPrototypeOf(o, p);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n if (source == null) return {};\n var target = {};\n var sourceKeys = Object.keys(source);\n var key, i;\n\n for (i = 0; i < sourceKeys.length; i++) {\n key = sourceKeys[i];\n if (excluded.indexOf(key) >= 0) continue;\n target[key] = source[key];\n }\n\n return target;\n}\n\nfunction removeUndefinedObjectKeys(obj) {\n Object.keys(obj).forEach(function (key) {\n return obj[key] === undefined ? delete obj[key] : {};\n });\n return obj;\n}\n\nvar _excluded = [\"disabled\", \"easing\", \"endScroll\", \"onChange\", \"onEnter\", \"onExit\", \"onProgressChange\", \"opacity\", \"rootMargin\", \"rotate\", \"rotateX\", \"rotateY\", \"rotateZ\", \"scale\", \"scaleX\", \"scaleY\", \"scaleZ\", \"shouldAlwaysCompleteAnimation\", \"shouldDisableScalingTranslations\", \"speed\", \"startScroll\", \"targetElement\", \"translateX\", \"translateY\"];\nfunction getIsolatedParallaxProps(props) {\n var disabled = props.disabled,\n easing = props.easing,\n endScroll = props.endScroll,\n onChange = props.onChange,\n onEnter = props.onEnter,\n onExit = props.onExit,\n onProgressChange = props.onProgressChange,\n opacity = props.opacity,\n rootMargin = props.rootMargin,\n rotate = props.rotate,\n rotateX = props.rotateX,\n rotateY = props.rotateY,\n rotateZ = props.rotateZ,\n scale = props.scale,\n scaleX = props.scaleX,\n scaleY = props.scaleY,\n scaleZ = props.scaleZ,\n shouldAlwaysCompleteAnimation = props.shouldAlwaysCompleteAnimation,\n shouldDisableScalingTranslations = props.shouldDisableScalingTranslations,\n speed = props.speed,\n startScroll = props.startScroll,\n targetElement = props.targetElement,\n translateX = props.translateX,\n translateY = props.translateY,\n rest = _objectWithoutPropertiesLoose(props, _excluded);\n\n var parallaxProps = removeUndefinedObjectKeys({\n disabled: disabled,\n easing: easing,\n endScroll: endScroll,\n onChange: onChange,\n onEnter: onEnter,\n onExit: onExit,\n onProgressChange: onProgressChange,\n opacity: opacity,\n rootMargin: rootMargin,\n rotate: rotate,\n rotateX: rotateX,\n rotateY: rotateY,\n rotateZ: rotateZ,\n scale: scale,\n scaleX: scaleX,\n scaleY: scaleY,\n scaleZ: scaleZ,\n shouldAlwaysCompleteAnimation: shouldAlwaysCompleteAnimation,\n shouldDisableScalingTranslations: shouldDisableScalingTranslations,\n speed: speed,\n startScroll: startScroll,\n targetElement: targetElement,\n translateX: translateX,\n translateY: translateY\n });\n return {\n parallaxProps: parallaxProps,\n rest: rest\n };\n}\n\nfunction useVerifyController(controller) {\n useEffect(function () {\n var isServer = typeof window === 'undefined'; // Make sure the provided controller is an instance of the Parallax Controller\n\n var isInstance = controller instanceof ParallaxController; // Throw if neither context or global is available\n\n if (!isServer && !controller && !isInstance) {\n throw new Error(\"Must wrap your application's components in a .\");\n }\n }, [controller]);\n}\n\nvar ParallaxContext = /*#__PURE__*/React.createContext(null);\n\nfunction useParallaxController() {\n var parallaxController = useContext(ParallaxContext);\n var isServer = typeof window === 'undefined';\n\n if (isServer) {\n return null;\n }\n\n if (!parallaxController) {\n throw new Error('Could not find `react-scroll-parallax` context value. Please ensure the component is wrapped in a ');\n }\n\n return parallaxController;\n}\n\nfunction useParallax(props) {\n var controller = useParallaxController();\n var ref = useRef(null);\n\n var _getIsolatedParallaxP = getIsolatedParallaxProps(props),\n parallaxProps = _getIsolatedParallaxP.parallaxProps;\n\n useVerifyController(controller);\n\n var _useState = useState(),\n element = _useState[0],\n setElement = _useState[1]; // create element\n\n\n useEffect(function () {\n var newElement;\n\n if (ref.current instanceof HTMLElement) {\n var options = {\n el: ref.current,\n props: parallaxProps\n };\n newElement = controller == null ? void 0 : controller.createElement(options);\n setElement(newElement);\n } else {\n throw new Error('You must assign the ref returned by the useParallax() hook to an HTML Element.');\n }\n\n return function () {\n if (newElement) {\n controller == null ? void 0 : controller.removeElementById(newElement.id);\n }\n };\n }, []); // update element\n\n useEffect(function () {\n if (element) {\n if (props.disabled) {\n controller == null ? void 0 : controller.resetElementStyles(element);\n controller == null ? void 0 : controller.updateElementPropsById(element.id, parallaxProps);\n } else {\n controller == null ? void 0 : controller.updateElementPropsById(element.id, parallaxProps);\n }\n }\n }, [props.disabled, props.easing, props.endScroll, props.onChange, props.onEnter, props.onExit, props.onProgressChange, props.opacity, props.rootMargin, props.rotate, props.rotateX, props.rotateY, props.rotateZ, props.scale, props.scaleX, props.scaleY, props.scaleZ, props.shouldAlwaysCompleteAnimation, props.shouldDisableScalingTranslations, props.speed, props.startScroll, props.targetElement, props.translateX, props.translateY]);\n return {\n ref: ref,\n controller: controller,\n element: element\n };\n}\n\nfunction Parallax(props) {\n var _getIsolatedParallaxP = getIsolatedParallaxProps(props),\n parallaxProps = _getIsolatedParallaxP.parallaxProps,\n rest = _getIsolatedParallaxP.rest;\n\n var _useParallax = useParallax(parallaxProps),\n ref = _useParallax.ref;\n\n return React.createElement(\"div\", Object.assign({\n ref: ref\n }, rest), props.children);\n}\n\nvar FALLBACK_RECT = {\n height: 0\n};\nfunction getExpandedStyle(layer) {\n if (Array.isArray(layer.translateY)) {\n var translateYStart = parseValueAndUnit(layer.translateY[0]);\n var translateYEnd = parseValueAndUnit(layer.translateY[1]);\n\n if (translateYStart.unit === 'px' && translateYEnd.unit === 'px') {\n return {\n top: Math.abs(translateYEnd.value) * -1 + \"px\",\n bottom: Math.abs(translateYStart.value) * -1 + \"px\"\n };\n }\n\n if (translateYStart.unit === '%' && translateYEnd.unit === '%') {\n var _layer$targetElement;\n\n var clientRect = ((_layer$targetElement = layer.targetElement) == null ? void 0 : _layer$targetElement.getBoundingClientRect()) || FALLBACK_RECT;\n var top = Math.abs(clientRect.height * 0.01 * translateYEnd.value) * -1;\n var bottom = Math.abs(clientRect.height * 0.01 * translateYStart.value) * -1;\n return {\n top: top + \"px\",\n bottom: bottom + \"px\"\n };\n }\n }\n\n if (layer.speed) {\n var speed = layer.speed || 0;\n return {\n top: Math.abs(speed) * 10 * -1 + 'px',\n bottom: Math.abs(speed) * 10 * -1 + 'px'\n };\n }\n\n return {};\n}\n\nfunction getImageStyle(layer) {\n return layer.image ? {\n backgroundImage: \"url(\" + layer.image + \")\",\n backgroundPosition: 'center',\n backgroundSize: 'cover'\n } : {};\n}\n\nvar _excluded$1 = [\"children\", \"disabled\", \"style\", \"expanded\", \"image\", \"testId\"];\nvar absoluteStyle = {\n position: 'absolute',\n top: 0,\n left: 0,\n right: 0,\n bottom: 0\n};\nvar ParallaxBannerLayer = function ParallaxBannerLayer(props) {\n var _getIsolatedParallaxP = getIsolatedParallaxProps(props),\n parallaxProps = _getIsolatedParallaxP.parallaxProps,\n rest = _getIsolatedParallaxP.rest;\n\n var style = rest.style,\n _rest$expanded = rest.expanded,\n expanded = _rest$expanded === void 0 ? true : _rest$expanded,\n testId = rest.testId,\n divProps = _objectWithoutPropertiesLoose(rest, _excluded$1);\n\n var imageStyle = getImageStyle(props);\n var expandedStyle = expanded ? getExpandedStyle(props) : {};\n var parallax = useParallax(_extends({\n targetElement: props.targetElement,\n shouldDisableScalingTranslations: true\n }, parallaxProps));\n return React.createElement(\"div\", Object.assign({\n \"data-testid\": testId,\n ref: parallax.ref,\n style: _extends({}, imageStyle, absoluteStyle, expandedStyle, style)\n }, divProps), rest.children);\n};\n\nvar _excluded$2 = [\"disabled\", \"style\", \"layers\"];\nvar containerStyle = {\n position: 'relative',\n overflow: 'hidden',\n width: '100%'\n};\nvar ParallaxBanner = function ParallaxBanner(props) {\n var _useState = useState(null),\n targetElement = _useState[0],\n setTargetElement = _useState[1];\n\n var containerRef = useRef(null);\n useEffect(function () {\n setTargetElement(containerRef.current);\n }, []);\n\n var rootStyle = props.style,\n _props$layers = props.layers,\n layers = _props$layers === void 0 ? [] : _props$layers,\n rootRest = _objectWithoutPropertiesLoose(props, _excluded$2);\n\n function renderLayers() {\n if (targetElement) {\n var shouldUseLayers = layers && layers.length > 0;\n\n if (shouldUseLayers) {\n return layers.map(function (layer, i) {\n return React.createElement(ParallaxBannerLayer, Object.assign({}, layer, {\n targetElement: targetElement,\n key: \"layer-\" + i,\n testId: \"layer-\" + i\n }));\n });\n }\n }\n\n return null;\n }\n\n function renderChildren() {\n if (targetElement) {\n return React.Children.map(props.children, function (child) {\n var item = child; // adds the targetElement prop to any ParallaxBannerLayer components\n\n if (item.type === ParallaxBannerLayer) {\n var clone = React.cloneElement(item, {\n targetElement: targetElement\n });\n return clone;\n }\n\n return child;\n });\n }\n\n return null;\n }\n\n return React.createElement(\"div\", Object.assign({\n ref: containerRef,\n style: _extends({}, containerStyle, rootStyle)\n }, rootRest), renderLayers(), renderChildren());\n};\n\nvar createController = function createController(options) {\n // Don't initialize on the server\n var isServer = typeof window === 'undefined';\n\n if (!isServer) {\n // Must not be the server so kick it off...\n return ParallaxController.init(options);\n }\n\n return null;\n};\n\nvar ParallaxProvider = /*#__PURE__*/function (_Component) {\n _inheritsLoose(ParallaxProvider, _Component);\n\n function ParallaxProvider(props) {\n var _this;\n\n _this = _Component.call(this, props) || this;\n _this.controller = createController({\n scrollAxis: props.scrollAxis,\n scrollContainer: props.scrollContainer\n });\n return _this;\n }\n\n var _proto = ParallaxProvider.prototype;\n\n _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n if (prevProps.scrollContainer !== this.props.scrollContainer) {\n // @ts-ignore\n this.controller.updateScrollContainer(this.props.scrollContainer);\n }\n };\n\n _proto.componentWillUnmount = function componentWillUnmount() {\n // @ts-ignore\n this.controller = this.controller.destroy();\n };\n\n _proto.render = function render() {\n var children = this.props.children;\n return (// @ts-ignore\n React.createElement(ParallaxContext.Provider, {\n value: this.controller\n }, children)\n );\n };\n\n return ParallaxProvider;\n}(Component);\nParallaxProvider.defaultProps = {\n scrollAxis: ScrollAxis.vertical\n};\n\nexport { Parallax, ParallaxBanner, ParallaxContext, ParallaxProvider, useParallax, useParallaxController };\n//# sourceMappingURL=react-scroll-parallax.esm.js.map\n","export default function _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n}\n","import defineProperty from './_define_property.mjs';\n\nexport default function _objectSpread(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n var ownKeys = Object.keys(source);\n\n if (typeof Object.getOwnPropertySymbols === 'function') {\n ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n }));\n }\n\n ownKeys.forEach(function (key) {\n defineProperty(target, key, source[key]);\n });\n }\n\n return target;\n}","function ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly) {\n symbols = symbols.filter(function (sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n });\n }\n keys.push.apply(keys, symbols);\n }\n return keys;\n}\n\nexport default function _objectSpreadProps(target, source) {\n source = source != null ? source : {}\n if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(\n target,\n key,\n Object.getOwnPropertyDescriptor(source, key)\n );\n });\n }\n\n return target;\n}"],"names":["DEFAULT_IGNORE_ERRORS","InboundFilters","static","this","id","__init","name","constructor","_options","prototype","call","setupOnce","addGlobalEventProcessor","getCurrentHub","eventProcess","event","hub","self","getIntegration","client","getClient","clientOptions","getOptions","options","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","undefined","_mergeOptions","exception","values","type","e","_isSentryError","__SENTRY_DEBUG__","length","message","value","oO","_getPossibleEventMessages","some","pattern","_isIgnoredError","url","_getEventFilterUrl","_isDeniedUrl","_isAllowedUrl","_shouldDropEvent","frames","stacktrace","i","frame","filename","_getLastValidUrl","__initStatic","originalFunctionToString","FunctionToString","Function","toString","args","context","apply","installedIntegrations","filterDuplicates","integrations","reduce","acc","every","accIntegration","push","getIntegrationsToSetup","defaultIntegrations","userIntegrations","Array","isArray","filter","userIntegration","integrationsNames","map","alwaysLastToRun","indexOf","splice","SentryError","Error","super","Object","setPrototypeOf","DSN_REGEX","dsn","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","from","str","match","exec","lastPath","slice","split","join","pop","projectMatch","dsnFromString","forEach","component","isValidProtocol","isNaN","parseInt","validateDsn","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItem","envelopeItemType","encodeUTF8","input","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","buffers","totalLength","buf","merged","offset","buffer","set","concatBuffers","createAttachmentEnvelopeItem","attachment","data","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","envelopeItemTypeToDataCategory","normalize","depth","Infinity","maxProperties","visit","err","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","key","memo","hasWeakSet","WeakSet","inner","obj","has","add","delete","memoBuilder","memoize","unmemoize","includes","is","stringified","_events","g","window","document","String","getPrototypeOf","stringifyValue","startsWith","replace","valueWithToJSON","toJSON","numAdded","visitable","visitKey","hasOwnProperty","visitValue","getBaseApiEndpoint","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","sdkInfo","_metadata","sdk","_getIngestEndpoint","sentry_key","sentry_version","sentry_client","version","_encodedAuth","getSdkMetadataForEnvelopeHeader","metadata","createEventEnvelope","eventType","transactionSampling","sdkProcessingMetadata","method","samplingMethod","rate","sampleRate","packages","enhanceEventWithSdkInfo","envelopeHeaders","baggage","dynamicSamplingContext","event_id","sent_at","Date","toISOString","trace","createEventEnvelopeHeaders","sample_rates","ALREADY_SEEN_ERROR","BaseClient","_integrations","__init2","_integrationsInitialized","__init3","_numProcessing","__init4","_outcomes","_dsn","_transport","transport","recordDroppedEvent","bind","transportOptions","captureException","hint","scope","log","eventId","_process","eventFromException","then","_captureEvent","result","captureMessage","level","promisedEvent","eventFromMessage","captureEvent","originalException","captureSession","_isEnabled","release","sendSession","init","getDsn","getTransport","flush","timeout","_isClientDoneProcessing","clientFinished","transportFlushed","close","enabled","setupIntegrations","integrationIndex","integration","getIntegrationById","integrationId","_oO","sendEvent","env","attachments","_sendEnvelope","createSessionEnvelope","reason","category","sendClientReports","_updateSessionFromEvent","crashed","errored","exceptions","ex","mechanism","handled","sessionNonTerminal","status","errors","Number","resolve","ticked","interval","setInterval","clearInterval","_prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","update","getAttachments","applyToEvent","evt","_normalizeEvent","maxBreadth","breadcrumbs","b","user","contexts","extra","spans","span","environment","dist","maxValueLength","request","integrationsArray","keys","_processEvent","finalEvent","beforeSend","isTransaction","Math","random","__sentry__","rv","nullErr","_ensureBeforeSendRv","processedEvent","getSession","promise","send","_clearOutcomes","outcomes","quantity","exceptionFromError","stackParser","parseStackFrames","extractMessage","eventFromError","stack","popSize","framesToPop","reactMinifiedRegexp","test","getPopSize","error","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","domException","eventFromString","tags","code","__serialized__","eventFromPlainObject","synthetic","validSeverityLevels","severityLevelFromString","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","console","dom","fetch","history","sentry","xhr","_consoleBreadcrumb","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","addBreadcrumb","global","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","arguments","logger","endTimestamp","__sentry_own_request__","status_code","body","__sentry_xhr__","fetchData","response","to","parsedLoc","location","href","parsedFrom","parsedTo","relative","cachedFetchImpl","getNativeFetchImplementation","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","globalObject","BrowserClient","addEventListener","visibilityState","_flushOutcomes","breadcrumbIntegration","platform","discarded_events","navigator","sendBeacon","supports","credentials","keepalive","sendReport","UNKNOWN_FUNCTION","createFrame","func","lineno","colno","function","in_app","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackLineParsers","line","subMatch","extractSafariExtensionDetails","defaultStackParser","isSafariExtension","isSafariWebExtension","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","addEventProcessor","property","getOwnPropertyDescriptor","configurable","defineProperty","get","DEFAULT_EVENT_TARGET","TryCatch","XMLHttpRequest","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","original","originalCallback","handler","originalSend","prop","wrapOptions","originalFunction","proto","eventName","handleEvent","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","stackTraceLimit","installFunc","getHubAndOptions","msg","column","ERROR_TYPES_RE","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","detail","ev","ev0","ev0s","ev0sf","LinkedErrors","_key","_limit","limit","parser","linkedErrors","_walkErrorTree","_handler","Dedupe","eventProcessor","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","HttpContext","referrer","userAgent","Referer","makePromiseBuffer","remove","task","$","taskProducer","drain","reject","counter","capturedSetTimeout","clearTimeout","updateRateLimits","limits","statusCode","now","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","headerDelay","delay","all","header","headerDate","parse","parseRetryAfterHeader","createTransport","makeRequest","bufferSize","rateLimits","filteredEnvelopeItems","envelopeItemDataCategory","disabledUntil","isRateLimited","filteredEnvelope","recordEnvelopeLoss","_","makeFetchTransport","nativeFetch","requestOptions","referrerPolicy","fetchOptions","makeXHRTransport","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","SENTRY_RELEASE","autoSessionTracking","clientClass","debug","warn","getScope","initialScope","bindClient","initAndBind","startSessionOnHub","startSessionTracking","startSession","ignoreDuration","SDK_VERSION","configureScope","withScope","DEFAULT_BREADCRUMBS","Hub","_stack","_version","getStackTop","isOlderThan","pushScope","getStack","popScope","_lastEventId","_withClient","lastEventId","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","setUser","setTags","setExtras","extras","setTag","setExtra","setContext","run","oldHub","makeMain","startTransaction","customSamplingContext","_callExtensionMethod","traceHeaders","endSession","_sendSessionUpdate","layer","setSession","getUser","currentSession","shouldSendDefaultPii","Boolean","sendDefaultPii","getMainCarrier","__SENTRY__","extensions","carrier","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","_notifyScopeListeners","getRequestSession","setRequestSession","requestSession","setFingerprint","setLevel","setTransactionName","setSpan","getSpan","getTransaction","updatedScope","clear","maxCrumbs","min","clearBreadcrumbs","addAttachment","clearAttachments","getTraceContext","transactionName","_applyFingerprint","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","index","processor","final","concat","makeSession","startingTime","sid","started","duration","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","updateSession","email","username","closeSession","errorCallback","activeTransaction","setStatus","toTraceparent","sample","samplingContext","sampled","setMetadata","tracesSampler","parentSampled","tracesSampleRate","isValidSampleRate","op","_startTransaction","transactionContext","initSpanRecorder","_experiments","startIdleTransaction","idleTimeout","finalTimeout","onScope","addExtensionMethods","_addTracingExtensions","packageToIntegrationMapping","mongodb","module","Mongo","mongoose","mysql","Mysql","pg","Postgres","mappedPackages","moduleName","pkg","p","_autoloadDatabaseIntegrations","DEFAULT_IDLE_TIMEOUT","DEFAULT_FINAL_TIMEOUT","IdleTransactionSpanRecorder","_pushActivity","_popActivity","transactionSpanId","maxlen","spanId","finish","IdleTransaction","activities","_heartbeatCounter","_finished","_beforeFinishCallbacks","_idleHub","_idleTimeout","_finalTimeout","_onScope","clearActiveTransaction","_startIdleTimeout","spanRecorder","keepSpan","startTimestamp","registerBeforeFinishCallback","_pingHeartbeat","_cancelIdleTimeout","_idleTimeoutID","_beat","heartbeatString","_prevHeartbeatString","SpanRecorder","_maxlen","Span","traceId","substring","__init5","__init6","spanContext","parentSpanId","description","startChild","childSpan","setData","setHttpStatus","httpStatus","spanStatus","spanStatusfromHttpCode","isSuccess","sampledString","toContext","updateWithContext","parent_span_id","span_id","trace_id","start_timestamp","Transaction","_measurements","_hub","_name","_trimEnd","trimEnd","newName","source","setName","setMeasurement","unit","newMetadata","finishedSpans","s","prev","current","getBaggage","transaction_info","measurements","existingBaggage","finalBaggage","_populateBaggageWithSentryValues","public_key","sample_rate","toLocaleString","useGrouping","maximumFractionDigits","segment","user_segment","hasTracingEnabled","maybeOptions","getActiveTransaction","maybeHub","msToSec","time","BAGGAGE_HEADER_NAME","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","createBaggage","initItems","baggageString","mutable","getSentryBaggageItems","isBaggageMutable","parseBaggageHeader","inputBaggageValue","includeThirdPartyEntries","entry","baggageObj","curr","val","baggageKey","decodeURIComponent","mergeAndSerializeBaggage","incomingBaggage","thirdPartyBaggageHeader","headerBaggage","thirdPartyHeaderBaggage","baggageEntry","encodeURIComponent","newVal","serializeBaggage","parseBaggageSetMutability","rawBaggageValue","sentryTraceHeader","isSentryBaggageEmpty","setBaggageImmutable","htmlTreeAsString","elem","currentElem","out","height","len","sepLength","nextStr","_htmlElementAsString","parentNode","reverse","el","className","classes","attr","tagName","toLowerCase","keyAttrPairs","keyAttr","getAttribute","keyAttrPair","allowedAttrs","getLocationHref","_nullishCoalesce","lhs","rhsFn","fallbackGlobalObject","getGlobalObject","getGlobalSingleton","creator","handlers","instrumented","instrument","originalConsoleMethod","triggerHandlers","instrumentConsole","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","instrumentDOM","xhrproto","originalOpen","xhrInfo","toUpperCase","onreadystatechangeHandler","readyStateArgs","instrumentXHR","originalFetch","getFetchMethod","getFetchUrl","instrumentFetch","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","lastHref","instrumentHistory","_oldOnErrorHandler","_oldOnUnhandledRejectionHandler","addInstrumentationHandler","fetchArgs","Request","debounceTimerID","lastCapturedEvent","globalListener","isContentEditable","shouldSkipDOMEvent","previous","shouldShortcircuitPreviousDebounce","objectToString","isError","wat","isInstanceOf","isBuiltin","ty","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","base","_e","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","enable","disable","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","c","r","parseUrl","query","fragment","getFirstException","getEventDescription","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","stripUrlQueryAndFragment","urlPath","checkOrSetAlreadyCaught","__sentry_captured__","isNodeEnv","__SENTRY_BROWSER_BUNDLE__","process","dynamicRequire","mod","require","loadModule","cwd","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","writable","getOriginalFunction","urlEncode","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","extractedProps","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","memoVal","returnValue","createStackParser","parsers","sortedParsers","a","skipFirst","localStack","firstFrameFunction","lastFrameFunction","stripSentryFramesAndReverse","stackParserFromStackParserOptions","defaultFunctionName","getFunctionName","truncate","max","substr","safeJoin","delimiter","output","isMatchingPattern","supportsFetch","Headers","Response","isNativeFetch","supportsNativeFetch","doc","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","_state","PENDING","_handlers","executor","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","kSampleStepSize","float32ArraySupported","Float32Array","A","aA1","aA2","B","C","calcBezier","aT","getSlope","LinearEasing","x","exports","mX1","mY1","mX2","mY2","sampleValues","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","__NEXT_P","initialState","dynamicGridParam","reducer","action","queryTagsKey","queryTagIds","paginationNo","paginationLimit","isFiltering","filterParams","StateContext","createContext","DispatchContext","ContextProvider","children","useReducer","dispatch","Provider","Component","pageProps","router","useRouter","useState","setKey","useEffect","asPath","k","scrollRestoration","Head","meta","content","ParallaxProvider","TRACEPARENT_REGEXP","RegExp","bindReporter","metric","reportAllChanges","prevValue","forceReport","delta","initMetric","entries","floor","observe","PerformanceObserver","supportedEntryTypes","po","l","getEntries","buffered","onHidden","cb","once","onHiddenOrPageHide","removeEventListener","firstHiddenTime","getVisibilityWatcher","timeStamp","reportedMetricIDs","isMeasurementValue","isFinite","_startChild","ctx","getBrowserPerformanceAPI","_lcpEntry","_clsEntry","_performanceCursor","startTrackingWebVitals","mark","onReport","report","sessionValue","sessionEntries","entryHandler","hadRecentInput","firstSessionEntry","lastSessionEntry","startTime","takeRecords","getCLS","visibilityWatcher","stopListening","disconnect","capture","getLCP","_trackLCP","processingStart","getFID","addPerformanceEntries","performanceEntries","responseStartTimestamp","requestStartTimestamp","entryType","_addPerformanceNavigationTiming","requestStart","responseEnd","responseStart","_addRequest","_addNavigationSpans","measureStartTimestamp","measureEndTimestamp","_addMeasureSpans","firstHidden","shouldRecord","resourceName","origin","initiatorType","transferSize","encodedBodySize","decodedBodySize","_addResourceSpans","connection","effectiveType","rtt","downlink","deviceMemory","hardwareConcurrency","_trackNavigator","oldValue","measurementTimestamp","normalizedValue","cls","measurementName","element","size","sources","node","_tagMetricInfo","eventEnd","end","start","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","instrumentOutgoingRequests","shouldCreateSpanForRequest","urlMap","defaultShouldCreateSpan","origins","shouldCreateSpan","__span","headerBaggageString","find","addTracingHeaders","fetchCallback","__sentry_xhr_span_id__","getRequestHeader","xhrCallback","DEFAULT_BROWSER_TRACING_OPTIONS","markBackgroundTransactions","routingInstrumentation","customStartTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","startingUrl","pathname","BrowserTracing","_emitOptionsWarning","_metricOptions","_reportAllChanges","_getCurrentHub","instrumentRouting","_createRouteTransaction","statusType","beforeNavigate","parentContextFromHeader","sentrytraceValue","getMetaContent","baggageValue","sentrytraceData","traceparent","matches","extractTraceparentData","extractTraceDataFromMetaTags","expandedContext","modifiedContext","finalContext","idleTransaction","metaName","querySelector","__SENTRY_TRACING__","DEFAULT_TAGS","prevTransactionName","nextRouterInstrumentation","startTransactionCb","pathIsRoute","routerPrototype","changeStateWrapper","originalChangeStateWrapper","as","newTransactionName","setNestedKey","keyPath","addIntegration","addIntegrationToArray","userIntegrationsFunc","userFinalIntegrations","addIntegrationToFunction","includesName","names","buildMetadata","defaultBrowserTracingIntegration","createClientIntegrations","filterTransactions","Sentry","SENTRY_DSN","NEXT_PUBLIC_SENTRY_DSN","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","Item","array","noop","nextTick","title","browser","argv","versions","on","addListener","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","chdir","dir","umask","ValidCSSEffects","Units","RotationUnits","ScaleUnits","ScrollAxis","EasingPreset","Limits","properties","startX","startY","endX","endY","totalX","totalY","startMultiplierX","endMultiplierX","startMultiplierY","endMultiplierY","_extends","assign","Rect","rect","getBoundingClientRect","view","scrollContainer","scrollRect","top","right","left","bottom","offsetHeight","width","offsetWidth","rootMargin","_setRectWithRootMargin","totalRootY","totalRootX","VALID_UNITS","px","deg","turn","rad","defaultUnit","parseFloat","easingPresets","ease","easeIn","easeOut","easeInOut","easeInQuad","easeInCubic","easeInQuart","easeInQuint","easeInSine","easeInExpo","easeInCirc","easeOutQuad","easeOutCubic","easeOutQuart","easeOutQuint","easeOutSine","easeOutExpo","easeOutCirc","easeInOutQuad","easeInOutCubic","easeInOutQuart","easeInOutQuint","easeInOutSine","easeInOutExpo","easeInOutCirc","easeInBack","easeOutBack","easeInOutBack","createEasingFunction","easing","params","PARALLAX_EFFECTS","MAP_EFFECT_TO_DEFAULT_UNIT","speed","translateX","translateY","rotate","rotateX","rotateY","rotateZ","scale","scaleX","scaleY","scaleZ","opacity","parseElementTransitionEffects","props","scrollAxis","parsedEffects","defaultValue","endSpeed","startParsed","endParsed","speedConfig","vertical","horizontal","_startParsed","_endParsed","getProgressAmount","totalDist","currentScroll","amount","scaleEffectByProgress","effect","progress","newMin","newMax","oldMin","oldMax","scaleBetween","TRANSFORM_EFFECTS","setElementStyles","effects","transform","scaledEffect","getTransformStyles","scaledOpacity","getOpacityStyles","style","resetStyles","getTranslateScalar","startTranslatePx","endTranslatePx","slow","totalDistTrue","getStartEndValueInPx","translate","elementSize","startScale","endScale","innerWidth","_startScale","_endScale","innerHeight","DEFAULT_VALUE","clamp","isInView","_setElementEasing","willChange","setWillChangeStyles","_proto","updateProps","nextProps","setCachedAttributes","scroll","targetElement","shouldScaleTranslateEffects","shouldDisableScalingTranslations","startScroll","endScroll","_setElementStyles","shouldAlwaysCompleteAnimation","_getStartEndValueInPx","startTranslateXPx","endTranslateXPx","_getStartEndValueInPx2","startTranslateYPx","endTranslateYPx","y","topBeginsInView","leftBeginsInView","bottomEndsInView","scrollHeight","rightEndsInView","scrollWidth","createLimitsWithTranslationsForRelativeElements","scaledEffects","effectsCopy","scaleTranslateEffectsForSlowerScroll","createLimitsForRelativeElements","_updateElementIsInView","nextIsInView","isFirstChange","onEnter","_setFinalProgress","onExit","finalProgress","round","_updateElementProgress","disabled","nextProgress","onProgressChange","onChange","updatePosition","isVertical","total","isElementInView","View","config","hasChanged","setSize","Scroll","dx","dy","setScroll","ParallaxController","_ref","_ref$scrollAxis","elements","_hasScrollContainer","viewEl","_this$_getScrollPosit","_getScrollPosition","_ticking","_supportsPassive","supportsPassiveOption","opts","testForPassiveScroll","_bindAllMethods","_addListeners","_addResizeObserver","_setViewSize","_this","_handleScroll","passive","_handleUpdateCache","_removeListeners","_this$_resizeObserver","_resizeObserver","_this2","observedEl","documentElement","ResizeObserver","scrollLeft","pageXOffset","scrollTop","pageYOffset","_this$_getScrollPosit2","nx","ny","_updateAllElements","updateCache","_temp","_this3","_updateElementPosition","_getViewParams","_width","_height","_scrollHeight","_scrollWidth","html","clientWidth","clientHeight","_checkIfViewHasChanged","getElements","newElement","removeElementById","updateElementPropsById","resetElementStyles","_this$_getScrollPosit3","updateScrollContainer","destroy","_setPrototypeOf","o","__proto__","_objectWithoutPropertiesLoose","excluded","sourceKeys","_excluded","getIsolatedParallaxProps","rest","parallaxProps","ParallaxContext","useParallax","controller","parallaxController","useContext","useParallaxController","ref","useRef","useVerifyController","_useState","setElement","HTMLElement","Parallax","_getIsolatedParallaxP","_Component","subClass","superClass","create","componentDidUpdate","prevProps","componentWillUnmount","render","defaultProps","_defineProperty","enumerable","_objectSpread","ownKeys","getOwnPropertySymbols","sym","_objectSpreadProps","getOwnPropertyDescriptors","defineProperties","enumerableOnly","symbols"],"source