{"version":3,"file":"vendors-fd03fc49.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/@sentry/utils/esm/aggregate-errors.js","webpack://iadviser/./node_modules/@sentry/utils/esm/browser.js","webpack://iadviser/./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack://iadviser/./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack://iadviser/./node_modules/@sentry/utils/esm/clientreport.js","webpack://iadviser/./node_modules/@sentry/utils/esm/debug-build.js","webpack://iadviser/./node_modules/@sentry/utils/esm/dsn.js","webpack://iadviser/./node_modules/@sentry/utils/esm/env.js","webpack://iadviser/./node_modules/@sentry/utils/esm/envelope.js","webpack://iadviser/./node_modules/@sentry/utils/esm/error.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/_handlers.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/console.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/dom.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/fetch.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/globalError.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/globalUnhandledRejection.js","webpack://iadviser/./node_modules/@sentry/utils/esm/vendor/supportsHistory.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/history.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/xhr.js","webpack://iadviser/./node_modules/@sentry/utils/esm/is.js","webpack://iadviser/./node_modules/@sentry/utils/esm/isBrowser.js","webpack://iadviser/./node_modules/@sentry/utils/esm/logger.js","webpack://iadviser/./node_modules/@sentry/utils/esm/misc.js","webpack://iadviser/./node_modules/@sentry/utils/esm/node.js","webpack://iadviser/./node_modules/@sentry/utils/esm/normalize.js","webpack://iadviser/./node_modules/@sentry/utils/esm/memo.js","webpack://iadviser/./node_modules/@sentry/utils/esm/object.js","webpack://iadviser/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://iadviser/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://iadviser/./node_modules/@sentry/utils/esm/severity.js","webpack://iadviser/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://iadviser/./node_modules/@sentry/utils/esm/string.js","webpack://iadviser/./node_modules/@sentry/utils/esm/supports.js","webpack://iadviser/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://iadviser/./node_modules/@sentry/utils/esm/time.js","webpack://iadviser/./node_modules/@sentry/utils/esm/url.js","webpack://iadviser/./node_modules/@sentry/utils/esm/worldwide.js"],"sourcesContent":["import { isInstanceOf } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nfunction applyAggregateErrorsToEvent(\n exceptionFromErrorImplementation,\n parser,\n maxValueLimit = 250,\n key,\n limit,\n event,\n hint,\n) {\n if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n return;\n }\n\n // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n const originalException =\n event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n // We only create exception grouping if there is an exception in the event.\n if (originalException) {\n event.exception.values = truncateAggregateExceptions(\n aggregateExceptionsFromError(\n exceptionFromErrorImplementation,\n parser,\n limit,\n hint.originalException ,\n key,\n event.exception.values,\n originalException,\n 0,\n ),\n maxValueLimit,\n );\n }\n}\n\nfunction aggregateExceptionsFromError(\n exceptionFromErrorImplementation,\n parser,\n limit,\n error,\n key,\n prevExceptions,\n exception,\n exceptionId,\n) {\n if (prevExceptions.length >= limit + 1) {\n return prevExceptions;\n }\n\n let newExceptions = [...prevExceptions];\n\n // Recursively call this function in order to walk down a chain of errors\n if (isInstanceOf(error[key], Error)) {\n applyExceptionGroupFieldsForParentException(exception, exceptionId);\n const newException = exceptionFromErrorImplementation(parser, error[key]);\n const newExceptionId = newExceptions.length;\n applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n newExceptions = aggregateExceptionsFromError(\n exceptionFromErrorImplementation,\n parser,\n limit,\n error[key],\n key,\n [newException, ...newExceptions],\n newException,\n newExceptionId,\n );\n }\n\n // This will create exception grouping for AggregateErrors\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n if (Array.isArray(error.errors)) {\n error.errors.forEach((childError, i) => {\n if (isInstanceOf(childError, Error)) {\n applyExceptionGroupFieldsForParentException(exception, exceptionId);\n const newException = exceptionFromErrorImplementation(parser, childError);\n const newExceptionId = newExceptions.length;\n applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n newExceptions = aggregateExceptionsFromError(\n exceptionFromErrorImplementation,\n parser,\n limit,\n childError,\n key,\n [newException, ...newExceptions],\n newException,\n newExceptionId,\n );\n }\n });\n }\n\n return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception, exceptionId) {\n // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n exception.mechanism = {\n ...exception.mechanism,\n ...(exception.type === 'AggregateError' && { is_exception_group: true }),\n exception_id: exceptionId,\n };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n exception,\n source,\n exceptionId,\n parentId,\n) {\n // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n exception.mechanism = {\n ...exception.mechanism,\n type: 'chained',\n source,\n exception_id: exceptionId,\n parent_id: parentId,\n };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions, maxValueLength) {\n return exceptions.map(exception => {\n if (exception.value) {\n exception.value = truncate(exception.value, maxValueLength);\n }\n return exception;\n });\n}\n\nexport { applyAggregateErrorsToEvent };\n//# sourceMappingURL=aggregate-errors.js.map\n","import { isString } from './is.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\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(\n elem,\n options = {},\n) {\n if (!elem) {\n return '';\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 const MAX_TRAVERSE_HEIGHT = 5;\n const out = [];\n let height = 0;\n let len = 0;\n const separator = ' > ';\n const sepLength = separator.length;\n let nextStr;\n const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\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 maxStringLength\n // (ignore this limit if we are on the first iteration)\n if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\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 const elem = el\n\n;\n\n const 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 // @ts-expect-error WINDOW has HTMLElement\n if (WINDOW.HTMLElement) {\n // If using the component name annotation plugin, this value may be available on the DOM node\n if (elem instanceof HTMLElement && elem.dataset && elem.dataset['sentryComponent']) {\n return elem.dataset['sentryComponent'];\n }\n }\n\n out.push(elem.tagName.toLowerCase());\n\n // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n const 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 // eslint-disable-next-line prefer-const\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 const allowedAttrs = ['aria-label', '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 try {\n return WINDOW.document.location.href;\n } catch (oO) {\n return '';\n }\n}\n\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `const element = getDomElement('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction getDomElement(selector) {\n if (WINDOW.document && WINDOW.document.querySelector) {\n return WINDOW.document.querySelector(selector) ;\n }\n return null;\n}\n\n/**\n * Given a DOM element, traverses up the tree until it finds the first ancestor node\n * that has the `data-sentry-component` attribute. This attribute is added at build-time\n * by projects that have the component name annotation plugin installed.\n *\n * @returns a string representation of the component for the provided DOM element, or `null` if not found\n */\nfunction getComponentName(elem) {\n // @ts-expect-error WINDOW has HTMLElement\n if (!WINDOW.HTMLElement) {\n return null;\n }\n\n let currentElem = elem ;\n const MAX_TRAVERSE_HEIGHT = 5;\n for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {\n if (!currentElem) {\n return null;\n }\n\n if (currentElem instanceof HTMLElement && currentElem.dataset['sentryComponent']) {\n return currentElem.dataset['sentryComponent'];\n }\n\n currentElem = currentElem.parentNode;\n }\n\n return null;\n}\n\nexport { getComponentName, getDomElement, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","// https://github.com/alangpierce/sucrase/tree/265887868966917f3b924ce38dfad01fbab1329f\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2012-2018 various contributors (see AUTHORS)\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\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","/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nfunction _optionalChain(ops) {\n let lastAccessLHS = undefined;\n let value = ops[0];\n let i = 1;\n while (i < ops.length) {\n const op = ops[i] ;\n const fn = ops[i + 1] ;\n i += 2;\n // by checking for loose equality to `null`, we catch both `null` and `undefined`\n if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n return;\n }\n if (op === 'access' || op === 'optionalAccess') {\n lastAccessLHS = value;\n value = fn(value);\n } else if (op === 'call' || op === 'optionalCall') {\n value = fn((...args) => (value ).call(lastAccessLHS, ...args));\n lastAccessLHS = undefined;\n }\n }\n return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n// let lastAccessLHS = undefined;\n// let value = ops[0];\n// let i = 1;\n// while (i < ops.length) {\n// const op = ops[i];\n// const fn = ops[i + 1];\n// i += 2;\n// if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n// return undefined;\n// }\n// if (op === 'access' || op === 'optionalAccess') {\n// lastAccessLHS = value;\n// value = fn(value);\n// } else if (op === 'call' || op === 'optionalCall') {\n// value = fn((...args) => value.call(lastAccessLHS, ...args));\n// lastAccessLHS = undefined;\n// }\n// }\n// return value;\n// }\n\nexport { _optionalChain };\n//# sourceMappingURL=_optionalChain.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n discarded_events,\n dsn,\n timestamp,\n) {\n const clientReportItem = [\n { type: 'client_report' },\n {\n timestamp: timestamp || dateTimestampInSeconds(),\n discarded_events,\n },\n ];\n return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { consoleSandbox, logger } from './logger.js';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n return (\n `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string\n */\nfunction dsnFromString(str) {\n const match = DSN_REGEX.exec(str);\n\n if (!match) {\n // This should be logged to the console\n consoleSandbox(() => {\n // eslint-disable-next-line no-console\n console.error(`Invalid Sentry Dsn: ${str}`);\n });\n return undefined;\n }\n\n const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n let path = '';\n let projectId = lastPath;\n\n const split = projectId.split('/');\n if (split.length > 1) {\n path = split.slice(0, -1).join('/');\n projectId = split.pop() ;\n }\n\n if (projectId) {\n const projectMatch = projectId.match(/^\\d+/);\n if (projectMatch) {\n projectId = projectMatch[0];\n }\n }\n\n return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n return {\n protocol: components.protocol,\n publicKey: components.publicKey || '',\n pass: components.pass || '',\n host: components.host,\n port: components.port || '',\n path: components.path || '',\n projectId: components.projectId,\n };\n}\n\nfunction validateDsn(dsn) {\n if (!DEBUG_BUILD) {\n return true;\n }\n\n const { port, projectId, protocol } = dsn;\n\n const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n const hasMissingRequiredComponent = requiredComponents.find(component => {\n if (!dsn[component]) {\n logger.error(`Invalid Sentry Dsn: ${component} missing`);\n return true;\n }\n return false;\n });\n\n if (hasMissingRequiredComponent) {\n return false;\n }\n\n if (!projectId.match(/^\\d+$/)) {\n logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n return false;\n }\n\n if (!isValidProtocol(protocol)) {\n logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n return false;\n }\n\n if (port && isNaN(parseInt(port, 10))) {\n logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n return false;\n }\n\n return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nfunction makeDsn(from) {\n const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n if (!components || !validateDsn(components)) {\n return undefined;\n }\n return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","/*\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 flags 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\n/**\n * Get source of SDK.\n */\nfunction getSDKSource() {\n // @ts-expect-error \"npm\" is injected by rollup during build process\n return \"npm\";\n}\n\nexport { getSDKSource, isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { dsnToString } from './dsn.js';\nimport { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n const [headers, items] = envelope;\n return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n *\n * If the callback returns true, the rest of the items will be skipped.\n */\nfunction forEachEnvelopeItem(\n envelope,\n callback,\n) {\n const envelopeItems = envelope[1];\n\n for (const envelopeItem of envelopeItems) {\n const envelopeItemType = envelopeItem[0].type;\n const result = callback(envelopeItem, envelopeItemType);\n\n if (result) {\n return true;\n }\n }\n\n return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nfunction envelopeContainsItemType(envelope, types) {\n return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8.\n */\nfunction encodeUTF8(input, textEncoder) {\n const utf8 = textEncoder || new TextEncoder();\n return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope, textEncoder) {\n const [envHeaders, items] = envelope;\n\n // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n let parts = JSON.stringify(envHeaders);\n\n function append(next) {\n if (typeof parts === 'string') {\n parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n } else {\n parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n }\n }\n\n for (const item of items) {\n const [itemHeaders, payload] = item;\n\n append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n if (typeof payload === 'string' || payload instanceof Uint8Array) {\n append(payload);\n } else {\n let stringifiedPayload;\n try {\n stringifiedPayload = JSON.stringify(payload);\n } catch (e) {\n // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n // performance impact but in this case a performance hit is better than throwing.\n stringifiedPayload = JSON.stringify(normalize(payload));\n }\n append(stringifiedPayload);\n }\n }\n\n return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n const merged = new Uint8Array(totalLength);\n let offset = 0;\n for (const buffer of buffers) {\n merged.set(buffer, offset);\n offset += buffer.length;\n }\n\n return merged;\n}\n\n/**\n * Parses an envelope\n */\nfunction parseEnvelope(\n env,\n textEncoder,\n textDecoder,\n) {\n let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;\n\n function readBinary(length) {\n const bin = buffer.subarray(0, length);\n // Replace the buffer with the remaining data excluding trailing newline\n buffer = buffer.subarray(length + 1);\n return bin;\n }\n\n function readJson() {\n let i = buffer.indexOf(0xa);\n // If we couldn't find a newline, we must have found the end of the buffer\n if (i < 0) {\n i = buffer.length;\n }\n\n return JSON.parse(textDecoder.decode(readBinary(i))) ;\n }\n\n const envelopeHeader = readJson();\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const items = [];\n\n while (buffer.length) {\n const itemHeader = readJson();\n const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n }\n\n return [envelopeHeader, items];\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(\n attachment,\n textEncoder,\n) {\n const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n return [\n dropUndefinedKeys({\n type: 'attachment',\n length: buffer.length,\n filename: attachment.filename,\n content_type: attachment.contentType,\n attachment_type: attachment.attachmentType,\n }),\n buffer,\n ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n session: 'session',\n sessions: 'session',\n attachment: 'attachment',\n transaction: 'transaction',\n event: 'error',\n client_report: 'internal',\n user_report: 'default',\n profile: 'profile',\n replay_event: 'replay',\n replay_recording: 'replay',\n check_in: 'monitor',\n feedback: 'feedback',\n span: 'span',\n statsd: 'metric_bucket',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\n/** Extracts the minimal SDK info from the metadata or an events */\nfunction getSdkMetadataForEnvelopeHeader(metadataOrEvent) {\n if (!metadataOrEvent || !metadataOrEvent.sdk) {\n return;\n }\n const { name, version } = metadataOrEvent.sdk;\n return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nfunction createEventEnvelopeHeaders(\n event,\n sdkInfo,\n tunnel,\n dsn,\n) {\n const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n return {\n event_id: event.event_id ,\n sent_at: new Date().toISOString(),\n ...(sdkInfo && { sdk: sdkInfo }),\n ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n ...(dynamicSamplingContext && {\n trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n }),\n };\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n /** Display name of this error instance. */\n\n constructor( message, logLevel = 'warn') {\n super(message);this.message = message;\n this.name = new.target.prototype.constructor.name;\n // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n // instances of `SentryError` fail `obj instanceof SentryError` checks.\n Object.setPrototypeOf(this, new.target.prototype);\n this.logLevel = logLevel;\n }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../logger.js';\nimport { getFunctionName } from '../stacktrace.js';\n\n// We keep the handlers globally\nconst handlers = {};\nconst instrumented = {};\n\n/** Add a handler function. */\nfunction addHandler(type, handler) {\n handlers[type] = handlers[type] || [];\n (handlers[type] ).push(handler);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nfunction resetInstrumentationHandlers() {\n Object.keys(handlers).forEach(key => {\n handlers[key ] = undefined;\n });\n}\n\n/** Maybe run an instrumentation function, unless it was already called. */\nfunction maybeInstrument(type, instrumentFn) {\n if (!instrumented[type]) {\n instrumentFn();\n instrumented[type] = true;\n }\n}\n\n/** Trigger handlers for a given instrumentation type. */\nfunction triggerHandlers(type, data) {\n const typeHandlers = type && handlers[type];\n if (!typeHandlers) {\n return;\n }\n\n for (const handler of typeHandlers) {\n try {\n handler(data);\n } catch (e) {\n DEBUG_BUILD &&\n logger.error(\n `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n e,\n );\n }\n }\n}\n\nexport { addHandler, maybeInstrument, resetInstrumentationHandlers, triggerHandlers };\n//# sourceMappingURL=_handlers.js.map\n","import { CONSOLE_LEVELS, originalConsoleMethods } from '../logger.js';\nimport { fill } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\n/**\n * Add an instrumentation handler for when a console.xxx method is called.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addConsoleInstrumentationHandler(handler) {\n const type = 'console';\n addHandler(type, handler);\n maybeInstrument(type, instrumentConsole);\n}\n\nfunction instrumentConsole() {\n if (!('console' in GLOBAL_OBJ)) {\n return;\n }\n\n CONSOLE_LEVELS.forEach(function (level) {\n if (!(level in GLOBAL_OBJ.console)) {\n return;\n }\n\n fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {\n originalConsoleMethods[level] = originalConsoleMethod;\n\n return function (...args) {\n const handlerData = { args, level };\n triggerHandlers('console', handlerData);\n\n const log = originalConsoleMethods[level];\n log && log.apply(GLOBAL_OBJ.console, args);\n };\n });\n });\n}\n\nexport { addConsoleInstrumentationHandler };\n//# sourceMappingURL=console.js.map\n","import { uuid4 } from '../misc.js';\nimport { fill, addNonEnumerableProperty } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nconst WINDOW = GLOBAL_OBJ ;\nconst DEBOUNCE_DURATION = 1000;\n\nlet debounceTimerID;\nlet lastCapturedEventType;\nlet lastCapturedEventTargetId;\n\n/**\n * Add an instrumentation handler for when a click or a keypress happens.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addClickKeypressInstrumentationHandler(handler) {\n const type = 'dom';\n addHandler(type, handler);\n maybeInstrument(type, instrumentDOM);\n}\n\n/** Exported for tests only. */\nfunction instrumentDOM() {\n if (!WINDOW.document) {\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 const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n WINDOW.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 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n const proto = (WINDOW )[target] && (WINDOW )[target].prototype;\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\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 const el = this ;\n const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n if (!handlerForType.handler) {\n const handler = makeDOMEventHandler(triggerDOMHandler);\n handlerForType.handler = handler;\n originalAddEventListener.call(this, type, handler, options);\n }\n\n handlerForType.refCount++;\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 const el = this ;\n const handlers = el.__sentry_instrumentation_handlers__ || {};\n const handlerForType = handlers[type];\n\n if (handlerForType) {\n handlerForType.refCount--;\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]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n }\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\n/**\n * Check whether the event is similar to the last captured one. For example, two click events on the same button.\n */\nfunction isSimilarToLastCapturedEvent(event) {\n // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n if (event.type !== lastCapturedEventType) {\n return false;\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 (!event.target || (event.target )._sentryId !== lastCapturedEventTargetId) {\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 // 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 true;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(eventType, target) {\n // We are only interested in filtering `keypress` events for now.\n if (eventType !== 'keypress') {\n return false;\n }\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\n return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n */\nfunction makeDOMEventHandler(\n handler,\n globalListener = false,\n) {\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 || event['_sentryCaptured']) {\n return;\n }\n\n const target = getEventTarget(event);\n\n // We always want to skip _some_ events.\n if (shouldSkipDOMEvent(event.type, target)) {\n return;\n }\n\n // Mark event as \"seen\"\n addNonEnumerableProperty(event, '_sentryCaptured', true);\n\n if (target && !target._sentryId) {\n // Add UUID to event target so we can identify if\n addNonEnumerableProperty(target, '_sentryId', uuid4());\n }\n\n const name = event.type === 'keypress' ? 'input' : event.type;\n\n // If there is no last captured event, it means that we can safely capture the new event and store it for future comparisons.\n // If there is a last captured event, 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 if (!isSimilarToLastCapturedEvent(event)) {\n const handlerData = { event, name, global: globalListener };\n handler(handlerData);\n lastCapturedEventType = event.type;\n lastCapturedEventTargetId = target ? target._sentryId : undefined;\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 = WINDOW.setTimeout(() => {\n lastCapturedEventTargetId = undefined;\n lastCapturedEventType = undefined;\n }, DEBOUNCE_DURATION);\n };\n}\n\nfunction getEventTarget(event) {\n try {\n return event.target ;\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 return null;\n }\n}\n\nexport { addClickKeypressInstrumentationHandler, instrumentDOM };\n//# sourceMappingURL=dom.js.map\n","import { fill } from '../object.js';\nimport { supportsNativeFetch } from '../supports.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addFetchInstrumentationHandler(handler) {\n const type = 'fetch';\n addHandler(type, handler);\n maybeInstrument(type, instrumentFetch);\n}\n\nfunction instrumentFetch() {\n if (!supportsNativeFetch()) {\n return;\n }\n\n fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {\n return function (...args) {\n const { method, url } = parseFetchArgs(args);\n\n const handlerData = {\n args,\n fetchData: {\n method,\n url,\n },\n startTimestamp: Date.now(),\n };\n\n triggerHandlers('fetch', {\n ...handlerData,\n });\n\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n return originalFetch.apply(GLOBAL_OBJ, args).then(\n (response) => {\n const finishedHandlerData = {\n ...handlerData,\n endTimestamp: Date.now(),\n response,\n };\n\n triggerHandlers('fetch', finishedHandlerData);\n return response;\n },\n (error) => {\n const erroredHandlerData = {\n ...handlerData,\n endTimestamp: Date.now(),\n error,\n };\n\n triggerHandlers('fetch', erroredHandlerData);\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\nfunction hasProp(obj, prop) {\n return !!obj && typeof obj === 'object' && !!(obj )[prop];\n}\n\nfunction getUrlFromResource(resource) {\n if (typeof resource === 'string') {\n return resource;\n }\n\n if (!resource) {\n return '';\n }\n\n if (hasProp(resource, 'url')) {\n return resource.url;\n }\n\n if (resource.toString) {\n return resource.toString();\n }\n\n return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request.\n * Exported for tests only.\n */\nfunction parseFetchArgs(fetchArgs) {\n if (fetchArgs.length === 0) {\n return { method: 'GET', url: '' };\n }\n\n if (fetchArgs.length === 2) {\n const [url, options] = fetchArgs ;\n\n return {\n url: getUrlFromResource(url),\n method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n };\n }\n\n const arg = fetchArgs[0];\n return {\n url: getUrlFromResource(arg ),\n method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n };\n}\n\nexport { addFetchInstrumentationHandler, parseFetchArgs };\n//# sourceMappingURL=fetch.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nlet _oldOnErrorHandler = null;\n\n/**\n * Add an instrumentation handler for when an error is captured by the global error handler.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalErrorInstrumentationHandler(handler) {\n const type = 'error';\n addHandler(type, handler);\n maybeInstrument(type, instrumentError);\n}\n\nfunction instrumentError() {\n _oldOnErrorHandler = GLOBAL_OBJ.onerror;\n\n GLOBAL_OBJ.onerror = function (\n msg,\n url,\n line,\n column,\n error,\n ) {\n const handlerData = {\n column,\n error,\n line,\n msg,\n url,\n };\n triggerHandlers('error', handlerData);\n\n if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {\n // eslint-disable-next-line prefer-rest-params\n return _oldOnErrorHandler.apply(this, arguments);\n }\n\n return false;\n };\n\n GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalErrorInstrumentationHandler };\n//# sourceMappingURL=globalError.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nlet _oldOnUnhandledRejectionHandler = null;\n\n/**\n * Add an instrumentation handler for when an unhandled promise rejection is captured.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalUnhandledRejectionInstrumentationHandler(\n handler,\n) {\n const type = 'unhandledrejection';\n addHandler(type, handler);\n maybeInstrument(type, instrumentUnhandledRejection);\n}\n\nfunction instrumentUnhandledRejection() {\n _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;\n\n GLOBAL_OBJ.onunhandledrejection = function (e) {\n const handlerData = e;\n triggerHandlers('unhandledrejection', handlerData);\n\n if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {\n // eslint-disable-next-line prefer-rest-params\n return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n }\n\n return true;\n };\n\n GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalUnhandledRejectionInstrumentationHandler };\n//# sourceMappingURL=globalUnhandledRejection.js.map\n","import { getGlobalObject } from '../worldwide.js';\n\n// Based on https://github.com/angular/angular.js/pull/13945/files\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\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 /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const chromeVar = (WINDOW ).chrome;\n const isChromePackagedApp = chromeVar && chromeVar.app && chromeVar.app.runtime;\n /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { supportsHistory };\n//# sourceMappingURL=supportsHistory.js.map\n","import { fill } from '../object.js';\nimport '../debug-build.js';\nimport '../logger.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { supportsHistory } from '../vendor/supportsHistory.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nlet lastHref;\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addHistoryInstrumentationHandler(handler) {\n const type = 'history';\n addHandler(type, handler);\n maybeInstrument(type, instrumentHistory);\n}\n\nfunction instrumentHistory() {\n if (!supportsHistory()) {\n return;\n }\n\n const oldOnPopState = WINDOW.onpopstate;\n WINDOW.onpopstate = function ( ...args) {\n const to = WINDOW.location.href;\n // keep track of the current URL state, as we always receive only the updated state\n const from = lastHref;\n lastHref = to;\n const handlerData = { from, to };\n triggerHandlers('history', handlerData);\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 function historyReplacementFunction(originalHistoryFunction) {\n return function ( ...args) {\n const url = args.length > 2 ? args[2] : undefined;\n if (url) {\n // coerce to string (this is what pushState does)\n const from = lastHref;\n const to = String(url);\n // keep track of the current URL state, as we always receive only the updated state\n lastHref = to;\n const handlerData = { from, to };\n triggerHandlers('history', handlerData);\n }\n return originalHistoryFunction.apply(this, args);\n };\n }\n\n fill(WINDOW.history, 'pushState', historyReplacementFunction);\n fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nexport { addHistoryInstrumentationHandler };\n//# sourceMappingURL=history.js.map\n","import { isString } from '../is.js';\nimport { fill } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nconst SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';\n\n/**\n * Add an instrumentation handler for when an XHR request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addXhrInstrumentationHandler(handler) {\n const type = 'xhr';\n addHandler(type, handler);\n maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nfunction instrumentXHR() {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n if (!(WINDOW ).XMLHttpRequest) {\n return;\n }\n\n const xhrproto = XMLHttpRequest.prototype;\n\n fill(xhrproto, 'open', function (originalOpen) {\n return function ( ...args) {\n const startTimestamp = Date.now();\n\n // open() should always be called with two or more arguments\n // But to be on the safe side, we actually validate this and bail out if we don't have a method & url\n const method = isString(args[0]) ? args[0].toUpperCase() : undefined;\n const url = parseUrl(args[1]);\n\n if (!method || !url) {\n return originalOpen.apply(this, args);\n }\n\n this[SENTRY_XHR_DATA_KEY] = {\n method,\n url,\n request_headers: {},\n };\n\n // if Sentry key appears in URL, don't capture it as a request\n if (method === 'POST' && url.match(/sentry_key/)) {\n this.__sentry_own_request__ = true;\n }\n\n const onreadystatechangeHandler = () => {\n // For whatever reason, this is not the same instance here as from the outer method\n const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n if (!xhrInfo) {\n return;\n }\n\n if (this.readyState === 4) {\n try {\n // touching statusCode in some platforms throws\n // an exception\n xhrInfo.status_code = this.status;\n } catch (e) {\n /* do nothing */\n }\n\n const handlerData = {\n args: [method, url],\n endTimestamp: Date.now(),\n startTimestamp,\n xhr: this,\n };\n triggerHandlers('xhr', handlerData);\n }\n };\n\n if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {\n fill(this, 'onreadystatechange', function (original) {\n return function ( ...readyStateArgs) {\n onreadystatechangeHandler();\n return original.apply(this, readyStateArgs);\n };\n });\n } else {\n this.addEventListener('readystatechange', onreadystatechangeHandler);\n }\n\n // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n fill(this, 'setRequestHeader', function (original) {\n return function ( ...setRequestHeaderArgs) {\n const [header, value] = setRequestHeaderArgs;\n\n const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n if (xhrInfo && isString(header) && isString(value)) {\n xhrInfo.request_headers[header.toLowerCase()] = value;\n }\n\n return original.apply(this, setRequestHeaderArgs);\n };\n });\n\n return originalOpen.apply(this, args);\n };\n });\n\n fill(xhrproto, 'send', function (originalSend) {\n return function ( ...args) {\n const sentryXhrData = this[SENTRY_XHR_DATA_KEY];\n\n if (!sentryXhrData) {\n return originalSend.apply(this, args);\n }\n\n if (args[0] !== undefined) {\n sentryXhrData.body = args[0];\n }\n\n const handlerData = {\n args: [sentryXhrData.method, sentryXhrData.url],\n startTimestamp: Date.now(),\n xhr: this,\n };\n triggerHandlers('xhr', handlerData);\n\n return originalSend.apply(this, args);\n };\n });\n}\n\nfunction parseUrl(url) {\n if (isString(url)) {\n return url;\n }\n\n try {\n // url can be a string or URL\n // but since URL is not available in IE11, we do not check for it,\n // but simply assume it is an URL and return `toString()` from it (which returns the full URL)\n // If that fails, we just return undefined\n return (url ).toString();\n } catch (e2) {} // eslint-disable-line no-empty\n\n return undefined;\n}\n\nexport { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler, instrumentXHR };\n//# sourceMappingURL=xhr.js.map\n","// eslint-disable-next-line @typescript-eslint/unbound-method\nconst 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/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat, className) {\n return objectToString.call(wat) === `[object ${className}]`;\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 string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isParameterizedString(wat) {\n return (\n typeof wat === 'object' &&\n wat !== null &&\n '__sentry_template_string__' in wat &&\n '__sentry_template_values__' in wat\n );\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 || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\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 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isVueViewModel(wat) {\n // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isParameterizedString, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };\n//# sourceMappingURL=is.js.map\n","import { isNodeEnv } from './node.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * Returns true if we are in the browser.\n */\nfunction isBrowser() {\n // eslint-disable-next-line no-restricted-globals\n return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());\n}\n\n// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them\nfunction isElectronNodeRenderer() {\n return (\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n (GLOBAL_OBJ ).process !== undefined && ((GLOBAL_OBJ ).process ).type === 'renderer'\n );\n}\n\nexport { isBrowser };\n//# sourceMappingURL=isBrowser.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = [\n 'debug',\n 'info',\n 'warn',\n 'error',\n 'log',\n 'assert',\n 'trace',\n] ;\n\n/** This may be mutated by the console instrumentation. */\nconst originalConsoleMethods\n\n = {};\n\n/** JSDoc */\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 if (!('console' in GLOBAL_OBJ)) {\n return callback();\n }\n\n const console = GLOBAL_OBJ.console ;\n const wrappedFuncs = {};\n\n const wrappedLevels = Object.keys(originalConsoleMethods) ;\n\n // Restore all wrapped console methods\n wrappedLevels.forEach(level => {\n const originalConsoleMethod = originalConsoleMethods[level] ;\n wrappedFuncs[level] = console[level] ;\n console[level] = originalConsoleMethod;\n });\n\n try {\n return callback();\n } finally {\n // Revert restoration to wrapped state\n wrappedLevels.forEach(level => {\n console[level] = wrappedFuncs[level] ;\n });\n }\n}\n\nfunction makeLogger() {\n let enabled = false;\n const logger = {\n enable: () => {\n enabled = true;\n },\n disable: () => {\n enabled = false;\n },\n isEnabled: () => enabled,\n };\n\n if (DEBUG_BUILD) {\n CONSOLE_LEVELS.forEach(name => {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n logger[name] = (...args) => {\n if (enabled) {\n consoleSandbox(() => {\n GLOBAL_OBJ.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\nconst logger = makeLogger();\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };\n//# sourceMappingURL=logger.js.map\n","import { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n const gbl = GLOBAL_OBJ ;\n const crypto = gbl.crypto || gbl.msCrypto;\n\n let getRandomByte = () => Math.random() * 16;\n try {\n if (crypto && crypto.randomUUID) {\n return crypto.randomUUID().replace(/-/g, '');\n }\n if (crypto && crypto.getRandomValues) {\n getRandomByte = () => {\n // crypto.getRandomValues might return undefined instead of the typed array\n // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n // However, `typedArray` is still filled in-place.\n // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n const typedArray = new Uint8Array(1);\n crypto.getRandomValues(typedArray);\n return typedArray[0];\n };\n }\n } catch (_) {\n // some runtimes can crash invoking crypto\n // https://github.com/getsentry/sentry-javascript/issues/8935\n }\n\n // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n // eslint-disable-next-line no-bitwise\n ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\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 const 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 const exception = (event.exception = event.exception || {});\n const values = (exception.values = exception.values || []);\n const 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 const firstException = getFirstException(event);\n if (!firstException) {\n return;\n }\n\n const defaultMechanism = { type: 'generic', handled: true };\n const currentMechanism = firstException.mechanism;\n firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n if (newMechanism && 'data' in newMechanism) {\n const 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\nconst 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 const match = input.match(SEMVER_REGEXP) || [];\n const major = parseInt(match[1], 10);\n const minor = parseInt(match[2], 10);\n const 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 // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n if (frame.lineno === undefined) {\n return;\n }\n\n const maxLines = lines.length;\n const sourceLine = Math.max(Math.min(maxLines - 1, frame.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 * 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 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nfunction arrayify(maybeArray) {\n return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, 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 */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nfunction dynamicRequire(mod, request) {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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","import { isNaN, isVueViewModel, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction normalize(input, depth = 100, maxProperties = +Infinity) {\n try {\n // since we're at the outermost level, we don't provide a key\n return visit('', input, depth, maxProperties);\n } catch (err) {\n return { ERROR: `**non-serializable** (${err})` };\n }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n object,\n // Default Node.js REPL depth\n depth = 3,\n // 100kB, as 200kB is max payload size, so half sounds reasonable\n maxSize = 100 * 1024,\n) {\n const normalized = normalize(object, depth);\n\n if (jsonSize(normalized) > maxSize) {\n return normalizeToSize(object, depth - 1, maxSize);\n }\n\n return normalized ;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n key,\n value,\n depth = +Infinity,\n maxProperties = +Infinity,\n memo = memoBuilder(),\n) {\n const [memoize, unmemoize] = memo;\n\n // Get the simple cases out of the way first\n if (\n value == null || // this matches null and undefined -> eqeq not eqeqeq\n (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))\n ) {\n return value ;\n }\n\n const stringified = stringifyValue(key, value);\n\n // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n if (!stringified.startsWith('[object ')) {\n return stringified;\n }\n\n // From here on, we can assert that `value` is either an object or an array.\n\n // Do not normalize objects that we know have already been normalized. As a general rule, the\n // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n // have already been normalized.\n if ((value )['__sentry_skip_normalization__']) {\n return value ;\n }\n\n // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n // We keep a certain amount of depth.\n // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n const remainingDepth =\n typeof (value )['__sentry_override_normalization_depth__'] === 'number'\n ? ((value )['__sentry_override_normalization_depth__'] )\n : depth;\n\n // We're also done if we've reached the max depth\n if (remainingDepth === 0) {\n // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n return stringified.replace('object ', '');\n }\n\n // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n if (memoize(value)) {\n return '[Circular ~]';\n }\n\n // If the value has a `toJSON` method, we call it to extract more information\n const valueWithToJSON = value ;\n if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n try {\n const jsonValue = valueWithToJSON.toJSON();\n // We need to normalize the return value of `.toJSON()` in case it has circular references\n return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n } catch (err) {\n // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n }\n }\n\n // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n // property/entry, and keep track of the number of items we add to it.\n const normalized = (Array.isArray(value) ? [] : {}) ;\n let numAdded = 0;\n\n // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n // properties are non-enumerable and otherwise would get missed.\n const visitable = convertToPlainObject(value );\n\n for (const visitKey in visitable) {\n // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n continue;\n }\n\n if (numAdded >= maxProperties) {\n normalized[visitKey] = '[MaxProperties ~]';\n break;\n }\n\n // Recursively visit all the child nodes\n const visitValue = visitable[visitKey];\n normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n numAdded++;\n }\n\n // Once we've visited all the branches, remove the parent from memo storage\n unmemoize(value);\n\n // Return accumulated values\n return normalized;\n}\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n key,\n // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n // our internal use, it'll do\n value,\n) {\n try {\n if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n return '[Domain]';\n }\n\n if (key === 'domainEmitter') {\n return '[DomainEmitter]';\n }\n\n // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n // which won't throw if they are not present.\n\n if (typeof global !== 'undefined' && value === global) {\n return '[Global]';\n }\n\n // eslint-disable-next-line no-restricted-globals\n if (typeof window !== 'undefined' && value === window) {\n return '[Window]';\n }\n\n // eslint-disable-next-line no-restricted-globals\n if (typeof document !== 'undefined' && value === document) {\n return '[Document]';\n }\n\n if (isVueViewModel(value)) {\n return '[VueViewModel]';\n }\n\n // React's SyntheticEvent thingy\n if (isSyntheticEvent(value)) {\n return '[SyntheticEvent]';\n }\n\n if (typeof value === 'number' && value !== value) {\n return '[NaN]';\n }\n\n if (typeof value === 'function') {\n return `[Function: ${getFunctionName(value)}]`;\n }\n\n if (typeof value === 'symbol') {\n return `[${String(value)}]`;\n }\n\n // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n if (typeof value === 'bigint') {\n return `[BigInt: ${String(value)}]`;\n }\n\n // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n // we can make sure that only plain objects come out that way.\n const objName = getConstructorName(value);\n\n // Handle HTML Elements\n if (/^HTML(\\w*)Element$/.test(objName)) {\n return `[HTMLElement: ${objName}]`;\n }\n\n return `[object ${objName}]`;\n } catch (err) {\n return `**non-serializable** (${err})`;\n }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value) {\n const prototype = Object.getPrototypeOf(value);\n\n return prototype ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n // eslint-disable-next-line no-bitwise\n return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value) {\n return utf8Length(JSON.stringify(value));\n}\n\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nfunction normalizeUrlToBase(url, basePath) {\n const escapedBase = basePath\n // Backslash to forward\n .replace(/\\\\/g, '/')\n // Escape RegExp special characters\n .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n let newUrl = url;\n try {\n newUrl = decodeURI(url);\n } catch (_Oo) {\n // Sometime this breaks\n }\n return (\n newUrl\n .replace(/\\\\/g, '/')\n .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n );\n}\n\nexport { normalize, normalizeToSize, normalizeUrlToBase, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n const hasWeakSet = typeof WeakSet === 'function';\n const inner = hasWeakSet ? new WeakSet() : [];\n function memoize(obj) {\n if (hasWeakSet) {\n if (inner.has(obj)) {\n return true;\n }\n inner.add(obj);\n return false;\n }\n // eslint-disable-next-line @typescript-eslint/prefer-for-of\n for (let i = 0; i < inner.length; i++) {\n const value = inner[i];\n if (value === obj) {\n return true;\n }\n }\n inner.push(obj);\n return false;\n }\n\n function unmemoize(obj) {\n if (hasWeakSet) {\n inner.delete(obj);\n } else {\n for (let i = 0; i < inner.length; i++) {\n if (inner[i] === obj) {\n inner.splice(i, 1);\n break;\n }\n }\n }\n }\n return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { logger } from './logger.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 const original = source[name] ;\n const 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 markFunctionWrapped(wrapped, original);\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 try {\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 } catch (o_O) {\n DEBUG_BUILD && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\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 try {\n const proto = original.prototype || {};\n wrapped.prototype = original.prototype = proto;\n addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n } catch (o_O) {} // eslint-disable-line no-empty\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 const 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 const extractedProps = {};\n for (const 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 const 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 const 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 const 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 (isPojo(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 const memoVal = memoizationMap.get(inputValue);\n if (memoVal !== undefined) {\n return memoVal ;\n }\n\n const 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 (const 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 const memoVal = memoizationMap.get(inputValue);\n if (memoVal !== undefined) {\n return memoVal ;\n }\n\n const 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\nfunction isPojo(input) {\n if (!isPlainObject(input)) {\n return false;\n }\n\n try {\n const name = (Object.getPrototypeOf(input) ).constructor.name;\n return !name || name === 'Object';\n } catch (e) {\n return true;\n }\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 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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 { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n const buffer = [];\n\n function isReady() {\n return limit === undefined || buffer.length < limit;\n }\n\n /**\n * Remove a promise from the queue.\n *\n * @param task Can be any PromiseLike\n * @returns Removed promise.\n */\n function remove(task) {\n return buffer.splice(buffer.indexOf(task), 1)[0];\n }\n\n /**\n * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n *\n * @param taskProducer A function producing any PromiseLike; In previous versions this used to be `task:\n * PromiseLike`, but under that model, Promises were instantly created on the call-site and their executor\n * functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n * requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n * limit check.\n * @returns The original promise.\n */\n function add(taskProducer) {\n if (!isReady()) {\n return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n }\n\n // start the task and add its promise to the queue\n const task = taskProducer();\n if (buffer.indexOf(task) === -1) {\n buffer.push(task);\n }\n void task\n .then(() => remove(task))\n // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n // have promises, so TS has to polyfill when down-compiling.)\n .then(null, () =>\n remove(task).then(null, () => {\n // We have to add another catch here because `remove()` starts a new promise chain.\n }),\n );\n return task;\n }\n\n /**\n * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n *\n * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n * `true`.\n * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n * `false` otherwise\n */\n function drain(timeout) {\n return new SyncPromise((resolve, reject) => {\n let counter = buffer.length;\n\n if (!counter) {\n return resolve(true);\n }\n\n // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n const capturedSetTimeout = setTimeout(() => {\n if (timeout && timeout > 0) {\n resolve(false);\n }\n }, timeout);\n\n // if all promises resolve in time, cancel the timer and resolve to `true`\n buffer.forEach(item => {\n void resolvedSyncPromise(item).then(() => {\n if (!--counter) {\n clearTimeout(capturedSetTimeout);\n resolve(true);\n }\n }, reject);\n });\n });\n }\n\n return {\n $: buffer,\n add,\n drain,\n };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\nconst DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n const headerDelay = parseInt(`${header}`, 10);\n if (!isNaN(headerDelay)) {\n return headerDelay * 1000;\n }\n\n const headerDate = Date.parse(`${header}`);\n if (!isNaN(headerDate)) {\n return headerDate - now;\n }\n\n return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nfunction disabledUntil(limits, dataCategory) {\n return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, dataCategory, now = Date.now()) {\n return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nfunction updateRateLimits(\n limits,\n { statusCode, headers },\n now = Date.now(),\n) {\n const updatedRateLimits = {\n ...limits,\n };\n\n // \"The name is case-insensitive.\"\n // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n const retryAfterHeader = headers && headers['retry-after'];\n\n if (rateLimitHeader) {\n /**\n * rate limit headers are of the form\n *
,
,..\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 * Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n * Only present if rate limit applies to the metric_bucket data category.\n */\n for (const limit of rateLimitHeader.trim().split(',')) {\n const [retryAfter, categories, , , namespaces] = limit.split(':', 5);\n const headerDelay = parseInt(retryAfter, 10);\n const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n if (!categories) {\n updatedRateLimits.all = now + delay;\n } else {\n for (const category of categories.split(';')) {\n if (category === 'metric_bucket') {\n // namespaces will be present when category === 'metric_bucket'\n if (!namespaces || namespaces.split(';').includes('custom')) {\n updatedRateLimits[category] = now + delay;\n }\n } else {\n updatedRateLimits[category] = now + delay;\n }\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","// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nconst validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nfunction severityFromString(level) {\n return severityLevelFromString(level) ;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nfunction severityLevelFromString(level) {\n return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","import { node } from './node-stack-trace.js';\nexport { filenameIsInApp } from './node-stack-trace.js';\n\nconst STACKTRACE_FRAME_LIMIT = 50;\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\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 const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n return (stack, skipFirst = 0) => {\n const frames = [];\n const lines = stack.split('\\n');\n\n for (let i = skipFirst; i < lines.length; i++) {\n const line = lines[i];\n // Ignore lines over 1kb as they are unlikely to be stack frames.\n // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n // input size. Huge strings can result in hangs/Denial of Service:\n // https://github.com/getsentry/sentry-javascript/issues/2286\n if (line.length > 1024) {\n continue;\n }\n\n // https://github.com/getsentry/sentry-javascript/issues/5459\n // Remove webpack (error: *) wrappers\n const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n // https://github.com/getsentry/sentry-javascript/issues/7813\n // Skip Error: lines\n if (cleanedLine.match(/\\S*Error: /)) {\n continue;\n }\n\n for (const parser of sortedParsers) {\n const frame = parser(cleanedLine);\n\n if (frame) {\n frames.push(frame);\n break;\n }\n }\n\n if (frames.length >= STACKTRACE_FRAME_LIMIT) {\n break;\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 * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n if (!stack.length) {\n return [];\n }\n\n const localStack = Array.from(stack);\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 (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {\n localStack.pop();\n }\n\n // Reversing in the middle of the procedure allows us to just pop the values off the stack\n localStack.reverse();\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 (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n localStack.pop();\n\n // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n // is produced within the hub itself, making it:\n //\n // Sentry.captureException()\n // getCurrentHub().captureException()\n //\n // instead of just the top `Sentry` call itself.\n // This forces us to possibly strip an additional frame in the exact same was as above.\n if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n localStack.pop();\n }\n }\n\n return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n ...frame,\n filename: frame.filename || localStack[localStack.length - 1].filename,\n function: frame.function || '?',\n }));\n}\n\nconst 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\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 { isVueViewModel, 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.slice(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 const lineLength = newLine.length;\n if (lineLength <= 150) {\n return newLine;\n }\n if (colno > lineLength) {\n // eslint-disable-next-line no-param-reassign\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction safeJoin(input, delimiter) {\n if (!Array.isArray(input)) {\n return '';\n }\n\n const output = [];\n // eslint-disable-next-line @typescript-eslint/prefer-for-of\n for (let i = 0; i < input.length; i++) {\n const value = input[i];\n try {\n // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n // console warnings. This happens when a Vue template is rendered with\n // an undeclared variable, which we try to stringify, ultimately causing\n // Vue to issue another warning which repeats indefinitely.\n // see: https://github.com/getsentry/sentry-javascript/pull/8981\n if (isVueViewModel(value)) {\n output.push('[VueViewModel]');\n } else {\n output.push(String(value));\n }\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 given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nfunction isMatchingPattern(\n value,\n pattern,\n requireExactStringMatch = false,\n) {\n if (!isString(value)) {\n return false;\n }\n\n if (isRegExp(pattern)) {\n return pattern.test(value);\n }\n if (isString(pattern)) {\n return requireExactStringMatch ? value === pattern : value.includes(pattern);\n }\n\n return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nfunction stringMatchesSomePattern(\n testString,\n patterns = [],\n requireExactStringMatch = false,\n) {\n return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n\nexport { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };\n//# sourceMappingURL=string.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { logger } from './logger.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\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-expect-error 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 WINDOW)) {\n return false;\n }\n\n try {\n new Headers();\n new Request('http://www.example.com');\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 */\n// eslint-disable-next-line @typescript-eslint/ban-types\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 (typeof EdgeRuntime === 'string') {\n return true;\n }\n\n if (!supportsFetch()) {\n return false;\n }\n\n // Fast path to avoid DOM I/O\n // eslint-disable-next-line @typescript-eslint/unbound-method\n if (isNativeFetch(WINDOW.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 const doc = WINDOW.document;\n // eslint-disable-next-line deprecation/deprecation\n if (doc && typeof (doc.createElement ) === 'function') {\n try {\n const sandbox = doc.createElement('iframe');\n sandbox.hidden = true;\n doc.head.appendChild(sandbox);\n if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n // eslint-disable-next-line @typescript-eslint/unbound-method\n result = isNativeFetch(sandbox.contentWindow.fetch);\n }\n doc.head.removeChild(sandbox);\n } catch (err) {\n DEBUG_BUILD &&\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 WINDOW;\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\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { isThenable } from './is.js';\n\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n /** Pending */\n const PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n /** Resolved / OK */\n const RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n /** Rejected / Error */\n const 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\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);\n this._state = States.PENDING;\n this._handlers = [];\n\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 __init() {this._resolve = (value) => {\n this._setResult(States.RESOLVED, value);\n };}\n\n /** JSDoc */\n __init2() {this._reject = (reason) => {\n this._setResult(States.REJECTED, reason);\n };}\n\n /** JSDoc */\n __init3() {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 __init4() {this._executeHandlers = () => {\n if (this._state === States.PENDING) {\n return;\n }\n\n const 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 // eslint-disable-next-line @typescript-eslint/no-floating-promises\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 { GLOBAL_OBJ } from './worldwide.js';\n\nconst ONE_SECOND_IN_MS = 1000;\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 timestamp in seconds since the UNIX epoch using the Date API.\n *\n * TODO(v8): Return type should be rounded.\n */\nfunction dateTimestampInSeconds() {\n return Date.now() / ONE_SECOND_IN_MS;\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 createUnixTimestampInSecondsFunc() {\n const { performance } = GLOBAL_OBJ ;\n if (!performance || !performance.now) {\n return dateTimestampInSeconds;\n }\n\n // Some browser and environments don't have a timeOrigin, so we fallback to\n // using Date.now() to compute the starting time.\n const approxStartingTimeOrigin = Date.now() - performance.now();\n const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;\n\n // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n //\n // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n // correct for this.\n // See: https://github.com/getsentry/sentry-javascript/issues/2590\n // See: https://github.com/mdn/content/issues/4713\n // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n return () => {\n return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n };\n}\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 * 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 */\nconst timestampInSeconds = createUnixTimestampInSecondsFunc();\n\n/**\n * Re-exported with an old name for backwards-compatibility.\n * TODO (v8): Remove this\n *\n * @deprecated Use `timestampInSeconds` instead.\n */\nconst timestampWithMs = timestampInSeconds;\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 */\nconst 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 } = GLOBAL_OBJ ;\n if (!performance || !performance.now) {\n _browserPerformanceTimeOriginMode = 'none';\n return undefined;\n }\n\n const threshold = 3600 * 1000;\n const performanceNow = performance.now();\n const dateNow = Date.now();\n\n // if timeOrigin isn't available set delta to threshold so it isn't used\n const timeOriginDelta = performance.timeOrigin\n ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n : threshold;\n const 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 // eslint-disable-next-line deprecation/deprecation\n const navigationStart = performance.timing && performance.timing.navigationStart;\n const hasNavigationStart = typeof navigationStart === 'number';\n // if navigationStart isn't available set delta to threshold so it isn't used\n const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n const 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 };\n//# sourceMappingURL=time.js.map\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 if (!url) {\n return {};\n }\n\n const 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 const query = match[6] || '';\n const fragment = match[8] || '';\n return {\n host: match[4],\n path: match[5],\n protocol: match[2],\n search: query,\n hash: fragment,\n relative: match[5] + query + fragment, // everything minus origin\n };\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 // eslint-disable-next-line no-useless-escape\n return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nfunction getNumberOfUrlSegments(url) {\n // split at '/' or at '\\/' to split regex urls correctly\n return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span description\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nfunction getSanitizedUrlString(url) {\n const { protocol, host, path } = url;\n\n const filteredHost =\n (host &&\n host\n // Always filter out authority\n .replace(/^.*@/, '[filtered]:[filtered]@')\n // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n // TODO: Use new URL global if it exists\n .replace(/(:80)$/, '')\n .replace(/(:443)$/, '')) ||\n '';\n\n return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n\nexport { getNumberOfUrlSegments, getSanitizedUrlString, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","/** Internal global with common properties and Sentry extensions */\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj) {\n return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ =\n (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n // eslint-disable-next-line no-restricted-globals\n (typeof window == 'object' && isGlobalObj(window)) ||\n (typeof self == 'object' && isGlobalObj(self)) ||\n (typeof global == 'object' && isGlobalObj(global)) ||\n (function () {\n return this;\n })() ||\n {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nfunction getGlobalObject() {\n return GLOBAL_OBJ ;\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 `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n const gbl = (obj || GLOBAL_OBJ) ;\n const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=worldwide.js.map\n"],"names":["applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","key","limit","event","hint","exception","values","originalException","Error","length","undefined","exceptions","maxValueLength","aggregateExceptionsFromError","map","value","error","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","Array","isArray","errors","forEach","childError","i","mechanism","type","handled","is_exception_group","exception_id","source","parentId","parent_id","WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","options","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","nextStr","keyAttrs","maxStringLength","_htmlElementAsString","push","parentNode","reverse","join","_oO","el","className","classes","attr","tagName","HTMLElement","dataset","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","keyAttrPair","id","split","allowedAttrs","getLocationHref","document","location","href","oO","getComponentName","_nullishCoalesce","lhs","rhsFn","_optionalChain","ops","lastAccessLHS","op","fn","args","call","createClientReportEnvelope","discarded_events","dsn","timestamp","clientReportItem","DEBUG_BUILD","__SENTRY_DEBUG__","DSN_REGEX","dsnToString","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","makeDsn","from","str","match","exec","console","lastPath","slice","pop","projectMatch","dsnFromString","find","component","isValidProtocol","isNaN","parseInt","validateDsn","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","encodeUTF8","input","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","e","buffers","totalLength","reduce","acc","buf","merged","offset","buffer","set","concatBuffers","createAttachmentEnvelopeItem","attachment","data","filename","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","profile","replay_event","replay_recording","check_in","feedback","span","statsd","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","sdk","name","version","createEventEnvelopeHeaders","sdkInfo","tunnel","dynamicSamplingContext","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","trace","SentryError","constructor","message","logLevel","super","this","prototype","Object","setPrototypeOf","handlers","instrumented","addHandler","handler","maybeInstrument","instrumentFn","triggerHandlers","typeHandlers","addConsoleInstrumentationHandler","instrumentConsole","level","originalConsoleMethod","handlerData","log","apply","DEBOUNCE_DURATION","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","addClickKeypressInstrumentationHandler","instrumentDOM","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","addEventListener","target","proto","hasOwnProperty","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","keys","globalListener","getEventTarget","eventType","isContentEditable","shouldSkipDOMEvent","_sentryId","isSimilarToLastCapturedEvent","global","clearTimeout","setTimeout","addFetchInstrumentationHandler","instrumentFetch","originalFetch","method","url","fetchArgs","getUrlFromResource","hasProp","String","toUpperCase","arg","parseFetchArgs","fetchData","startTimestamp","now","then","response","finishedHandlerData","endTimestamp","erroredHandlerData","obj","prop","resource","toString","_oldOnErrorHandler","addGlobalErrorInstrumentationHandler","instrumentError","onerror","msg","line","column","__SENTRY_LOADER__","arguments","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","addGlobalUnhandledRejectionInstrumentationHandler","instrumentUnhandledRejection","onunhandledrejection","lastHref","addHistoryInstrumentationHandler","instrumentHistory","chromeVar","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","SENTRY_XHR_DATA_KEY","addXhrInstrumentationHandler","instrumentXHR","XMLHttpRequest","xhrproto","originalOpen","e2","parseUrl","request_headers","__sentry_own_request__","onreadystatechangeHandler","xhrInfo","readyState","status_code","status","xhr","onreadystatechange","original","readyStateArgs","setRequestHeaderArgs","header","originalSend","sentryXhrData","body","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isParameterizedString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","isVueViewModel","__isVue","_isVue","isBrowser","window","process","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","logger","enabled","enable","disable","isEnabled","makeLogger","uuid4","gbl","crypto","msCrypto","getRandomByte","Math","random","randomUUID","replace","getRandomValues","typedArray","_","c","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","err","arrayify","maybeArray","isNodeEnv","normalize","depth","maxProperties","visit","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","has","add","delete","splice","memoBuilder","memoize","unmemoize","includes","is","stringified","_events","g","objName","getPrototypeOf","getConstructorName","test","stringifyValue","startsWith","remainingDepth","valueWithToJSON","toJSON","numAdded","visitable","visitKey","visitValue","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","defineProperty","writable","configurable","o_O","getOriginalFunction","func","__sentry_original__","urlEncode","encodeURIComponent","convertToPlainObject","stack","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","isPojo","memoVal","get","returnValue","makePromiseBuffer","remove","task","indexOf","$","taskProducer","drain","timeout","resolve","reject","counter","capturedSetTimeout","DEFAULT_RETRY_AFTER","isRateLimited","limits","dataCategory","all","disabledUntil","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","namespaces","headerDelay","delay","category","headerDate","parse","parseRetryAfterHeader","validSeverityLevels","severityLevelFromString","STACKTRACE_FRAME_LIMIT","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","a","b","p","skipFirst","frames","lines","cleanedLine","frame","localStack","function","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","defaultFunctionName","getFunctionName","truncate","max","safeJoin","delimiter","output","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","isMatchingPattern","supportsFetch","Headers","Request","Response","isNativeFetch","supportsNativeFetch","EdgeRuntime","fetch","result","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","warn","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","executor","__init","__init2","__init3","__init4","_state","PENDING","_handlers","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","ONE_SECOND_IN_MS","dateTimestampInSeconds","timestampInSeconds","performance","approxStartingTimeOrigin","timeOrigin","createUnixTimestampInSecondsFunc","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","query","fragment","search","hash","relative","isGlobalObj","GLOBAL_OBJ","globalThis","self","getGlobalObject","getGlobalSingleton","creator","__SENTRY__"],"sourceRoot":""}