{"version":3,"sources":["webpack:///./node_modules/@sentry/utils/esm/normalize.js","webpack:///./node_modules/hyphenate-style-name/index.js","webpack:///./node_modules/css-in-js-utils/lib/hyphenateProperty.js","webpack:///./node_modules/@sentry/core/esm/version.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/utils/esm/envelope.js","webpack:///./node_modules/@sentry/utils/esm/baggage.js","webpack:///./node_modules/@sentry/core/esm/envelope.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/utils/esm/clientreport.js","webpack:///./node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/utils/esm/severity.js","webpack:///./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/transports/utils.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/@sentry/browser/esm/stack-parsers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack:///./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/utils/esm/ratelimit.js","webpack:///./node_modules/@sentry/core/esm/transports/base.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js","webpack:///./node_modules/@sentry/react/esm/sdk.js","webpack:///./node_modules/@sentry/react/esm/errorboundary.js","webpack:///./node_modules/inline-style-prefixer/es/utils/capitalizeString.js","webpack:///./node_modules/inline-style-prefixer/es/utils/prefixProperty.js","webpack:///./node_modules/inline-style-prefixer/es/utils/prefixValue.js","webpack:///./node_modules/inline-style-prefixer/es/utils/addNewValuesOnly.js","webpack:///./node_modules/inline-style-prefixer/es/utils/isObject.js","webpack:///./node_modules/inline-style-prefixer/es/createPrefixer.js","webpack:///./node_modules/inline-style-prefixer/es/data.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/backgroundClip.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/cursor.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/crossFade.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/filter.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/flex.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/flexboxOld.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/gradient.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/grid.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/imageSet.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/logical.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/position.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/sizing.js","webpack:///./node_modules/inline-style-prefixer/es/plugins/transition.js","webpack:///./node_modules/inline-style-prefixer/es/index.js","webpack:///./node_modules/styletron-engine-atomic/dist/browser.es5.es.js","webpack:///./src/layouts/Overlay.tsx","webpack:///./src/layouts/Root.jsx","webpack:///./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack:///./node_modules/@sentry/utils/esm/stacktrace.js","webpack:///./node_modules/css-in-js-utils/lib/isPrefixedValue.js","webpack:///./node_modules/@sentry/utils/esm/memo.js"],"names":["normalize","input","depth","Infinity","maxProperties","visit","err","ERROR","normalizeToSize","object","maxSize","normalized","jsonSize","key","value","memo","memoize","unmemoize","valueWithToJSON","toJSON","includes","stringified","stringifyValue","startsWith","replace","Array","isArray","numAdded","visitable","visitKey","Object","prototype","hasOwnProperty","call","visitValue","_events","global","window","document","String","getPrototypeOf","constructor","name","utf8Length","encodeURI","split","length","JSON","stringify","uppercasePattern","msPattern","cache","toHyphenLower","match","toLowerCase","hyphenateStyleName","hName","test","defineProperty","exports","default","hyphenateProperty","_hyphenateStyleName","_hyphenateStyleName2","_interopRequireDefault","obj","__esModule","property","module","SDK_VERSION","originalFunctionToString","__init","this","id","Function","toString","args","context","apply","__initStatic","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","addGlobalEventProcessor","getCurrentHub","eventProcess","event","hub","self","getIntegration","client","getClient","clientOptions","getOptions","options","_mergeOptions","_shouldDropEvent","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","undefined","_isSentryError","__SENTRY_DEBUG__","logger","warn","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","_getPossibleEventMessages","some","message","pattern","url","exception","type","values","oO","error","e","_getLastValidUrl","frames","i","frame","filename","stacktrace","installedIntegrations","filterDuplicates","integrations","reduce","acc","every","accIntegration","push","getIntegrationsToSetup","defaultIntegrations","userIntegrations","filter","userIntegration","integrationsNames","map","alwaysLastToRun","indexOf","splice","setupIntegrations","integrationIndex","forEach","integration","setupOnce","log","initAndBind","clientClass","debug","enable","console","scope","getScope","update","initialScope","bindClient","SentryError","Error","super","setPrototypeOf","DSN_REGEX","isValidProtocol","protocol","dsnToString","dsn","withPassword","host","path","pass","port","projectId","publicKey","dsnFromString","str","exec","lastPath","slice","join","pop","projectMatch","dsnFromComponents","components","validateDsn","requiredComponents","component","isNaN","parseInt","makeDsn","from","SENTRY_API_VERSION","getBaseApiEndpoint","_getIngestEndpoint","_encodedAuth","sentry_key","sentry_version","getEnvelopeEndpointWithUrlEncodedAuth","tunnel","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","user","encodeURIComponent","email","supportsFetch","Headers","Request","Response","isNativeFetch","func","supportsNativeFetch","fetch","result","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","handlers","instrumented","instrument","instrumentConsole","instrumentDOM","instrumentXHR","instrumentFetch","instrumentHistory","instrumentError","instrumentUnhandledRejection","addInstrumentationHandler","callback","triggerHandlers","data","handler","level","originalConsoleMethod","originalFetch","handlerData","fetchData","method","getFetchMethod","getFetchUrl","startTimestamp","Date","now","then","response","endTimestamp","fetchArgs","is","toUpperCase","xhrproto","XMLHttpRequest","originalOpen","xhr","xhrInfo","__sentry_xhr__","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","onreadystatechange","original","readyStateArgs","addEventListener","originalSend","body","lastHref","oldOnPopState","onpopstate","to","location","href","_oO","historyReplacementFunction","originalHistoryFunction","debounceDuration","debounceTimerID","lastCapturedEvent","shouldShortcircuitPreviousDebounce","previous","current","target","shouldSkipDOMEvent","tagName","isContentEditable","makeDOMEventHandler","globalListener","clearTimeout","setTimeout","triggerDOMHandler","bind","globalDOMEventHandler","proto","originalAddEventListener","listener","el","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","keys","_oldOnErrorHandler","onerror","msg","line","column","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","envelopeItems","envelopeItem","envelopeItemType","encodeUTF8","textEncoder","utf8","TextEncoder","encode","serializeEnvelope","envHeaders","parts","append","next","item","itemHeaders","payload","Uint8Array","concatBuffers","buffers","totalLength","buf","merged","offset","buffer","set","createAttachmentEnvelopeItem","attachment","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","envelopeItemTypeToDataCategory","getSentryBaggageItems","baggage","getSdkMetadataForEnvelopeHeader","metadata","sdk","version","enhanceEventWithSdkInfo","sdkInfo","packages","createSessionEnvelope","envelopeHeaders","sent_at","toISOString","createEventEnvelope","eventType","transactionSampling","sdkProcessingMetadata","samplingMethod","rate","sampleRate","createEventEnvelopeHeaders","eventItem","sample_rates","dynamicSamplingContext","event_id","trace","ALREADY_SEEN_ERROR","_integrations","_integrationsInitialized","_numProcessing","_outcomes","__init2","__init3","__init4","_dsn","_transport","transport","recordDroppedEvent","transportOptions","hint","eventId","_process","eventFromException","_captureEvent","promisedEvent","eventFromMessage","originalException","_isEnabled","release","sendSession","init","timeout","_isClientDoneProcessing","clientFinished","flush","transportFlushed","enabled","integrationId","env","_metadata","attachments","_optionalChain","_","_2","_3","_sendEnvelope","reason","category","sendClientReports","crashed","errored","exceptions","ex","mechanism","handled","sessionNonTerminal","shouldUpdateAndSend","errors","Number","captureSession","resolve","ticked","tick","interval","setInterval","clearInterval","normalizeDepth","normalizeMaxBreadth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","clone","getAttachments","applyToEvent","evt","_normalizeEvent","maxBreadth","breadcrumbs","b","contexts","extra","spans","span","environment","dist","maxValueLength","request","integrationsArray","_processEvent","finalEvent","beforeSend","isTransaction","Math","random","_prepareEvent","isInternalException","__sentry__","beforeSendResult","_ensureBeforeSendRv","processedEvent","getSession","_updateSessionFromEvent","sendEvent","captureException","promise","send","outcomes","quantity","rv","nullErr","createClientReportEnvelope","discarded_events","clientReportItem","exceptionFromError","stackParser","parseStackFrames","extractMessage","eventFromPlainObject","syntheticException","isUnhandledRejection","__serialized__","eventFromError","stack","popSize","getPopSize","reactMinifiedRegexp","framesToPop","attachStacktrace","eventFromUnknownInput","eventFromString","errorEvent","domException","tags","code","objectException","synthetic","validSeverityLevels","severityLevelFromString","BREADCRUMB_INTEGRATION_ID","dom","sentry","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","_innerDomBreadcrumb","keyAttrs","serializeAttribute","addBreadcrumb","breadcrumb","parsedLoc","parsedFrom","parsedTo","relative","cachedFetchImpl","getNativeFetchImplementation","fetchImpl","sendReport","isRealNavigator","navigator","hasSendBeacon","sendBeacon","credentials","keepalive","globalObject","visibilityState","_flushOutcomes","breadcrumbIntegration","getIntegrationById","platform","_clearOutcomes","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","addEventProcessor","descriptor","getOwnPropertyDescriptor","configurable","UNKNOWN_FUNCTION","CHROME_PRIORITY","WINJS_PRIORITY","GECKO_PRIORITY","createFrame","lineno","colno","function","in_app","chromeRegex","chromeEvalRegex","isEval","subMatch","extractSafariExtensionDetails","chromeStackLineParser","geckoREgex","geckoEvalRegex","gecko","geckoStackLineParser","winjsRegex","winjs","winjsStackLineParser","defaultStackLineParsers","defaultStackParser","isSafariExtension","isSafariWebExtension","DEFAULT_EVENT_TARGET","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","originalCallback","xmlHttpRequestProps","prop","wrapOptions","originalFunction","eventName","handleEvent","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","stackTraceLimit","installFunc","globalHandlerLog","getHubAndOptions","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","addMechanismAndCapture","detail","_eventFromRejectionWithPrimitive","ERROR_TYPES_RE","groups","ev","ev0","ev0s","ev0sf","captureEvent","DEFAULT_KEY","DEFAULT_LIMIT","_key","_limit","limit","_handler","parser","linkedErrors","_walkErrorTree","eventProcessor","currentEvent","_previousEvent","previousEvent","_isSameMessageEvent","_isSameExceptionEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","previousException","_getExceptionFromEvent","currentException","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","referrer","userAgent","Referer","makePromiseBuffer","isReady","remove","task","add","taskProducer","drain","reject","counter","capturedSetTimeout","$","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","header","headerDelay","headerDate","parse","disabledUntil","limits","all","isRateLimited","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","delay","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","bufferSize","rateLimits","filteredEnvelopeItems","envelopeItemDataCategory","filteredEnvelope","recordEnvelopeLoss","requestTask","makeFetchTransport","nativeFetch","requestOptions","referrerPolicy","fetchOptions","get","XHR_READYSTATE_DONE","makeXHRTransport","getResponseHeader","open","setRequestHeader","FunctionToString","SENTRY_RELEASE","autoSessionTracking","startSessionTracking","showReportDialog","getStackTop","getDsn","getUser","lastEventId","script","async","src","onLoad","onload","injectionPoint","startSessionOnHub","startSession","ignoreDuration","isAtLeastReact17","major","INITIAL_STATE","componentStack","state","beforeCapture","onError","showDialog","props","errorBoundaryError","cause","react","setState","onMount","onUnmount","resetErrorBoundary","onReset","fallback","children","element","resetError","capitalizeString","charAt","prefixProperty","prefixProperties","style","newStyle","requiredPrefixes","capitalizedProperty","styleProperty","j","prefixValue","plugins","metaData","len","processedValue","addIfNew","list","addNewValuesOnly","isObject","createPrefixer","_ref","prefixMap","prefix","combinedValue","_processedValue","w","m","ms","wm","wms","wmms","backgroundClip","grab","grabbing","cursor","crossFade","flex","alternativeValues","alternativeProps","alignItems","justifyContent","flexWrap","flexGrow","flexboxOld","WebkitBoxOrient","WebkitBoxDirection","gradient","grad","_slicedToArray","sliceIterator","arr","_arr","_n","_d","_e","_s","_i","Symbol","iterator","done","TypeError","isSimplePositionValue","isComplexSpanValue","alignmentValues","displayValues","grid","propertyConverters","alignSelf","msGridRowAlign","gridColumn","msGridColumn","_value$split","_value$split2","start","end","gridColumnStart","_end$split","_end$split2","maybeSpan","maybeNumber","gridColumnEnd","msGridColumnSpan","gridRow","msGridRow","_value$split3","_value$split4","gridRowStart","_end$split3","_end$split4","gridRowEnd","msGridRowSpan","gridTemplateColumns","msGridColumns","gridTemplateRows","msGridRows","justifySelf","msGridColumnAlign","propertyConverter","imageSet","marginBlockStart","marginBlockEnd","marginInlineStart","marginInlineEnd","paddingBlockStart","paddingBlockEnd","paddingInlineStart","paddingInlineEnd","borderBlockStart","borderBlockStartColor","borderBlockStartStyle","borderBlockStartWidth","borderBlockEnd","borderBlockEndColor","borderBlockEndStyle","borderBlockEndWidth","borderInlineStart","borderInlineStartColor","borderInlineStartStyle","borderInlineStartWidth","borderInlineEnd","borderInlineEndColor","borderInlineEndStyle","borderInlineEndWidth","logical","alternativePropList","position","properties","maxHeight","maxWidth","width","height","columnWidth","minWidth","minHeight","sizing","transition","transitionProperty","WebkitTransition","WebkitTransitionProperty","MozTransition","MozTransitionProperty","prefixMapping","Webkit","Moz","propertyPrefixMap","multipleValues","singleValue","dashCaseProperty","prefixes","pLen","unshift","outputValue","webkitOutput","val","mozOutput","SequentialIDGenerator","prefix$$1","count","msb","power","_proto","increment","pow","minMaxWidth","maxMinWidth","isMinWidth","_testQuery","isMaxWidth","minMaxHeight","maxMinHeight","isMinHeight","isMaxHeight","isPrint","isPrintOnly","maxValue","MAX_VALUE","_getQueryLength","matches","number","unit","parseFloat","doubleTestTrue","doubleTestFalse","singleTest","query","_testIsPrint","a","isPrintA","isPrintOnlyA","isPrintB","isPrintOnlyB","localeCompare","sortCSSmq","testIsPrint","minA","maxA","minB","maxB","lengthA","lengthB","MultiCache","idGenerator","onNewCache","onNewValue","sortedCacheKeys","caches","getCache","_cache","Cache","sort","keyIndex","insertBeforeMedia","getSortedCacheKeys","_proto2","addValue","cached","_typeof","injectStylePrefixed","styleCache","styles","media","pseudo","classString","originalKey","originalVal","propValPair","cachedId","_prefix","block","prefixed","prefixedKey","prefixedVal","prefixedValType","prefixedPair","hyphenated","_prefixedPair","substring","substr","atomicSelector","selector","keyframesToBlock","keyframes","animationState","declarationsToBlock","css","keyframesBlockToRule","fontFaceBlockToRule","styleBlockToRule","STYLES_HYDRATOR","KEYFRAMES_HYRDATOR","FONT_FACE_HYDRATOR","hydrateStyles","hydrator","_match","fullKey","hydrate","_match2","StyletronClient","opts","_this","styleElements","styleIdGenerator","onNewStyle","sheet","rule","insertRule","cssRules","styleElement","container","insertBeforeIndex","findSheetIndexWithMedia","insertBefore","keyframesCache","fontFaceCache","parentElement","hydrateType","getAttribute","textContent","renderStyle","renderFontFace","fontFace","renderKeyframes","index","child","OverlayContainer","styled","$isOpen","visibility","transform","opacity","backgroundColor","zIndex","Overlay","overlay","dispatch","isMarketPlaceUiOpen","isSettingsOpen","isOpen","useEffect","onKeyDown","repeat","preventDefault","overlayType","removeEventListener","AddIntegration","Settings","mapStateToProps","connect","Sentry","AWS_COMMIT_ID","USER_BRANCH","flagConfig","appName","process","instanceId","engine","Styletron","config","debugAfterHydration","ops","lastAccessLHS","op","STACKTRACE_LIMIT","createStackParser","parsers","sortedParsers","p","skipFirst","stripSentryFramesAndReverse","stackParserFromStackParserOptions","localStack","firstFrameFunction","lastFrameFunction","reverse","defaultFunctionName","getFunctionName","isPrefixedValue","regex","memoBuilder","hasWeakSet","WeakSet","inner","has","delete"],"mappings":"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","file":"layouts__Root.37907f92.async.js","sourcesContent":["import { isNaN, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output..\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\nfunction normalize(input, depth = +Infinity, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n    object,\n  // Default Node.js REPL depth\n  depth = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize = 100 * 1024,\n) {\n  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/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key,\n  value,\n  depth = +Infinity,\n  maxProperties = +Infinity,\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // If the value has a `toJSON` method, see if we can bail and let it do the work\n  var valueWithToJSON = value ;\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      return valueWithToJSON.toJSON();\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // Get the simple cases out of the way first\n  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\n    return value ;\n  }\n\n  var stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value )['__sentry_skip_normalization__']) {\n    return value ;\n  }\n\n  // We're also done if we've reached the max depth\n  if (depth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // 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  var normalized = (Array.isArray(value) ? [] : {}) ;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  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    }\n\n    // Recursively visit all the child nodes\n    var visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);\n\n    numAdded += 1;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value,\n) {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n        if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n        if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    return `[object ${(Object.getPrototypeOf(value) ).constructor.name}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","/* eslint-disable no-var, prefer-template */\nvar uppercasePattern = /[A-Z]/g\nvar msPattern = /^ms-/\nvar cache = {}\n\nfunction toHyphenLower(match) {\n  return '-' + match.toLowerCase()\n}\n\nfunction hyphenateStyleName(name) {\n  if (cache.hasOwnProperty(name)) {\n    return cache[name]\n  }\n\n  var hName = name.replace(uppercasePattern, toHyphenLower)\n  return (cache[name] = msPattern.test(hName) ? '-' + hName : hName)\n}\n\nexport default hyphenateStyleName\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = hyphenateProperty;\n\nvar _hyphenateStyleName = require('hyphenate-style-name');\n\nvar _hyphenateStyleName2 = _interopRequireDefault(_hyphenateStyleName);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction hyphenateProperty(property) {\n  return (0, _hyphenateStyleName2.default)(property);\n}\nmodule.exports = exports['default'];","var SDK_VERSION = '7.3.0';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString;\n\n/** Patch toString calls to return proper name for wrapped functions */\nclass FunctionToString  {constructor() { FunctionToString.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'FunctionToString';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = FunctionToString.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n        originalFunctionToString = Function.prototype.toString;\n\n        Function.prototype.toString = function ( ...args) {\n      var context = getOriginalFunction(this) || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n} FunctionToString.__initStatic();\n\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map\n","import { logger, getEventDescription, isMatchingPattern } from '@sentry/utils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n\n/** Options for the InboundFilters integration */\n\n/** Inbound filters configurable by the user */\nclass InboundFilters  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'InboundFilters';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = InboundFilters.id;}\n\n   constructor(  _options = {}) {;this._options = _options;InboundFilters.prototype.__init.call(this);}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    var eventProcess = (event) => {\n      var hub = getCurrentHub();\n      if (hub) {\n        var self = hub.getIntegration(InboundFilters);\n        if (self) {\n          var client = hub.getClient();\n          var clientOptions = client ? client.getOptions() : {};\n          var options = _mergeOptions(self._options, clientOptions);\n          return _shouldDropEvent(event, options) ? null : event;\n        }\n      }\n      return event;\n    };\n\n    eventProcess.id = this.name;\n    addGlobalEventProcessor(eventProcess);\n  }\n} InboundFilters.__initStatic();\n\n/** JSDoc */\nfunction _mergeOptions(\n  internalOptions = {},\n  clientOptions = {},\n) {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...DEFAULT_IGNORE_ERRORS,\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(event, options) {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event, ignoreErrors) {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message =>\n    ignoreErrors.some(pattern => isMatchingPattern(message, pattern)),\n  );\n}\n\nfunction _isDeniedUrl(event, denyUrls) {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  var url = _getEventFilterUrl(event);\n  return !url ? false : denyUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _isAllowedUrl(event, allowUrls) {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  var url = _getEventFilterUrl(event);\n  return !url ? true : allowUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _getPossibleEventMessages(event) {\n  if (event.message) {\n    return [event.message];\n  }\n  if (event.exception) {\n    try {\n      const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n      return [`${value}`, `${type}: ${value}`];\n    } catch (oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n      return [];\n    }\n  }\n  return [];\n}\n\nfunction _isSentryError(event) {\n  try {\n    // @ts-ignore can't be a sentry error if undefined\n        return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames = []) {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    var frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event) {\n  try {\n    let frames;\n    try {\n      // @ts-ignore we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n\nexport { InboundFilters, _mergeOptions, _shouldDropEvent };\n//# sourceMappingURL=inboundfilters.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\nvar installedIntegrations = [];\n\n/** Map of integrations assigned to a client */\n\n/**\n * @private\n */\nfunction filterDuplicates(integrations) {\n  return integrations.reduce((acc, integrations) => {\n    if (acc.every(accIntegration => integrations.name !== accIntegration.name)) {\n      acc.push(integrations);\n    }\n    return acc;\n  }, [] );\n}\n\n/** Gets integration to install */\nfunction getIntegrationsToSetup(options) {\n  var defaultIntegrations = (options.defaultIntegrations && [...options.defaultIntegrations]) || [];\n  var userIntegrations = options.integrations;\n\n  let integrations = [...filterDuplicates(defaultIntegrations)];\n\n  if (Array.isArray(userIntegrations)) {\n    // Filter out integrations that are also included in user options\n    integrations = [\n      ...integrations.filter(integrations =>\n        userIntegrations.every(userIntegration => userIntegration.name !== integrations.name),\n      ),\n      // And filter out duplicated user options integrations\n      ...filterDuplicates(userIntegrations),\n    ];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = userIntegrations(integrations);\n    integrations = Array.isArray(integrations) ? integrations : [integrations];\n  }\n\n  // Make sure that if present, `Debug` integration will always run last\n  var integrationsNames = integrations.map(i => i.name);\n  var alwaysLastToRun = 'Debug';\n  if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n    integrations.push(...integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1));\n  }\n\n  return integrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nfunction setupIntegrations(integrations) {\n  var integrationIndex = {};\n\n  integrations.forEach(integration => {\n    integrationIndex[integration.name] = integration;\n\n    if (installedIntegrations.indexOf(integration.name) === -1) {\n      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n      installedIntegrations.push(integration.name);\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);\n    }\n  });\n\n  return integrationIndex;\n}\n\nexport { getIntegrationsToSetup, installedIntegrations, setupIntegrations };\n//# sourceMappingURL=integration.js.map\n","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\n/** A class object that can instantiate Client objects. */\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nfunction initAndBind(\n  clientClass,\n  options,\n) {\n  if (options.debug === true) {\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n            console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n    }\n  }\n  var hub = getCurrentHub();\n  var scope = hub.getScope();\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  var client = new clientClass(options);\n  hub.bindClient(client);\n}\n\nexport { initAndBind };\n//# sourceMappingURL=sdk.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n  \n\n   constructor( message) {\n    super(message);this.message = message;;\n\n    this.name = new.target.prototype.constructor.name;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { SentryError } from './error.js';\n\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents\n */\nfunction dsnFromString(str) {\n  var match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  var split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() ;\n  }\n\n  if (projectId) {\n    var projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  var requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nfunction makeDsn(from) {\n  var components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n\n/**\n * Changes a Dsn to point to the `relay` server running in the Lambda Extension.\n *\n * This is only used by the serverless integration for AWS Lambda.\n *\n * @param originalDsn The original Dsn of the customer.\n * @returns Dsn pointing to Lambda extension.\n */\nfunction extensionRelayDSN(originalDsn) {\n  if (originalDsn === undefined) {\n    return undefined;\n  }\n\n  var dsn = dsnFromString(originalDsn);\n  dsn.host = 'localhost';\n  dsn.port = '3000';\n  dsn.protocol = 'http';\n\n  return dsnToString(dsn);\n}\n\nexport { dsnToString, extensionRelayDSN, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","import { urlEncode, makeDsn, dsnToString } from '@sentry/utils';\n\nvar SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn) {\n  var protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  var port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn) {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn) {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nfunction getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnel) {\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nfunction getReportDialogEndpoint(\n  dsnLike,\n  dialogOptions\n\n,\n) {\n  var dsn = makeDsn(dsnLike);\n  var endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (var key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      var user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] )}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };\n//# sourceMappingURL=api.js.map\n","import { getGlobalObject } from './global.js';\nimport { logger } from './logger.js';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-ignore It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n  if (!('fetch' in getGlobalObject())) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  var global = getGlobalObject();\n\n  // Fast path to avoid DOM I/O\n    if (isNativeFetch(global.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  var doc = global.document;\n    if (doc && typeof (doc.createElement ) === 'function') {\n    try {\n      var sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in getGlobalObject();\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReferrerPolicy() {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' ,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsHistory() {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  var global = getGlobalObject();\n      var chrome = (global ).chrome;\n  var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { getGlobalObject } from './global.js';\nimport { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\n\nvar global = getGlobalObject();\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nvar handlers = {};\nvar instrumented = {};\n\n/** Instruments given API */\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(callback);\n  instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (var handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole() {\n  if (!('console' in global)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in global.console)) {\n      return;\n    }\n\n    fill(global.console, level, function (originalConsoleMethod) {\n      return function (...args) {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(global.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(global, 'fetch', function (originalFetch) {\n    return function (...args) {\n      var handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n            return originalFetch.apply(global, args).then(\n        (response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs = []) {\n  if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs = []) {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n\n/** JSDoc */\nfunction instrumentXHR() {\n  if (!('XMLHttpRequest' in global)) {\n    return;\n  }\n\n  var xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function ( ...args) {\n            var xhr = this;\n      var url = args[1];\n      var xhrInfo = (xhr.__sentry_xhr__ = {\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n            if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      var onreadystatechangeHandler = function () {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original) {\n          return function (...readyStateArgs) {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend) {\n    return function ( ...args) {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref;\n\n/** JSDoc */\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  var oldOnPopState = global.onpopstate;\n  global.onpopstate = function ( ...args) {\n    var to = global.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    var from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from,\n      to,\n    });\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  /** @hidden */\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function ( ...args) {\n      var url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        var from = lastHref;\n        var to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(global.history, 'pushState', historyReplacementFunction);\n  fill(global.history, 'replaceState', historyReplacementFunction);\n}\n\nvar debounceDuration = 1000;\nlet debounceTimerID;\nlet lastCapturedEvent;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (previous.target !== current.target) {\n      return true;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event) {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    var target = event.target ;\n\n    if (!target || !target.tagName) {\n      return true;\n    }\n\n    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler, globalListener = false) {\n  return (event) => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    var name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = global.setTimeout(() => {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\n/** JSDoc */\nfunction instrumentDOM() {\n  if (!('document' in global)) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  var triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  global.document.addEventListener('click', globalDOMEventHandler, false);\n  global.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target) => {\n        var proto = (global )[target] && (global )[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (\n        \n        type,\n        listener,\n        options,\n      ) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this ;\n            var handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            var handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              var handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount += 1;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function (\n          \n          type,\n          listener,\n          options,\n        ) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              var el = this ;\n              var handlers = el.__sentry_instrumentation_handlers__ || {};\n              var handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount -= 1;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type];                 }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n  _oldOnErrorHandler = global.onerror;\n\n  global.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n            return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n\n  global.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","import { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  var envelopeItems = envelope[1];\n  envelopeItems.forEach((envelopeItem) => {\n    var envelopeItemType = envelopeItem[0].type;\n    callback(envelopeItem, envelopeItemType);\n  });\n}\n\nfunction encodeUTF8(input, textEncoder) {\n  var utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope, textEncoder) {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (var item of items) {\n    const [itemHeaders, payload] = item ;\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n    append(typeof payload === 'string' || payload instanceof Uint8Array ? payload : JSON.stringify(payload));\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  var totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  var merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (var buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(\n  attachment,\n  textEncoder,\n) {\n  var buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\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};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, envelopeItemTypeToDataCategory, forEachEnvelopeItem, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { isString } from './is.js';\nimport { logger } from './logger.js';\n\nvar BAGGAGE_HEADER_NAME = 'baggage';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nvar MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/** Create an instance of Baggage */\nfunction createBaggage(initItems, baggageString = '', mutable = true) {\n  return [{ ...initItems }, baggageString, mutable];\n}\n\n/** Get a value from baggage */\nfunction getBaggageValue(baggage, key) {\n  return baggage[0][key];\n}\n\n/** Add a value to baggage */\nfunction setBaggageValue(baggage, key, value) {\n  if (isBaggageMutable(baggage)) {\n    baggage[0][key] = value;\n  }\n}\n\n/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */\nfunction isSentryBaggageEmpty(baggage) {\n  return Object.keys(baggage[0]).length === 0;\n}\n\n/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */\nfunction isBaggageEmpty(baggage) {\n  var thirdPartyBaggage = getThirdPartyBaggage(baggage);\n  return isSentryBaggageEmpty(baggage) && (thirdPartyBaggage == undefined || thirdPartyBaggage.length === 0);\n}\n\n/** Returns Sentry specific baggage values */\nfunction getSentryBaggageItems(baggage) {\n  return baggage[0];\n}\n\n/**\n * Returns 3rd party baggage string of @param baggage\n * @param baggage\n */\nfunction getThirdPartyBaggage(baggage) {\n  return baggage[1];\n}\n\n/**\n * Checks if baggage is mutable\n * @param baggage\n * @returns true if baggage is mutable, else false\n */\nfunction isBaggageMutable(baggage) {\n  return baggage[2];\n}\n\n/**\n * Sets the passed baggage immutable\n * @param baggage\n */\nfunction setBaggageImmutable(baggage) {\n  baggage[2] = false;\n}\n\n/** Serialize a baggage object */\nfunction serializeBaggage(baggage) {\n  return Object.keys(baggage[0]).reduce((prev, key) => {\n    var val = baggage[0][key] ;\n    var baggageEntry = `${SENTRY_BAGGAGE_KEY_PREFIX}${encodeURIComponent(key)}=${encodeURIComponent(val)}`;\n    var newVal = prev === '' ? baggageEntry : `${prev},${baggageEntry}`;\n    if (newVal.length > MAX_BAGGAGE_STRING_LENGTH) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(`Not adding key: ${key} with val: ${val} to baggage due to exceeding baggage size limits.`);\n      return prev;\n    } else {\n      return newVal;\n    }\n  }, baggage[1]);\n}\n\n/** Parse a baggage header from a string or a string array and return a Baggage object */\nfunction parseBaggageHeader(inputBaggageValue) {\n  // Adding this check here because we got reports of this function failing due to the input value\n  // not being a string. This debug log might help us determine what's going on here.\n  if ((!Array.isArray(inputBaggageValue) && !isString(inputBaggageValue)) || typeof inputBaggageValue === 'number') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        '[parseBaggageHeader] Received input value of incompatible type: ',\n        typeof inputBaggageValue,\n        inputBaggageValue,\n      );\n\n    // Gonna early-return an empty baggage object so that we don't fail later on\n    return createBaggage({}, '');\n  }\n\n  var baggageEntries = (isString(inputBaggageValue) ? inputBaggageValue : inputBaggageValue.join(','))\n    .split(',')\n    .map(entry => entry.trim())\n    .filter(entry => entry !== '');\n\n  return baggageEntries.reduce(\n    ([baggageObj, baggageString], curr) => {\n      const [key, val] = curr.split('=');\n      if (SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(key)) {\n        var baggageKey = decodeURIComponent(key.split('-')[1]);\n        return [\n          {\n            ...baggageObj,\n            [baggageKey]: decodeURIComponent(val),\n          },\n          baggageString,\n          true,\n        ];\n      } else {\n        return [baggageObj, baggageString === '' ? curr : `${baggageString},${curr}`, true];\n      }\n    },\n    [{}, '', true],\n  );\n}\n\n/**\n * Merges the baggage header we saved from the incoming request (or meta tag) with\n * a possibly created or modified baggage header by a third party that's been added\n * to the outgoing request header.\n *\n * In case @param headerBaggageString exists, we can safely add the the 3rd party part of @param headerBaggage\n * with our @param incomingBaggage. This is possible because if we modified anything beforehand,\n * it would only affect parts of the sentry baggage (@see Baggage interface).\n *\n * @param incomingBaggage the baggage header of the incoming request that might contain sentry entries\n * @param thirdPartyBaggageHeader possibly existing baggage header string or string[] added from a third\n *        party to the request headers\n *\n * @return a merged and serialized baggage string to be propagated with the outgoing request\n */\nfunction mergeAndSerializeBaggage(incomingBaggage, thirdPartyBaggageHeader) {\n  if (!incomingBaggage && !thirdPartyBaggageHeader) {\n    return '';\n  }\n\n  var headerBaggage = (thirdPartyBaggageHeader && parseBaggageHeader(thirdPartyBaggageHeader)) || undefined;\n  var thirdPartyHeaderBaggage = headerBaggage && getThirdPartyBaggage(headerBaggage);\n\n  var finalBaggage = createBaggage(\n    (incomingBaggage && incomingBaggage[0]) || {},\n    thirdPartyHeaderBaggage || (incomingBaggage && incomingBaggage[1]) || '',\n  );\n  return serializeBaggage(finalBaggage);\n}\n\n/**\n * Helper function that takes a raw baggage string (if available) and the processed sentry-trace header\n * data (if available), parses the baggage string and creates a Baggage object\n * If there is no baggage string, it will create an empty Baggage object.\n * In a second step, this functions determines if the created Baggage object should be set immutable\n * to prevent mutation of the Sentry data.\n *\n * Extracted this logic to a function because it's duplicated in a lot of places.\n *\n * @param rawBaggageValue\n * @param sentryTraceHeader\n */\nfunction parseBaggageSetMutability(\n  rawBaggageValue,\n  sentryTraceHeader,\n) {\n  var baggage = parseBaggageHeader(rawBaggageValue || '');\n  if (!isSentryBaggageEmpty(baggage) || (sentryTraceHeader && isSentryBaggageEmpty(baggage))) {\n    setBaggageImmutable(baggage);\n  }\n  return baggage;\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, createBaggage, getBaggageValue, getSentryBaggageItems, getThirdPartyBaggage, isBaggageEmpty, isBaggageMutable, isSentryBaggageEmpty, mergeAndSerializeBaggage, parseBaggageHeader, parseBaggageSetMutability, serializeBaggage, setBaggageImmutable, setBaggageValue };\n//# sourceMappingURL=baggage.js.map\n","import { dsnToString, createEnvelope, dropUndefinedKeys, getSentryBaggageItems } from '@sentry/utils';\n\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(metadata) {\n  if (!metadata || !metadata.sdk) {\n    return;\n  }\n  const { name, version } = metadata.sdk;\n  return { name, version };\n}\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nfunction createSessionEnvelope(\n  session,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n  };\n\n  var envelopeItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];\n\n  return createEnvelope(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nfunction createEventEnvelope(\n  event,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var eventType = event.type || 'event';\n\n  const { transactionSampling } = event.sdkProcessingMetadata || {};\n  const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};\n\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n  var envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  var eventItem = [\n    {\n      type: eventType,\n      sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n    },\n    event,\n  ];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  var baggage = event.sdkProcessingMetadata && event.sdkProcessingMetadata.baggage;\n  var dynamicSamplingContext = baggage && getSentryBaggageItems(baggage);\n\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\n      dynamicSamplingContext && {\n        trace: dropUndefinedKeys({ ...dynamicSamplingContext }) ,\n      }),\n  };\n}\n\nexport { createEventEnvelope, createSessionEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { _optionalChain } from '@sentry/utils/esm/buildPolyfills';\nimport { updateSession, Scope } from '@sentry/hub';\nimport { makeDsn, logger, checkOrSetAlreadyCaught, isPrimitive, resolvedSyncPromise, addItemToEnvelope, createAttachmentEnvelopeItem, SyncPromise, uuid4, dateTimestampInSeconds, normalize, truncate, rejectedSyncPromise, SentryError, isThenable, isPlainObject } from '@sentry/utils';\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegrations } from './integration.js';\n\nvar ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nclass BaseClient {\n  /** Options passed to the SDK. */\n  \n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  \n\n  /** Array of set up integrations. */\n   __init() {this._integrations = {};}\n\n  /** Indicates whether this client's integrations have been set up. */\n   __init2() {this._integrationsInitialized = false;}\n\n  /** Number of calls being processed */\n   __init3() {this._numProcessing = 0;}\n\n  /** Holds flushable  */\n   __init4() {this._outcomes = {};}\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n   constructor(options) {;BaseClient.prototype.__init.call(this);BaseClient.prototype.__init2.call(this);BaseClient.prototype.__init3.call(this);BaseClient.prototype.__init4.call(this);\n    this._options = options;\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options.tunnel);\n      this._transport = options.transport({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n     captureException(exception, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n        level,\n    hint,\n    scope,\n  ) {\n    let eventId = hint && hint.event_id;\n\n    var promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(String(message), level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this._captureEvent(event, hint, scope).then(result => {\n        eventId = result;\n      }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(session) {\n    if (!this._isEnabled()) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture session.');\n      return;\n    }\n\n    if (!(typeof session.release === 'string')) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getDsn() {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransport() {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   flush(timeout) {\n    var transport = this._transport;\n    if (transport) {\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   close(timeout) {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      return result;\n    });\n  }\n\n  /**\n   * Sets up the integrations\n   */\n   setupIntegrations() {\n    if (this._isEnabled() && !this._integrationsInitialized) {\n      this._integrations = setupIntegrations(this._options.integrations);\n      this._integrationsInitialized = true;\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   */\n   getIntegrationById(integrationId) {\n    return this._integrations[integrationId];\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    try {\n      return (this._integrations[integration.id] ) || null;\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint = {}) {\n    if (this._dsn) {\n      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n      for (var attachment of hint.attachments || []) {\n        env = addItemToEnvelope(\n          env,\n          createAttachmentEnvelopeItem(attachment, _optionalChain([this, 'access', _ => _._options, 'access', _2 => _2.transportOptions, 'optionalAccess', _3 => _3.textEncoder])),\n        );\n      }\n\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendSession(session) {\n    if (this._dsn) {\n      var env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   recordDroppedEvent(reason, category) {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      var key = `${reason}:${category}`;\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Adding outcome: \"${key}\"`);\n\n      // The following works because undefined + 1 === NaN and NaN is falsy\n      this._outcomes[key] = this._outcomes[key] + 1 || 1;\n    }\n  }\n\n  /** Updates existing session based on the provided event */\n   _updateSessionFromEvent(session, event) {\n    let crashed = false;\n    let errored = false;\n    var exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (var ex of exceptions) {\n        var mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    var sessionNonTerminal = session.status === 'ok';\n    var shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n   _isClientDoneProcessing(timeout) {\n    return new SyncPromise(resolve => {\n      let ticked = 0;\n      var tick = 1;\n\n      var interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n   _isEnabled() {\n    return this.getOptions().enabled !== false && this._dsn !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n   _prepareEvent(event, hint, scope) {\n    const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = this.getOptions();\n    var prepared = {\n      ...event,\n      event_id: event.event_id || hint.event_id || uuid4(),\n      timestamp: event.timestamp || dateTimestampInSeconds(),\n    };\n\n    this._applyClientOptions(prepared);\n    this._applyIntegrationsMetadata(prepared);\n\n    // If we have scope given to us, use it as the base for further modifications.\n    // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n    let finalScope = scope;\n    if (hint.captureContext) {\n      finalScope = Scope.clone(finalScope).update(hint.captureContext);\n    }\n\n    // We prepare the result here with a resolved Event.\n    let result = resolvedSyncPromise(prepared);\n\n    // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n    if (finalScope) {\n      // Collect attachments from the hint and scope\n      var attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n      if (attachments.length) {\n        hint.attachments = attachments;\n      }\n\n      // In case we have a hub we reassign it.\n      result = finalScope.applyToEvent(prepared, hint);\n    }\n\n    return result.then(evt => {\n      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n      }\n      return evt;\n    });\n  }\n\n  /**\n   * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n   * Normalized keys:\n   * - `breadcrumbs.data`\n   * - `user`\n   * - `contexts`\n   * - `extra`\n   * @param event Event\n   * @returns Normalized event\n   */\n   _normalizeEvent(event, depth, maxBreadth) {\n    if (!event) {\n      return null;\n    }\n\n    var normalized = {\n      ...event,\n      ...(event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(b => ({\n          ...b,\n          ...(b.data && {\n            data: normalize(b.data, depth, maxBreadth),\n          }),\n        })),\n      }),\n      ...(event.user && {\n        user: normalize(event.user, depth, maxBreadth),\n      }),\n      ...(event.contexts && {\n        contexts: normalize(event.contexts, depth, maxBreadth),\n      }),\n      ...(event.extra && {\n        extra: normalize(event.extra, depth, maxBreadth),\n      }),\n    };\n\n    // event.contexts.trace stores information about a Transaction. Similarly,\n    // event.spans[] stores information about child Spans. Given that a\n    // Transaction is conceptually a Span, normalization should apply to both\n    // Transactions and Spans consistently.\n    // For now the decision is to skip normalization of Transactions and Spans,\n    // so this block overwrites the normalized event to add back the original\n    // Transaction information prior to normalization.\n    if (event.contexts && event.contexts.trace && normalized.contexts) {\n      normalized.contexts.trace = event.contexts.trace;\n\n      // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n      if (event.contexts.trace.data) {\n        normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n      }\n    }\n\n    // event.spans[].data may contain circular/dangerous data so we need to normalize it\n    if (event.spans) {\n      normalized.spans = event.spans.map(span => {\n        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n        if (span.data) {\n          span.data = normalize(span.data, depth, maxBreadth);\n        }\n        return span;\n      });\n    }\n\n    return normalized;\n  }\n\n  /**\n   *  Enhances event using the client configuration.\n   *  It takes care of all \"static\" values like environment, release and `dist`,\n   *  as well as truncating overly long values.\n   * @param event event instance to be enhanced\n   */\n   _applyClientOptions(event) {\n    var options = this.getOptions();\n    const { environment, release, dist, maxValueLength = 250 } = options;\n\n    if (!('environment' in event)) {\n      event.environment = 'environment' in options ? environment : 'production';\n    }\n\n    if (event.release === undefined && release !== undefined) {\n      event.release = release;\n    }\n\n    if (event.dist === undefined && dist !== undefined) {\n      event.dist = dist;\n    }\n\n    if (event.message) {\n      event.message = truncate(event.message, maxValueLength);\n    }\n\n    var exception = event.exception && event.exception.values && event.exception.values[0];\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    var request = event.request;\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\n    }\n  }\n\n  /**\n   * This function adds all used integrations to the SDK info in the event.\n   * @param event The event that will be filled with all integrations.\n   */\n   _applyIntegrationsMetadata(event) {\n    var integrationsArray = Object.keys(this._integrations);\n    if (integrationsArray.length > 0) {\n      event.sdk = event.sdk || {};\n      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n    }\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n   _captureEvent(event, hint = {}, scope) {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(reason);\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n   _processEvent(event, hint, scope) {\n    const { beforeSend, sampleRate } = this.getOptions();\n\n    if (!this._isEnabled()) {\n      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.'));\n    }\n\n    var isTransaction = event.type === 'transaction';\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n        ),\n      );\n    }\n\n    return this._prepareEvent(event, hint, scope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', event.type || 'error');\n          throw new SentryError('An event processor returned null, will not send event.');\n        }\n\n        var isInternalException = hint.data && (hint.data ).__sentry__ === true;\n        if (isInternalException || isTransaction || !beforeSend) {\n          return prepared;\n        }\n\n        var beforeSendResult = beforeSend(prepared, hint);\n        return _ensureBeforeSendRv(beforeSendResult);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', event.type || 'error');\n          throw new SentryError('`beforeSend` returned `null`, will not send event.');\n        }\n\n        var session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason ,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n   _process(promise) {\n    this._numProcessing += 1;\n    void promise.then(\n      value => {\n        this._numProcessing -= 1;\n        return value;\n      },\n      reason => {\n        this._numProcessing -= 1;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n   _sendEnvelope(envelope) {\n    if (this._transport && this._dsn) {\n      this._transport.send(envelope).then(null, reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n   _clearOutcomes() {\n    var outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') ;\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n    \n\n}\n\n/**\n * Verifies that return value of configured `beforeSend` is of expected type.\n */\nfunction _ensureBeforeSendRv(rv) {\n  var nullErr = '`beforeSend` method has to return `null` or a valid event.';\n  if (isThenable(rv)) {\n    return rv.then(\n      event => {\n        if (!(isPlainObject(event) || event === null)) {\n          throw new SentryError(nullErr);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`beforeSend rejected with ${e}`);\n      },\n    );\n  } else if (!(isPlainObject(rv) || rv === null)) {\n    throw new SentryError(nullErr);\n  }\n  return rv;\n}\n\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n  discarded_events,\n  dsn,\n  timestamp,\n) {\n  var clientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","import { isEvent, extractExceptionKeysForMessage, normalizeToSize, addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject } from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nfunction exceptionFromError(stackParser, ex) {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  var frames = parseStackFrames(stackParser, ex);\n\n  var exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nfunction eventFromPlainObject(\n  stackParser,\n  exception,\n  syntheticException,\n  isUnhandledRejection,\n) {\n  var event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception),\n    },\n  };\n\n  if (syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception ).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromError(stackParser, ex) {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser,\n  ex,\n) {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  var stacktrace = ex.stacktrace || ex.stack || '';\n\n  var popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex) {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n  var message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nfunction eventFromException(\n  stackParser,\n  exception,\n  hint,\n  attachStacktrace,\n) {\n  var syntheticException = (hint && hint.syntheticException) || undefined;\n  var event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n  stackParser,\n  message,\n    level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  var syntheticException = (hint && hint.syntheticException) || undefined;\n  var event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n  stackParser,\n  exception,\n  syntheticException,\n  attachStacktrace,\n  isUnhandledRejection,\n) {\n  let event;\n\n  if (isErrorEvent(exception ) && (exception ).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    var errorEvent = exception ;\n    return eventFromError(stackParser, errorEvent.error );\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception ) || isDOMException(exception )) {\n    var domException = exception ;\n\n    if ('stack' in (exception )) {\n      event = eventFromError(stackParser, exception );\n    } else {\n      var name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      var message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    var objectException = exception ;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromString(\n  stackParser,\n  input,\n  syntheticException,\n  attachStacktrace,\n) {\n  var event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: input, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  return event;\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nvar validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nfunction severityFromString(level) {\n  return severityLevelFromString(level) ;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nfunction severityLevelFromString(level) {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, getGlobalObject, parseUrl } from '@sentry/utils';\n\n/** JSDoc */\n\nvar BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nclass Breadcrumbs  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = BREADCRUMB_INTEGRATION_ID;}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Breadcrumbs.id;}\n\n  /**\n   * Options of the breadcrumbs integration.\n   */\n  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;Breadcrumbs.prototype.__init.call(this);\n    this.options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n   setupOnce() {\n    if (this.options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this.options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n    }\n    if (this.options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this.options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this.options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n} Breadcrumbs.__initStatic();\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\nfunction _domBreadcrumb(dom) {\n    function _innerDomBreadcrumb(handlerData) {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target , keyAttrs)\n        : htmlTreeAsString(handlerData.event , keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _consoleBreadcrumb(handlerData) {\n  var breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityLevelFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _xhrBreadcrumb(handlerData) {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _fetchBreadcrumb(handlerData) {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: 'error',\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _historyBreadcrumb(handlerData) {\n  var global = getGlobalObject();\n  let from = handlerData.from;\n  let to = handlerData.to;\n  var parsedLoc = parseUrl(global.location.href);\n  let parsedFrom = parseUrl(from);\n  var parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n\nexport { BREADCRUMB_INTEGRATION_ID, Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { getGlobalObject, isNativeFetch, logger, supportsFetch } from '@sentry/utils';\n\nvar global = getGlobalObject();\nlet cachedFetchImpl;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * var f = window.fetch;\n * window.fetch = function () {\n *   var p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction getNativeFetchImplementation() {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(global.fetch)) {\n    return (cachedFetchImpl = global.fetch.bind(global));\n  }\n\n  var document = global.document;\n  let fetchImpl = global.fetch;\n    if (document && typeof document.createElement === 'function') {\n    try {\n      var sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      var contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(global));\n  }\n\n/**\n * Sends sdk client report using sendBeacon or fetch as a fallback if available\n *\n * @param url report endpoint\n * @param body report payload\n */\nfunction sendReport(url, body) {\n  var isRealNavigator = Object.prototype.toString.call(global && global.navigator) === '[object Navigator]';\n  var hasSendBeacon = isRealNavigator && typeof global.navigator.sendBeacon === 'function';\n\n  if (hasSendBeacon) {\n    // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n    var sendBeacon = global.navigator.sendBeacon.bind(global.navigator);\n    sendBeacon(url, body);\n  } else if (supportsFetch()) {\n    var fetch = getNativeFetchImplementation();\n    fetch(url, {\n      body,\n      method: 'POST',\n      credentials: 'omit',\n      keepalive: true,\n    }).then(null, error => {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(error);\n    });\n  }\n}\n\nexport { getNativeFetchImplementation, sendReport };\n//# sourceMappingURL=utils.js.map\n","import { BaseClient, SDK_VERSION, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { getGlobalObject, getEventDescription, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs.js';\nimport { sendReport } from './transports/utils.js';\n\nvar globalObject = getGlobalObject();\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nclass BrowserClient extends BaseClient {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n   constructor(options) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(options);\n\n    if (options.sendClientReports && globalObject.document) {\n      globalObject.document.addEventListener('visibilitychange', () => {\n        if (globalObject.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromException(exception, hint) {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromMessage(\n    message,\n        level = 'info',\n    hint,\n  ) {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint) {\n    // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n    // activated its `sentry` option.\n    // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n    // bundles, if it is not used by the SDK.\n    // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n    // way for now.\n    var breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) ;\n    if (\n      breadcrumbIntegration &&\n      // We check for definedness of `options`, even though it is not strictly necessary, because that access to\n      // `.sentry` below does not throw, in case users provided their own integration with id \"Breadcrumbs\" that does\n      // not have an`options` field\n      breadcrumbIntegration.options &&\n      breadcrumbIntegration.options.sentry\n    ) {\n      getCurrentHub().addBreadcrumb(\n        {\n          category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event),\n        },\n        {\n          event,\n        },\n      );\n    }\n\n    super.sendEvent(event, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   _prepareEvent(event, hint, scope) {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n   _flushOutcomes() {\n    var outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');\n      return;\n    }\n\n    if (!this._dsn) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);\n\n    var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options.tunnel);\n    var envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    try {\n      sendReport(url, serializeEnvelope(envelope));\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);\n    }\n  }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { withScope, captureException } from '@sentry/core';\nimport { getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';\n\nlet ignoreOnError = 0;\n\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(() => {\n    ignoreOnError -= 1;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nfunction wrap(\n  fn,\n  options\n\n = {},\n  before,\n  ) {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    var wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n    // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  var sentryWrapped = function () {\n    var args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n            var wrappedArguments = args.map((arg) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope) => {\n        scope.addEventProcessor((event) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  \n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (var property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} \n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get() {\n          return fn.name;\n        },\n      });\n    }\n      } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\n\nexport { ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","import { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n\nvar OPERA10_PRIORITY = 10;\nvar OPERA11_PRIORITY = 20;\nvar CHROME_PRIORITY = 30;\nvar WINJS_PRIORITY = 40;\nvar GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  var frame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chromeRegex =\n  /^\\s*at (?:(.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nvar chrome = line => {\n  var parts = chromeRegex.exec(line);\n\n  if (parts) {\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      var subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nvar chromeStackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nvar gecko = line => {\n  var parts = geckoREgex.exec(line);\n\n  if (parts) {\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      var subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nvar geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nvar winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nvar winjs = line => {\n  var parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nvar winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nvar opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nvar opera10 = line => {\n  var parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nvar opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nvar opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nvar opera11 = line => {\n  var parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nvar opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nvar defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nvar defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nvar extractSafariExtensionDetails = (func, filename) => {\n  var isSafariExtension = func.indexOf('safari-extension') !== -1;\n  var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };\n//# sourceMappingURL=stack-parsers.js.map\n","import { getGlobalObject, fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { wrap } from '../helpers.js';\n\nvar DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nclass TryCatch  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'TryCatch';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = TryCatch.id;}\n\n  /** JSDoc */\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;TryCatch.prototype.__init.call(this);\n    this._options = {\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n   setupOnce() {\n    var global = getGlobalObject();\n\n    if (this._options.setTimeout) {\n      fill(global, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(global, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(global, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    var eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      var eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n} TryCatch.__initStatic();\n\n/** JSDoc */\nfunction _wrapTimeFunction(original) {\n    return function ( ...args) {\n    var originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapRAF(original) {\n    return function ( callback) {\n        return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend) {\n    return function ( ...args) {\n        var xhr = this;\n    var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n                fill(xhr, prop, function (original) {\n          var wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          var originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target) {\n    var global = getGlobalObject() ;\n    var proto = global[target] && global[target].prototype;\n\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original)\n\n {\n    return function (\n            \n      eventName,\n      fn,\n      options,\n    ) {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n                    fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n                wrap(fn , {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener,\n          ) {\n      return function (\n                \n        eventName,\n        fn,\n        options,\n      ) {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        var wrappedEventHandler = fn ;\n        try {\n          var originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\n/** Global handlers */\nclass GlobalHandlers  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'GlobalHandlers';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = GlobalHandlers.id;}\n\n  /** JSDoc */\n  \n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n   __init2() {this._installFunc = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };}\n\n  /** JSDoc */\n   constructor(options) {;GlobalHandlers.prototype.__init.call(this);GlobalHandlers.prototype.__init2.call(this);\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    Error.stackTraceLimit = 50;\n    var options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n        for (var key in options) {\n      var installFunc = this._installFunc[key ];\n      if (installFunc && options[key ]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key ] = undefined;\n      }\n    }\n  }\n} GlobalHandlers.__initStatic();\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler() {\n  addInstrumentationHandler(\n    'error',\n        (data) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      var event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler() {\n  addInstrumentationHandler(\n    'unhandledrejection',\n        (e) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      var event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n  var ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  var groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  var event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n  // event.exception\n  var e = (event.exception = event.exception || {});\n  // event.exception.values\n  var ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  var ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  var ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  var ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub, error, event, type) {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndOptions() {\n  var hub = getCurrentHub();\n  var client = hub.getClient();\n  var options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map\n","import { getCurrentHub, addGlobalEventProcessor } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n\n/** Adds SDK info to an event. */\nclass LinkedErrors  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'LinkedErrors';}\n\n  /**\n   * @inheritDoc\n   */\n    __init() {this.name = LinkedErrors.id;}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options = {}) {;LinkedErrors.prototype.__init.call(this);\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    var client = getCurrentHub().getClient();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event, hint) => {\n      var self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n} LinkedErrors.__initStatic();\n\n/**\n * @inheritDoc\n */\nfunction _handler(\n  parser,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  var linkedErrors = _walkErrorTree(parser, limit, hint.originalException , key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nfunction _walkErrorTree(\n  parser,\n  limit,\n  error,\n  key,\n  stack = [],\n) {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  var exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n\nexport { LinkedErrors, _handler, _walkErrorTree };\n//# sourceMappingURL=linkederrors.js.map\n","import { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nclass Dedupe  {constructor() { Dedupe.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'Dedupe';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Dedupe.id;}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    var eventProcessor = currentEvent => {\n      var self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    };\n\n    eventProcessor.id = this.name;\n    addGlobalEventProcessor(eventProcessor);\n  }\n} Dedupe.__initStatic();\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent, previousEvent) {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n  var currentMessage = currentEvent.message;\n  var previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n  var previousException = _getExceptionFromEvent(previousEvent);\n  var currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames ;\n  previousFrames = previousFrames ;\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    var frameA = previousFrames[i];\n    var frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint ;\n  previousFingerprint = previousFingerprint ;\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event) {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event) {\n  var exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nexport { Dedupe };\n//# sourceMappingURL=dedupe.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\n\nvar global = getGlobalObject();\n\n/** HttpContext integration collects information about HTTP request headers */\nclass HttpContext  {constructor() { HttpContext.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'HttpContext';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = HttpContext.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    addGlobalEventProcessor((event) => {\n      if (getCurrentHub().getIntegration(HttpContext)) {\n        // if none of the information we want exists, don't bother\n        if (!global.navigator && !global.location && !global.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        var url = (event.request && event.request.url) || (global.location && global.location.href);\n        const { referrer } = global.document || {};\n        const { userAgent } = global.navigator || {};\n\n        var headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        var request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n} HttpContext.__initStatic();\n\nexport { HttpContext };\n//# sourceMappingURL=httpcontext.js.map\n","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n  var buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<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  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise due to buffer limit reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    var task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout) {\n    return new SyncPromise((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      var capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n                    if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\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 */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n  var headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  var headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that given category is disabled until for rate limiting\n */\nfunction disabledUntil(limits, category) {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, category, now = Date.now()) {\n  return disabledUntil(limits, category) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n * Returns true if headers contains a non-empty rate limiting header.\n */\nfunction updateRateLimits(\n  limits,\n  { statusCode, headers },\n  now = Date.now(),\n) {\n  var updatedRateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\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    for (var limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\n      var headerDelay = parseInt(retryAfter, 10);\n      var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (var category of categories.split(';')) {\n          updatedRateLimits[category] = now + delay;\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","import { makePromiseBuffer, forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, serializeEnvelope, logger, updateRateLimits, SentryError } from '@sentry/utils';\n\nvar DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nfunction createTransport(\n  options,\n  makeRequest,\n  buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n) {\n  let rateLimits = {};\n\n  var flush = (timeout) => buffer.drain(timeout);\n\n  function send(envelope) {\n    var filteredEnvelopeItems = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      var envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n        var filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n    // Creates client report for each item in an envelope\n    var recordEnvelopeLoss = (reason) => {\n      forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    var requestTask = () =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n        },\n        error => {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);\n          recordEnvelopeLoss('network_error');\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Skipped sending event due to full buffer');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { createTransport } from '@sentry/core';\nimport { getNativeFetchImplementation } from './utils.js';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n  options,\n  nativeFetch = getNativeFetchImplementation(),\n) {\n  function makeRequest(request) {\n    var requestOptions = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      ...options.fetchOptions,\n    };\n\n    return nativeFetch(options.url, requestOptions).then(response => ({\n      statusCode: response.status,\n      headers: {\n        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n        'retry-after': response.headers.get('Retry-After'),\n      },\n    }));\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nvar XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nfunction makeXHRTransport(options) {\n  function makeRequest(request) {\n    return new SyncPromise((resolve, reject) => {\n      var xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = () => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (var header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeXHRTransport };\n//# sourceMappingURL=xhr.js.map\n","import { Integrations, getIntegrationsToSetup, initAndBind, getCurrentHub, getReportDialogEndpoint } from '@sentry/core';\nimport { getGlobalObject, stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { wrap as wrap$1 } from './helpers.js';\nimport './integrations/index.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport './transports/index.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\nvar defaultIntegrations = [\n  new Integrations.InboundFilters(),\n  new Integrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nfunction init(options = {}) {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    var window = getGlobalObject();\n    // This supports the variable that sentry-webpack-plugin injects\n    if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {\n      options.release = window.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  var clientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nfunction showReportDialog(options = {}, hub = getCurrentHub()) {\n  // doesn't work without a document (React Native)\n  var global = getGlobalObject();\n  if (!global.document) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const { client, scope } = hub.getStackTop();\n  var dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  var script = global.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n        script.onload = options.onLoad;\n  }\n\n  var injectionPoint = global.document.head || global.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nfunction lastEventId() {\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n  callback();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nfunction flush(timeout) {\n  var client = getCurrentHub().getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nfunction close(timeout) {\n  var client = getCurrentHub().getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\nfunction wrap(fn) {\n  return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n  var window = getGlobalObject();\n  var document = window.document;\n\n  if (typeof document === 'undefined') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  var hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n","import { SDK_VERSION, init as init$1 } from '@sentry/browser';\n\n/**\n * Inits the React SDK\n */\nfunction init(options) {\n  options._metadata = options._metadata || {};\n  options._metadata.sdk = options._metadata.sdk || {\n    name: 'sentry.javascript.react',\n    packages: [\n      {\n        name: 'npm:@sentry/react',\n        version: SDK_VERSION,\n      },\n    ],\n    version: SDK_VERSION,\n  };\n  init$1(options);\n}\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n","import { withScope, captureException, showReportDialog } from '@sentry/browser';\nimport { logger } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\n\nvar _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/errorboundary.tsx\";\nfunction isAtLeastReact17(version) {\n  var major = version.match(/^([^.]+)/);\n  return major !== null && parseInt(major[0]) >= 17;\n}\n\nvar UNKNOWN_COMPONENT = 'unknown';\n\nvar INITIAL_STATE = {\n  componentStack: null,\n  error: null,\n  eventId: null,\n};\n\n/**\n * A ErrorBoundary component that logs errors to Sentry. Requires React >= 16.\n * NOTE: If you are a Sentry user, and you are seeing this stack frame, it means the\n * Sentry React SDK ErrorBoundary caught an error invoking your application code. This\n * is expected behavior and NOT indicative of a bug with the Sentry React SDK.\n */\nclass ErrorBoundary extends React.Component {constructor(...args) { super(...args); ErrorBoundary.prototype.__init.call(this);ErrorBoundary.prototype.__init2.call(this); }\n   __init() {this.state = INITIAL_STATE;}\n\n   componentDidCatch(error, { componentStack }) {\n    const { beforeCapture, onError, showDialog, dialogOptions } = this.props;\n\n    withScope(scope => {\n      // If on React version >= 17, create stack trace from componentStack param and links\n      // to to the original error using `error.cause` otherwise relies on error param for stacktrace.\n      // Linking errors requires the `LinkedErrors` integration be enabled.\n      if (isAtLeastReact17(React.version)) {\n        var errorBoundaryError = new Error(error.message);\n        errorBoundaryError.name = `React ErrorBoundary ${errorBoundaryError.name}`;\n        errorBoundaryError.stack = componentStack;\n\n        // Using the `LinkedErrors` integration to link the errors together.\n        error.cause = errorBoundaryError;\n      }\n\n      if (beforeCapture) {\n        beforeCapture(scope, error, componentStack);\n      }\n      var eventId = captureException(error, { contexts: { react: { componentStack } } });\n      if (onError) {\n        onError(error, componentStack, eventId);\n      }\n      if (showDialog) {\n        showReportDialog({ ...dialogOptions, eventId });\n      }\n\n      // componentDidCatch is used over getDerivedStateFromError\n      // so that componentStack is accessible through state.\n      this.setState({ error, componentStack, eventId });\n    });\n  }\n\n   componentDidMount() {\n    const { onMount } = this.props;\n    if (onMount) {\n      onMount();\n    }\n  }\n\n   componentWillUnmount() {\n    const { error, componentStack, eventId } = this.state;\n    const { onUnmount } = this.props;\n    if (onUnmount) {\n      onUnmount(error, componentStack, eventId);\n    }\n  }\n\n   __init2() {this.resetErrorBoundary = () => {\n    const { onReset } = this.props;\n    const { error, componentStack, eventId } = this.state;\n    if (onReset) {\n      onReset(error, componentStack, eventId);\n    }\n    this.setState(INITIAL_STATE);\n  };}\n\n   render() {\n    const { fallback, children } = this.props;\n    const { error, componentStack, eventId } = this.state;\n\n    if (error) {\n      let element = undefined;\n      if (typeof fallback === 'function') {\n        element = fallback({ error, componentStack, resetError: this.resetErrorBoundary, eventId });\n      } else {\n        element = fallback;\n      }\n\n      if (React.isValidElement(element)) {\n        return element;\n      }\n\n      if (fallback) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('fallback did not produce a valid ReactElement');\n      }\n\n      // Fail gracefully if no fallback provided or is not valid\n      return null;\n    }\n\n    if (typeof children === 'function') {\n      return (children )();\n    }\n    return children;\n  }\n}\n\nfunction withErrorBoundary(\n  WrappedComponent,\n  errorBoundaryOptions,\n) {\n    var componentDisplayName = WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;\n\n  var Wrapped = (props) => (\n    React.createElement(ErrorBoundary, { ...errorBoundaryOptions, __self: this, __source: {fileName: _jsxFileName, lineNumber: 168}}\n      , React.createElement(WrappedComponent, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 169}} )\n    )\n  );\n\n    Wrapped.displayName = `errorBoundary(${componentDisplayName})`;\n\n  // Copy over static methods from Wrapped component to Profiler HOC\n  // See: https://reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\n  hoistNonReactStatics(Wrapped, WrappedComponent);\n  return Wrapped;\n}\n\nexport { ErrorBoundary, UNKNOWN_COMPONENT, isAtLeastReact17, withErrorBoundary };\n//# sourceMappingURL=errorboundary.js.map\n","export default function capitalizeString(str) {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}","import capitalizeString from './capitalizeString';\n\n\nexport default function prefixProperty(prefixProperties, property, style) {\n  if (prefixProperties.hasOwnProperty(property)) {\n    var newStyle = {};\n    var requiredPrefixes = prefixProperties[property];\n    var capitalizedProperty = capitalizeString(property);\n    var keys = Object.keys(style);\n    for (var i = 0; i < keys.length; i++) {\n      var styleProperty = keys[i];\n      if (styleProperty === property) {\n        for (var j = 0; j < requiredPrefixes.length; j++) {\n          newStyle[requiredPrefixes[j] + capitalizedProperty] = style[property];\n        }\n      }\n      newStyle[styleProperty] = style[styleProperty];\n    }\n    return newStyle;\n  }\n  return style;\n}","export default function prefixValue(plugins, property, value, style, metaData) {\n  for (var i = 0, len = plugins.length; i < len; ++i) {\n    var processedValue = plugins[i](property, value, style, metaData);\n\n    // we can stop processing if a value is returned\n    // as all plugin criteria are unique\n    if (processedValue) {\n      return processedValue;\n    }\n  }\n}","function addIfNew(list, value) {\n  if (list.indexOf(value) === -1) {\n    list.push(value);\n  }\n}\n\nexport default function addNewValuesOnly(list, values) {\n  if (Array.isArray(values)) {\n    for (var i = 0, len = values.length; i < len; ++i) {\n      addIfNew(list, values[i]);\n    }\n  } else {\n    addIfNew(list, values);\n  }\n}","export default function isObject(value) {\n  return value instanceof Object && !Array.isArray(value);\n}","import prefixProperty from './utils/prefixProperty';\nimport prefixValue from './utils/prefixValue';\n\nimport addNewValuesOnly from './utils/addNewValuesOnly';\nimport isObject from './utils/isObject';\n\nexport default function createPrefixer(_ref) {\n  var prefixMap = _ref.prefixMap,\n      plugins = _ref.plugins;\n\n  return function prefix(style) {\n    for (var property in style) {\n      var value = style[property];\n\n      // handle nested objects\n      if (isObject(value)) {\n        style[property] = prefix(value);\n        // handle array values\n      } else if (Array.isArray(value)) {\n        var combinedValue = [];\n\n        for (var i = 0, len = value.length; i < len; ++i) {\n          var processedValue = prefixValue(plugins, property, value[i], style, prefixMap);\n          addNewValuesOnly(combinedValue, processedValue || value[i]);\n        }\n\n        // only modify the value if it was touched\n        // by any plugin to prevent unnecessary mutations\n        if (combinedValue.length > 0) {\n          style[property] = combinedValue;\n        }\n      } else {\n        var _processedValue = prefixValue(plugins, property, value, style, prefixMap);\n\n        // only modify the value if it was touched\n        // by any plugin to prevent unnecessary mutations\n        if (_processedValue) {\n          style[property] = _processedValue;\n        }\n\n        style = prefixProperty(prefixMap, property, style);\n      }\n    }\n\n    return style;\n  };\n}","\nvar w = [\"Webkit\"];\nvar m = [\"Moz\"];\nvar ms = [\"ms\"];\nvar wm = [\"Webkit\", \"Moz\"];\nvar wms = [\"Webkit\", \"ms\"];\nvar wmms = [\"Webkit\", \"Moz\", \"ms\"];\n\nexport default {\n  plugins: [],\n  prefixMap: { \"appearance\": wm, \"textEmphasisPosition\": w, \"textEmphasis\": w, \"textEmphasisStyle\": w, \"textEmphasisColor\": w, \"boxDecorationBreak\": w, \"maskImage\": w, \"maskMode\": w, \"maskRepeat\": w, \"maskPosition\": w, \"maskClip\": w, \"maskOrigin\": w, \"maskSize\": w, \"maskComposite\": w, \"mask\": w, \"maskBorderSource\": w, \"maskBorderMode\": w, \"maskBorderSlice\": w, \"maskBorderWidth\": w, \"maskBorderOutset\": w, \"maskBorderRepeat\": w, \"maskBorder\": w, \"maskType\": w, \"textDecorationStyle\": w, \"textDecorationSkip\": w, \"textDecorationLine\": w, \"textDecorationColor\": w, \"userSelect\": wmms, \"backdropFilter\": w, \"fontKerning\": w, \"scrollSnapType\": wms, \"scrollSnapPointsX\": wms, \"scrollSnapPointsY\": wms, \"scrollSnapDestination\": wms, \"scrollSnapCoordinate\": wms, \"clipPath\": w, \"shapeImageThreshold\": w, \"shapeImageMargin\": w, \"shapeImageOutside\": w, \"filter\": w, \"hyphens\": wms, \"flowInto\": wms, \"flowFrom\": wms, \"breakBefore\": wms, \"breakAfter\": wms, \"breakInside\": wms, \"regionFragment\": wms, \"writingMode\": wms, \"textOrientation\": w, \"tabSize\": m, \"fontFeatureSettings\": w, \"columnCount\": w, \"columnFill\": w, \"columnGap\": w, \"columnRule\": w, \"columnRuleColor\": w, \"columnRuleStyle\": w, \"columnRuleWidth\": w, \"columns\": w, \"columnSpan\": w, \"columnWidth\": w, \"wrapFlow\": ms, \"wrapThrough\": ms, \"wrapMargin\": ms, \"textSizeAdjust\": wms }\n};","\n// https://developer.mozilla.org/en-US/docs/Web/CSS/background-clip#Browser_compatibility\nexport default function backgroundClip(property, value) {\n  if (typeof value === 'string' && value === 'text') {\n    return ['-webkit-text', 'text'];\n  }\n}","var prefixes = ['-webkit-', '-moz-', ''];\n\nvar values = {\n  'zoom-in': true,\n  'zoom-out': true,\n  grab: true,\n  grabbing: true\n};\n\nexport default function cursor(property, value) {\n  if (property === 'cursor' && values.hasOwnProperty(value)) {\n    return prefixes.map(function (prefix) {\n      return prefix + value;\n    });\n  }\n}","import isPrefixedValue from 'css-in-js-utils/lib/isPrefixedValue';\n\n// http://caniuse.com/#search=cross-fade\nvar prefixes = ['-webkit-', ''];\n\nexport default function crossFade(property, value) {\n  if (typeof value === 'string' && !isPrefixedValue(value) && value.indexOf('cross-fade(') > -1) {\n    return prefixes.map(function (prefix) {\n      return value.replace(/cross-fade\\(/g, prefix + 'cross-fade(');\n    });\n  }\n}","import isPrefixedValue from 'css-in-js-utils/lib/isPrefixedValue';\n\n// http://caniuse.com/#feat=css-filter-function\nvar prefixes = ['-webkit-', ''];\n\nexport default function filter(property, value) {\n  if (typeof value === 'string' && !isPrefixedValue(value) && value.indexOf('filter(') > -1) {\n    return prefixes.map(function (prefix) {\n      return value.replace(/filter\\(/g, prefix + 'filter(');\n    });\n  }\n}","var values = {\n  flex: ['-webkit-box', '-moz-box', '-ms-flexbox', '-webkit-flex', 'flex'],\n  'inline-flex': ['-webkit-inline-box', '-moz-inline-box', '-ms-inline-flexbox', '-webkit-inline-flex', 'inline-flex']\n};\n\nexport default function flex(property, value) {\n  if (property === 'display' && values.hasOwnProperty(value)) {\n    return values[value];\n  }\n}","var alternativeValues = {\n  'space-around': 'justify',\n  'space-between': 'justify',\n  'flex-start': 'start',\n  'flex-end': 'end',\n  'wrap-reverse': 'multiple',\n  wrap: 'multiple'\n};\n\nvar alternativeProps = {\n  alignItems: 'WebkitBoxAlign',\n  justifyContent: 'WebkitBoxPack',\n  flexWrap: 'WebkitBoxLines',\n  flexGrow: 'WebkitBoxFlex'\n};\n\nexport default function flexboxOld(property, value, style) {\n  if (property === 'flexDirection' && typeof value === 'string') {\n    if (value.indexOf('column') > -1) {\n      style.WebkitBoxOrient = 'vertical';\n    } else {\n      style.WebkitBoxOrient = 'horizontal';\n    }\n    if (value.indexOf('reverse') > -1) {\n      style.WebkitBoxDirection = 'reverse';\n    } else {\n      style.WebkitBoxDirection = 'normal';\n    }\n  }\n  if (alternativeProps.hasOwnProperty(property)) {\n    style[alternativeProps[property]] = alternativeValues[value] || value;\n  }\n}","import isPrefixedValue from 'css-in-js-utils/lib/isPrefixedValue';\n\nvar prefixes = ['-webkit-', '-moz-', ''];\nvar values = /linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient/gi;\n\nexport default function gradient(property, value) {\n  if (typeof value === 'string' && !isPrefixedValue(value) && values.test(value)) {\n    return prefixes.map(function (prefix) {\n      return value.replace(values, function (grad) {\n        return prefix + grad;\n      });\n    });\n  }\n}","var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nfunction isSimplePositionValue(value) {\n  return typeof value === 'number' && !isNaN(value);\n}\n\nfunction isComplexSpanValue(value) {\n  return typeof value === 'string' && value.includes('/');\n}\n\nvar alignmentValues = ['center', 'end', 'start', 'stretch'];\n\nvar displayValues = {\n  'inline-grid': ['-ms-inline-grid', 'inline-grid'],\n  grid: ['-ms-grid', 'grid']\n};\n\nvar propertyConverters = {\n  alignSelf: function alignSelf(value, style) {\n    if (alignmentValues.indexOf(value) > -1) {\n      style.msGridRowAlign = value;\n    }\n  },\n\n  gridColumn: function gridColumn(value, style) {\n    if (isSimplePositionValue(value)) {\n      style.msGridColumn = value;\n    } else if (isComplexSpanValue(value)) {\n      var _value$split = value.split('/'),\n          _value$split2 = _slicedToArray(_value$split, 2),\n          start = _value$split2[0],\n          end = _value$split2[1];\n\n      propertyConverters.gridColumnStart(+start, style);\n\n      var _end$split = end.split(/ ?span /),\n          _end$split2 = _slicedToArray(_end$split, 2),\n          maybeSpan = _end$split2[0],\n          maybeNumber = _end$split2[1];\n\n      if (maybeSpan === '') {\n        propertyConverters.gridColumnEnd(+start + +maybeNumber, style);\n      } else {\n        propertyConverters.gridColumnEnd(+end, style);\n      }\n    } else {\n      propertyConverters.gridColumnStart(value, style);\n    }\n  },\n\n  gridColumnEnd: function gridColumnEnd(value, style) {\n    var msGridColumn = style.msGridColumn;\n\n    if (isSimplePositionValue(value) && isSimplePositionValue(msGridColumn)) {\n      style.msGridColumnSpan = value - msGridColumn;\n    }\n  },\n\n  gridColumnStart: function gridColumnStart(value, style) {\n    if (isSimplePositionValue(value)) {\n      style.msGridColumn = value;\n    }\n  },\n\n  gridRow: function gridRow(value, style) {\n    if (isSimplePositionValue(value)) {\n      style.msGridRow = value;\n    } else if (isComplexSpanValue(value)) {\n      var _value$split3 = value.split('/'),\n          _value$split4 = _slicedToArray(_value$split3, 2),\n          start = _value$split4[0],\n          end = _value$split4[1];\n\n      propertyConverters.gridRowStart(+start, style);\n\n      var _end$split3 = end.split(/ ?span /),\n          _end$split4 = _slicedToArray(_end$split3, 2),\n          maybeSpan = _end$split4[0],\n          maybeNumber = _end$split4[1];\n\n      if (maybeSpan === '') {\n        propertyConverters.gridRowEnd(+start + +maybeNumber, style);\n      } else {\n        propertyConverters.gridRowEnd(+end, style);\n      }\n    } else {\n      propertyConverters.gridRowStart(value, style);\n    }\n  },\n\n  gridRowEnd: function gridRowEnd(value, style) {\n    var msGridRow = style.msGridRow;\n\n    if (isSimplePositionValue(value) && isSimplePositionValue(msGridRow)) {\n      style.msGridRowSpan = value - msGridRow;\n    }\n  },\n\n  gridRowStart: function gridRowStart(value, style) {\n    if (isSimplePositionValue(value)) {\n      style.msGridRow = value;\n    }\n  },\n\n  gridTemplateColumns: function gridTemplateColumns(value, style) {\n    style.msGridColumns = value;\n  },\n\n  gridTemplateRows: function gridTemplateRows(value, style) {\n    style.msGridRows = value;\n  },\n\n  justifySelf: function justifySelf(value, style) {\n    if (alignmentValues.indexOf(value) > -1) {\n      style.msGridColumnAlign = value;\n    }\n  }\n};\n\nexport default function grid(property, value, style) {\n  if (property === 'display' && value in displayValues) {\n    return displayValues[value];\n  }\n\n  if (property in propertyConverters) {\n    var propertyConverter = propertyConverters[property];\n    propertyConverter(value, style);\n  }\n}","import isPrefixedValue from 'css-in-js-utils/lib/isPrefixedValue';\n\n// http://caniuse.com/#feat=css-image-set\nvar prefixes = ['-webkit-', ''];\n\nexport default function imageSet(property, value) {\n  if (typeof value === 'string' && !isPrefixedValue(value) && value.indexOf('image-set(') > -1) {\n    return prefixes.map(function (prefix) {\n      return value.replace(/image-set\\(/g, prefix + 'image-set(');\n    });\n  }\n}","var alternativeProps = {\n  marginBlockStart: ['WebkitMarginBefore'],\n  marginBlockEnd: ['WebkitMarginAfter'],\n  marginInlineStart: ['WebkitMarginStart', 'MozMarginStart'],\n  marginInlineEnd: ['WebkitMarginEnd', 'MozMarginEnd'],\n  paddingBlockStart: ['WebkitPaddingBefore'],\n  paddingBlockEnd: ['WebkitPaddingAfter'],\n  paddingInlineStart: ['WebkitPaddingStart', 'MozPaddingStart'],\n  paddingInlineEnd: ['WebkitPaddingEnd', 'MozPaddingEnd'],\n  borderBlockStart: ['WebkitBorderBefore'],\n  borderBlockStartColor: ['WebkitBorderBeforeColor'],\n  borderBlockStartStyle: ['WebkitBorderBeforeStyle'],\n  borderBlockStartWidth: ['WebkitBorderBeforeWidth'],\n  borderBlockEnd: ['WebkitBorderAfter'],\n  borderBlockEndColor: ['WebkitBorderAfterColor'],\n  borderBlockEndStyle: ['WebkitBorderAfterStyle'],\n  borderBlockEndWidth: ['WebkitBorderAfterWidth'],\n  borderInlineStart: ['WebkitBorderStart', 'MozBorderStart'],\n  borderInlineStartColor: ['WebkitBorderStartColor', 'MozBorderStartColor'],\n  borderInlineStartStyle: ['WebkitBorderStartStyle', 'MozBorderStartStyle'],\n  borderInlineStartWidth: ['WebkitBorderStartWidth', 'MozBorderStartWidth'],\n  borderInlineEnd: ['WebkitBorderEnd', 'MozBorderEnd'],\n  borderInlineEndColor: ['WebkitBorderEndColor', 'MozBorderEndColor'],\n  borderInlineEndStyle: ['WebkitBorderEndStyle', 'MozBorderEndStyle'],\n  borderInlineEndWidth: ['WebkitBorderEndWidth', 'MozBorderEndWidth']\n};\n\nexport default function logical(property, value, style) {\n  if (Object.prototype.hasOwnProperty.call(alternativeProps, property)) {\n    var alternativePropList = alternativeProps[property];\n    for (var i = 0, len = alternativePropList.length; i < len; ++i) {\n      style[alternativePropList[i]] = value;\n    }\n  }\n}","export default function position(property, value) {\n  if (property === 'position' && value === 'sticky') {\n    return ['-webkit-sticky', 'sticky'];\n  }\n}","var prefixes = ['-webkit-', '-moz-', ''];\n\nvar properties = {\n  maxHeight: true,\n  maxWidth: true,\n  width: true,\n  height: true,\n  columnWidth: true,\n  minWidth: true,\n  minHeight: true\n};\nvar values = {\n  'min-content': true,\n  'max-content': true,\n  'fill-available': true,\n  'fit-content': true,\n  'contain-floats': true\n};\n\nexport default function sizing(property, value) {\n  if (properties.hasOwnProperty(property) && values.hasOwnProperty(value)) {\n    return prefixes.map(function (prefix) {\n      return prefix + value;\n    });\n  }\n}","import hyphenateProperty from 'css-in-js-utils/lib/hyphenateProperty';\nimport isPrefixedValue from 'css-in-js-utils/lib/isPrefixedValue';\n\nimport capitalizeString from '../utils/capitalizeString';\n\nvar properties = {\n  transition: true,\n  transitionProperty: true,\n  WebkitTransition: true,\n  WebkitTransitionProperty: true,\n  MozTransition: true,\n  MozTransitionProperty: true\n};\n\nvar prefixMapping = {\n  Webkit: '-webkit-',\n  Moz: '-moz-',\n  ms: '-ms-'\n};\n\nfunction prefixValue(value, propertyPrefixMap) {\n  if (isPrefixedValue(value)) {\n    return value;\n  }\n\n  // only split multi values, not cubic beziers\n  var multipleValues = value.split(/,(?![^()]*(?:\\([^()]*\\))?\\))/g);\n\n  for (var i = 0, len = multipleValues.length; i < len; ++i) {\n    var singleValue = multipleValues[i];\n    var values = [singleValue];\n    for (var property in propertyPrefixMap) {\n      var dashCaseProperty = hyphenateProperty(property);\n\n      if (singleValue.indexOf(dashCaseProperty) > -1 && dashCaseProperty !== 'order') {\n        var prefixes = propertyPrefixMap[property];\n        for (var j = 0, pLen = prefixes.length; j < pLen; ++j) {\n          // join all prefixes and create a new value\n          values.unshift(singleValue.replace(dashCaseProperty, prefixMapping[prefixes[j]] + dashCaseProperty));\n        }\n      }\n    }\n\n    multipleValues[i] = values.join(',');\n  }\n\n  return multipleValues.join(',');\n}\n\nexport default function transition(property, value, style, propertyPrefixMap) {\n  // also check for already prefixed transitions\n  if (typeof value === 'string' && properties.hasOwnProperty(property)) {\n    var outputValue = prefixValue(value, propertyPrefixMap);\n    // if the property is already prefixed\n    var webkitOutput = outputValue.split(/,(?![^()]*(?:\\([^()]*\\))?\\))/g).filter(function (val) {\n      return !/-moz-|-ms-/.test(val);\n    }).join(',');\n\n    if (property.indexOf('Webkit') > -1) {\n      return webkitOutput;\n    }\n\n    var mozOutput = outputValue.split(/,(?![^()]*(?:\\([^()]*\\))?\\))/g).filter(function (val) {\n      return !/-webkit-|-ms-/.test(val);\n    }).join(',');\n\n    if (property.indexOf('Moz') > -1) {\n      return mozOutput;\n    }\n\n    style['Webkit' + capitalizeString(property)] = webkitOutput;\n    style['Moz' + capitalizeString(property)] = mozOutput;\n    return outputValue;\n  }\n}","import createPrefixer from './createPrefixer';\n\nimport data from './data';\n\nimport backgroundClip from './plugins/backgroundClip';\nimport cursor from './plugins/cursor';\nimport crossFade from './plugins/crossFade';\nimport filter from './plugins/filter';\nimport flex from './plugins/flex';\nimport flexboxOld from './plugins/flexboxOld';\nimport gradient from './plugins/gradient';\nimport grid from './plugins/grid';\nimport imageSet from './plugins/imageSet';\nimport logical from './plugins/logical';\nimport position from './plugins/position';\nimport sizing from './plugins/sizing';\nimport transition from './plugins/transition';\n\nvar plugins = [backgroundClip, crossFade, cursor, filter, flexboxOld, gradient, grid, imageSet, logical, position, sizing, transition, flex];\n\nvar prefix = createPrefixer({\n  prefixMap: data.prefixMap,\n  plugins: plugins\n});\n\nexport { createPrefixer, prefix };","import { prefix } from 'inline-style-prefixer';\n\nvar SequentialIDGenerator =\n/*#__PURE__*/\nfunction () {\n  function SequentialIDGenerator(prefix$$1) {\n    if (prefix$$1 === void 0) {\n      prefix$$1 = \"\";\n    }\n\n    // ensure start with \"ae\" so \"ad\" is never produced\n    this.prefix = prefix$$1;\n    this.count = 0;\n    this.offset = 374;\n    this.msb = 1295;\n    this.power = 2;\n  }\n\n  var _proto = SequentialIDGenerator.prototype;\n\n  _proto.next = function next() {\n    var id = this.increment().toString(36);\n    return this.prefix ? \"\" + this.prefix + id : id;\n  };\n\n  _proto.increment = function increment() {\n    var id = this.count + this.offset;\n\n    if (id === this.msb) {\n      this.offset += (this.msb + 1) * 9;\n      this.msb = Math.pow(36, ++this.power) - 1;\n    }\n\n    this.count++;\n    return id;\n  };\n\n  return SequentialIDGenerator;\n}();\n\n// adapted from https://github.com/dutchenkoOleg/sort-css-media-queries\nvar minMaxWidth = /(!?\\(\\s*min(-device-)?-width).+\\(\\s*max(-device)?-width/i;\nvar minWidth = /\\(\\s*min(-device)?-width/i;\nvar maxMinWidth = /(!?\\(\\s*max(-device)?-width).+\\(\\s*min(-device)?-width/i;\nvar maxWidth = /\\(\\s*max(-device)?-width/i;\n\nvar isMinWidth = _testQuery(minMaxWidth, maxMinWidth, minWidth);\n\nvar isMaxWidth = _testQuery(maxMinWidth, minMaxWidth, maxWidth);\n\nvar minMaxHeight = /(!?\\(\\s*min(-device)?-height).+\\(\\s*max(-device)?-height/i;\nvar minHeight = /\\(\\s*min(-device)?-height/i;\nvar maxMinHeight = /(!?\\(\\s*max(-device)?-height).+\\(\\s*min(-device)?-height/i;\nvar maxHeight = /\\(\\s*max(-device)?-height/i;\n\nvar isMinHeight = _testQuery(minMaxHeight, maxMinHeight, minHeight);\n\nvar isMaxHeight = _testQuery(maxMinHeight, minMaxHeight, maxHeight);\n\nvar isPrint = /print/i;\nvar isPrintOnly = /^print$/i;\nvar maxValue = Number.MAX_VALUE;\n\nfunction _getQueryLength(length) {\n  var matches = /(-?\\d*\\.?\\d+)(ch|em|ex|px|rem)/.exec(length);\n\n  if (matches === null) {\n    return maxValue;\n  }\n\n  var number = matches[1];\n  var unit = matches[2];\n\n  switch (unit) {\n    case \"ch\":\n      number = parseFloat(number) * 8.8984375;\n      break;\n\n    case \"em\":\n    case \"rem\":\n      number = parseFloat(number) * 16;\n      break;\n\n    case \"ex\":\n      number = parseFloat(number) * 8.296875;\n      break;\n\n    case \"px\":\n      number = parseFloat(number);\n      break;\n  }\n\n  return +number;\n}\n\nfunction _testQuery(doubleTestTrue, doubleTestFalse, singleTest) {\n  return function (query) {\n    if (doubleTestTrue.test(query)) {\n      return true;\n    } else if (doubleTestFalse.test(query)) {\n      return false;\n    }\n\n    return singleTest.test(query);\n  };\n}\n\nfunction _testIsPrint(a, b) {\n  var isPrintA = isPrint.test(a);\n  var isPrintOnlyA = isPrintOnly.test(a);\n  var isPrintB = isPrint.test(b);\n  var isPrintOnlyB = isPrintOnly.test(b);\n\n  if (isPrintA && isPrintB) {\n    if (!isPrintOnlyA && isPrintOnlyB) {\n      return 1;\n    }\n\n    if (isPrintOnlyA && !isPrintOnlyB) {\n      return -1;\n    }\n\n    return a.localeCompare(b);\n  }\n\n  if (isPrintA) {\n    return 1;\n  }\n\n  if (isPrintB) {\n    return -1;\n  }\n\n  return null;\n}\n\nfunction sortCSSmq(a, b) {\n  if (a === \"\") {\n    return -1;\n  }\n\n  if (b === \"\") {\n    return 1;\n  }\n\n  var testIsPrint = _testIsPrint(a, b);\n\n  if (testIsPrint !== null) {\n    return testIsPrint;\n  }\n\n  var minA = isMinWidth(a) || isMinHeight(a);\n  var maxA = isMaxWidth(a) || isMaxHeight(a);\n  var minB = isMinWidth(b) || isMinHeight(b);\n  var maxB = isMaxWidth(b) || isMaxHeight(b);\n\n  if (minA && maxB) {\n    return -1;\n  }\n\n  if (maxA && minB) {\n    return 1;\n  }\n\n  var lengthA = _getQueryLength(a);\n\n  var lengthB = _getQueryLength(b);\n\n  if (lengthA === maxValue && lengthB === maxValue) {\n    return a.localeCompare(b);\n  } else if (lengthA === maxValue) {\n    return 1;\n  } else if (lengthB === maxValue) {\n    return -1;\n  }\n\n  if (lengthA > lengthB) {\n    if (maxA) {\n      return -1;\n    }\n\n    return 1;\n  }\n\n  if (lengthA < lengthB) {\n    if (maxA) {\n      return 1;\n    }\n\n    return -1;\n  }\n\n  return a.localeCompare(b);\n}\n\nvar MultiCache =\n/*#__PURE__*/\nfunction () {\n  function MultiCache(idGenerator, onNewCache, onNewValue) {\n    this.idGenerator = idGenerator;\n    this.onNewCache = onNewCache;\n    this.onNewValue = onNewValue;\n    this.sortedCacheKeys = [];\n    this.caches = {};\n  }\n\n  var _proto = MultiCache.prototype;\n\n  _proto.getCache = function getCache(key) {\n    if (!this.caches[key]) {\n      var _cache = new Cache(this.idGenerator, this.onNewValue);\n\n      _cache.key = key;\n      this.sortedCacheKeys.push(key);\n      this.sortedCacheKeys.sort(sortCSSmq);\n      var keyIndex = this.sortedCacheKeys.indexOf(key);\n      var insertBeforeMedia = keyIndex < this.sortedCacheKeys.length - 1 ? this.sortedCacheKeys[keyIndex + 1] : void 0;\n      this.caches[key] = _cache;\n      this.onNewCache(key, _cache, insertBeforeMedia);\n    }\n\n    return this.caches[key];\n  };\n\n  _proto.getSortedCacheKeys = function getSortedCacheKeys() {\n    return this.sortedCacheKeys;\n  };\n\n  return MultiCache;\n}();\nvar Cache =\n/*#__PURE__*/\nfunction () {\n  function Cache(idGenerator, onNewValue) {\n    this.cache = {};\n    this.idGenerator = idGenerator;\n    this.onNewValue = onNewValue;\n  }\n\n  var _proto2 = Cache.prototype;\n\n  _proto2.addValue = function addValue(key, value) {\n    var cached = this.cache[key];\n\n    if (cached) {\n      return cached;\n    }\n\n    var id = this.idGenerator.next();\n    this.cache[key] = id;\n    this.onNewValue(this, id, value);\n    return id;\n  };\n\n  return Cache;\n}();\n\nvar uppercasePattern = /[A-Z]/g;\nvar msPattern = /^ms-/;\nvar cache = {};\nfunction hyphenateStyleName(prop) {\n  return prop in cache ? cache[prop] : cache[prop] = prop.replace(uppercasePattern, \"-$&\").toLowerCase().replace(msPattern, \"-ms-\");\n}\n\n/**\n * Adapted from https://github.com/gilmoreorless/css-shorthand-properties\n */\nvar shorthandMap = {\n  // CSS 2.1: https://www.w3.org/TR/CSS2/propidx.html\n  \"list-style\": [\"list-style-type\", \"list-style-position\", \"list-style-image\"],\n  margin: [\"margin-top\", \"margin-right\", \"margin-bottom\", \"margin-left\"],\n  outline: [\"outline-width\", \"outline-style\", \"outline-color\"],\n  padding: [\"padding-top\", \"padding-right\", \"padding-bottom\", \"padding-left\"],\n  // CSS Backgrounds and Borders Module Level 3: https://www.w3.org/TR/css3-background/\n  background: [\"background-image\", \"background-position\", \"background-size\", \"background-repeat\", \"background-origin\", \"background-clip\", \"background-attachment\", \"background-color\"],\n  border: [\"border-top-width\", \"border-right-width\", \"border-bottom-width\", \"border-left-width\", \"border-width\", \"border-top-style\", \"border-right-style\", \"border-bottom-style\", \"border-left-style\", \"border-style\", \"border-top-color\", \"border-right-color\", \"border-bottom-color\", \"border-left-color\", \"border-color\"],\n  \"border-color\": [\"border-top-color\", \"border-right-color\", \"border-bottom-color\", \"border-left-color\"],\n  \"border-style\": [\"border-top-style\", \"border-right-style\", \"border-bottom-style\", \"border-left-style\"],\n  \"border-width\": [\"border-top-width\", \"border-right-width\", \"border-bottom-width\", \"border-left-width\"],\n  \"border-top\": [\"border-top-width\", \"border-top-style\", \"border-top-color\"],\n  \"border-right\": [\"border-right-width\", \"border-right-style\", \"border-right-color\"],\n  \"border-bottom\": [\"border-bottom-width\", \"border-bottom-style\", \"border-bottom-color\"],\n  \"border-left\": [\"border-left-width\", \"border-left-style\", \"border-left-color\"],\n  \"border-radius\": [\"border-top-left-radius\", \"border-top-right-radius\", \"border-bottom-right-radius\", \"border-bottom-left-radius\"],\n  \"border-image\": [\"border-image-source\", \"border-image-slice\", \"border-image-width\", \"border-image-outset\", \"border-image-repeat\"],\n  // CSS Fonts Module Level 3: https://www.w3.org/TR/css3-fonts/\n  font: [\"font-style\", \"font-variant-ligatures\", \"font-variant-alternates\", \"font-variant-caps\", \"font-variant-numeric\", \"font-variant-east-asian\", \"font-variant\", \"font-weight\", \"font-stretch\", \"font-size\", \"line-height\", \"font-family\"],\n  \"font-variant\": [\"font-variant-ligatures\", \"font-variant-alternates\", \"font-variant-caps\", \"font-variant-numeric\", \"font-variant-east-asian\"],\n  // CSS Flexible Box Layout Module Level 1: https://www.w3.org/TR/css3-flexbox-1/\n  flex: [\"flex-grow\", \"flex-shrink\", \"flex-basis\"],\n  \"flex-flow\": [\"flex-direction\", \"flex-wrap\"],\n  // CSS Grid Layout Module Level 1: https://www.w3.org/TR/css-grid-1/\n  grid: [\"grid-template-rows\", \"grid-template-columns\", \"grid-template-areas\", \"grid-auto-rows\", \"grid-auto-columns\", \"grid-auto-flow\"],\n  \"grid-template\": [\"grid-template-rows\", \"grid-template-columns\", \"grid-template-areas\"],\n  \"grid-row\": [\"grid-row-start\", \"grid-row-end\"],\n  \"grid-column\": [\"grid-column-start\", \"grid-column-end\"],\n  \"grid-area\": [\"grid-row-start\", \"grid-column-start\", \"grid-row-end\", \"grid-column-end\"],\n  \"grid-gap\": [\"grid-row-gap\", \"grid-column-gap\"],\n  // CSS Masking Module Level 1: https://www.w3.org/TR/css-masking/\n  mask: [\"mask-image\", \"mask-mode\", \"mask-position\", \"mask-size\", \"mask-repeat\", \"mask-origin\", \"mask-clip\"],\n  \"mask-border\": [\"mask-border-source\", \"mask-border-slice\", \"mask-border-width\", \"mask-border-outset\", \"mask-border-repeat\", \"mask-border-mode\"],\n  // CSS Multi-column Layout Module: https://www.w3.org/TR/css3-multicol/\n  columns: [\"column-width\", \"column-count\"],\n  \"column-rule\": [\"column-rule-width\", \"column-rule-style\", \"column-rule-color\"],\n  // CSS Scroll Snap Module Level 1: https://www.w3.org/TR/css-scroll-snap-1/\n  \"scroll-padding\": [\"scroll-padding-top\", \"scroll-padding-right\", \"scroll-padding-bottom\", \"scroll-padding-left\"],\n  \"scroll-padding-block\": [\"scroll-padding-block-start\", \"scroll-padding-block-end\"],\n  \"scroll-padding-inline\": [\"scroll-padding-inline-start\", \"scroll-padding-inline-end\"],\n  \"scroll-snap-margin\": [\"scroll-snap-margin-top\", \"scroll-snap-margin-right\", \"scroll-snap-margin-bottom\", \"scroll-snap-margin-left\"],\n  \"scroll-snap-margin-block\": [\"scroll-snap-margin-block-start\", \"scroll-snap-margin-block-end\"],\n  \"scroll-snap-margin-inline\": [\"scroll-snap-margin-inline-start\", \"scroll-snap-margin-inline-end\"],\n  // CSS Speech Module: https://www.w3.org/TR/css3-speech/\n  cue: [\"cue-before\", \"cue-after\"],\n  pause: [\"pause-before\", \"pause-after\"],\n  rest: [\"rest-before\", \"rest-after\"],\n  // CSS Text Decoration Module Level 3: https://www.w3.org/TR/css-text-decor-3/\n  \"text-decoration\": [\"text-decoration-line\", \"text-decoration-style\", \"text-decoration-color\"],\n  \"text-emphasis\": [\"text-emphasis-style\", \"text-emphasis-color\"],\n  // CSS Animations (WD): https://www.w3.org/TR/css3-animations\n  animation: [\"animation-name\", \"animation-duration\", \"animation-timing-function\", \"animation-delay\", \"animation-iteration-count\", \"animation-direction\", \"animation-fill-mode\", \"animation-play-state\"],\n  // CSS Transitions (WD): https://www.w3.org/TR/css3-transitions/\n  transition: [\"transition-property\", \"transition-duration\", \"transition-timing-function\", \"transition-delay\"]\n};\nfunction validateNoMixedHand(style) {\n  var hyphenatedProperties = Object.keys(style).reduce(function (acc, property) {\n    acc[hyphenateStyleName(property)] = property;\n    return acc;\n  }, {});\n  var mixed = [];\n\n  for (var property in hyphenatedProperties) {\n    if (property in shorthandMap) {\n      for (var _iterator = shorthandMap[property], _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n        var _ref;\n\n        if (_isArray) {\n          if (_i >= _iterator.length) break;\n          _ref = _iterator[_i++];\n        } else {\n          _i = _iterator.next();\n          if (_i.done) break;\n          _ref = _i.value;\n        }\n\n        var _longhand = _ref;\n\n        if (_longhand in hyphenatedProperties) {\n          var long = hyphenatedProperties[_longhand];\n          var short = hyphenatedProperties[property];\n          mixed.push({\n            shorthand: {\n              property: short,\n              value: style[short]\n            },\n            longhand: {\n              property: long,\n              value: style[long]\n            }\n          });\n        }\n      }\n    }\n  }\n\n  return mixed;\n}\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction injectStylePrefixed(styleCache, styles, media, pseudo) {\n  var cache = styleCache.getCache(media);\n  var classString = \"\";\n\n  for (var originalKey in styles) {\n    var originalVal = styles[originalKey];\n\n    if (originalVal === void 0 || originalVal === null) {\n      continue;\n    }\n\n    if (_typeof(originalVal) !== \"object\") {\n      // Non-null and non-undefined primitive value\n      if (process.env.NODE_ENV !== \"production\") {\n        validateValueType(originalVal, originalKey);\n      }\n\n      var propValPair = hyphenateStyleName(originalKey) + \":\" + originalVal;\n      var key = \"\" + pseudo + propValPair;\n      var cachedId = cache.cache[key];\n\n      if (cachedId !== void 0) {\n        // cache hit\n        classString += \" \" + cachedId;\n        continue;\n      } else {\n        var _prefix;\n\n        // cache miss\n        var block = \"\";\n        var prefixed = prefix((_prefix = {}, _prefix[originalKey] = originalVal, _prefix));\n\n        for (var prefixedKey in prefixed) {\n          var prefixedVal = prefixed[prefixedKey];\n\n          var prefixedValType = _typeof(prefixedVal);\n\n          if (prefixedValType === \"string\" || prefixedValType === \"number\") {\n            var prefixedPair = hyphenateStyleName(prefixedKey) + \":\" + prefixedVal;\n\n            if (prefixedPair !== propValPair) {\n              block += prefixedPair + \";\";\n            }\n          } else if (Array.isArray(prefixedVal)) {\n            var hyphenated = hyphenateStyleName(prefixedKey);\n\n            for (var i = 0; i < prefixedVal.length; i++) {\n              var _prefixedPair = hyphenated + \":\" + prefixedVal[i];\n\n              if (_prefixedPair !== propValPair) {\n                block += _prefixedPair + \";\";\n              }\n            }\n          }\n        }\n\n        block += propValPair; // ensure original prop/val is last (for hydration)\n\n        var id = cache.addValue(key, {\n          pseudo: pseudo,\n          block: block\n        });\n        classString += \" \" + id;\n      }\n    } else {\n      // Non-null object value\n      if (originalKey[0] === \":\") {\n        classString += \" \" + injectStylePrefixed(styleCache, originalVal, media, pseudo + originalKey);\n      } else if (originalKey.substring(0, 6) === \"@media\") {\n        classString += \" \" + injectStylePrefixed(styleCache, originalVal, originalKey.substr(7), pseudo);\n      }\n    }\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var conflicts = validateNoMixedHand(styles);\n\n    if (conflicts.length) {\n      conflicts.forEach(function (_ref) {\n        var _JSON$stringify, _JSON$stringify2;\n\n        var shorthand = _ref.shorthand,\n            longhand = _ref.longhand;\n        var short = JSON.stringify((_JSON$stringify = {}, _JSON$stringify[shorthand.property] = shorthand.value, _JSON$stringify));\n        var long = JSON.stringify((_JSON$stringify2 = {}, _JSON$stringify2[longhand.property] = longhand.value, _JSON$stringify2)); // eslint-disable-next-line no-console\n\n        console.warn(\"Styles `\" + short + \"` and `\" + long + \"` in object yielding class \\\"\" + classString.slice(1) + \"\\\" may result in unexpected behavior. Mixing shorthand and longhand properties within the same style object is unsupported with atomic rendering.\");\n      });\n    }\n  } // remove leading space\n\n\n  return classString.slice(1);\n}\n\nfunction validateValueType(value, key) {\n  if (value === null || Array.isArray(value) || typeof value !== \"number\" && typeof value !== \"string\") {\n    throw new Error(\"Unsupported style value: \" + JSON.stringify(value) + \" used in property \" + JSON.stringify(key));\n  }\n}\n\nfunction _typeof$1(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof$1(obj); }\n\n/* eslint-disable no-console */\nvar validAnimationState = /^(from|to|\\+?(\\d*\\.)?\\d+%)(\\s*,\\s*(from|to|\\+?(\\d*\\.)?\\d+%))*$/;\nfunction validateKeyframesObject(keyframes) {\n  var valid = true;\n\n  for (var animationState in keyframes) {\n    var value = keyframes[animationState];\n\n    if (!validAnimationState.test(animationState)) {\n      valid = false;\n      console.warn(\"Warning: property \\\"\" + animationState + \"\\\" in keyframes object \" + JSON.stringify(keyframes) + \" is not a valid. Must be \\\"from\\\", \\\"to\\\", or a percentage.\");\n    }\n\n    if (_typeof$1(value) !== \"object\") {\n      valid = false;\n      console.warn(\"Warning: value for \\\"\" + animationState + \"\\\" property in keyframes object \" + JSON.stringify(keyframes) + \" must be an object. Instead it was a \" + _typeof$1(value) + \".\");\n    }\n\n    if (!valid) {\n      console.warn(\"Warning: object used as value for \\\"animationName\\\" style is invalid:\", keyframes);\n    }\n  }\n}\n\nfunction atomicSelector(id, pseudo) {\n  var selector = \".\" + id;\n\n  if (pseudo) {\n    selector += pseudo;\n  }\n\n  return selector;\n}\nfunction keyframesToBlock(keyframes) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateKeyframesObject(keyframes);\n  }\n\n  if (process.env.NODE_ENV !== \"production\" && typeof Object.getPrototypeOf(keyframes) !== \"undefined\") {\n    if (Object.getPrototypeOf(keyframes) !== Object.getPrototypeOf({})) {\n      // eslint-disable-next-line no-console\n      console.warn(\"Only plain objects should be used as animation values. Unexpectedly recieved:\", keyframes);\n    }\n  }\n\n  var result = \"\";\n\n  for (var animationState in keyframes) {\n    result += animationState + \"{\" + declarationsToBlock(keyframes[animationState]) + \"}\";\n  }\n\n  return result;\n}\nfunction declarationsToBlock(style) {\n  var css = \"\";\n\n  for (var prop in style) {\n    var val = style[prop];\n\n    if (typeof val === \"string\" || typeof val === \"number\") {\n      css += hyphenateStyleName(prop) + \":\" + val + \";\";\n    }\n  } // trim trailing semicolon\n\n\n  return css.slice(0, -1);\n}\nfunction keyframesBlockToRule(id, block) {\n  return \"@keyframes \" + id + \"{\" + block + \"}\";\n}\nfunction fontFaceBlockToRule(id, block) {\n  return \"@font-face{font-family:\" + id + \";\" + block + \"}\";\n}\nfunction styleBlockToRule(selector, block) {\n  return selector + \"{\" + block + \"}\";\n}\n\n/* eslint-env browser */\nvar insertRuleIntoDevtools = function insertRuleIntoDevtools(selector, block) {\n  // start after the . combinator and cut at the first : if there is one to cut out the pseudo classes\n  var key = selector.substring(1, selector.indexOf(\":\") !== -1 ? selector.indexOf(\":\") : selector.length);\n  var styles = {}; // split the declaration to catch vendor prefixing\n\n  for (var _iterator = block.split(\";\"), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n    var _ref;\n\n    if (_isArray) {\n      if (_i >= _iterator.length) break;\n      _ref = _iterator[_i++];\n    } else {\n      _i = _iterator.next();\n      if (_i.done) break;\n      _ref = _i.value;\n    }\n\n    var _decl = _ref;\n    if (_decl.trim() !== \"\" && !window.__STYLETRON_DEVTOOLS__.atomicMap[key]) styles[_decl.substring(0, _decl.indexOf(\":\"))] = _decl.substring(_decl.indexOf(\":\") + 1, _decl.length);\n  }\n\n  window.__STYLETRON_DEVTOOLS__.atomicMap[key] = styles;\n};\nvar hydrateDevtoolsRule = function hydrateDevtoolsRule(cssString) {\n  var id = cssString.substring(0, 3);\n  var block = cssString.substring(4, cssString.length - 1);\n  insertRuleIntoDevtools(id, block);\n};\n\n/* eslint-env browser */\nvar STYLES_HYDRATOR = /\\.([^{:]+)(:[^{]+)?{(?:[^}]*;)?([^}]*?)}/g;\nvar KEYFRAMES_HYRDATOR = /@keyframes ([^{]+){((?:(?:from|to|(?:\\d+\\.?\\d*%))\\{(?:[^}])*})*)}/g;\nvar FONT_FACE_HYDRATOR = /@font-face\\{font-family:([^;]+);([^}]*)\\}/g;\n\nfunction hydrateStyles(cache, hydrator, css) {\n  var match;\n\n  while (match = hydrator.exec(css)) {\n    var _match = match,\n        id = _match[1],\n        pseudo = _match[2],\n        key = _match[3];\n\n    if (true && process.env.NODE_ENV !== \"production\" && window.__STYLETRON_DEVTOOLS__) {\n      hydrateDevtoolsRule(match[0]);\n    }\n\n    var fullKey = pseudo ? \"\" + pseudo + key : key;\n    cache.cache[fullKey] = id; // set cache without triggering side effects\n\n    cache.idGenerator.increment(); // increment id\n  }\n}\n\nfunction hydrate(cache, hydrator, css) {\n  var match;\n\n  while (match = hydrator.exec(css)) {\n    var _match2 = match,\n        id = _match2[1],\n        key = _match2[2];\n\n    if (true && process.env.NODE_ENV !== \"production\" && window.__STYLETRON_DEVTOOLS__) {\n      hydrateDevtoolsRule(match[0]);\n    }\n\n    cache.cache[key] = id; // set cache without triggering side effects\n\n    cache.idGenerator.increment(); // increment id\n  }\n}\n\nvar StyletronClient =\n/*#__PURE__*/\nfunction () {\n  function StyletronClient(opts) {\n    var _this = this;\n\n    if (opts === void 0) {\n      opts = {};\n    }\n\n    this.styleElements = {};\n    var styleIdGenerator = new SequentialIDGenerator(opts.prefix);\n\n    var onNewStyle = function onNewStyle(cache, id, value) {\n      var pseudo = value.pseudo,\n          block = value.block;\n      var sheet = _this.styleElements[cache.key].sheet;\n      var selector = atomicSelector(id, pseudo);\n      var rule = styleBlockToRule(selector, block);\n\n      try {\n        sheet.insertRule(rule, sheet.cssRules.length);\n\n        if (true && process.env.NODE_ENV !== \"production\" && window.__STYLETRON_DEVTOOLS__) {\n          insertRuleIntoDevtools(selector, block);\n        }\n      } catch (e) {\n        if (process.env.NODE_ENV !== \"production\") {\n          // eslint-disable-next-line no-console\n          console.warn(\"Failed to inject CSS: \\\"\" + rule + \"\\\". Perhaps this has invalid or un-prefixed properties?\");\n        }\n      }\n    }; // Setup style cache\n\n\n    this.styleCache = new MultiCache(styleIdGenerator, function (media, _cache, insertBeforeMedia) {\n      var styleElement = document.createElement(\"style\");\n      styleElement.media = media;\n\n      if (insertBeforeMedia === void 0) {\n        _this.container.appendChild(styleElement);\n      } else {\n        var insertBeforeIndex = findSheetIndexWithMedia(_this.container.children, insertBeforeMedia);\n\n        _this.container.insertBefore(styleElement, _this.container.children[insertBeforeIndex]);\n      }\n\n      _this.styleElements[media] = styleElement;\n    }, onNewStyle);\n    this.keyframesCache = new Cache(new SequentialIDGenerator(opts.prefix), function (cache, id, value) {\n      _this.styleCache.getCache(\"\");\n\n      var sheet = _this.styleElements[\"\"].sheet;\n      var rule = keyframesBlockToRule(id, keyframesToBlock(value));\n\n      try {\n        sheet.insertRule(rule, sheet.cssRules.length);\n      } catch (e) {\n        if (process.env.NODE_ENV !== \"production\") {\n          // eslint-disable-next-line no-console\n          console.warn(\"Failed to inject CSS: \\\"\" + rule + \"\\\". Perhaps this has invalid or un-prefixed properties?\");\n        }\n      }\n    });\n    this.fontFaceCache = new Cache(new SequentialIDGenerator(opts.prefix), function (cache, id, value) {\n      _this.styleCache.getCache(\"\");\n\n      var sheet = _this.styleElements[\"\"].sheet;\n      var rule = fontFaceBlockToRule(id, declarationsToBlock(value));\n\n      try {\n        sheet.insertRule(rule, sheet.cssRules.length);\n      } catch (e) {\n        if (process.env.NODE_ENV !== \"production\") {\n          // eslint-disable-next-line no-console\n          console.warn(\"Failed to inject CSS: \\\"\" + rule + \"\\\". Perhaps this has invalid or un-prefixed properties?\");\n        }\n      }\n    });\n\n    if (opts.container) {\n      this.container = opts.container;\n    } // Hydrate\n\n\n    if (opts.hydrate && opts.hydrate.length > 0) {\n      // infer container from parent element\n      if (!this.container) {\n        var parentElement = opts.hydrate[0].parentElement;\n\n        if (parentElement !== null && parentElement !== void 0) {\n          this.container = parentElement;\n        }\n      }\n\n      for (var i = 0; i < opts.hydrate.length; i++) {\n        var element = opts.hydrate[i];\n        var hydrateType = element.getAttribute(\"data-hydrate\");\n\n        if (hydrateType === \"font-face\") {\n          hydrate(this.fontFaceCache, FONT_FACE_HYDRATOR, element.textContent);\n          continue;\n        }\n\n        if (hydrateType === \"keyframes\") {\n          hydrate(this.keyframesCache, KEYFRAMES_HYRDATOR, element.textContent);\n          continue;\n        }\n\n        var key = element.media ? element.media : \"\";\n        this.styleElements[key] = element;\n        var cache = new Cache(styleIdGenerator, onNewStyle);\n        cache.key = key;\n        hydrateStyles(cache, STYLES_HYDRATOR, element.textContent);\n        this.styleCache.sortedCacheKeys.push(key);\n        this.styleCache.caches[key] = cache;\n      }\n    }\n\n    if (!this.container) {\n      if (document.head === null) {\n        throw new Error(\"No container provided and `document.head` was null\");\n      }\n\n      this.container = document.head;\n    }\n  }\n\n  var _proto = StyletronClient.prototype;\n\n  _proto.renderStyle = function renderStyle(style) {\n    return injectStylePrefixed(this.styleCache, style, \"\", \"\");\n  };\n\n  _proto.renderFontFace = function renderFontFace(fontFace) {\n    var key = declarationsToBlock(fontFace);\n    return this.fontFaceCache.addValue(key, fontFace);\n  };\n\n  _proto.renderKeyframes = function renderKeyframes(keyframes) {\n    var key = keyframesToBlock(keyframes);\n    return this.keyframesCache.addValue(key, keyframes);\n  };\n\n  return StyletronClient;\n}();\n\nfunction findSheetIndexWithMedia(children, media) {\n  var index = 0;\n\n  for (; index < children.length; index++) {\n    var child = children[index];\n\n    if (child.tagName === \"STYLE\" && child.media === media) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\nvar StyletronServer =\n/*#__PURE__*/\nfunction () {\n  function StyletronServer(opts) {\n    var _this = this;\n\n    if (opts === void 0) {\n      opts = {};\n    }\n\n    this.styleRules = {\n      \"\": \"\"\n    };\n    this.styleCache = new MultiCache(new SequentialIDGenerator(opts.prefix), function (media) {\n      _this.styleRules[media] = \"\";\n    }, function (cache, id, value) {\n      var pseudo = value.pseudo,\n          block = value.block;\n      _this.styleRules[cache.key] += styleBlockToRule(atomicSelector(id, pseudo), block);\n    });\n    this.fontFaceRules = \"\";\n    this.fontFaceCache = new Cache(new SequentialIDGenerator(opts.prefix), function (cache, id, value) {\n      _this.fontFaceRules += fontFaceBlockToRule(id, declarationsToBlock(value));\n    });\n    this.keyframesRules = \"\";\n    this.keyframesCache = new Cache(new SequentialIDGenerator(opts.prefix), function (cache, id, value) {\n      _this.keyframesRules += keyframesBlockToRule(id, keyframesToBlock(value));\n    });\n  }\n\n  var _proto = StyletronServer.prototype;\n\n  _proto.renderStyle = function renderStyle(style) {\n    return injectStylePrefixed(this.styleCache, style, \"\", \"\");\n  };\n\n  _proto.renderFontFace = function renderFontFace(fontFace) {\n    var key = JSON.stringify(fontFace);\n    return this.fontFaceCache.addValue(key, fontFace);\n  };\n\n  _proto.renderKeyframes = function renderKeyframes(keyframes) {\n    var key = JSON.stringify(keyframes);\n    return this.keyframesCache.addValue(key, keyframes);\n  };\n\n  _proto.getStylesheets = function getStylesheets() {\n    return [].concat(this.keyframesRules.length ? [{\n      css: this.keyframesRules,\n      attrs: {\n        \"data-hydrate\": \"keyframes\"\n      }\n    }] : [], this.fontFaceRules.length ? [{\n      css: this.fontFaceRules,\n      attrs: {\n        \"data-hydrate\": \"font-face\"\n      }\n    }] : [], sheetify(this.styleRules, this.styleCache.getSortedCacheKeys()));\n  };\n\n  _proto.getStylesheetsHtml = function getStylesheetsHtml(className) {\n    if (className === void 0) {\n      className = \"_styletron_hydrate_\";\n    }\n\n    return generateHtmlString(this.getStylesheets(), className);\n  };\n\n  _proto.getCss = function getCss() {\n    return this.keyframesRules + this.fontFaceRules + stringify(this.styleRules, this.styleCache.getSortedCacheKeys());\n  };\n\n  return StyletronServer;\n}();\n\nfunction generateHtmlString(sheets, className) {\n  var html = \"\";\n\n  for (var i = 0; i < sheets.length; i++) {\n    var sheet = sheets[i];\n\n    var _sheet$attrs = sheet.attrs,\n        originalClassName = _sheet$attrs.class,\n        rest = _objectWithoutProperties(_sheet$attrs, [\"class\"]);\n\n    var attrs = Object.assign({\n      class: originalClassName ? className + \" \" + originalClassName : className\n    }, rest);\n    html += \"<style\" + attrsToString(attrs) + \">\" + sheet.css + \"</style>\";\n  }\n\n  return html;\n}\n\nfunction attrsToString(attrs) {\n  var result = \"\";\n\n  for (var attr in attrs) {\n    var value = attrs[attr];\n\n    if (value === true) {\n      result += \" \" + attr;\n    } else if (value !== false) {\n      result += \" \" + attr + \"=\\\"\" + value + \"\\\"\";\n    }\n  }\n\n  return result;\n}\n\nfunction stringify(styleRules, sortedCacheKeys) {\n  var result = \"\";\n  sortedCacheKeys.forEach(function (cacheKey) {\n    var rules = styleRules[cacheKey];\n\n    if (cacheKey !== \"\") {\n      result += \"@media \" + cacheKey + \"{\" + rules + \"}\";\n    } else {\n      result += rules;\n    }\n  });\n  return result;\n}\n\nfunction sheetify(styleRules, sortedCacheKeys) {\n  if (sortedCacheKeys.length === 0) {\n    return [{\n      css: \"\",\n      attrs: {}\n    }];\n  }\n\n  var sheets = [];\n  sortedCacheKeys.forEach(function (cacheKey) {\n    // omit media (cacheKey) attribute if empty\n    var attrs = cacheKey === \"\" ? {} : {\n      media: cacheKey\n    };\n    sheets.push({\n      css: styleRules[cacheKey],\n      attrs: attrs\n    });\n  });\n  return sheets;\n}\n\nexport { StyletronClient as Client, StyletronServer as Server };\n//# sourceMappingURL=browser.es5.es.js.map\n","import type { DispatchProp } from 'react-redux';\nimport type { ReduxState } from '@/models/types';\nimport React, { useEffect } from 'react';\nimport { connect } from 'umi';\nimport AddIntegration from '@/pages/Integrations/AddIntegration';\nimport Settings from '@/pages/Settings';\nimport { styled } from '@/theme';\n\nconst OverlayContainer = styled('div', ({ $isOpen }: { $isOpen: boolean }) => ({\n  visibility: $isOpen ? 'visible' : 'hidden',\n  position: 'fixed',\n  width: '100vw',\n  height: '100vh',\n  transform: $isOpen ? 'translateY(0%)' : 'translateY(30%)',\n  opacity: $isOpen ? 1 : 0,\n  transition: 'all 0.2s ease-in',\n  backgroundColor: '#FFF',\n  // overflowY: 'scroll',\n  zIndex: 1033,\n}));\n\nconst Overlay = ({ overlay, dispatch }: StateProps & DispatchProp) => {\n  const { isMarketPlaceUiOpen, isSettingsOpen } = overlay;\n  const isOpen = isMarketPlaceUiOpen || isSettingsOpen;\n\n  useEffect(() => {\n    const onKeyDown = (e: globalThis.KeyboardEvent) => {\n      if (e.key === 'Escape' && !e.repeat) {\n        e.preventDefault();\n        Object.keys(overlay).forEach((overlayType) =>\n          dispatch({ type: 'overlay/update', payload: { overlayType, status: false } }),\n        );\n      }\n    };\n\n    window.addEventListener('keydown', onKeyDown);\n\n    return () => window.removeEventListener('keydown', onKeyDown);\n  }, []);\n\n  return (\n    <>\n      <OverlayContainer $isOpen={isOpen}>\n        {isMarketPlaceUiOpen && <AddIntegration />}\n        {isSettingsOpen && <Settings />}\n      </OverlayContainer>\n    </>\n  );\n};\n\nconst mapStateToProps = (state: ReduxState) => ({\n  overlay: state.overlay,\n});\n\ntype StateProps = ReturnType<typeof mapStateToProps>;\n\nexport default connect<StateProps, unknown, unknown, ReduxState>(mapStateToProps)(Overlay);\n","import React from 'react';\nimport * as Sentry from '@sentry/react';\nimport { Provider as StyletronProvider, DebugEngine } from 'styletron-react';\nimport { Client as Styletron } from 'styletron-engine-atomic';\nimport { FlagsProvider } from 'react-unleash-flags';\nimport { ThemeProvider } from '../theme';\nimport Overlay from './Overlay';\n\nif (process.env.NODE_ENV === 'production') {\n  Sentry.init({\n    dsn: 'https://17b895f0b4834673a5b919c290758a30@o54051.ingest.sentry.io/5352598',\n    release: `beem@${AWS_COMMIT_ID}`,\n    environment: USER_BRANCH,\n  });\n}\n\nconst debug = process.env.NODE_ENV === 'production' ? undefined : new DebugEngine();\n\nconst flagConfig = {\n  appName: process.env.NODE_ENV,\n  url: 'https://gitlab.com/api/v4/feature_flags/unleash/16490234',\n  instanceId: 'osLpc7P9QmB4mC3CAsf8',\n};\n\nconst engine = new Styletron();\n\nexport default (props) => (\n  <Sentry.ErrorBoundary fallback=\"An error has occurred\">\n    <FlagsProvider config={flagConfig}>\n      <StyletronProvider value={engine} debug={debug} debugAfterHydration>\n        <Overlay />\n        <>\n          <ThemeProvider>{props.children}</ThemeProvider>\n        </>\n      </StyletronProvider>\n    </FlagsProvider>\n  </Sentry.ErrorBoundary>\n);\n","/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nfunction _optionalChain(ops) {\n  let lastAccessLHS = undefined;\n  let value = ops[0];\n  let i = 1;\n  while (i < ops.length) {\n    var op = ops[i] ;\n    var fn = ops[i + 1] ;\n    i += 2;\n    // by checking for loose equality to `null`, we catch both `null` and `undefined`\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn((...args) => (value ).call(lastAccessLHS, ...args));\n      lastAccessLHS = undefined;\n    }\n  }\n  return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     var op = ops[i];\n//     var fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n\nexport { _optionalChain };\n//# sourceMappingURL=_optionalChain.js.map\n","import { _optionalChain } from './buildPolyfills';\n\nvar STACKTRACE_LIMIT = 50;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n  var sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack, skipFirst = 0) => {\n    var frames = [];\n\n    for (var line of stack.split('\\n').slice(skipFirst)) {\n      for (var parser of sortedParsers) {\n        var frame = parser(line);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  var firstFrameFunction = localStack[0].function || '';\n  var lastFrameFunction = localStack[localStack.length - 1].function || '';\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\n}\n\nvar defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\nfunction node(getModule) {\n  var FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  var FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+?):(\\d+)(?::(\\d+))?|([^)]+))\\)?/;\n\n    return (line) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    var lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object;\n    let method;\n    let functionName;\n    let typeName;\n    let methodName;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n                methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.substr(0, methodStart);\n        method = functionName.substr(methodStart + 1);\n        var objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    var filename = _optionalChain([lineMatch, 'access', _ => _[2], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3('file://')]) ? lineMatch[2].substr(7) : lineMatch[2];\n    var isNative = lineMatch[5] === 'native';\n    var isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    var in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: _optionalChain([getModule, 'optionalCall', _4 => _4(filename)]),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\n  };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = isPrefixedValue;\nvar regex = /-webkit-|-moz-|-ms-/;\n\nfunction isPrefixedValue(value) {\n  return typeof value === 'string' && regex.test(value);\n}\nmodule.exports = exports['default'];","/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  var hasWeakSet = typeof WeakSet === 'function';\n  var inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n        for (let i = 0; i < inner.length; i++) {\n      var value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n"],"sourceRoot":""}