{"version":3,"file":"static/js/92415.dc83959d.js","mappings":"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","sources":["../node_modules/@sentry/react/esm/sdk.js","../node_modules/@sentry/utils/esm/aggregate-errors.js","../node_modules/@sentry/utils/esm/baggage.js","../node_modules/@sentry/utils/esm/browser.js","../node_modules/@sentry/utils/esm/clientreport.js","../node_modules/@sentry/utils/esm/dsn.js","../node_modules/@sentry/utils/esm/env.js","../node_modules/@sentry/utils/esm/envelope.js","../node_modules/@sentry/utils/esm/error.js","../node_modules/@sentry/utils/esm/vendor/supportsHistory.js","../node_modules/@sentry/utils/esm/instrument.js","../node_modules/@sentry/utils/esm/is.js","../node_modules/@sentry/utils/esm/isBrowser.js","../node_modules/@sentry/utils/esm/logger.js","../node_modules/@sentry/utils/esm/misc.js","../node_modules/@sentry/utils/esm/node.js","../node_modules/@sentry/utils/esm/normalize.js","../node_modules/@sentry/utils/esm/memo.js","../node_modules/@sentry/utils/esm/object.js","../node_modules/@sentry/utils/esm/promisebuffer.js","../node_modules/@sentry/utils/esm/ratelimit.js","../node_modules/@sentry/utils/esm/severity.js","../node_modules/@sentry/utils/esm/stacktrace.js","../node_modules/@sentry/utils/esm/string.js","../node_modules/@sentry/utils/esm/supports.js","../node_modules/@sentry/utils/esm/syncpromise.js","../node_modules/@sentry/utils/esm/time.js","../node_modules/@sentry/utils/esm/tracing.js","../node_modules/@sentry/utils/esm/url.js","../node_modules/@sentry/utils/esm/worldwide.js"],"sourcesContent":["import _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport { SDK_VERSION, init as init$1 } from '@sentry/browser';\n/**\n * Inits the React SDK\n */\n\nfunction init(options) {\n  var opts = _objectSpread({\n    _metadata: {}\n  }, options);\n\n  opts._metadata.sdk = opts._metadata.sdk || {\n    name: 'sentry.javascript.react',\n    packages: [{\n      name: 'npm:@sentry/react',\n      version: SDK_VERSION\n    }],\n    version: SDK_VERSION\n  };\n  init$1(opts);\n}\n\nexport { init };","import _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport _toConsumableArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js\";\nimport { isInstanceOf } from './is.js';\nimport { truncate } from './string.js';\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\n\nfunction applyAggregateErrorsToEvent(exceptionFromErrorImplementation, parser) {\n  var maxValueLimit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 250;\n  var key = arguments.length > 3 ? arguments[3] : undefined;\n  var limit = arguments.length > 4 ? arguments[4] : undefined;\n  var event = arguments.length > 5 ? arguments[5] : undefined;\n  var hint = arguments.length > 6 ? arguments[6] : undefined;\n\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  } // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n\n\n  var originalException = event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined; // We only create exception grouping if there is an exception in the event.\n\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, hint.originalException, key, event.exception.values, originalException, 0), maxValueLimit);\n  }\n}\n\nfunction aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error, key, prevExceptions, exception, exceptionId) {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  var newExceptions = _toConsumableArray(prevExceptions);\n\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    var newException = exceptionFromErrorImplementation(parser, error[key]);\n    var newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error[key], key, [newException].concat(_toConsumableArray(newExceptions)), newException, newExceptionId);\n  } // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n\n\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach(function (childError, i) {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n\n        var _newException = exceptionFromErrorImplementation(parser, childError);\n\n        var _newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(_newException, \"errors[\".concat(i, \"]\"), _newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, childError, key, [_newException].concat(_toConsumableArray(newExceptions)), _newException, _newExceptionId);\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 || {\n    type: 'generic',\n    handled: true\n  };\n  exception.mechanism = _objectSpread(_objectSpread({}, exception.mechanism), {}, {\n    is_exception_group: true,\n    exception_id: exceptionId\n  });\n}\n\nfunction applyExceptionGroupFieldsForChildException(exception, source, exceptionId, parentId) {\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 || {\n    type: 'generic',\n    handled: true\n  };\n  exception.mechanism = _objectSpread(_objectSpread({}, exception.mechanism), {}, {\n    type: 'chained',\n    source: source,\n    exception_id: exceptionId,\n    parent_id: parentId\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 */\n\n\nfunction truncateAggregateExceptions(exceptions, maxValueLength) {\n  return exceptions.map(function (exception) {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    return exception;\n  });\n}\n\nexport { applyAggregateErrorsToEvent };","import _slicedToArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nimport _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport { isString } from './is.js';\nimport { logger } from './logger.js';\nvar BAGGAGE_HEADER_NAME = 'baggage';\nvar SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\nvar SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\n\nvar MAX_BAGGAGE_STRING_LENGTH = 8192;\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\n\nfunction baggageHeaderToDynamicSamplingContext( // Very liberal definition of what any incoming header might look like\nbaggageHeader) {\n  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {\n    return undefined;\n  } // Intermediary object to store baggage key value pairs of incoming baggage headers on.\n  // It is later used to read Sentry-DSC-values from.\n\n\n  var baggageObject = {};\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    baggageObject = baggageHeader.reduce(function (acc, curr) {\n      var currBaggageObject = baggageHeaderToObject(curr);\n      return _objectSpread(_objectSpread({}, acc), currBaggageObject);\n    }, {});\n  } else {\n    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but\n    // this is how we choose to handle it)\n    if (!baggageHeader) {\n      return undefined;\n    }\n\n    baggageObject = baggageHeaderToObject(baggageHeader);\n  } // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n\n\n  var dynamicSamplingContext = Object.entries(baggageObject).reduce(function (acc, _ref) {\n    var _ref2 = _slicedToArray(_ref, 2),\n        key = _ref2[0],\n        value = _ref2[1];\n\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      var nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n\n    return acc;\n  }, {}); // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext;\n  } else {\n    return undefined;\n  }\n}\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\n\n\nfunction dynamicSamplingContextToSentryBaggageHeader( // this also takes undefined for convenience and bundle size in other places\ndynamicSamplingContext) {\n  if (!dynamicSamplingContext) {\n    return undefined;\n  } // Prefix all DSC keys with \"sentry-\" and put them into a new object\n\n\n  var sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(function (acc, _ref3) {\n    var _ref4 = _slicedToArray(_ref3, 2),\n        dscKey = _ref4[0],\n        dscValue = _ref4[1];\n\n    if (dscValue) {\n      acc[\"\".concat(SENTRY_BAGGAGE_KEY_PREFIX).concat(dscKey)] = dscValue;\n    }\n\n    return acc;\n  }, {});\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\n\n\nfunction baggageHeaderToObject(baggageHeader) {\n  return baggageHeader.split(',').map(function (baggageEntry) {\n    return baggageEntry.split('=').map(function (keyOrValue) {\n      return decodeURIComponent(keyOrValue.trim());\n    });\n  }).reduce(function (acc, _ref5) {\n    var _ref6 = _slicedToArray(_ref5, 2),\n        key = _ref6[0],\n        value = _ref6[1];\n\n    acc[key] = value;\n    return acc;\n  }, {});\n}\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\n\n\nfunction objectToBaggageHeader(object) {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce(function (baggageHeader, _ref7, currentIndex) {\n    var _ref8 = _slicedToArray(_ref7, 2),\n        objectKey = _ref8[0],\n        objectValue = _ref8[1];\n\n    var baggageEntry = \"\".concat(encodeURIComponent(objectKey), \"=\").concat(encodeURIComponent(objectValue));\n    var newBaggageHeader = currentIndex === 0 ? baggageEntry : \"\".concat(baggageHeader, \",\").concat(baggageEntry);\n\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(\"Not adding key: \".concat(objectKey, \" with val: \").concat(objectValue, \" to baggage header due to exceeding baggage size limits.\"));\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader };","import { isString } from './is.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\nvar DEFAULT_MAX_STRING_LENGTH = 80;\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 */\n\nfunction htmlTreeAsString(elem) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  if (!elem) {\n    return '<unknown>';\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\n\n  try {\n    var currentElem = elem;\n    var MAX_TRAVERSE_HEIGHT = 5;\n    var out = [];\n    var height = 0;\n    var len = 0;\n    var separator = ' > ';\n    var sepLength = separator.length;\n    var nextStr;\n    var keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    var maxStringLength = !Array.isArray(options) && options.maxStringLength || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs); // 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\n      if (nextStr === 'html' || height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength) {\n        break;\n      }\n\n      out.push(nextStr);\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\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 */\n\n\nfunction _htmlElementAsString(el, keyAttrs) {\n  var elem = el;\n  var out = [];\n  var className;\n  var classes;\n  var key;\n  var attr;\n  var i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase()); // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n\n  var keyAttrPairs = keyAttrs && keyAttrs.length ? keyAttrs.filter(function (keyAttr) {\n    return elem.getAttribute(keyAttr);\n  }).map(function (keyAttr) {\n    return [keyAttr, elem.getAttribute(keyAttr)];\n  }) : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(function (keyAttrPair) {\n      out.push(\"[\".concat(keyAttrPair[0], \"=\\\"\").concat(keyAttrPair[1], \"\\\"]\"));\n    });\n  } else {\n    if (elem.id) {\n      out.push(\"#\".concat(elem.id));\n    } // eslint-disable-next-line prefer-const\n\n\n    className = elem.className;\n\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n\n      for (i = 0; i < classes.length; i++) {\n        out.push(\".\".concat(classes[i]));\n      }\n    }\n  }\n\n  var allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n\n    if (attr) {\n      out.push(\"[\".concat(key, \"=\\\"\").concat(attr, \"\\\"]\"));\n    }\n  }\n\n  return out.join('');\n}\n/**\n * A safe form of location.href\n */\n\n\nfunction getLocationHref() {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\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<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction getDomElement(selector) {\n  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector);\n  }\n\n  return null;\n}\n\nexport { getDomElement, getLocationHref, htmlTreeAsString };","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\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 */\n\nfunction createClientReportEnvelope(discarded_events, dsn, timestamp) {\n  var clientReportItem = [{\n    type: 'client_report'\n  }, {\n    timestamp: timestamp || dateTimestampInSeconds(),\n    discarded_events: discarded_events\n  }];\n  return createEnvelope(dsn ? {\n    dsn: dsn\n  } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };","import _slicedToArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nimport { logger } from './logger.js';\n/** Regular expression used to parse a Dsn. */\n\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\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 */\n\n\nfunction dsnToString(dsn) {\n  var withPassword = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  var host = dsn.host,\n      path = dsn.path,\n      pass = dsn.pass,\n      port = dsn.port,\n      projectId = dsn.projectId,\n      protocol = dsn.protocol,\n      publicKey = dsn.publicKey;\n  return \"\".concat(protocol, \"://\").concat(publicKey).concat(withPassword && pass ? \":\".concat(pass) : '') + \"@\".concat(host).concat(port ? \":\".concat(port) : '', \"/\").concat(path ? \"\".concat(path, \"/\") : path).concat(projectId);\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 */\n\n\nfunction dsnFromString(str) {\n  var match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    // eslint-disable-next-line no-console\n    console.error(\"Invalid Sentry Dsn: \".concat(str));\n    return undefined;\n  }\n\n  var _match$slice = match.slice(1),\n      _match$slice2 = _slicedToArray(_match$slice, 6),\n      protocol = _match$slice2[0],\n      publicKey = _match$slice2[1],\n      _match$slice2$ = _match$slice2[2],\n      pass = _match$slice2$ === void 0 ? '' : _match$slice2$,\n      host = _match$slice2[3],\n      _match$slice2$2 = _match$slice2[4],\n      port = _match$slice2$2 === void 0 ? '' : _match$slice2$2,\n      lastPath = _match$slice2[5];\n\n  var path = '';\n  var projectId = lastPath;\n  var split = projectId.split('/');\n\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop();\n  }\n\n  if (projectId) {\n    var projectMatch = projectId.match(/^\\d+/);\n\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({\n    host: host,\n    pass: pass,\n    path: path,\n    projectId: projectId,\n    port: port,\n    protocol: protocol,\n    publicKey: publicKey\n  });\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 (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return true;\n  }\n\n  var port = dsn.port,\n      projectId = dsn.projectId,\n      protocol = dsn.protocol;\n  var requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  var hasMissingRequiredComponent = requiredComponents.find(function (component) {\n    if (!dsn[component]) {\n      logger.error(\"Invalid Sentry Dsn: \".concat(component, \" missing\"));\n      return true;\n    }\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 \".concat(projectId));\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(\"Invalid Sentry Dsn: Invalid protocol \".concat(protocol));\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(\"Invalid Sentry Dsn: Invalid port \".concat(port));\n    return false;\n  }\n\n  return true;\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 */\n\n\nfunction makeDsn(from) {\n  var components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };","/*\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 * Get source of SDK.\n */\n\n\nfunction getSDKSource() {\n  // @ts-expect-error \"npm\" is injected by rollup during build process\n  return \"npm\";\n}\n\nexport { getSDKSource, isBrowserBundle };","import _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport _createForOfIteratorHelper from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js\";\nimport _toConsumableArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js\";\nimport _slicedToArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nimport { dsnToString } from './dsn.js';\nimport { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\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 */\n\nfunction createEnvelope(headers) {\n  var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  return [headers, items];\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 */\n\n\nfunction addItemToEnvelope(envelope, newItem) {\n  var _envelope = _slicedToArray(envelope, 2),\n      headers = _envelope[0],\n      items = _envelope[1];\n\n  return [headers, [].concat(_toConsumableArray(items), [newItem])];\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 */\n\n\nfunction forEachEnvelopeItem(envelope, callback) {\n  var envelopeItems = envelope[1];\n\n  var _iterator = _createForOfIteratorHelper(envelopeItems),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var envelopeItem = _step.value;\n      var envelopeItemType = envelopeItem[0].type;\n      var result = callback(envelopeItem, envelopeItemType);\n\n      if (result) {\n        return true;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return false;\n}\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\n\n\nfunction envelopeContainsItemType(envelope, types) {\n  return forEachEnvelopeItem(envelope, function (_, type) {\n    return types.includes(type);\n  });\n}\n/**\n * Encode a string to UTF8.\n */\n\n\nfunction encodeUTF8(input, textEncoder) {\n  var utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n/**\n * Serializes an envelope.\n */\n\n\nfunction serializeEnvelope(envelope, textEncoder) {\n  var _envelope2 = _slicedToArray(envelope, 2),\n      envHeaders = _envelope2[0],\n      items = _envelope2[1]; // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n\n\n  var 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  var _iterator2 = _createForOfIteratorHelper(items),\n      _step2;\n\n  try {\n    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n      var item = _step2.value;\n\n      var _item = _slicedToArray(item, 2),\n          itemHeaders = _item[0],\n          payload = _item[1];\n\n      append(\"\\n\".concat(JSON.stringify(itemHeaders), \"\\n\"));\n\n      if (typeof payload === 'string' || payload instanceof Uint8Array) {\n        append(payload);\n      } else {\n        var stringifiedPayload = void 0;\n\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\n        append(stringifiedPayload);\n      }\n    }\n  } catch (err) {\n    _iterator2.e(err);\n  } finally {\n    _iterator2.f();\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  var totalLength = buffers.reduce(function (acc, buf) {\n    return acc + buf.length;\n  }, 0);\n  var merged = new Uint8Array(totalLength);\n  var offset = 0;\n\n  var _iterator3 = _createForOfIteratorHelper(buffers),\n      _step3;\n\n  try {\n    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n      var buffer = _step3.value;\n      merged.set(buffer, offset);\n      offset += buffer.length;\n    }\n  } catch (err) {\n    _iterator3.e(err);\n  } finally {\n    _iterator3.f();\n  }\n\n  return merged;\n}\n/**\n * Parses an envelope\n */\n\n\nfunction parseEnvelope(env, textEncoder, textDecoder) {\n  var buffer = typeof env === 'string' ? textEncoder.encode(env) : env;\n\n  function readBinary(length) {\n    var bin = buffer.subarray(0, length); // Replace the buffer with the remaining data excluding trailing newline\n\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson() {\n    var i = buffer.indexOf(0xa); // If we couldn't find a newline, we must have found the end of the buffer\n\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(textDecoder.decode(readBinary(i)));\n  }\n\n  var envelopeHeader = readJson(); // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n  var items = [];\n\n  while (buffer.length) {\n    var itemHeader = readJson();\n    var binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n/**\n * Creates attachment envelope items\n */\n\n\nfunction createAttachmentEnvelopeItem(attachment, textEncoder) {\n  var buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n  return [dropUndefinedKeys({\n    type: 'attachment',\n    length: buffer.length,\n    filename: attachment.filename,\n    content_type: attachment.contentType,\n    attachment_type: attachment.attachmentType\n  }), buffer];\n}\n\nvar 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  // TODO: This is a temporary workaround until we have a proper data category for metrics\n  statsd: 'unknown'\n};\n/**\n * Maps the type of an envelope item to a data category.\n */\n\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n/** Extracts the minimal SDK info from from the metadata or an events */\n\n\nfunction getSdkMetadataForEnvelopeHeader(metadataOrEvent) {\n  if (!metadataOrEvent || !metadataOrEvent.sdk) {\n    return;\n  }\n\n  var _metadataOrEvent$sdk = metadataOrEvent.sdk,\n      name = _metadataOrEvent$sdk.name,\n      version = _metadataOrEvent$sdk.version;\n  return {\n    name: name,\n    version: 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 */\n\n\nfunction createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {\n  var dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return _objectSpread(_objectSpread(_objectSpread({\n    event_id: event.event_id,\n    sent_at: new Date().toISOString()\n  }, sdkInfo && {\n    sdk: sdkInfo\n  }), !!tunnel && dsn && {\n    dsn: dsnToString(dsn)\n  }), dynamicSamplingContext && {\n    trace: dropUndefinedKeys(_objectSpread({}, dynamicSamplingContext))\n  });\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };","import _createClass from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createClass.js\";\nimport _classCallCheck from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/classCallCheck.js\";\nimport _assertThisInitialized from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js\";\nimport _inherits from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/inherits.js\";\nimport _createSuper from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createSuper.js\";\nimport _wrapNativeSuper from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js\";\n\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /*#__PURE__*/function (_Error) {\n  _inherits(SentryError, _Error);\n\n  var _super = _createSuper(SentryError);\n\n  /** Display name of this error instance. */\n  function SentryError(message) {\n    var _this;\n\n    var logLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'warn';\n\n    _classCallCheck(this, SentryError);\n\n    _this = _super.call(this, message);\n    _this.message = message;\n    _this.name = (this instanceof SentryError ? this.constructor : void 0).prototype.constructor.name; // 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\n    Object.setPrototypeOf(_assertThisInitialized(_this), (this instanceof SentryError ? this.constructor : void 0).prototype);\n    _this.logLevel = logLevel;\n    return _this;\n  }\n\n  return _createClass(SentryError);\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n\nexport { SentryError };","import { getGlobalObject } from '../worldwide.js'; // Based on https://github.com/angular/angular.js/pull/13945/files\n// eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\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\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  var chrome = WINDOW.chrome;\n  var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n  var hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { supportsHistory };","import _slicedToArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nimport _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport _createForOfIteratorHelper from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js\";\nimport { isString } from './is.js';\nimport { logger, CONSOLE_LEVELS, originalConsoleMethods } from './logger.js';\nimport { uuid4 } from './misc.js';\nimport { fill, addNonEnumerableProperty } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch } from './supports.js';\nimport { getGlobalObject, GLOBAL_OBJ } from './worldwide.js';\nimport { supportsHistory } from './vendor/supportsHistory.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\nvar SENTRY_XHR_DATA_KEY = '__sentry_xhr_v2__';\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\n\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n\n    case 'dom':\n      instrumentDOM();\n      break;\n\n    case 'xhr':\n      instrumentXHR();\n      break;\n\n    case 'fetch':\n      instrumentFetch();\n      break;\n\n    case 'history':\n      instrumentHistory();\n      break;\n\n    case 'error':\n      instrumentError();\n      break;\n\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\n\n\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  handlers[type].push(callback);\n  instrument(type);\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 */\n\n\nfunction resetInstrumentationHandlers() {\n  Object.keys(handlers).forEach(function (key) {\n    handlers[key] = undefined;\n  });\n}\n/** JSDoc */\n\n\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  var _iterator = _createForOfIteratorHelper(handlers[type] || []),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var handler = _step.value;\n\n      try {\n        handler(data);\n      } catch (e) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(\"Error while triggering instrumentation handler.\\nType: \".concat(type, \"\\nName: \").concat(getFunctionName(handler), \"\\nError:\"), e);\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n}\n/** JSDoc */\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      return function () {\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        triggerHandlers('console', {\n          args: args,\n          level: level\n        });\n        var log = originalConsoleMethods[level];\n        log && log.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n/** JSDoc */\n\n\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {\n    return function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      var _parseFetchArgs = parseFetchArgs(args),\n          method = _parseFetchArgs.method,\n          url = _parseFetchArgs.url;\n\n      var handlerData = {\n        args: args,\n        fetchData: {\n          method: method,\n          url: url\n        },\n        startTimestamp: Date.now()\n      };\n      triggerHandlers('fetch', _objectSpread({}, handlerData)); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\n      return originalFetch.apply(GLOBAL_OBJ, args).then(function (response) {\n        triggerHandlers('fetch', _objectSpread(_objectSpread({}, handlerData), {}, {\n          endTimestamp: Date.now(),\n          response: response\n        }));\n        return response;\n      }, function (error) {\n        triggerHandlers('fetch', _objectSpread(_objectSpread({}, handlerData), {}, {\n          endTimestamp: Date.now(),\n          error: error\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\n        throw error;\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 * Parses the fetch arguments to find the used Http method and the url of the request\n */\n\n\nfunction parseFetchArgs(fetchArgs) {\n  if (fetchArgs.length === 0) {\n    return {\n      method: 'GET',\n      url: ''\n    };\n  }\n\n  if (fetchArgs.length === 2) {\n    var _fetchArgs = _slicedToArray(fetchArgs, 2),\n        url = _fetchArgs[0],\n        options = _fetchArgs[1];\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET'\n    };\n  }\n\n  var arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET'\n  };\n}\n/** JSDoc */\n\n\nfunction instrumentXHR() {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (!WINDOW.XMLHttpRequest) {\n    return;\n  }\n\n  var xhrproto = XMLHttpRequest.prototype;\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function () {\n      var _this = this;\n\n      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n        args[_key3] = arguments[_key3];\n      }\n\n      var startTimestamp = Date.now();\n      var url = args[1];\n      var xhrInfo = this[SENTRY_XHR_DATA_KEY] = {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n        request_headers: {}\n      }; // if Sentry key appears in URL, don't capture it as a request\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        this.__sentry_own_request__ = true;\n      }\n\n      var onreadystatechangeHandler = function onreadystatechangeHandler() {\n        // For whatever reason, this is not the same instance here as from the outer method\n        var 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          triggerHandlers('xhr', {\n            args: args,\n            endTimestamp: Date.now(),\n            startTimestamp: startTimestamp,\n            xhr: _this\n          });\n        }\n      };\n\n      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {\n        fill(this, 'onreadystatechange', function (original) {\n          return function () {\n            onreadystatechangeHandler();\n\n            for (var _len4 = arguments.length, readyStateArgs = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n              readyStateArgs[_key4] = arguments[_key4];\n            }\n\n            return original.apply(this, readyStateArgs);\n          };\n        });\n      } else {\n        this.addEventListener('readystatechange', onreadystatechangeHandler);\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\n\n      fill(this, 'setRequestHeader', function (original) {\n        return function () {\n          for (var _len5 = arguments.length, setRequestHeaderArgs = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n            setRequestHeaderArgs[_key5] = arguments[_key5];\n          }\n\n          var header = setRequestHeaderArgs[0],\n              value = setRequestHeaderArgs[1];\n          var xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return original.apply(this, setRequestHeaderArgs);\n        };\n      });\n      return originalOpen.apply(this, args);\n    };\n  });\n  fill(xhrproto, 'send', function (originalSend) {\n    return function () {\n      var sentryXhrData = this[SENTRY_XHR_DATA_KEY];\n\n      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n        args[_key6] = arguments[_key6];\n      }\n\n      if (sentryXhrData && args[0] !== undefined) {\n        sentryXhrData.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args: args,\n        startTimestamp: Date.now(),\n        xhr: this\n      });\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nvar lastHref;\n/** JSDoc */\n\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  var oldOnPopState = WINDOW.onpopstate;\n\n  WINDOW.onpopstate = function () {\n    var to = WINDOW.location.href; // keep track of the current URL state, as we always receive only the updated state\n\n    var from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from: from,\n      to: to\n    });\n\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {\n          args[_key7] = arguments[_key7];\n        }\n\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {// no-empty\n      }\n    }\n  };\n  /** @hidden */\n\n\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function () {\n      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {\n        args[_key8] = arguments[_key8];\n      }\n\n      var url = args.length > 2 ? args[2] : undefined;\n\n      if (url) {\n        // coerce to string (this is what pushState does)\n        var from = lastHref;\n        var to = String(url); // keep track of the current URL state, as we always receive only the updated state\n\n        lastHref = to;\n        triggerHandlers('history', {\n          from: from,\n          to: to\n        });\n      }\n\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nvar DEBOUNCE_DURATION = 1000;\nvar debounceTimerID;\nvar lastCapturedEventType;\nvar lastCapturedEventTargetId;\n/**\n * Check whether the event is similar to the last captured one. For example, two click events on the same button.\n */\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) {// just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\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\n\n  return true;\n}\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\n\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  } // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n  // e.g.tabbing through elements, hotkeys, etc.\n\n\n  if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n    return false;\n  }\n\n  return true;\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/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\n\n\nfunction makeDOMEventHandler(handler) {\n  var globalListener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  return function (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    var target = getEventTarget(event); // We always want to skip _some_ events.\n\n    if (shouldSkipDOMEvent(event.type, target)) {\n      return;\n    } // Mark event as \"seen\"\n\n\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    var name = event.type === 'keypress' ? 'input' : event.type; // 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\n    if (!isSimilarToLastCapturedEvent(event)) {\n      handler({\n        event: event,\n        name: name,\n        global: globalListener\n      });\n      lastCapturedEventType = event.type;\n      lastCapturedEventTargetId = target ? target._sentryId : undefined;\n    } // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n\n\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(function () {\n      lastCapturedEventTargetId = undefined;\n      lastCapturedEventType = undefined;\n    }, DEBOUNCE_DURATION);\n  };\n}\n/** JSDoc */\n\n\nfunction instrumentDOM() {\n  if (!WINDOW.document) {\n    return;\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\n\n  var triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false); // 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\n  ['EventTarget', 'Node'].forEach(function (target) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var proto = WINDOW[target] && WINDOW[target].prototype; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (type, listener, options) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this;\n\n            var _handlers = el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {};\n\n            var handlerForType = _handlers[type] = _handlers[type] || {\n              refCount: 0\n            };\n\n            if (!handlerForType.handler) {\n              var handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount++;\n          } catch (e) {// 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    fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n      return function (type, listener, options) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this;\n\n            var _handlers2 = el.__sentry_instrumentation_handlers__ || {};\n\n            var handlerForType = _handlers2[type];\n\n            if (handlerForType) {\n              handlerForType.refCount--; // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n\n              if (handlerForType.refCount <= 0) {\n                originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                handlerForType.handler = undefined;\n                delete _handlers2[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n              } // If there are no longer any custom handlers of any type on this element, cleanup everything.\n\n\n              if (Object.keys(_handlers2).length === 0) {\n                delete el.__sentry_instrumentation_handlers__;\n              }\n            }\n          } catch (e) {// 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\nvar _oldOnErrorHandler = null;\n/** JSDoc */\n\nfunction instrumentError() {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column: column,\n      error: error,\n      line: line,\n      msg: msg,\n      url: url\n    });\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  WINDOW.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\n\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;\n\n  WINDOW.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\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  WINDOW.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { SENTRY_XHR_DATA_KEY, addInstrumentationHandler, instrumentDOM, instrumentXHR, parseFetchArgs, resetInstrumentationHandlers };","// eslint-disable-next-line @typescript-eslint/unbound-method\nvar objectToString = Object.prototype.toString;\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 */\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\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 */\n\n\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === \"[object \".concat(className, \"]\");\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 */\n\n\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\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 */\n\n\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\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 */\n\n\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\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 */\n\n\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\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 */\n\n\nfunction isPrimitive(wat) {\n  return wat === null || typeof wat !== 'object' && typeof wat !== 'function';\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\n\n\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\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 */\n\n\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\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 */\n\n\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\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 */\n\n\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\n\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 * 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 */\n\n\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\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 */\n\n\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\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 */\n\n\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\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 */\n\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, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };","import { isNodeEnv } from './node.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n/**\n * Returns true if we are in the browser.\n */\n\nfunction isBrowser() {\n  // eslint-disable-next-line no-restricted-globals\n  return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());\n} // Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them\n\n\nfunction isElectronNodeRenderer() {\n  return (// 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 };","import { GLOBAL_OBJ } from './worldwide.js';\n/** Prefix for logging strings */\n\nvar PREFIX = 'Sentry Logger ';\nvar CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'];\n/** This may be mutated by the console instrumentation. */\n\nvar originalConsoleMethods = {};\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 */\n\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  var console = GLOBAL_OBJ.console;\n  var wrappedFuncs = {};\n  var wrappedLevels = Object.keys(originalConsoleMethods); // Restore all wrapped console methods\n\n  wrappedLevels.forEach(function (level) {\n    var 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(function (level) {\n      console[level] = wrappedFuncs[level];\n    });\n  }\n}\n\nfunction makeLogger() {\n  var enabled = false;\n  var logger = {\n    enable: function enable() {\n      enabled = true;\n    },\n    disable: function disable() {\n      enabled = false;\n    },\n    isEnabled: function isEnabled() {\n      return enabled;\n    }\n  };\n\n  if (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) {\n    CONSOLE_LEVELS.forEach(function (name) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = function () {\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        if (enabled) {\n          consoleSandbox(function () {\n            var _GLOBAL_OBJ$console;\n\n            (_GLOBAL_OBJ$console = GLOBAL_OBJ.console)[name].apply(_GLOBAL_OBJ$console, [\"\".concat(PREFIX, \"[\").concat(name, \"]:\")].concat(args));\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(function (name) {\n      logger[name] = function () {\n        return undefined;\n      };\n    });\n  }\n\n  return logger;\n}\n\nvar logger = makeLogger();\nexport { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };","import _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\n\nfunction uuid4() {\n  var gbl = GLOBAL_OBJ;\n  var crypto = gbl.crypto || gbl.msCrypto;\n\n  var getRandomByte = function getRandomByte() {\n    return Math.random() * 16;\n  };\n\n  try {\n    if (crypto && crypto.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n\n    if (crypto && crypto.getRandomValues) {\n      getRandomByte = function getRandomByte() {\n        return crypto.getRandomValues(new Uint8Array(1))[0];\n      };\n    }\n  } catch (_) {// some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\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\n\n  return ([1e7] + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, function (c) {\n    return (// eslint-disable-next-line no-bitwise\n      (c ^ (getRandomByte() & 15) >> c / 4).toString(16)\n    );\n  });\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\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 */\n\n\nfunction getEventDescription(event) {\n  var message = event.message,\n      eventId = event.event_id;\n\n  if (message) {\n    return message;\n  }\n\n  var firstException = getFirstException(event);\n\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return \"\".concat(firstException.type, \": \").concat(firstException.value);\n    }\n\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n\n  return eventId || '<unknown>';\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 */\n\n\nfunction addExceptionTypeValue(event, value, type) {\n  var exception = event.exception = event.exception || {};\n  var values = exception.values = exception.values || [];\n  var firstException = values[0] = values[0] || {};\n\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\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 */\n\n\nfunction addExceptionMechanism(event, newMechanism) {\n  var firstException = getFirstException(event);\n\n  if (!firstException) {\n    return;\n  }\n\n  var defaultMechanism = {\n    type: 'generic',\n    handled: true\n  };\n  var currentMechanism = firstException.mechanism;\n  firstException.mechanism = _objectSpread(_objectSpread(_objectSpread({}, defaultMechanism), currentMechanism), newMechanism);\n\n  if (newMechanism && 'data' in newMechanism) {\n    var mergedData = _objectSpread(_objectSpread({}, currentMechanism && currentMechanism.data), newMechanism.data);\n\n    firstException.mechanism.data = mergedData;\n  }\n} // https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\n\n\nvar SEMVER_REGEXP = /^(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 * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\n\nfunction parseSemver(input) {\n  var match = input.match(SEMVER_REGEXP) || [];\n  var major = parseInt(match[1], 10);\n  var minor = parseInt(match[2], 10);\n  var patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4]\n  };\n}\n/**\n * 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 */\n\n\nfunction addContextToFrame(lines, frame) {\n  var linesOfContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;\n\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  var maxLines = lines.length;\n  var sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n  frame.pre_context = lines.slice(Math.max(0, sourceLine - linesOfContext), sourceLine).map(function (line) {\n    return snipLine(line, 0);\n  });\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n  frame.post_context = lines.slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext).map(function (line) {\n    return 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 */\n\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) {// `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\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 */\n\n\nfunction arrayify(maybeArray) {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };","import { isBrowserBundle } from './env.js';\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 */\n\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return !isBrowserBundle() && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\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\n\n\nfunction dynamicRequire(mod, request) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\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 */\n\n\nfunction loadModule(moduleName) {\n  var mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {// no-empty\n  }\n\n  try {\n    var _dynamicRequire = dynamicRequire(module, 'process'),\n        cwd = _dynamicRequire.cwd;\n\n    mod = dynamicRequire(module, \"\".concat(cwd(), \"/node_modules/\").concat(moduleName));\n  } catch (e) {// no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };","import _slicedToArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nimport { isNaN, isVueViewModel, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\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\n\nfunction normalize(input) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;\n  var maxProperties = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : +Infinity;\n\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 {\n      ERROR: \"**non-serializable** (\".concat(err, \")\")\n    };\n  }\n}\n/** JSDoc */\n\n\nfunction normalizeToSize( // eslint-disable-next-line @typescript-eslint/no-explicit-any\nobject) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;\n  var maxSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100 * 1024;\n  var 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 * 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 */\n\n\nfunction visit(key, value) {\n  var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : +Infinity;\n  var maxProperties = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : +Infinity;\n  var memo = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : memoBuilder();\n\n  var _memo = _slicedToArray(memo, 2),\n      memoize = _memo[0],\n      unmemoize = _memo[1]; // Get the simple cases out of the way first\n\n\n  if (value == null || // this matches null and undefined -> eqeq not eqeqeq\n  ['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value)) {\n    return value;\n  }\n\n  var stringified = stringifyValue(key, value); // 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\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  } // From here on, we can assert that `value` is either an object or an array.\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\n\n  if (value['__sentry_skip_normalization__']) {\n    return value;\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\n\n  var remainingDepth = typeof value['__sentry_override_normalization_depth__'] === 'number' ? value['__sentry_override_normalization_depth__'] : depth; // We're also done if we've reached the max depth\n\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  } // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n\n\n  if (memoize(value)) {\n    return '[Circular ~]';\n  } // If the value has a `toJSON` method, we call it to extract more information\n\n\n  var valueWithToJSON = value;\n\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      var jsonValue = valueWithToJSON.toJSON(); // We need to normalize the return value of `.toJSON()` in case it has circular references\n\n      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n    } catch (err) {// pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\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\n\n  var normalized = Array.isArray(value) ? [] : {};\n  var numAdded = 0; // 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\n  var visitable = convertToPlainObject(value);\n\n  for (var 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    } // Recursively visit all the child nodes\n\n\n    var visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n    numAdded++;\n  } // Once we've visited all the branches, remove the parent from memo storage\n\n\n  unmemoize(value); // Return accumulated values\n\n  return normalized;\n}\n/* eslint-disable complexity */\n\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 */\n\n\nfunction stringifyValue(key, // 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\nvalue) {\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    } // 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\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    } // eslint-disable-next-line no-restricted-globals\n\n\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    } // eslint-disable-next-line no-restricted-globals\n\n\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    if (isVueViewModel(value)) {\n      return '[VueViewModel]';\n    } // React's SyntheticEvent thingy\n\n\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: \".concat(getFunctionName(value), \"]\");\n    }\n\n    if (typeof value === 'symbol') {\n      return \"[\".concat(String(value), \"]\");\n    } // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n\n\n    if (typeof value === 'bigint') {\n      return \"[BigInt: \".concat(String(value), \"]\");\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\n\n    var objName = getConstructorName(value); // Handle HTML Elements\n\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return \"[HTMLElement: \".concat(objName, \"]\");\n    }\n\n    return \"[object \".concat(objName, \"]\");\n  } catch (err) {\n    return \"**non-serializable** (\".concat(err, \")\");\n  }\n}\n/* eslint-enable complexity */\n\n\nfunction getConstructorName(value) {\n  var prototype = Object.getPrototypeOf(value);\n  return prototype ? prototype.constructor.name : 'null prototype';\n}\n/** Calculates bytes size of input string */\n\n\nfunction utf8Length(value) {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  var hasWeakSet = typeof WeakSet === 'function';\n  var inner = hasWeakSet ? new WeakSet() : [];\n\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n\n      inner.add(obj);\n      return false;\n    } // eslint-disable-next-line @typescript-eslint/prefer-for-of\n\n\n    for (var i = 0; i < inner.length; i++) {\n      var value = inner[i];\n\n      if (value === obj) {\n        return true;\n      }\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 (var i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };","import _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { logger } from './logger.js';\nimport { truncate } from './string.js';\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, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\n\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  var original = source[name];\n  var wrapped = replacementFactory(original); // 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\n  if (typeof wrapped === 'function') {\n    markFunctionWrapped(wrapped, original);\n  }\n\n  source[name] = wrapped;\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 */\n\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    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(\"Failed to add non-enumerable property \\\"\".concat(name, \"\\\" to object\"), obj);\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 */\n\n\nfunction markFunctionWrapped(wrapped, original) {\n  try {\n    var 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 */\n\n\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\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 */\n\n\nfunction urlEncode(object) {\n  return Object.keys(object).map(function (key) {\n    return \"\".concat(encodeURIComponent(key), \"=\").concat(encodeURIComponent(object[key]));\n  }).join('&');\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 */\n\n\nfunction convertToPlainObject(value) {\n  if (isError(value)) {\n    return _objectSpread({\n      message: value.message,\n      name: value.name,\n      stack: value.stack\n    }, getOwnProperties(value));\n  } else if (isEvent(value)) {\n    var newObj = _objectSpread({\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget)\n    }, getOwnProperties(value));\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/** Creates a string representation of the target of an `Event` object */\n\n\nfunction serializeEventTarget(target) {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n/** Filters out all but an object's own properties */\n\n\nfunction getOwnProperties(obj) {\n  if (typeof obj === 'object' && obj !== null) {\n    var extractedProps = {};\n\n    for (var property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = obj[property];\n      }\n    }\n\n    return extractedProps;\n  } else {\n    return {};\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 */\n\n\nfunction extractExceptionKeysForMessage(exception) {\n  var maxLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 40;\n  var keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    var serialized = keys.slice(0, includedKeys).join(', ');\n\n    if (serialized.length > maxLength) {\n      continue;\n    }\n\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\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 */\n\n\nfunction dropUndefinedKeys(inputValue) {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  var memoizationMap = new Map(); // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    var memoVal = memoizationMap.get(inputValue);\n\n    if (memoVal !== undefined) {\n      return memoVal;\n    }\n\n    var returnValue = {}; // Store the mapping of this value in case we visit it again, in case of circular data\n\n    memoizationMap.set(inputValue, returnValue);\n\n    for (var _i = 0, _Object$keys = Object.keys(inputValue); _i < _Object$keys.length; _i++) {\n      var key = _Object$keys[_i];\n\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    var _memoVal = memoizationMap.get(inputValue);\n\n    if (_memoVal !== undefined) {\n      return _memoVal;\n    }\n\n    var _returnValue = []; // Store the mapping of this value in case we visit it again, in case of circular data\n\n    memoizationMap.set(inputValue, _returnValue);\n    inputValue.forEach(function (item) {\n      _returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n    return _returnValue;\n  }\n\n  return inputValue;\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 */\n\n\nfunction objectify(wat) {\n  var objectified;\n\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\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\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new wat.constructor(wat);\n      break;\n    // by process of elimination, at this point we know that `wat` must already be an object\n\n    default:\n      objectified = wat;\n      break;\n  }\n\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\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 */\n\nfunction makePromiseBuffer(limit) {\n  var buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n\n\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\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<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, 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\n\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    } // start the task and add its promise to the queue\n\n\n    var task = taskProducer();\n\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n\n    void task.then(function () {\n      return 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, function () {\n      return remove(task).then(null, function () {// We have to add another catch here because `remove()` starts a new promise chain.\n      });\n    });\n    return task;\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\n\n  function drain(timeout) {\n    return new SyncPromise(function (resolve, reject) {\n      var counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      } // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n\n\n      var capturedSetTimeout = setTimeout(function () {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout); // if all promises resolve in time, cancel the timer and resolve to `true`\n\n      buffer.forEach(function (item) {\n        void resolvedSyncPromise(item).then(function () {\n          if (! --counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add: add,\n    drain: drain\n  };\n}\n\nexport { makePromiseBuffer };","import _slicedToArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js\";\nimport _createForOfIteratorHelper from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js\";\nimport _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nvar 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 */\n\nfunction parseRetryAfterHeader(header) {\n  var now = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Date.now();\n  var headerDelay = parseInt(\"\".concat(header), 10);\n\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  var headerDate = Date.parse(\"\".concat(header));\n\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\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 */\n\n\nfunction disabledUntil(limits, category) {\n  return limits[category] || limits.all || 0;\n}\n/**\n * Checks if a category is rate limited\n */\n\n\nfunction isRateLimited(limits, category) {\n  var now = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Date.now();\n  return disabledUntil(limits, category) > now;\n}\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\n\n\nfunction updateRateLimits(limits, _ref) {\n  var statusCode = _ref.statusCode,\n      headers = _ref.headers;\n  var now = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Date.now();\n\n  var updatedRateLimits = _objectSpread({}, limits); // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n\n\n  var rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  var retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     */\n    var _iterator = _createForOfIteratorHelper(rateLimitHeader.trim().split(',')),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var limit = _step.value;\n\n        var _limit$split = limit.split(':', 2),\n            _limit$split2 = _slicedToArray(_limit$split, 2),\n            retryAfter = _limit$split2[0],\n            categories = _limit$split2[1];\n\n        var headerDelay = parseInt(retryAfter, 10);\n        var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n\n        if (!categories) {\n          updatedRateLimits.all = now + delay;\n        } else {\n          var _iterator2 = _createForOfIteratorHelper(categories.split(';')),\n              _step2;\n\n          try {\n            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n              var category = _step2.value;\n              updatedRateLimits[category] = now + delay;\n            }\n          } catch (err) {\n            _iterator2.e(err);\n          } finally {\n            _iterator2.f();\n          }\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\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 };","// 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.\nvar validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\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 */\n\nfunction severityFromString(level) {\n  return severityLevelFromString(level);\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 */\n\n\nfunction severityLevelFromString(level) {\n  return level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log';\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };","import _objectSpread from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/objectSpread2.js\";\nimport _toConsumableArray from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js\";\nimport _createForOfIteratorHelper from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js\";\nimport { node } from './node-stack-trace.js';\nexport { filenameIsInApp } from './node-stack-trace.js';\nvar STACKTRACE_FRAME_LIMIT = 50; // Used to sanitize webpack (error: *) wrapped stack errors\n\nvar WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nvar STRIP_FRAME_REGEXP = /captureMessage|captureException/;\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 */\n\nfunction createStackParser() {\n  for (var _len = arguments.length, parsers = new Array(_len), _key = 0; _key < _len; _key++) {\n    parsers[_key] = arguments[_key];\n  }\n\n  var sortedParsers = parsers.sort(function (a, b) {\n    return a[0] - b[0];\n  }).map(function (p) {\n    return p[1];\n  });\n  return function (stack) {\n    var skipFirst = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    var frames = [];\n    var lines = stack.split('\\n');\n\n    for (var i = skipFirst; i < lines.length; i++) {\n      var line = lines[i]; // 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\n      if (line.length > 1024) {\n        continue;\n      } // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n\n\n      var cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line; // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\n\n      var _iterator = _createForOfIteratorHelper(sortedParsers),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var parser = _step.value;\n          var frame = parser(cleanedLine);\n\n          if (frame) {\n            frames.push(frame);\n            break;\n          }\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n\n      if (frames.length >= STACKTRACE_FRAME_LIMIT) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\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 */\n\n\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser.apply(void 0, _toConsumableArray(stackParser));\n  }\n\n  return stackParser;\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 */\n\n\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  var localStack = Array.from(stack); // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n\n  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n  } // Reversing in the middle of the procedure allows us to just pop the values off the stack\n\n\n  localStack.reverse(); // 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\n  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop(); // 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\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(function (frame) {\n    return _objectSpread(_objectSpread({}, frame), {}, {\n      filename: frame.filename || localStack[localStack.length - 1].filename,\n      function: frame.function || '?'\n    });\n  });\n}\n\nvar defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\n\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\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 * 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 */\n\n\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };","import { isVueViewModel, isString, isRegExp } from './is.js';\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 */\n\nfunction truncate(str) {\n  var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n\n  return str.length <= max ? str : \"\".concat(str.slice(0, max), \"...\");\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 */\n\n\nfunction snipLine(line, colno) {\n  var newLine = line;\n  var lineLength = newLine.length;\n\n  if (lineLength <= 150) {\n    return newLine;\n  }\n\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  var start = Math.max(colno - 60, 0);\n\n  if (start < 5) {\n    start = 0;\n  }\n\n  var end = Math.min(start + 140, lineLength);\n\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n\n  if (start > 0) {\n    newLine = \"'{snip} \".concat(newLine);\n  }\n\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\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\n\n\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  var output = []; // eslint-disable-next-line @typescript-eslint/prefer-for-of\n\n  for (var i = 0; i < input.length; i++) {\n    var value = input[i];\n\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 * 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 */\n\n\nfunction isMatchingPattern(value, pattern) {\n  var requireExactStringMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\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 */\n\n\nfunction stringMatchesSomePattern(testString) {\n  var patterns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  var requireExactStringMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  return patterns.some(function (pattern) {\n    return isMatchingPattern(testString, pattern, requireExactStringMatch);\n  });\n}\n\nexport { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };","import { logger } from './logger.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\n\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\n\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 * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\n\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\n\n\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\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 */\n\n\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  } // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n\n\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\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\n\n  var result = false;\n  var doc = WINDOW.document; // eslint-disable-next-line deprecation/deprecation\n\n  if (doc && typeof doc.createElement === 'function') {\n    try {\n      var sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && 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 * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\n\n\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in WINDOW;\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\n\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  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 };","import _classCallCheck from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/classCallCheck.js\";\nimport _createClass from \"/home/deploy/dash/node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createClass.js\";\nimport { isThenable } from './is.js';\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\n\nvar States;\n\n(function (States) {\n  /** Pending */\n  var PENDING = 0;\n  States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n\n  var RESOLVED = 1;\n  States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n\n  var REJECTED = 2;\n  States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {})); // 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 */\n\n\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(function (resolve) {\n    resolve(value);\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 */\n\n\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise(function (_, reject) {\n    reject(reason);\n  });\n}\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\n\n\nvar SyncPromise = /*#__PURE__*/function () {\n  function SyncPromise(executor) {\n    _classCallCheck(this, SyncPromise);\n\n    SyncPromise.prototype.__init.call(this);\n\n    SyncPromise.prototype.__init2.call(this);\n\n    SyncPromise.prototype.__init3.call(this);\n\n    SyncPromise.prototype.__init4.call(this);\n\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  /** JSDoc */\n\n\n  _createClass(SyncPromise, [{\n    key: \"then\",\n    value: function then(onfulfilled, onrejected) {\n      var _this = this;\n\n      return new SyncPromise(function (resolve, reject) {\n        _this._handlers.push([false, function (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        }, function (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    /** JSDoc */\n\n  }, {\n    key: \"catch\",\n    value: function _catch(onrejected) {\n      return this.then(function (val) {\n        return val;\n      }, onrejected);\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"finally\",\n    value: function _finally(onfinally) {\n      var _this2 = this;\n\n      return new SyncPromise(function (resolve, reject) {\n        var val;\n        var isRejected;\n        return _this2.then(function (value) {\n          isRejected = false;\n          val = value;\n\n          if (onfinally) {\n            onfinally();\n          }\n        }, function (reason) {\n          isRejected = true;\n          val = reason;\n\n          if (onfinally) {\n            onfinally();\n          }\n        }).then(function () {\n          if (isRejected) {\n            reject(val);\n            return;\n          }\n\n          resolve(val);\n        });\n      });\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init\",\n    value: function __init() {\n      var _this3 = this;\n\n      this._resolve = function (value) {\n        _this3._setResult(States.RESOLVED, value);\n      };\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init2\",\n    value: function __init2() {\n      var _this4 = this;\n\n      this._reject = function (reason) {\n        _this4._setResult(States.REJECTED, reason);\n      };\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init3\",\n    value: function __init3() {\n      var _this5 = this;\n\n      this._setResult = function (state, value) {\n        if (_this5._state !== States.PENDING) {\n          return;\n        }\n\n        if (isThenable(value)) {\n          void value.then(_this5._resolve, _this5._reject);\n          return;\n        }\n\n        _this5._state = state;\n        _this5._value = value;\n\n        _this5._executeHandlers();\n      };\n    }\n    /** JSDoc */\n\n  }, {\n    key: \"__init4\",\n    value: function __init4() {\n      var _this6 = this;\n\n      this._executeHandlers = function () {\n        if (_this6._state === States.PENDING) {\n          return;\n        }\n\n        var cachedHandlers = _this6._handlers.slice();\n\n        _this6._handlers = [];\n        cachedHandlers.forEach(function (handler) {\n          if (handler[0]) {\n            return;\n          }\n\n          if (_this6._state === States.RESOLVED) {\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\n            handler[1](_this6._value);\n          }\n\n          if (_this6._state === States.REJECTED) {\n            handler[2](_this6._value);\n          }\n\n          handler[0] = true;\n        });\n      };\n    }\n  }]);\n\n  return SyncPromise;\n}();\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };","import { isNodeEnv, dynamicRequire } from './node.js';\nimport { getGlobalObject } from './worldwide.js'; // eslint-disable-next-line deprecation/deprecation\n\nvar WINDOW = getGlobalObject();\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\n\nvar dateTimestampSource = {\n  nowSeconds: function nowSeconds() {\n    return Date.now() / 1000;\n  }\n};\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\n\nfunction getBrowserPerformance() {\n  var performance = WINDOW.performance;\n\n  if (!performance || !performance.now) {\n    return undefined;\n  } // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n\n\n  var timeOrigin = Date.now() - performance.now();\n  return {\n    now: function now() {\n      return performance.now();\n    },\n    timeOrigin: timeOrigin\n  };\n}\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\n\n\nfunction getNodePerformance() {\n  try {\n    var perfHooks = dynamicRequire(module, 'perf_hooks');\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\n\n\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined ? dateTimestampSource : {\n  nowSeconds: function nowSeconds() {\n    return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000;\n  }\n};\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\n\nvar dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\n\nvar timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n/**\n * Re-exported with an old name for backwards-compatibility.\n * TODO (v8): Remove this\n *\n * @deprecated Use `timestampInSeconds` instead.\n */\n\nvar timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\n\nvar usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\n\nvar _browserPerformanceTimeOriginMode;\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 */\n\n\nvar browserPerformanceTimeOrigin = function () {\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  var performance = WINDOW.performance;\n\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  var threshold = 3600 * 1000;\n  var performanceNow = performance.now();\n  var dateNow = Date.now(); // if timeOrigin isn't available set delta to threshold so it isn't used\n\n  var timeOriginDelta = performance.timeOrigin ? Math.abs(performance.timeOrigin + performanceNow - dateNow) : threshold;\n  var timeOriginIsReliable = timeOriginDelta < threshold; // 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\n  var navigationStart = performance.timing && performance.timing.navigationStart;\n  var hasNavigationStart = typeof navigationStart === 'number'; // if navigationStart isn't available set delta to threshold so it isn't used\n\n  var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  var navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  } // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n\n\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n}();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };","import { baggageHeaderToDynamicSamplingContext } from './baggage.js';\nimport { uuid4 } from './misc.js';\nvar TRACEPARENT_REGEXP = new RegExp('^[ \\\\t]*' + // whitespace\n'([0-9a-f]{32})?' + // trace_id\n'-?([0-9a-f]{16})?' + // span_id\n'-?([01])?' + // sampled\n'[ \\\\t]*$');\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\n\nfunction extractTraceparentData(traceparent) {\n  if (!traceparent) {\n    return undefined;\n  }\n\n  var matches = traceparent.match(TRACEPARENT_REGEXP);\n\n  if (!matches) {\n    return undefined;\n  }\n\n  var parentSampled;\n\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled: parentSampled,\n    parentSpanId: matches[2]\n  };\n}\n/**\n * Create tracing context from incoming headers.\n */\n\n\nfunction tracingContextFromHeaders(sentryTrace, baggage) {\n  var traceparentData = extractTraceparentData(sentryTrace);\n  var dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  var _ref = traceparentData || {},\n      traceId = _ref.traceId,\n      parentSpanId = _ref.parentSpanId,\n      parentSampled = _ref.parentSampled;\n\n  var propagationContext = {\n    traceId: traceId || uuid4(),\n    spanId: uuid4().substring(16),\n    sampled: parentSampled\n  };\n\n  if (parentSpanId) {\n    propagationContext.parentSpanId = parentSpanId;\n  }\n\n  if (dynamicSamplingContext) {\n    propagationContext.dsc = dynamicSamplingContext;\n  }\n\n  return {\n    traceparentData: traceparentData,\n    dynamicSamplingContext: dynamicSamplingContext,\n    propagationContext: propagationContext\n  };\n}\n/**\n * Create sentry-trace header from span context values.\n */\n\n\nfunction generateSentryTraceHeader() {\n  var traceId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : uuid4();\n  var spanId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : uuid4().substring(16);\n  var sampled = arguments.length > 2 ? arguments[2] : undefined;\n  var sampledString = '';\n\n  if (sampled !== undefined) {\n    sampledString = sampled ? '-1' : '-0';\n  }\n\n  return \"\".concat(traceId, \"-\").concat(spanId).concat(sampledString);\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, tracingContextFromHeaders };","/**\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 <a/> 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  var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  } // coerce to undefined values to empty string so we don't get 'undefined'\n\n\n  var query = match[6] || '';\n  var fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    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 */\n\n\nfunction stripUrlQueryAndFragment(urlPath) {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n/**\n * Returns number of URL segments of a passed string URL.\n */\n\n\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(function (s) {\n    return s.length > 0 && s !== ',';\n  }).length;\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 */\n\n\nfunction getSanitizedUrlString(url) {\n  var protocol = url.protocol,\n      host = url.host,\n      path = url.path;\n  var filteredHost = host && host // Always filter out authority\n  .replace(/^.*@/, '[filtered]:[filtered]@') // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n  .replace(':80', '').replace(':443', '') || '';\n  return \"\".concat(protocol ? \"\".concat(protocol, \"://\") : '').concat(filteredHost).concat(path);\n}\n\nexport { getNumberOfUrlSegments, getSanitizedUrlString, parseUrl, stripUrlQueryAndFragment };","/** Internal global with common properties and Sentry extensions  */\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/** Get's the global object for the current JavaScript runtime */\n\n\nvar GLOBAL_OBJ = typeof globalThis == 'object' && isGlobalObj(globalThis) || // eslint-disable-next-line no-restricted-globals\ntypeof window == 'object' && isGlobalObj(window) || typeof self == 'object' && isGlobalObj(self) || typeof global == 'object' && isGlobalObj(global) || function () {\n  return this;\n}() || {};\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\n\n\nfunction getGlobalObject() {\n  return GLOBAL_OBJ;\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 */\n\n\nfunction getGlobalSingleton(name, creator, obj) {\n  var gbl = obj || GLOBAL_OBJ;\n\n  var __SENTRY__ = gbl.__SENTRY__ = gbl.__SENTRY__ || {};\n\n  var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };"],"names":["init","options","opts","_metadata","sdk","name","packages","version","applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","arguments","length","undefined","key","limit","event","hint","exception","values","originalException","Error","exceptions","maxValueLength","aggregateExceptionsFromError","map","value","error","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","concat","Array","isArray","errors","forEach","childError","i","_newException","_newExceptionId","mechanism","type","handled","is_exception_group","exception_id","source","parentId","parent_id","BAGGAGE_HEADER_NAME","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","baggageHeaderToDynamicSamplingContext","baggageHeader","baggageObject","reduce","acc","curr","currBaggageObject","baggageHeaderToObject","dynamicSamplingContext","Object","entries","_ref","_ref2","match","slice","keys","dynamicSamplingContextToSentryBaggageHeader","object","_ref7","currentIndex","_ref8","objectKey","objectValue","baggageEntry","encodeURIComponent","newBaggageHeader","__SENTRY_DEBUG__","warn","objectToBaggageHeader","_ref3","_ref4","dscKey","dscValue","split","keyOrValue","decodeURIComponent","trim","_ref5","_ref6","WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","nextStr","currentElem","out","height","len","keyAttrs","maxStringLength","_htmlElementAsString","separator","push","parentNode","reverse","join","_oO","el","className","classes","attr","tagName","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","keyAttrPair","id","allowedAttrs","getLocationHref","document","location","href","oO","getDomElement","selector","querySelector","createClientReportEnvelope","discarded_events","dsn","timestamp","clientReportItem","DSN_REGEX","dsnToString","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","makeDsn","from","str","exec","_match$slice","_match$slice2","_match$slice2$","_match$slice2$2","pop","projectMatch","console","dsnFromString","find","component","isValidProtocol","isNaN","parseInt","validateDsn","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","headers","addItemToEnvelope","envelope","newItem","_envelope","items","forEachEnvelopeItem","callback","_step","envelopeItems","_iterator","s","n","done","envelopeItem","err","e","f","encodeUTF8","input","textEncoder","TextEncoder","encode","serializeEnvelope","_envelope2","envHeaders","parts","JSON","stringify","append","next","_step2","_iterator2","item","_item","itemHeaders","payload","Uint8Array","stringifiedPayload","buffers","_step3","totalLength","buf","merged","offset","_iterator3","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","statsd","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","_metadataOrEvent$sdk","createEventEnvelopeHeaders","sdkInfo","tunnel","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","trace","SentryError","_Error","_super","message","_this","logLevel","this","call","constructor","prototype","setPrototypeOf","lastHref","SENTRY_XHR_DATA_KEY","handlers","instrumented","instrument","level","originalConsoleMethod","_len","args","_key","triggerHandlers","log","apply","instrumentConsole","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","addEventListener","target","proto","hasOwnProperty","originalAddEventListener","listener","_handlers","__sentry_instrumentation_handlers__","handlerForType","refCount","handler","originalRemoveEventListener","_handlers2","instrumentDOM","XMLHttpRequest","xhrproto","originalOpen","_len3","_key3","startTimestamp","now","url","xhrInfo","method","is","toUpperCase","request_headers","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","endTimestamp","xhr","onreadystatechange","original","_len4","readyStateArgs","_key4","_len5","setRequestHeaderArgs","_key5","header","originalSend","sentryXhrData","_len6","_key6","body","instrumentXHR","supports","originalFetch","_len2","_key2","_parseFetchArgs","fetchArgs","_fetchArgs","getUrlFromResource","hasProp","String","arg","parseFetchArgs","handlerData","fetchData","then","response","instrumentFetch","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","_len8","_key8","to","_len7","_key7","instrumentHistory","_oldOnErrorHandler","onerror","msg","line","column","__SENTRY_LOADER__","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","onunhandledrejection","logger","addInstrumentationHandler","obj","prop","resource","toString","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","DEBOUNCE_DURATION","globalListener","getEventTarget","eventType","isContentEditable","shouldSkipDOMEvent","_sentryId","isSimilarToLastCapturedEvent","global","clearTimeout","setTimeout","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","isVueViewModel","__isVue","_isVue","isBrowser","window","process","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","enabled","enable","disable","isEnabled","_GLOBAL_OBJ$console","makeLogger","uuid4","gbl","crypto","msCrypto","getRandomByte","Math","random","randomUUID","replace","getRandomValues","_","c","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","arrayify","maybeArray","isNodeEnv","dynamicRequire","mod","request","require","normalize","depth","maxProperties","Infinity","visit","ERROR","normalizeToSize","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","has","add","delete","splice","memoBuilder","_memo","memoize","unmemoize","includes","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","convertToPlainObject","stack","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","memoVal","get","returnValue","_i","_Object$keys","_memoVal","_returnValue","makePromiseBuffer","remove","task","indexOf","$","taskProducer","drain","timeout","resolve","reject","counter","capturedSetTimeout","DEFAULT_RETRY_AFTER","isRateLimited","limits","category","all","disabledUntil","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","_limit$split","_limit$split2","retryAfter","categories","headerDelay","delay","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","fn","truncate","max","safeJoin","delimiter","output","stringMatchesSomePattern","testString","requireExactStringMatch","some","pattern","isMatchingPattern","supportsFetch","Headers","Request","Response","isNativeFetch","supportsNativeFetch","fetch","result","doc","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","executor","__init","__init2","__init3","__init4","_state","PENDING","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","_this2","isRejected","_this3","_setResult","RESOLVED","_this4","REJECTED","_this5","state","_value","_this6","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","TRACEPARENT_REGEXP","RegExp","tracingContextFromHeaders","sentryTrace","baggage","traceparentData","traceparent","parentSampled","matches","traceId","parentSpanId","extractTraceparentData","propagationContext","spanId","substring","sampled","dsc","generateSentryTraceHeader","sampledString","parseUrl","query","fragment","search","hash","relative","isGlobalObj","GLOBAL_OBJ","globalThis","self","getGlobalObject","getGlobalSingleton","creator","__SENTRY__"],"sourceRoot":""}