{"version":3,"sources":["webpack:///static-appopensalud/js/45.65d5988866b3909a4295.js","webpack:///./src/components/public/HubspotChat.vue","webpack:///./src/components/video-launcher/Error.vue","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/types/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/helpers.js","webpack:///src/components/public/HubspotChat.vue","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/node.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/stacktrace.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/tracekit.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/base.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/index.js","webpack:///./src/components/public/HubspotChat.vue?7dd3","webpack:///./src/components/public/HubspotChat.vue?1e1b","webpack:///./src/components/public/HubspotChat.vue?f9ec","webpack:///src/components/video-launcher/Error.vue","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/scope.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/browser.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/session.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/transports/noop.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/parsers.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/version.js","webpack:///./src/components/video-launcher/Error.vue?ec84","webpack:///./src/components/video-launcher/Error.vue?41fe","webpack:///./node_modules/@sentry/vue/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/exports.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/types/esm/loglevel.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/types/esm/session.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/types/esm/status.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/types/esm/transaction.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/polyfill.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/path.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/time.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/basebackend.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/request.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integrations/index.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/backend.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/useragent.js","webpack:///./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/sdk.js","webpack:///./node_modules/@sentry/vue/esm/sdk.js","webpack:///./node_modules/@sentry/vue/esm/eventprocessor.js","webpack:///./node_modules/@sentry/vue/esm/vuerouter.js","webpack:///./src/components/video-launcher/Error.vue?dfd2"],"names":["webpackJsonp","1258","module","__webpack_exports__","__webpack_require__","injectStyle","ssrContext","disposed","normalizeComponent","__vue_styles__","Component","options","__file","2351","2440","2450","2493","2524","isError","wat","Object","prototype","toString","call","isInstanceOf","Error","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","then","isSyntheticEvent","base","_e","2539","2549","getGlobalObject","global","window","self","fallbackGlobalObject","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","length","replace","c","r","Math","random","parseUrl","url","match","query","fragment","host","path","protocol","relative","getEventDescription","event","message","exception","values","type","value","event_id","consoleSandbox","callback","levels","originalConsole","console","wrappedLevels","forEach","level","__sentry_original__","result","keys","addExceptionTypeValue","addExceptionMechanism","mechanism","key","_oO","getLocationHref","document","location","href","oO","parseRetryAfterHeader","now","header","defaultRetryAfter","headerDelay","parseInt","isNaN","headerDate","Date","parse","2550","shouldIgnoreOnError","ignoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","__sentry__","__sentry_wrapped__","e","sentryWrapped","args","Array","slice","arguments","apply","this","wrappedArguments","map","arg","handleEvent","ex","scope","addEventProcessor","processedEvent","undefined","extra","property","hasOwnProperty","defineProperty","enumerable","defineProperties","getOwnPropertyDescriptor","configurable","get","name","injectReportDialog","eventId","error","dsn","script","createElement","async","src","getReportDialogEndpoint","onLoad","onload","head","body","appendChild","2577","__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_promise__","__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_promise___default","n","__WEBPACK_IMPORTED_MODULE_1__constants_vendorKeys__","methods","loadScriptAsync","getElementById","id","resolve","tag","text","setAttribute","mounted","documentElement","style","setProperty","chatBtn","click","created","2578","windowIntegrations","_window","Sentry","Integrations","2601","SentryError","_super","_newTarget","constructor","_this","2602","PREFIX","Logger","_enabled","disable","enable","log","_i","join","warn","__SENTRY__","logger","2603","isNodeEnv","process","dynamicRequire","mod","request","require","2604","fill","source","replacementFactory","original","wrapped","_Oo","urlEncode","object","encodeURIComponent","getWalkSource","err","stack","i","event_1","target","currentTarget","CustomEvent","detail","utf8Length","encodeURI","split","jsonSize","JSON","stringify","normalizeToSize","depth","maxSize","serialized","normalize","serializeValue","normalized","normalizeValue","_events","String","walk","memo","Infinity","toJSON","acc","isArray","memoize","innerKey","unmemoize","input","extractExceptionKeysForMessage","maxLength","sort","includedKeys","dropUndefinedKeys","val","e_1","_a","obj","rv","_b","_c","next","done","e_1_1","return","2605","getFunctionName","defaultFunctionName","2606","truncate","str","max","substr","snipLine","line","colno","newLine","ll","start","end","min","safeJoin","delimiter","output","push","isMatchingPattern","pattern","test","indexOf","2607","eventFromException","hint","syntheticException","eventFromUnknownInput","attachStacktrace","handled","eventFromMessage","Info","eventFromString","domException","name_1","tags","code","objectException","rejection","synthetic","stacktrace","frames_1","frames","2608","computeStackTrace","popSize","framesToPop","reactMinifiedRegexp","computeStackTraceFromStacktraceProp","popFrames","computeStackTraceFromStackProp","extractMessage","failed","isEval","submatch","parts","element","lines","chrome","exec","isNative","chromeEval","func","UNKNOWN_FUNCTION","column","winjs","gecko","geckoEval","columnNumber","opera10Regex","opera11Regex","2609","BaseTransport","_buffer","_rateLimits","_api","getStoreEndpointWithUrlEncodedAuth","sendEvent","_","close","timeout","drain","_handleResponse","requestType","response","headers","reject","status","fromHttpCode","_handleRateLimit","_disabledUntil","Success","category","all","_isRateLimited","e_2","rlHeader","raHeader","trim","_d","limit","parameters","delay","_f","e_2_1","2610","2653","exports","content","locals","2654","2655","render","_vm","_h","$createElement","_self","attrs","staticRenderFns","_withStripped","esExports","2658","__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__","__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default","__WEBPACK_IMPORTED_MODULE_1_bootstrap_vue__","__WEBPACK_IMPORTED_MODULE_2__components_public_HubspotChat__","__WEBPACK_IMPORTED_MODULE_3__plugins_filters__","__WEBPACK_IMPORTED_MODULE_4__sentry_vue__","__WEBPACK_IMPORTED_MODULE_5_vuex__","components","BIcon","BIconArrowCounterclockwise","BModal","BButton","props","customError","required","data","modalShow","smallToken","showDetailedError","supportChatVisible","opentok","title","logErrorMsg","$store","state","video","commit","$route","error_title","msg","error_msg","$root","$emit","token","pageReload","history","back","toggleShowDetailedError","doCustomErrorAction","$helpers","goToPatientWebApp","computed","getErrorTitle","$te","i18nMsgKey","$t","getErrorMsg","appointment","date","appointmentDate","getErrorImg","img","getCustomErrorBtnMsg","getErrorColorVariant","2659","getGlobalEventProcessors","globalEventProcessors","addGlobalEventProcessor","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","clone","newScope","_level","_span","_session","_transactionName","_fingerprint","addScopeListener","setUser","user","update","_notifyScopeListeners","getUser","setTags","setTag","setExtras","extras","setExtra","setFingerprint","fingerprint","setLevel","setTransactionName","setTransaction","setContext","context","setSpan","span","getSpan","getTransaction","transaction","spanRecorder","spans","setSession","session","getSession","captureContext","updatedScope","contexts","clear","addBreadcrumb","breadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","clearBreadcrumbs","applyToEvent","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","_notifyEventProcessors","processors","index","processor","final","concat","2660","htmlTreeAsString","elem","currentElem","out","height","len","sepLength","nextStr","_htmlElementAsString","parentNode","reverse","el","className","classes","attr","tagName","toLowerCase","allowedAttrs","getAttribute","2661","Memo","_hasWeakSet","WeakSet","_inner","has","add","delete","splice","2662","supportsFetch","Headers","Request","Response","isNativeFetch","supportsNativeFetch","fetch","doc","sandbox","hidden","contentWindow","removeChild","supportsReferrerPolicy","referrerPolicy","supportsHistory","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","2663","States","SyncPromise","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","reason","REJECTED","_value","_executeHandlers","_attachHandler","handler","cachedHandlers","onfulfilled","onrejected","collection","TypeError","counter","resolvedCollection","item","catch","finally","onfinally","isRejected","2664","Session","errors","sid","started","duration","Ok","ip_address","ipAddress","did","email","username","release","environment","userAgent","Exited","init","toISOString","user_agent","2665","NoopTransport","Skipped","2666","BrowserClient","showReportDialog","_isEnabled","getDsn","_prepareEvent","platform","sdk","packages","version","_sendEvent","integration","getIntegration","addSentryBreadcrumb","2667","exceptionFromStacktrace","prepareFramesForEvent","eventFromPlainObject","__serialized__","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","STACKTRACE_LIMIT","frame","filename","function","in_app","lineno","2668","2669","SDK_NAME","SDK_VERSION","2732","2733","2734","2735","2736","LogLevel","2737","SessionStatus","2738","Severity","fromString","Debug","Warning","Fatal","Critical","Log","2739","Status","RateLimit","Invalid","Failed","Unknown","2740","TransactionSamplingMethod","2741","callOnHub","method","hub","captureException","originalException","captureMessage","withScope","2742","2743","DSN_REGEX","Dsn","from","_fromString","_fromComponents","_validate","withPassword","pass","port","projectId","lastPath","pop","projectMatch","component","ERROR_MESSAGE","2744","setProtoOf","proto","__proto__","mixinProperties","prop","setPrototypeOf","2745","instrument","instrumented","instrumentConsole","instrumentDOM","instrumentXHR","instrumentFetch","instrumentHistory","instrumentError","instrumentUnhandledRejection","addInstrumentationHandler","handlers","triggerHandlers","originalConsoleLevel","Function","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","startTimestamp","endTimestamp","fetchArgs","toUpperCase","requestKeys","requestValues","xhrproto","XMLHttpRequest","originalOpen","xhr","__sentry_xhr__","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","requestPos","args_1","onreadystatechange","readyStateArgs","addEventListener","originalSend","historyReplacementFunction","originalHistoryFunction","lastHref","to","oldOnPopState","onpopstate","domEventHandler","bind","keypressEventHandler","eventName","innerOriginal","debounce","keypressTimeout","lastCapturedEvent","debounceTimer","clearTimeout","isContentEditable","debounceDuration","_oldOnErrorHandler","onerror","_oldOnUnhandledRejectionHandler","onunhandledrejection","2746","splitPath","splitPathRe","basename","ext","f","2747","PromiseBuffer","_limit","isReady","task","remove","capturedSetTimeout","2748","dateTimestampSource","nowSeconds","platformPerformance","performance","timeOrigin","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","timing","navigationStart","2749","getMainCarrier","carrier","extensions","makeMain","registry","oldHub","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","isOlderThan","API_VERSION","Hub","getHubFromActiveDomain","getActiveDomain","sentry","domain","active","activeDomain","registryHubTopStack","getStackTop","client","_version","_stack","bindClient","setupIntegrations","pushScope","getScope","getStack","getClient","popScope","_lastEventId","finalHint","_invokeClient","captureEvent","lastEventId","getOptions","beforeBreadcrumb","finalBreadcrumb","configureScope","run","startSpan","_callExtensionMethod","startTransaction","customSamplingContext","traceHeaders","startSession","endSession","captureSession","2750","API","_dsnObject","getBaseApiEndpoint","getStoreEndpoint","_getIngestEndpoint","_encodedAuth","getEnvelopeEndpointWithUrlEncodedAuth","_getEnvelopeEndpoint","getStoreEndpointPath","getRequestHeaders","clientName","clientVersion","dialogOptions","endpoint","encodedOptions","auth","sentry_key","sentry_version","2751","BaseClient","backendClass","_integrations","_processing","_backend","_options","_dsn","_process","_getBackend","_captureEvent","promisedEvent","_sendSession","flush","_isClientProcessing","ready","getTransport","transportFlushed","enabled","_updateSessionFromEvent","crashed","errored","exceptions","exceptions_1","exceptions_1_1","Crashed","Number","sendSession","ticked","interval","setInterval","clearInterval","normalizeDepth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","evt","_normalizeEvent","b","dist","maxValueLength","sdkInfo","integrationsArray","integrations","_processEvent","finalEvent","beforeSend","sampleRate","isTransaction","beforeSendResult","promise","2752","getIntegrationsToSetup","defaultIntegrations","userIntegrations","userIntegrationsNames_1","pickedIntegrationsNames_1","defaultIntegration","userIntegration","integrationsNames","setupIntegration","installedIntegrations","setupOnce","2753","BaseBackend","_transport","_setupTransport","_exception","_hint","_message","2754","sessionToSentryRequest","api","sent_at","eventToSentryRequest","samplingMethod","__sentry_samplingMethod","__sentry_sampleRate","otherTags","useEnvelope","req","envelopeHeaders","itemHeaders","sample_rates","rate","envelope","2755","initAndBind","clientClass","debug","2756","2757","originalFunctionToString","FunctionToString","2758","DEFAULT_IGNORE_ERRORS","InboundFilters","clientOptions","_mergeOptions","_shouldDropEvent","_isSentryError","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","ignoreInternal","ignoreErrors","_getPossibleEventMessages","some","denyUrls","allowUrls","whitelistUrls","blacklistUrls","frames_2","2759","BrowserBackend","transportOptions","transport","2760","FetchTransport","_sendRequest","sentryRequest","originalPayload","Promise","fetchParameters","assign","2761","XHRTransport","getResponseHeader","open","setRequestHeader","send","2762","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","_eventFromRejectionWithPrimitive","ERROR_TYPES_RE","groups","2763","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","_wrapEventTarget","originalCallback","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","wrapOptions","2764","Breadcrumbs","dom","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","parsedLoc","parsedFrom","parsedTo","2765","DEFAULT_KEY","DEFAULT_LIMIT","LinkedErrors","_key","_handler","linkedErrors","_walkErrorTree","2766","UserAgent","navigator","referrer","Referer","2767","2768","getActiveTransaction","HOOKS","activate","create","destroy","mount","COMPONENT_NAME_REGEXP","ROOT_COMPONENT_NAME","VueHelper","_componentsCache","_applyTracingHooks","vm","$options","$_sentryPerfHook","_getComponentName","rootMount","rootHandler","hook","_rootSpan","_finishRootSpan","$once","activeTransaction","startChild","description","op","childHandler","operation","shouldTrack","tracingOptions","trackComponents","childOf","finish","hooks","internalHooks","internalHook","currentValue","setup","_attachErrorHandler","_startTracing","_componentTag","unifiedFile","_rootSpanTimer","applyTracingHooks","appliedTracingHooks","Vue","mixin","beforeCreate","currentErrorHandler","config","errorHandler","info","metadata","componentName","attachProps","propsData","lifecycleHook","logErrors","util","2769","createVueEventProcessor","2770","2771","centered","model","$$v","expression","staticClass","width","_v","class","domProps","innerHTML","_s","on","center","variant","icon","size","$event","openSupportChat"],"mappings":"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","file":"static-appopensalud/js/45.65d5988866b3909a4295.js","sourcesContent":["webpackJsonp([45,27],{\n\n/***/ 1258:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_HubspotChat_vue__ = __webpack_require__(2577);\n/* empty harmony namespace reexport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_3e33ba39_hasScoped_false_transformToRequire_video_src_poster_source_src_img_src_image_xlink_href_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_HubspotChat_vue__ = __webpack_require__(2655);\nvar disposed = false\nfunction injectStyle (ssrContext) {\n  if (disposed) return\n  __webpack_require__(2653)\n}\nvar normalizeComponent = __webpack_require__(6)\n/* script */\n\n\n/* template */\n\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_HubspotChat_vue__[\"a\" /* default */],\n  __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_3e33ba39_hasScoped_false_transformToRequire_video_src_poster_source_src_img_src_image_xlink_href_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_HubspotChat_vue__[\"a\" /* default */],\n  __vue_template_functional__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\nComponent.options.__file = \"src/components/public/HubspotChat.vue\"\n\n/* hot reload */\nif (false) {(function () {\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), false)\n  if (!hotAPI.compatible) return\n  module.hot.accept()\n  if (!module.hot.data) {\n    hotAPI.createRecord(\"data-v-3e33ba39\", Component.options)\n  } else {\n    hotAPI.reload(\"data-v-3e33ba39\", Component.options)\n  }\n  module.hot.dispose(function (data) {\n    disposed = true\n  })\n})()}\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (Component.exports);\n\n\n/***/ }),\n\n/***/ 2351:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_Error_vue__ = __webpack_require__(2658);\n/* empty harmony namespace reexport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_23316cdb_hasScoped_false_transformToRequire_video_src_poster_source_src_img_src_image_xlink_href_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_Error_vue__ = __webpack_require__(2771);\nvar disposed = false\nfunction injectStyle (ssrContext) {\n  if (disposed) return\n  __webpack_require__(2732)\n}\nvar normalizeComponent = __webpack_require__(6)\n/* script */\n\n\n/* template */\n\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_Error_vue__[\"a\" /* default */],\n  __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_23316cdb_hasScoped_false_transformToRequire_video_src_poster_source_src_img_src_image_xlink_href_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_Error_vue__[\"a\" /* default */],\n  __vue_template_functional__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\nComponent.options.__file = \"src/components/video-launcher/Error.vue\"\n\n/* hot reload */\nif (false) {(function () {\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), false)\n  if (!hotAPI.compatible) return\n  module.hot.accept()\n  if (!module.hot.data) {\n    hotAPI.createRecord(\"data-v-23316cdb\", Component.options)\n  } else {\n    hotAPI.reload(\"data-v-23316cdb\", Component.options)\n  }\n  module.hot.dispose(function (data) {\n    disposed = true\n  })\n})()}\n\n/* harmony default export */ __webpack_exports__[\"default\"] = (Component.exports);\n\n\n/***/ }),\n\n/***/ 2440:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__async__ = __webpack_require__(2742);\n/* unused harmony namespace reexport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__browser__ = __webpack_require__(2660);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"r\", function() { return __WEBPACK_IMPORTED_MODULE_1__browser__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__dsn__ = __webpack_require__(2743);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_2__dsn__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__error__ = __webpack_require__(2601);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return __WEBPACK_IMPORTED_MODULE_3__error__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__instrument__ = __webpack_require__(2745);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"g\", function() { return __WEBPACK_IMPORTED_MODULE_4__instrument__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__is__ = __webpack_require__(2524);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"s\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"t\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"b\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"u\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"d\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"v\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"e\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"w\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"f\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"x\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"g\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"A\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"h\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"B\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"i\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"C\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"k\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"D\", function() { return __WEBPACK_IMPORTED_MODULE_5__is__[\"m\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__logger__ = __webpack_require__(2602);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"E\", function() { return __WEBPACK_IMPORTED_MODULE_6__logger__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__memo__ = __webpack_require__(2661);\n/* unused harmony namespace reexport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__misc__ = __webpack_require__(2549);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"e\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"f\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"b\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"i\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"c\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"n\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"d\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"p\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"e\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"q\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"f\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"H\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"g\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"I\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"h\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"P\", function() { return __WEBPACK_IMPORTED_MODULE_8__misc__[\"i\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__node__ = __webpack_require__(2603);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"z\", function() { return __WEBPACK_IMPORTED_MODULE_9__node__[\"b\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__object__ = __webpack_require__(2604);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"k\", function() { return __WEBPACK_IMPORTED_MODULE_10__object__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"l\", function() { return __WEBPACK_IMPORTED_MODULE_10__object__[\"b\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"m\", function() { return __WEBPACK_IMPORTED_MODULE_10__object__[\"c\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"F\", function() { return __WEBPACK_IMPORTED_MODULE_10__object__[\"d\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"G\", function() { return __WEBPACK_IMPORTED_MODULE_10__object__[\"e\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"O\", function() { return __WEBPACK_IMPORTED_MODULE_10__object__[\"f\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__path__ = __webpack_require__(2746);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"h\", function() { return __WEBPACK_IMPORTED_MODULE_11__path__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__promisebuffer__ = __webpack_require__(2747);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_12__promisebuffer__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__stacktrace__ = __webpack_require__(2605);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"o\", function() { return __WEBPACK_IMPORTED_MODULE_13__stacktrace__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__string__ = __webpack_require__(2606);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"y\", function() { return __WEBPACK_IMPORTED_MODULE_14__string__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"J\", function() { return __WEBPACK_IMPORTED_MODULE_14__string__[\"b\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"N\", function() { return __WEBPACK_IMPORTED_MODULE_14__string__[\"d\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__supports__ = __webpack_require__(2662);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"K\", function() { return __WEBPACK_IMPORTED_MODULE_15__supports__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"L\", function() { return __WEBPACK_IMPORTED_MODULE_15__supports__[\"d\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_16__syncpromise__ = __webpack_require__(2663);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"d\", function() { return __WEBPACK_IMPORTED_MODULE_16__syncpromise__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_17__time__ = __webpack_require__(2748);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"j\", function() { return __WEBPACK_IMPORTED_MODULE_17__time__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"M\", function() { return __WEBPACK_IMPORTED_MODULE_17__time__[\"b\"]; });\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2450:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_minimal__ = __webpack_require__(2741);\n/* unused harmony reexport addBreadcrumb */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"f\", function() { return __WEBPACK_IMPORTED_MODULE_0__sentry_minimal__[\"a\"]; });\n/* unused harmony reexport captureEvent */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"g\", function() { return __WEBPACK_IMPORTED_MODULE_0__sentry_minimal__[\"b\"]; });\n/* unused harmony reexport configureScope */\n/* unused harmony reexport startTransaction */\n/* unused harmony reexport setContext */\n/* unused harmony reexport setExtra */\n/* unused harmony reexport setExtras */\n/* unused harmony reexport setTag */\n/* unused harmony reexport setTags */\n/* unused harmony reexport setUser */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"l\", function() { return __WEBPACK_IMPORTED_MODULE_0__sentry_minimal__[\"c\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_hub__ = __webpack_require__(2539);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"e\", function() { return __WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"b\"]; });\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"i\", function() { return __WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"c\"]; });\n/* unused harmony reexport getHubFromCarrier */\n/* unused harmony reexport Hub */\n/* unused harmony reexport makeMain */\n/* unused harmony reexport Scope */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__api__ = __webpack_require__(2750);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_2__api__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__baseclient__ = __webpack_require__(2751);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return __WEBPACK_IMPORTED_MODULE_3__baseclient__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__basebackend__ = __webpack_require__(2753);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_4__basebackend__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__request__ = __webpack_require__(2754);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"h\", function() { return __WEBPACK_IMPORTED_MODULE_5__request__[\"a\"]; });\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"k\", function() { return __WEBPACK_IMPORTED_MODULE_5__request__[\"b\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__sdk__ = __webpack_require__(2755);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"j\", function() { return __WEBPACK_IMPORTED_MODULE_6__sdk__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__transports_noop__ = __webpack_require__(2665);\n/* unused harmony reexport NoopTransport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__integrations__ = __webpack_require__(2756);\n/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, \"d\", function() { return __WEBPACK_IMPORTED_MODULE_8__integrations__; });\n\n\n\n\n\n\n\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2493:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__loglevel__ = __webpack_require__(2736);\n/* unused harmony reexport LogLevel */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__session__ = __webpack_require__(2737);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_1__session__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__severity__ = __webpack_require__(2738);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_2__severity__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__status__ = __webpack_require__(2739);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return __WEBPACK_IMPORTED_MODULE_3__status__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__transaction__ = __webpack_require__(2740);\n/* unused harmony reexport TransactionSamplingMethod */\n\n\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2524:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = isError;\n/* harmony export (immutable) */ __webpack_exports__[\"e\"] = isErrorEvent;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = isDOMError;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = isDOMException;\n/* harmony export (immutable) */ __webpack_exports__[\"k\"] = isString;\n/* harmony export (immutable) */ __webpack_exports__[\"i\"] = isPrimitive;\n/* harmony export (immutable) */ __webpack_exports__[\"h\"] = isPlainObject;\n/* harmony export (immutable) */ __webpack_exports__[\"f\"] = isEvent;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = isElement;\n/* harmony export (immutable) */ __webpack_exports__[\"j\"] = isRegExp;\n/* harmony export (immutable) */ __webpack_exports__[\"m\"] = isThenable;\n/* harmony export (immutable) */ __webpack_exports__[\"l\"] = isSyntheticEvent;\n/* harmony export (immutable) */ __webpack_exports__[\"g\"] = isInstanceOf;\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n    try {\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map\n\n/***/ }),\n\n/***/ 2539:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__scope__ = __webpack_require__(2659);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_0__scope__[\"b\"]; });\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_0__scope__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__session__ = __webpack_require__(2664);\n/* unused harmony reexport Session */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__hub__ = __webpack_require__(2749);\n/* unused harmony reexport getActiveDomain */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return __WEBPACK_IMPORTED_MODULE_2__hub__[\"a\"]; });\n/* unused harmony reexport getHubFromCarrier */\n/* unused harmony reexport getMainCarrier */\n/* unused harmony reexport Hub */\n/* unused harmony reexport makeMain */\n/* unused harmony reexport setHubOnCarrier */\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2549:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (immutable) */ __webpack_exports__[\"e\"] = getGlobalObject;\n/* harmony export (immutable) */ __webpack_exports__[\"i\"] = uuid4;\n/* harmony export (immutable) */ __webpack_exports__[\"h\"] = parseUrl;\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = getEventDescription;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = consoleSandbox;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = addExceptionTypeValue;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = addExceptionMechanism;\n/* harmony export (immutable) */ __webpack_exports__[\"f\"] = getLocationHref;\n/* unused harmony export parseSemver */\n/* harmony export (immutable) */ __webpack_exports__[\"g\"] = parseRetryAfterHeader;\n/* unused harmony export addContextToFrame */\n/* unused harmony export stripUrlQueryAndFragment */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__node__ = __webpack_require__(2603);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__string__ = __webpack_require__(2606);\n\n\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nfunction getGlobalObject() {\n    return (Object(__WEBPACK_IMPORTED_MODULE_0__node__[\"b\" /* isNodeEnv */])()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // eslint-disable-next-line no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // eslint-disable-next-line no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // eslint-disable-next-line no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // eslint-disable-next-line no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nfunction consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nfunction addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore Mechanism has no index signature\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nfunction getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nfunction parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\n}\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { linesOfContext = 5; }\n    var lineno = frame.lineno || 0;\n    var maxLines = lines.length;\n    var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return Object(__WEBPACK_IMPORTED_MODULE_1__string__[\"c\" /* snipLine */])(line, 0); });\n    frame.context_line = Object(__WEBPACK_IMPORTED_MODULE_1__string__[\"c\" /* snipLine */])(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return Object(__WEBPACK_IMPORTED_MODULE_1__string__[\"c\" /* snipLine */])(line, 0); });\n}\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n    // eslint-disable-next-line no-useless-escape\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n//# sourceMappingURL=misc.js.map\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(35)))\n\n/***/ }),\n\n/***/ 2550:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = shouldIgnoreOnError;\n/* unused harmony export ignoreNextOnError */\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = wrap;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = injectReportDialog;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n\n\n\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\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.\n * @returns The wrapped function.\n * @hidden\n */\nfunction wrap(fn, options, before) {\n    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\n        }\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    /* eslint-disable prefer-rest-params */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        try {\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            if (fn.handleEvent) {\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                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                return fn.handleEvent.apply(this, wrappedArguments);\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        }\n        catch (ex) {\n            ignoreNextOnError();\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"l\" /* withScope */])(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event);\n                    if (options.mechanism) {\n                        Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"f\" /* addExceptionTypeValue */])(processedEvent, undefined, undefined);\n                        Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"e\" /* addExceptionMechanism */])(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, processedEvent.extra), { arguments: args });\n                    return processedEvent;\n                });\n                Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"f\" /* captureException */])(ex);\n            });\n            throw ex;\n        }\n    };\n    /* eslint-enable prefer-rest-params */\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    }\n    catch (_oO) { } // eslint-disable-line no-empty\n    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\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: function () {\n                    return fn.name;\n                },\n            });\n        }\n        // eslint-disable-next-line no-empty\n    }\n    catch (_oO) { }\n    return sentryWrapped;\n}\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nfunction injectReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].error(\"Missing eventId option in showReportDialog call\");\n        return;\n    }\n    if (!options.dsn) {\n        __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].error(\"Missing dsn option in showReportDialog call\");\n        return;\n    }\n    var script = document.createElement('script');\n    script.async = true;\n    script.src = new __WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"a\" /* API */](options.dsn).getReportDialogEndpoint(options);\n    if (options.onLoad) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        script.onload = options.onLoad;\n    }\n    (document.head || document.body).appendChild(script);\n}\n//# sourceMappingURL=helpers.js.map\n\n/***/ }),\n\n/***/ 2577:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_promise__ = __webpack_require__(158);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_promise___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_promise__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__constants_vendorKeys__ = __webpack_require__(1260);\n\n//\n//\n//\n//\n\n\n\n/* harmony default export */ __webpack_exports__[\"a\"] = ({\n  methods: {\n    loadScriptAsync: function loadScriptAsync(id) {\n      return new __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_promise___default.a(function (resolve, reject) {\n        if (!document.getElementById(id)) {\n          var tag = document.createElement('script');\n          tag.text = 'var _smartsupp = _smartsupp || {}; _smartsupp.key = \\'' + __WEBPACK_IMPORTED_MODULE_1__constants_vendorKeys__[\"c\" /* getSmartsuppKey */] + '\\';          window.smartsupp||(function(d) {            var s,c,o=smartsupp=function(){ o._.push(arguments)};o._=[];            s=d.getElementsByTagName(\\'script\\')[0];c=d.createElement(\\'script\\');            c.type=\\'text/javascript\\';c.charset=\\'utf-8\\';c.async=true;            c.src=\\'https://www.smartsuppchat.com/loader.js?\\';s.parentNode.insertBefore(c,s);          })(document);';\n          /* tag.src = uri */\n          tag.type = 'text/javascript';\n          /* tag.async = true\r\n          tag.defer = true */\n          tag.setAttribute('id', id);\n          tag.onload = function () {\n            resolve();\n          };\n          document.head.appendChild(tag);\n        } else {\n          resolve();\n        }\n      });\n    }\n  },\n  mounted: function mounted() {\n    var _this = this;\n\n    // const _this = this\n    var vh = window.innerHeight * 0.01;\n    document.documentElement.style.setProperty('--vh', vh + 'px');\n    this.loadScriptAsync('smartsupp-script-loader').then(function () {\n      _this.loading = false;\n      var chatBtn = null;\n      setTimeout(function () {\n        chatBtn = document.getElementById('chat-application');\n        if (chatBtn) {\n          chatBtn.click();\n        }\n      }, 2000);\n    });\n  },\n  created: function created() {\n    /* window.hsConversationsSettings = {\r\n      loadImmediately: true,\r\n      inlineEmbedSelector: '#support-chat-container',\r\n      enableWidgetCookieBanner: false,\r\n      disableAttachment: false\r\n    } */\n  }\n});\n\n/***/ }),\n\n/***/ 2578:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export Integrations */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__exports__ = __webpack_require__(2735);\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"a\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"b\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"c\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"d\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"d\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"e\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"e\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"f\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"f\"]; });\n/* harmony namespace reexport (by used) */ __webpack_require__.d(__webpack_exports__, \"g\", function() { return __WEBPACK_IMPORTED_MODULE_1__exports__[\"g\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__integrations__ = __webpack_require__(2610);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__transports__ = __webpack_require__(2668);\n/* unused harmony reexport Transports */\n\n\n\n\n\n\nvar windowIntegrations = {};\n// This block is needed to add compatibility with the integrations packages when used with a CDN\nvar _window = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"p\" /* getGlobalObject */])();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\nvar INTEGRATIONS = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, windowIntegrations), __WEBPACK_IMPORTED_MODULE_2__sentry_core__[\"d\" /* Integrations */]), __WEBPACK_IMPORTED_MODULE_4__integrations__);\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2601:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return SentryError; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__polyfill__ = __webpack_require__(2744);\n\n\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"c\" /* __extends */])(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.name = _newTarget.prototype.constructor.name;\n        Object(__WEBPACK_IMPORTED_MODULE_1__polyfill__[\"a\" /* setPrototypeOf */])(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\n\n//# sourceMappingURL=error.js.map\n\n/***/ }),\n\n/***/ 2602:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return logger; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__misc__ = __webpack_require__(2549);\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n// TODO: Implement different loggers for different environments\nvar global = Object(__WEBPACK_IMPORTED_MODULE_0__misc__[\"e\" /* getGlobalObject */])();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_0__misc__[\"c\" /* consoleSandbox */])(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_0__misc__[\"c\" /* consoleSandbox */])(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_0__misc__[\"c\" /* consoleSandbox */])(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' '));\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\n\n//# sourceMappingURL=logger.js.map\n\n/***/ }),\n\n/***/ 2603:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process, module) {/* harmony export (immutable) */ __webpack_exports__[\"b\"] = isNodeEnv;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = dynamicRequire;\n/* unused harmony export extractNodeRequestData */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__is__ = __webpack_require__(2524);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__object__ = __webpack_require__(2604);\n\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction dynamicRequire(mod, request) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return mod.require(request);\n}\n/** Default request keys that'll be used to extract data from the request */\nvar DEFAULT_REQUEST_KEYS = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];\n/**\n * Normalizes data from the request object, accounting for framework differences.\n *\n * @param req The request object from which to extract data\n * @param keys An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_KEYS if not\n * provided.\n * @returns An object containing normalized request data\n */\nfunction extractNodeRequestData(req, keys) {\n    if (keys === void 0) { keys = DEFAULT_REQUEST_KEYS; }\n    // make sure we can safely use dynamicRequire below\n    if (!isNodeEnv()) {\n        throw new Error(\"Can't get node request data outside of a node environment\");\n    }\n    var requestData = {};\n    // headers:\n    //   node, express: req.headers\n    //   koa: req.header\n    var headers = (req.headers || req.header || {});\n    // method:\n    //   node, express, koa: req.method\n    var method = req.method;\n    // host:\n    //   express: req.hostname in > 4 and req.host in < 4\n    //   koa: req.host\n    //   node: req.headers.host\n    var host = req.hostname || req.host || headers.host || '<no host>';\n    // protocol:\n    //   node: <n/a>\n    //   express, koa: req.protocol\n    var protocol = req.protocol === 'https' || req.secure || (req.socket || {}).encrypted\n        ? 'https'\n        : 'http';\n    // url (including path and query string):\n    //   node, express: req.originalUrl\n    //   koa: req.url\n    var originalUrl = (req.originalUrl || req.url || '');\n    // absolute url\n    var absoluteUrl = protocol + \"://\" + host + originalUrl;\n    keys.forEach(function (key) {\n        switch (key) {\n            case 'headers':\n                requestData.headers = headers;\n                break;\n            case 'method':\n                requestData.method = method;\n                break;\n            case 'url':\n                requestData.url = absoluteUrl;\n                break;\n            case 'cookies':\n                // cookies:\n                //   node, express, koa: req.headers.cookie\n                //   vercel, sails.js, express (w/ cookie middleware): req.cookies\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.cookies = req.cookies || dynamicRequire(module, 'cookie').parse(headers.cookie || '');\n                break;\n            case 'query_string':\n                // query string:\n                //   node: req.url (raw)\n                //   express, koa: req.query\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.query_string = dynamicRequire(module, 'url').parse(originalUrl || '', false).query;\n                break;\n            case 'data':\n                if (method === 'GET' || method === 'HEAD') {\n                    break;\n                }\n                // body data:\n                //   node, express, koa: req.body\n                if (req.body !== undefined) {\n                    requestData.data = Object(__WEBPACK_IMPORTED_MODULE_0__is__[\"k\" /* isString */])(req.body) ? req.body : JSON.stringify(Object(__WEBPACK_IMPORTED_MODULE_1__object__[\"d\" /* normalize */])(req.body));\n                }\n                break;\n            default:\n                if ({}.hasOwnProperty.call(req, key)) {\n                    requestData[key] = req[key];\n                }\n        }\n    });\n    return requestData;\n}\n//# sourceMappingURL=node.js.map\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(162), __webpack_require__(126)(module)))\n\n/***/ }),\n\n/***/ 2604:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (immutable) */ __webpack_exports__[\"c\"] = fill;\n/* harmony export (immutable) */ __webpack_exports__[\"f\"] = urlEncode;\n/* harmony export (immutable) */ __webpack_exports__[\"e\"] = normalizeToSize;\n/* unused harmony export walk */\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = normalize;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = extractExceptionKeysForMessage;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = dropUndefinedKeys;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__browser__ = __webpack_require__(2660);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__is__ = __webpack_require__(2524);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__memo__ = __webpack_require__(2661);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__stacktrace__ = __webpack_require__(2605);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__string__ = __webpack_require__(2606);\n\n\n\n\n\n\n/**\n * Wrap a given object method with a higher-order function\n *\n * @param source An object that contains a method to be wrapped.\n * @param name A name of method to be wrapped.\n * @param replacementFactory A function that should be used to wrap a given method, returning the wrapped method which\n * will be substituted in for `source[name]`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacementFactory(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    if (typeof wrapped === 'function') {\n        try {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n    return Object.keys(object)\n        .map(function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all its attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"d\" /* isError */])(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"f\" /* isEvent */])(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"c\" /* isElement */])(event_1.target)\n                ? Object(__WEBPACK_IMPORTED_MODULE_1__browser__[\"a\" /* htmlTreeAsString */])(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"c\" /* isElement */])(event_1.currentTarget)\n                ? Object(__WEBPACK_IMPORTED_MODULE_1__browser__[\"a\" /* htmlTreeAsString */])(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        if (typeof CustomEvent !== 'undefined' && Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"g\" /* isInstanceOf */])(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // eslint-disable-next-line no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nfunction normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/**\n * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,\n * booleans, null, and undefined.\n *\n * @param value The value to stringify\n * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or\n *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,\n *  unchanged.\n */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"i\" /* isPrimitive */])(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"l\" /* isSyntheticEvent */])(value)) {\n        return '[SyntheticEvent]';\n    }\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + Object(__WEBPACK_IMPORTED_MODULE_4__stacktrace__[\"a\" /* getFunctionName */])(value) + \"]\";\n    }\n    // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable\n    if (typeof value === 'symbol') {\n        return \"[\" + String(value) + \"]\";\n    }\n    if (typeof value === 'bigint') {\n        return \"[BigInt: \" + String(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new __WEBPACK_IMPORTED_MODULE_3__memo__[\"a\" /* Memo */](); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // If value implements `toJSON` method, call it and return early\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"i\" /* isPrimitive */])(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction normalize(input, depth) {\n    try {\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\n    }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nfunction extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return Object(__WEBPACK_IMPORTED_MODULE_5__string__[\"d\" /* truncate */])(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return Object(__WEBPACK_IMPORTED_MODULE_5__string__[\"d\" /* truncate */])(serialized, maxLength);\n    }\n    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nfunction dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__is__[\"h\" /* isPlainObject */])(val)) {\n        var obj = val;\n        var rv = {};\n        try {\n            for (var _b = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"h\" /* __values */])(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof obj[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(obj[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n//# sourceMappingURL=object.js.map\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(35)))\n\n/***/ }),\n\n/***/ 2605:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = getFunctionName;\nvar defaultFunctionName = '<anonymous>';\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    }\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//# sourceMappingURL=stacktrace.js.map\n\n/***/ }),\n\n/***/ 2606:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = truncate;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = snipLine;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = safeJoin;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = isMatchingPattern;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__is__ = __webpack_require__(2524);\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        // eslint-disable-next-line no-param-reassign\n        colno = ll;\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nfunction isMatchingPattern(value, pattern) {\n    if (!Object(__WEBPACK_IMPORTED_MODULE_0__is__[\"k\" /* isString */])(value)) {\n        return false;\n    }\n    if (Object(__WEBPACK_IMPORTED_MODULE_0__is__[\"j\" /* isRegExp */])(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n//# sourceMappingURL=string.js.map\n\n/***/ }),\n\n/***/ 2607:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = eventFromException;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = eventFromMessage;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = eventFromUnknownInput;\n/* unused harmony export eventFromString */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__parsers__ = __webpack_require__(2667);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__tracekit__ = __webpack_require__(2608);\n\n\n\n\n\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nfunction eventFromException(options, exception, hint) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"e\" /* addExceptionMechanism */])(event, {\n        handled: true,\n        type: 'generic',\n    });\n    event.level = __WEBPACK_IMPORTED_MODULE_1__sentry_types__[\"b\" /* Severity */].Error;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"d\" /* SyncPromise */].resolve(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(options, message, level, hint) {\n    if (level === void 0) { level = __WEBPACK_IMPORTED_MODULE_1__sentry_types__[\"b\" /* Severity */].Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"d\" /* SyncPromise */].resolve(event);\n}\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event;\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"v\" /* isErrorEvent */])(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        // eslint-disable-next-line no-param-reassign\n        exception = errorEvent.error;\n        event = Object(__WEBPACK_IMPORTED_MODULE_3__parsers__[\"b\" /* eventFromStacktrace */])(Object(__WEBPACK_IMPORTED_MODULE_4__tracekit__[\"a\" /* computeStackTrace */])(exception));\n        return event;\n    }\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"s\" /* isDOMError */])(exception) || Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"t\" /* isDOMException */])(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name, code, and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\n        var name_1 = domException.name || (Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"s\" /* isDOMError */])(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"f\" /* addExceptionTypeValue */])(event, message);\n        if ('code' in domException) {\n            event.tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event.tags), { 'DOMException.code': \"\" + domException.code });\n        }\n        return event;\n    }\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"u\" /* isError */])(exception)) {\n        // we have a real Error object, do nothing\n        event = Object(__WEBPACK_IMPORTED_MODULE_3__parsers__[\"b\" /* eventFromStacktrace */])(Object(__WEBPACK_IMPORTED_MODULE_4__tracekit__[\"a\" /* computeStackTrace */])(exception));\n        return event;\n    }\n    if (Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"A\" /* isPlainObject */])(exception) || Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"w\" /* isEvent */])(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = Object(__WEBPACK_IMPORTED_MODULE_3__parsers__[\"a\" /* eventFromPlainObject */])(objectException, syntheticException, options.rejection);\n        Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"e\" /* addExceptionMechanism */])(event, {\n            synthetic: true,\n        });\n        return event;\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(exception, syntheticException, options);\n    Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"f\" /* addExceptionTypeValue */])(event, \"\" + exception, undefined);\n    Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"e\" /* addExceptionMechanism */])(event, {\n        synthetic: true,\n    });\n    return event;\n}\n/**\n * @hidden\n */\nfunction eventFromString(input, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = Object(__WEBPACK_IMPORTED_MODULE_4__tracekit__[\"a\" /* computeStackTrace */])(syntheticException);\n        var frames_1 = Object(__WEBPACK_IMPORTED_MODULE_3__parsers__[\"d\" /* prepareFramesForEvent */])(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map\n\n/***/ }),\n\n/***/ 2608:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = computeStackTrace;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\n\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\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 gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\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/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nfunction computeStackTrace(ex) {\n    var stack = null;\n    var popSize = 0;\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            popSize = ex.framesToPop;\n        }\n        else if (reactMinifiedRegexp.test(ex.message)) {\n            popSize = 1;\n        }\n    }\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex) {\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\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            element = {\n                // working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n                // prefix here seems like the quickest solution for now.\n                url: parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: isNative ? [parts[2]] : [],\n                line: parts[3] ? +parts[3] : null,\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\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            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            element = {\n                url: parts[3],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\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;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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//# sourceMappingURL=tracekit.js.map\n\n/***/ }),\n\n/***/ 2609:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return BaseTransport; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n\n\n\n\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"b\" /* PromiseBuffer */](30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._api = new __WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"a\" /* API */](this.options.dsn);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */]('Transport Class has to implement `sendEvent` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    /**\n     * Handle Sentry repsonse for promise-based transports.\n     */\n    BaseTransport.prototype._handleResponse = function (_a) {\n        var requestType = _a.requestType, response = _a.response, headers = _a.headers, resolve = _a.resolve, reject = _a.reject;\n        var status = __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"c\" /* Status */].fromHttpCode(response.status);\n        /**\n         * \"The name is case-insensitive.\"\n         * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n         */\n        var limited = this._handleRateLimit(headers);\n        if (limited)\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn(\"Too many requests, backing off until: \" + this._disabledUntil(requestType));\n        if (status === __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"c\" /* Status */].Success) {\n            resolve({ status: status });\n            return;\n        }\n        reject(response);\n    };\n    /**\n     * Gets the time that given category is disabled until for rate limiting\n     */\n    BaseTransport.prototype._disabledUntil = function (category) {\n        return this._rateLimits[category] || this._rateLimits.all;\n    };\n    /**\n     * Checks if a category is rate limited\n     */\n    BaseTransport.prototype._isRateLimited = function (category) {\n        return this._disabledUntil(category) > new Date(Date.now());\n    };\n    /**\n     * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n     */\n    BaseTransport.prototype._handleRateLimit = function (headers) {\n        var e_1, _a, e_2, _b;\n        var now = Date.now();\n        var rlHeader = headers['x-sentry-rate-limits'];\n        var raHeader = headers['retry-after'];\n        if (rlHeader) {\n            try {\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 ms\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                for (var _c = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"h\" /* __values */])(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {\n                    var limit = _d.value;\n                    var parameters = limit.split(':', 2);\n                    var headerDelay = parseInt(parameters[0], 10);\n                    var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n                    try {\n                        for (var _e = (e_2 = void 0, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"h\" /* __values */])(parameters[1].split(';'))), _f = _e.next(); !_f.done; _f = _e.next()) {\n                            var category = _f.value;\n                            this._rateLimits[category || 'all'] = new Date(now + delay);\n                        }\n                    }\n                    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                    finally {\n                        try {\n                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                        }\n                        finally { if (e_2) throw e_2.error; }\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            return true;\n        }\n        else if (raHeader) {\n            this._rateLimits.all = new Date(now + Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"H\" /* parseRetryAfterHeader */])(now, raHeader));\n            return true;\n        }\n        return false;\n    };\n    return BaseTransport;\n}());\n\n//# sourceMappingURL=base.js.map\n\n/***/ }),\n\n/***/ 2610:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__globalhandlers__ = __webpack_require__(2762);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"GlobalHandlers\", function() { return __WEBPACK_IMPORTED_MODULE_0__globalhandlers__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__trycatch__ = __webpack_require__(2763);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"TryCatch\", function() { return __WEBPACK_IMPORTED_MODULE_1__trycatch__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__breadcrumbs__ = __webpack_require__(2764);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"Breadcrumbs\", function() { return __WEBPACK_IMPORTED_MODULE_2__breadcrumbs__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__linkederrors__ = __webpack_require__(2765);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"LinkedErrors\", function() { return __WEBPACK_IMPORTED_MODULE_3__linkederrors__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__useragent__ = __webpack_require__(2766);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"UserAgent\", function() { return __WEBPACK_IMPORTED_MODULE_4__useragent__[\"a\"]; });\n\n\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2653:\n/***/ (function(module, exports, __webpack_require__) {\n\n// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = __webpack_require__(2654);\nif(typeof content === 'string') content = [[module.i, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = __webpack_require__(9)(\"447d1b86\", content, false, {});\n// Hot Module Replacement\nif(false) {\n // When the styles change, update the <style> tags\n if(!content.locals) {\n   module.hot.accept(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/less-loader/dist/cjs.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./HubspotChat.vue\", function() {\n     var newContent = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/less-loader/dist/cjs.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./HubspotChat.vue\");\n     if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n     update(newContent);\n   });\n }\n // When the module is disposed, remove the <style> tags\n module.hot.dispose(function() { update(); });\n}\n\n/***/ }),\n\n/***/ 2654:\n/***/ (function(module, exports, __webpack_require__) {\n\nexports = module.exports = __webpack_require__(8)(false);\n// imports\n\n\n// module\nexports.push([module.i, \"\\n#hubspot-conversations-inline-iframe {\\n  height: calc(var(--vh, 1vh) * 100) !important;\\n  height: 100vh;\\n  width: 100%;\\n  border: 0px;\\n}\\n\", \"\"]);\n\n// exports\n\n\n/***/ }),\n\n/***/ 2655:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar render = function() {\n  var _vm = this\n  var _h = _vm.$createElement\n  var _c = _vm._self._c || _h\n  return _c(\"div\", { attrs: { id: \"support-chat-container\" } })\n}\nvar staticRenderFns = []\nrender._withStripped = true\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\n/* harmony default export */ __webpack_exports__[\"a\"] = (esExports);\nif (false) {\n  module.hot.accept()\n  if (module.hot.data) {\n    require(\"vue-hot-reload-api\")      .rerender(\"data-v-3e33ba39\", esExports)\n  }\n}\n\n/***/ }),\n\n/***/ 2658:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(97);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_bootstrap_vue__ = __webpack_require__(18);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__components_public_HubspotChat__ = __webpack_require__(1258);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__plugins_filters__ = __webpack_require__(1250);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__sentry_vue__ = __webpack_require__(2734);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_vuex__ = __webpack_require__(216);\n\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n//\n\n\n\n\n\n\n\n/* harmony default export */ __webpack_exports__[\"a\"] = ({\n  name: 'Error',\n  components: {\n    BIcon: __WEBPACK_IMPORTED_MODULE_1_bootstrap_vue__[\"C\" /* BIcon */],\n    BIconArrowCounterclockwise: __WEBPACK_IMPORTED_MODULE_1_bootstrap_vue__[\"E\" /* BIconArrowCounterclockwise */],\n    BModal: __WEBPACK_IMPORTED_MODULE_1_bootstrap_vue__[\"_32\" /* BModal */],\n    BButton: __WEBPACK_IMPORTED_MODULE_1_bootstrap_vue__[\"d\" /* BButton */],\n    'hubspot-chat': __WEBPACK_IMPORTED_MODULE_2__components_public_HubspotChat__[\"default\"]\n  },\n  props: {\n    customError: {\n      type: String,\n      required: false\n    }\n  },\n  data: function data() {\n    return {\n      modalShow: false,\n      smallToken: '',\n      showDetailedError: false,\n      supportChatVisible: false\n    };\n  },\n  created: function created() {\n    var logErrorMsg = this.customError;\n    if (this.opentok && this.opentok.error && this.opentok.error.title) {\n      logErrorMsg = this.opentok.error.title;\n    }\n    __WEBPACK_IMPORTED_MODULE_4__sentry_vue__[\"a\" /* captureMessage */]('Error video: ' + logErrorMsg);\n\n    if (!this.customError) {\n      this.$store.commit('video/setOpentokError', {\n        title: this.$route.query.error_title,\n        msg: this.$route.query.error_msg\n      });\n      this.$root.$emit('bv::show::modal', 'modal-1', '#btnShow');\n      this.smallToken = this.$route.query.token;\n    } else {\n      this.smallToken = this.$store.state.video.smallToken;\n    }\n    this.modalShow = true;\n  },\n\n  methods: {\n    pageReload: function pageReload() {\n      history.back();\n    },\n    toggleShowDetailedError: function toggleShowDetailedError() {\n      this.showDetailedError = !this.showDetailedError;\n    },\n    doCustomErrorAction: function doCustomErrorAction() {\n      switch (this.customError) {\n        case 'VideoSessionFinishedException':\n          this.$helpers.goToPatientWebApp('appointments/preview/' + this.appointment.id);\n          break;\n        case 'VideoSessionFinishedWithReportException':\n          this.$helpers.goToPatientWebApp('appointments/report/' + this.appointment.id);\n          break;\n        case 'PaymentNotFoundException':\n          this.$helpers.goToPatientWebApp('appointments/pay/' + this.appointment.id + '/' + this.appointment.price);\n          break;\n        default:\n          return null;\n      }\n    }\n  },\n  computed: __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, Object(__WEBPACK_IMPORTED_MODULE_5_vuex__[\"d\" /* mapState */])('video', ['opentok', 'appointment']), {\n    getErrorTitle: function getErrorTitle() {\n      var i18nMsgKey = 'errors.' + this.customError + '.title' + (this.$store.getters['session/userIsProfessional'] ? '_professional' : '');\n      if (this.$te(i18nMsgKey)) {\n        return this.$t(i18nMsgKey);\n      } else {\n        return this.$t('dialog-title-error');\n      }\n    },\n    getErrorMsg: function getErrorMsg() {\n      var i18nMsgKey = !this.customError ? 'errors.' + this.opentok.error.title : 'errors.' + this.customError + '.msg' + (this.$store.getters['session/userIsProfessional'] ? '_professional' : '');\n      if (this.$te(i18nMsgKey) && !!this.appointment) {\n        var appointmentDate = __WEBPACK_IMPORTED_MODULE_3__plugins_filters__[\"a\" /* default */].beautifyDate(this.appointment.fromDateTime);\n        return !this.customError ? this.$t(i18nMsgKey) : this.$t(i18nMsgKey, { date: appointmentDate });\n      } else {\n        return this.$t('errorVideoConnection');\n      }\n    },\n    getErrorImg: function getErrorImg() {\n      var img = this.customError;\n      switch (this.customError) {\n        case 'VideoSessionFinishedException':\n        case 'VideoSessionFinishedWithReportException':\n        case 'VideoSessionWaitingReportException':\n          img = 'VideoSessionFinishedException';\n          break;\n        case 'VideoSessionExpiredException':\n          img = 'VideoSessionNoLongerAccessibleException';\n          break;\n        default:\n          return '/static-appopensalud/img/icons/unplugged-icon-red-fill.svg';\n      }\n      return this.customError ? '/static-appopensalud/img/icons/errors/' + img + '.svg' : '/static-appopensalud/img/icons/unplugged-icon-red-fill.svg';\n    },\n    getCustomErrorBtnMsg: function getCustomErrorBtnMsg() {\n      switch (this.customError) {\n        case 'VideoSessionFinishedException':\n        case 'VideoSessionFinishedWithReportException':\n          return this.$t('go-to-consultation');\n        case 'PaymentNotFoundException':\n          return this.$t('pay-consultation');\n        case 'VideoSessionExpiredException':\n        case 'VideoSessionNoLongerAccessibleException':\n        case 'VideoSessionNotYetAccessibleException':\n        case 'VideoSessionWaitingReportException':\n          return '';\n        default:\n          return null;\n      }\n    },\n    getErrorColorVariant: function getErrorColorVariant() {\n      switch (this.customError) {\n        case 'VideoSessionNoLongerAccessibleException':\n        case 'VideoSessionNotYetAccessibleException':\n        case 'VideoSessionWaitingReportException':\n        case 'VideoSessionFinishedException':\n        case 'VideoSessionExpiredException':\n        case 'VideoSessionFinishedWithReportException':\n        case 'PaymentNotFoundException':\n          return 'primary';\n        default:\n          return 'danger';\n      }\n    }\n  })\n});\n\n/***/ }),\n\n/***/ 2659:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Scope; });\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = addGlobalEventProcessor;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(scope._breadcrumbs);\n            newScope._tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, scope._tags);\n            newScope._extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, scope._extra);\n            newScope._contexts = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._session = scope._session;\n            newScope._transactionName = scope._transactionName;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        var _a, _b, _c, _d;\n        // often, this span will be a transaction, but it's not guaranteed to be\n        var span = this.getSpan();\n        // try it the new way first\n        if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {\n            return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;\n        }\n        // fallback to the old way (known bug: this only finds transactions with sampled = true)\n        if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {\n            return span.spanRecorder.spans[0];\n        }\n        // neither way found a transaction\n        return undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._tags), captureContext._tags);\n            this._extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._extra), captureContext._extra);\n            this._contexts = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._contexts), captureContext._contexts);\n            if (captureContext._user && Object.keys(captureContext._user).length) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n        }\n        else if (Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"A\" /* isPlainObject */])(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._tags), captureContext.tags);\n            this._extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._extra), captureContext.extra);\n            this._contexts = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._contexts), captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transactionName = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._session = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ timestamp: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"j\" /* dateTimestampInSeconds */])() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        var _a;\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._contexts), event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transactionName) {\n            event.transaction = this._transactionName;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relys on that.\n        if (this._span) {\n            event.contexts = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;\n            if (transactionName) {\n                event.tags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"d\" /* SyncPromise */](function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event), hint);\n                if (Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"D\" /* isThenable */])(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        // We need this check for this._notifyingListeners to be able to work on scope during updates\n        // If this check is not here we'll produce endless recursion when something is done with the scope\n        // during the callback.\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            this._scopeListeners.forEach(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\n        }\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    return Scope;\n}());\n\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n    var global = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"p\" /* getGlobalObject */])();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nfunction addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map\n\n/***/ }),\n\n/***/ 2660:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = htmlTreeAsString;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__is__ = __webpack_require__(2524);\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(elem) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        // eslint-disable-next-line no-plusplus\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && Object(__WEBPACK_IMPORTED_MODULE_0__is__[\"k\" /* isString */])(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var allowedAttrs = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < allowedAttrs.length; i++) {\n        key = allowedAttrs[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n//# sourceMappingURL=browser.js.map\n\n/***/ }),\n\n/***/ 2661:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Memo; });\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\n\n//# sourceMappingURL=memo.js.map\n\n/***/ }),\n\n/***/ 2662:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export supportsErrorEvent */\n/* unused harmony export supportsDOMError */\n/* unused harmony export supportsDOMException */\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = supportsFetch;\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = supportsNativeFetch;\n/* unused harmony export supportsReportingObserver */\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = supportsReferrerPolicy;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = supportsHistory;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__logger__ = __webpack_require__(2602);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__misc__ = __webpack_require__(2549);\n\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    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\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    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n    try {\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n    if (!('fetch' in Object(__WEBPACK_IMPORTED_MODULE_1__misc__[\"e\" /* getGlobalObject */])())) {\n        return false;\n    }\n    try {\n        new Headers();\n        new Request('');\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * 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    var global = Object(__WEBPACK_IMPORTED_MODULE_1__misc__[\"e\" /* getGlobalObject */])();\n    // Fast path to avoid DOM I/O\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\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    var result = false;\n    var doc = global.document;\n    // eslint-disable-next-line deprecation/deprecation\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                // eslint-disable-next-line @typescript-eslint/unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            __WEBPACK_IMPORTED_MODULE_0__logger__[\"a\" /* logger */].warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n    return 'ReportingObserver' in Object(__WEBPACK_IMPORTED_MODULE_1__misc__[\"e\" /* getGlobalObject */])();\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    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\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 = Object(__WEBPACK_IMPORTED_MODULE_1__misc__[\"e\" /* getGlobalObject */])();\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var chrome = global.chrome;\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map\n\n/***/ }),\n\n/***/ 2663:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return SyncPromise; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__is__ = __webpack_require__(2524);\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (Object(__WEBPACK_IMPORTED_MODULE_0__is__[\"m\" /* isThenable */])(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler.done) {\n                    return;\n                }\n                if (_this._state === States.RESOLVED) {\n                    if (handler.onfulfilled) {\n                        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                        handler.onfulfilled(_this._value);\n                    }\n                }\n                if (_this._state === States.REJECTED) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                }\n                handler.done = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                done: false,\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    return SyncPromise;\n}());\n\n//# sourceMappingURL=syncpromise.js.map\n\n/***/ }),\n\n/***/ 2664:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Session; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n\n\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"P\" /* uuid4 */])();\n        this.timestamp = Date.now();\n        this.started = Date.now();\n        this.duration = 0;\n        this.status = __WEBPACK_IMPORTED_MODULE_0__sentry_types__[\"a\" /* SessionStatus */].Ok;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || Date.now();\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"P\" /* uuid4 */])();\n        }\n        if (context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            this.duration = this.timestamp - this.started;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === __WEBPACK_IMPORTED_MODULE_0__sentry_types__[\"a\" /* SessionStatus */].Ok) {\n            this.update({ status: __WEBPACK_IMPORTED_MODULE_0__sentry_types__[\"a\" /* SessionStatus */].Exited });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"k\" /* dropUndefinedKeys */])({\n            sid: \"\" + this.sid,\n            init: true,\n            started: new Date(this.started).toISOString(),\n            timestamp: new Date(this.timestamp).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"k\" /* dropUndefinedKeys */])({\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            }),\n        });\n    };\n    return Session;\n}());\n\n//# sourceMappingURL=session.js.map\n\n/***/ }),\n\n/***/ 2665:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return NoopTransport; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n\n\n/** Noop transport */\nvar NoopTransport = /** @class */ (function () {\n    function NoopTransport() {\n    }\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.sendEvent = function (_) {\n        return __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"d\" /* SyncPromise */].resolve({\n            reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n            status: __WEBPACK_IMPORTED_MODULE_0__sentry_types__[\"c\" /* Status */].Skipped,\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.close = function (_) {\n        return __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"d\" /* SyncPromise */].resolve(true);\n    };\n    return NoopTransport;\n}());\n\n//# sourceMappingURL=noop.js.map\n\n/***/ }),\n\n/***/ 2666:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return BrowserClient; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__backend__ = __webpack_require__(2759);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__helpers__ = __webpack_require__(2550);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__integrations__ = __webpack_require__(2610);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__version__ = __webpack_require__(2669);\n\n\n\n\n\n\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"c\" /* __extends */])(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        return _super.call(this, __WEBPACK_IMPORTED_MODULE_3__backend__[\"a\" /* BrowserBackend */], options) || this;\n    }\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"p\" /* getGlobalObject */])().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].error('Trying to call showReportDialog with Sentry Client disabled');\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_4__helpers__[\"a\" /* injectReportDialog */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, options), { dsn: options.dsn || this.getDsn() }));\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event.sdk), { name: __WEBPACK_IMPORTED_MODULE_6__version__[\"a\" /* SDK_NAME */], packages: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: __WEBPACK_IMPORTED_MODULE_6__version__[\"b\" /* SDK_VERSION */],\n                },\n            ]), version: __WEBPACK_IMPORTED_MODULE_6__version__[\"b\" /* SDK_VERSION */] });\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._sendEvent = function (event) {\n        var integration = this.getIntegration(__WEBPACK_IMPORTED_MODULE_5__integrations__[\"Breadcrumbs\"]);\n        if (integration) {\n            integration.addSentryBreadcrumb(event);\n        }\n        _super.prototype._sendEvent.call(this, event);\n    };\n    return BrowserClient;\n}(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"c\" /* BaseClient */]));\n\n//# sourceMappingURL=client.js.map\n\n/***/ }),\n\n/***/ 2667:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = exceptionFromStacktrace;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = eventFromPlainObject;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = eventFromStacktrace;\n/* harmony export (immutable) */ __webpack_exports__[\"d\"] = prepareFramesForEvent;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__tracekit__ = __webpack_require__(2608);\n\n\nvar STACKTRACE_LIMIT = 50;\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nfunction exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nfunction eventFromPlainObject(exception, syntheticException, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: Object(__WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"w\" /* isEvent */])(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + Object(__WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"l\" /* extractExceptionKeysForMessage */])(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: Object(__WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"G\" /* normalizeToSize */])(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = Object(__WEBPACK_IMPORTED_MODULE_1__tracekit__[\"a\" /* computeStackTrace */])(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nfunction eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nfunction prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\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    // 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    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .slice(0, STACKTRACE_LIMIT)\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map\n\n/***/ }),\n\n/***/ 2668:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__base__ = __webpack_require__(2609);\n/* unused harmony reexport BaseTransport */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__fetch__ = __webpack_require__(2760);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_1__fetch__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__xhr__ = __webpack_require__(2761);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_2__xhr__[\"a\"]; });\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2669:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return SDK_NAME; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return SDK_VERSION; });\nvar SDK_NAME = 'sentry.javascript.browser';\nvar SDK_VERSION = '5.30.0';\n//# sourceMappingURL=version.js.map\n\n/***/ }),\n\n/***/ 2732:\n/***/ (function(module, exports, __webpack_require__) {\n\n// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = __webpack_require__(2733);\nif(typeof content === 'string') content = [[module.i, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = __webpack_require__(9)(\"4dc5969a\", content, false, {});\n// Hot Module Replacement\nif(false) {\n // When the styles change, update the <style> tags\n if(!content.locals) {\n   module.hot.accept(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Error.vue\", function() {\n     var newContent = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Error.vue\");\n     if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n     update(newContent);\n   });\n }\n // When the module is disposed, remove the <style> tags\n module.hot.dispose(function() { update(); });\n}\n\n/***/ }),\n\n/***/ 2733:\n/***/ (function(module, exports, __webpack_require__) {\n\nexports = module.exports = __webpack_require__(8)(false);\n// imports\n\n\n// module\nexports.push([module.i, \"\\n.overline-typescale{font-size:12px;letter-spacing:1.25px;font-weight:lighter;text-transform:uppercase\\n}\\n.slide-down-enter-active,.slide-down-leave-active{-webkit-transition:all 0.5s ease;transition:all 0.5s ease\\n}\\n.slide-down-enter,.slide-down-leave-to{-webkit-transform:translateY(-100%);transform:translateY(-100%);opacity:0\\n}\\n.slide-fade-left-enter-active,.slide-fade-left-leave-active{-webkit-transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease, -webkit-transform 0.3s ease\\n}\\n.slide-fade-left-enter,.slide-fade-left-leave-to{-webkit-transform:translateX(100%);transform:translateX(100%);opacity:0\\n}\\n.fade-enter-active{-webkit-transition:opacity 0.3s ease;transition:opacity 0.3s ease\\n}\\n.fade-enter,.fade-leave-to{opacity:0\\n}\\nh1,h2{font-weight:normal\\n}\\nul{list-style-type:none;padding:0\\n}\\nli{display:inline-block;margin:0 10px\\n}\\na{color:#35495e\\n}\\n.code-format{display:block;font-family:'Source Code Pro', monospace;background-color:lightgray;border:1px solid gray;font-size:12px;padding:10px\\n}\\n.error-img{width:96px;margin:20px 0 40px 0\\n}\\n\", \"\"]);\n\n// exports\n\n\n/***/ }),\n\n/***/ 2734:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_browser__ = __webpack_require__(2578);\n/* unused harmony reexport addGlobalEventProcessor */\n/* unused harmony reexport addBreadcrumb */\n/* unused harmony reexport captureException */\n/* unused harmony reexport captureEvent */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_0__sentry_browser__[\"e\"]; });\n/* unused harmony reexport configureScope */\n/* unused harmony reexport getHubFromCarrier */\n/* unused harmony reexport getCurrentHub */\n/* unused harmony reexport Hub */\n/* unused harmony reexport Scope */\n/* unused harmony reexport setContext */\n/* unused harmony reexport setExtra */\n/* unused harmony reexport setExtras */\n/* unused harmony reexport setTag */\n/* unused harmony reexport setTags */\n/* unused harmony reexport setUser */\n/* unused harmony reexport startTransaction */\n/* unused harmony reexport withScope */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sdk__ = __webpack_require__(2768);\n/* unused harmony reexport init */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__vuerouter__ = __webpack_require__(2770);\n/* unused harmony reexport vueRouterInstrumentation */\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2735:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_types__ = __webpack_require__(2493);\n/* unused harmony reexport Severity */\n/* unused harmony reexport Status */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"c\", function() { return __WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"e\"]; });\n/* unused harmony reexport addBreadcrumb */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"d\", function() { return __WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"f\"]; });\n/* unused harmony reexport captureEvent */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"e\", function() { return __WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"g\"]; });\n/* unused harmony reexport configureScope */\n/* unused harmony reexport getHubFromCarrier */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"g\", function() { return __WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\"]; });\n/* unused harmony reexport Hub */\n/* unused harmony reexport makeMain */\n/* unused harmony reexport Scope */\n/* unused harmony reexport startTransaction */\n/* unused harmony reexport setContext */\n/* unused harmony reexport setExtra */\n/* unused harmony reexport setExtras */\n/* unused harmony reexport setTag */\n/* unused harmony reexport setTags */\n/* unused harmony reexport setUser */\n/* unused harmony reexport withScope */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__client__ = __webpack_require__(2666);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return __WEBPACK_IMPORTED_MODULE_2__client__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__helpers__ = __webpack_require__(2550);\n/* unused harmony reexport injectReportDialog */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__eventbuilder__ = __webpack_require__(2607);\n/* unused harmony reexport eventFromException */\n/* unused harmony reexport eventFromMessage */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__sdk__ = __webpack_require__(2767);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"f\", function() { return __WEBPACK_IMPORTED_MODULE_5__sdk__[\"a\"]; });\n/* unused harmony reexport forceLoad */\n/* unused harmony reexport init */\n/* unused harmony reexport lastEventId */\n/* unused harmony reexport onLoad */\n/* unused harmony reexport showReportDialog */\n/* unused harmony reexport flush */\n/* unused harmony reexport close */\n/* unused harmony reexport wrap */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__version__ = __webpack_require__(2669);\n/* unused harmony reexport SDK_NAME */\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return __WEBPACK_IMPORTED_MODULE_6__version__[\"b\"]; });\n\n\n\n\n\n\n\n//# sourceMappingURL=exports.js.map\n\n/***/ }),\n\n/***/ 2736:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export LogLevel */\n/** Console logging verbosity for the SDK. */\nvar LogLevel;\n(function (LogLevel) {\n    /** No logs will be generated. */\n    LogLevel[LogLevel[\"None\"] = 0] = \"None\";\n    /** Only SDK internal errors will be logged. */\n    LogLevel[LogLevel[\"Error\"] = 1] = \"Error\";\n    /** Information useful for debugging the SDK will be logged. */\n    LogLevel[LogLevel[\"Debug\"] = 2] = \"Debug\";\n    /** All SDK actions will be logged. */\n    LogLevel[LogLevel[\"Verbose\"] = 3] = \"Verbose\";\n})(LogLevel || (LogLevel = {}));\n//# sourceMappingURL=loglevel.js.map\n\n/***/ }),\n\n/***/ 2737:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return SessionStatus; });\n/**\n * Session Status\n */\nvar SessionStatus;\n(function (SessionStatus) {\n    /** JSDoc */\n    SessionStatus[\"Ok\"] = \"ok\";\n    /** JSDoc */\n    SessionStatus[\"Exited\"] = \"exited\";\n    /** JSDoc */\n    SessionStatus[\"Crashed\"] = \"crashed\";\n    /** JSDoc */\n    SessionStatus[\"Abnormal\"] = \"abnormal\";\n})(SessionStatus || (SessionStatus = {}));\n//# sourceMappingURL=session.js.map\n\n/***/ }),\n\n/***/ 2738:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Severity; });\n/** JSDoc */\n// eslint-disable-next-line import/export\nvar Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map\n\n/***/ }),\n\n/***/ 2739:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Status; });\n/** The status of an event. */\n// eslint-disable-next-line import/export\nvar Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map\n\n/***/ }),\n\n/***/ 2740:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export TransactionSamplingMethod */\nvar TransactionSamplingMethod;\n(function (TransactionSamplingMethod) {\n    TransactionSamplingMethod[\"Explicit\"] = \"explicitly_set\";\n    TransactionSamplingMethod[\"Sampler\"] = \"client_sampler\";\n    TransactionSamplingMethod[\"Rate\"] = \"client_rate\";\n    TransactionSamplingMethod[\"Inheritance\"] = \"inheritance\";\n})(TransactionSamplingMethod || (TransactionSamplingMethod = {}));\n//# sourceMappingURL=transaction.js.map\n\n/***/ }),\n\n/***/ 2741:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = captureException;\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = captureMessage;\n/* unused harmony export captureEvent */\n/* unused harmony export configureScope */\n/* unused harmony export addBreadcrumb */\n/* unused harmony export setContext */\n/* unused harmony export setExtras */\n/* unused harmony export setTags */\n/* unused harmony export setExtra */\n/* unused harmony export setTag */\n/* unused harmony export setUser */\n/* harmony export (immutable) */ __webpack_exports__[\"c\"] = withScope;\n/* unused harmony export _callOnClient */\n/* unused harmony export startTransaction */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_hub__ = __webpack_require__(2539);\n\n\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"c\" /* getCurrentHub */])();\n    if (hub && hub[method]) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return hub[method].apply(hub, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nfunction captureException(exception, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param level Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(message, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    // This is necessary to provide explicit scopes upgrade, without changing the original\n    // arity of the `captureMessage(message, level)` method.\n    var level = typeof captureContext === 'string' ? captureContext : undefined;\n    var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ originalException: message, syntheticException: syntheticException }, context));\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(['_invokeClient', method], args));\n}\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(context, customSamplingContext) {\n    return callOnHub('startTransaction', Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, context), customSamplingContext);\n}\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2742:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export forget */\n/**\n * Consumes the promise and logs the error when it rejects.\n * @param promise A promise to forget.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction forget(promise) {\n    promise.then(null, function (e) {\n        // TODO: Use a better logging mechanism\n        // eslint-disable-next-line no-console\n        console.error(e);\n    });\n}\n//# sourceMappingURL=async.js.map\n\n/***/ }),\n\n/***/ 2743:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Dsn; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__error__ = __webpack_require__(2601);\n\n\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\n    }\n    /**\n     * Renders the string representation of this Dsn.\n     *\n     * By default, this will render the public representation without the password\n     * component. To get the deprecated private representation, set `withPassword`\n     * to true.\n     *\n     * @param withPassword When set to true, the password will be included.\n     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, user = _a.user;\n        return (protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') +\n            (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId));\n    };\n    /** Parses a string into this Dsn. */\n    Dsn.prototype._fromString = function (str) {\n        var match = DSN_REGEX.exec(str);\n        if (!match) {\n            throw new __WEBPACK_IMPORTED_MODULE_1__error__[\"a\" /* SentryError */](ERROR_MESSAGE);\n        }\n        var _a = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"e\" /* __read */])(match.slice(1), 6), protocol = _a[0], user = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];\n        var path = '';\n        var projectId = lastPath;\n        var split = projectId.split('/');\n        if (split.length > 1) {\n            path = split.slice(0, -1).join('/');\n            projectId = split.pop();\n        }\n        if (projectId) {\n            var projectMatch = projectId.match(/^\\d+/);\n            if (projectMatch) {\n                projectId = projectMatch[0];\n            }\n        }\n        this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, user: user });\n    };\n    /** Maps Dsn components into this instance. */\n    Dsn.prototype._fromComponents = function (components) {\n        this.protocol = components.protocol;\n        this.user = components.user;\n        this.pass = components.pass || '';\n        this.host = components.host;\n        this.port = components.port || '';\n        this.path = components.path || '';\n        this.projectId = components.projectId;\n    };\n    /** Validates this Dsn and throws on error. */\n    Dsn.prototype._validate = function () {\n        var _this = this;\n        ['protocol', 'user', 'host', 'projectId'].forEach(function (component) {\n            if (!_this[component]) {\n                throw new __WEBPACK_IMPORTED_MODULE_1__error__[\"a\" /* SentryError */](ERROR_MESSAGE + \": \" + component + \" missing\");\n            }\n        });\n        if (!this.projectId.match(/^\\d+$/)) {\n            throw new __WEBPACK_IMPORTED_MODULE_1__error__[\"a\" /* SentryError */](ERROR_MESSAGE + \": Invalid projectId \" + this.projectId);\n        }\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new __WEBPACK_IMPORTED_MODULE_1__error__[\"a\" /* SentryError */](ERROR_MESSAGE + \": Invalid protocol \" + this.protocol);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new __WEBPACK_IMPORTED_MODULE_1__error__[\"a\" /* SentryError */](ERROR_MESSAGE + \": Invalid port \" + this.port);\n        }\n    };\n    return Dsn;\n}());\n\n//# sourceMappingURL=dsn.js.map\n\n/***/ }),\n\n/***/ 2744:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return setPrototypeOf; });\nvar setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n/**\n * setPrototypeOf polyfill using __proto__\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore __proto__ does not exist on obj\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore typescript complains about indexing so we remove\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map\n\n/***/ }),\n\n/***/ 2745:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = addInstrumentationHandler;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__is__ = __webpack_require__(2524);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__logger__ = __webpack_require__(2602);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__misc__ = __webpack_require__(2549);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__object__ = __webpack_require__(2604);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__stacktrace__ = __webpack_require__(2605);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__supports__ = __webpack_require__(2662);\n\n\n\n\n\n\n\nvar global = Object(__WEBPACK_IMPORTED_MODULE_3__misc__[\"e\" /* getGlobalObject */])();\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 */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\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            __WEBPACK_IMPORTED_MODULE_2__logger__[\"a\" /* logger */].warn('unknown instrumentation type:', type);\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(handler) {\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"h\" /* __values */])(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                __WEBPACK_IMPORTED_MODULE_2__logger__[\"a\" /* logger */].error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + Object(__WEBPACK_IMPORTED_MODULE_5__stacktrace__[\"a\" /* getFunctionName */])(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!Object(__WEBPACK_IMPORTED_MODULE_6__supports__[\"c\" /* supportsNativeFetch */])()) {\n        return;\n    }\n    Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var handlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, handlerData));\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, handlerData), { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, handlerData), { endTimestamp: Date.now(), error: error }));\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n                //       it means the sentry.javascript SDK caught an error invoking your application code.\n                //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n                throw error;\n            });\n        };\n    });\n}\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if ('Request' in global && Object(__WEBPACK_IMPORTED_MODULE_1__is__[\"g\" /* 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/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if (typeof fetchArgs[0] === 'string') {\n        return fetchArgs[0];\n    }\n    if ('Request' in global && Object(__WEBPACK_IMPORTED_MODULE_1__is__[\"g\" /* isInstanceOf */])(fetchArgs[0], Request)) {\n        return fetchArgs[0].url;\n    }\n    return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.\n    var requestKeys = [];\n    var requestValues = [];\n    var xhrproto = XMLHttpRequest.prototype;\n    Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var url = args[1];\n            xhr.__sentry_xhr__ = {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                method: Object(__WEBPACK_IMPORTED_MODULE_1__is__[\"k\" /* isString */])(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            if (Object(__WEBPACK_IMPORTED_MODULE_1__is__[\"k\" /* isString */])(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                xhr.__sentry_own_request__ = true;\n            }\n            var onreadystatechangeHandler = function () {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    try {\n                        var requestPos = requestKeys.indexOf(xhr);\n                        if (requestPos !== -1) {\n                            // Make sure to pop both key and value to keep it in sync.\n                            requestKeys.splice(requestPos);\n                            var args_1 = requestValues.splice(requestPos)[0];\n                            if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {\n                                xhr.__sentry_xhr__.body = args_1[0];\n                            }\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', {\n                        args: args,\n                        endTimestamp: Date.now(),\n                        startTimestamp: Date.now(),\n                        xhr: xhr,\n                    });\n                }\n            };\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n            }\n            return originalOpen.apply(xhr, args);\n        };\n    });\n    Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            requestKeys.push(this);\n            requestValues.push(args);\n            triggerHandlers('xhr', {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: this,\n            });\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!Object(__WEBPACK_IMPORTED_MODULE_6__supports__[\"b\" /* supportsHistory */])()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\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: from,\n            to: to,\n        });\n        if (oldOnPopState) {\n            return oldOnPopState.apply(this, args);\n        }\n    };\n    /** @hidden */\n    function historyReplacementFunction(originalHistoryFunction) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\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: from,\n                    to: to,\n                });\n            }\n            return originalHistoryFunction.apply(this, args);\n        };\n    }\n    Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(global.history, 'pushState', historyReplacementFunction);\n    Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(global.history, 'replaceState', historyReplacementFunction);\n}\n/** JSDoc */\nfunction instrumentDOM() {\n    if (!('document' in global)) {\n        return;\n    }\n    // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n    // to the document. Do this before we instrument addEventListener.\n    global.document.addEventListener('click', domEventHandler('click', triggerHandlers.bind(null, 'dom')), false);\n    global.document.addEventListener('keypress', keypressEventHandler(triggerHandlers.bind(null, 'dom')), false);\n    // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n    ['EventTarget', 'Node'].forEach(function (target) {\n        /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line no-prototype-builtins\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n        Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                if (fn && fn.handleEvent) {\n                    if (eventName === 'click') {\n                        Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                domEventHandler('click', triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                    if (eventName === 'keypress') {\n                        Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                keypressEventHandler(triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                }\n                else {\n                    if (eventName === 'click') {\n                        domEventHandler('click', triggerHandlers.bind(null, 'dom'), true)(this);\n                    }\n                    if (eventName === 'keypress') {\n                        keypressEventHandler(triggerHandlers.bind(null, 'dom'))(this);\n                    }\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n        Object(__WEBPACK_IMPORTED_MODULE_4__object__[\"c\" /* fill */])(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    original.call(this, eventName, fn.__sentry_wrapped__, options);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n    });\n}\nvar debounceDuration = 1000;\nvar debounceTimer = 0;\nvar keypressTimeout;\nvar lastCapturedEvent;\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param name the event name (e.g. \"click\")\n * @param handler function that will be triggered\n * @param debounce decides whether it should wait till another event loop\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction domEventHandler(name, handler, debounce) {\n    if (debounce === void 0) { debounce = false; }\n    return function (event) {\n        // reset keypress timeout; e.g. triggering a 'click' after\n        // a 'keypress' will reset the keypress debounce so that a new\n        // set of keypresses can be recorded\n        keypressTimeout = undefined;\n        // It's possible this handler might trigger multiple times for the same\n        // event (e.g. event propagation through node ancestors). Ignore if we've\n        // already captured the event.\n        if (!event || lastCapturedEvent === event) {\n            return;\n        }\n        lastCapturedEvent = event;\n        if (debounceTimer) {\n            clearTimeout(debounceTimer);\n        }\n        if (debounce) {\n            debounceTimer = setTimeout(function () {\n                handler({ event: event, name: name });\n            });\n        }\n        else {\n            handler({ event: event, name: name });\n        }\n    };\n}\n/**\n * Wraps addEventListener to capture keypress UI events\n * @param handler function that will be triggered\n * @returns wrapped keypress events handler\n * @hidden\n */\nfunction keypressEventHandler(handler) {\n    // TODO: if somehow user switches keypress target before\n    //       debounce timeout is triggered, we will only capture\n    //       a single breadcrumb from the FIRST target (acceptable?)\n    return function (event) {\n        var target;\n        try {\n            target = event.target;\n        }\n        catch (e) {\n            // just accessing event properties can throw an exception in some rare circumstances\n            // see: https://github.com/getsentry/raven-js/issues/838\n            return;\n        }\n        var tagName = target && target.tagName;\n        // only consider keypress events on actual input elements\n        // this will disregard keypresses targeting body (e.g. tabbing\n        // through elements, hotkeys, etc)\n        if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {\n            return;\n        }\n        // record first keypress in a series, but ignore subsequent\n        // keypresses until debounce clears\n        if (!keypressTimeout) {\n            domEventHandler('input', handler)(event);\n        }\n        clearTimeout(keypressTimeout);\n        keypressTimeout = setTimeout(function () {\n            keypressTimeout = undefined;\n        }, debounceDuration);\n    };\n}\nvar _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n    _oldOnErrorHandler = global.onerror;\n    global.onerror = function (msg, url, line, column, error) {\n        triggerHandlers('error', {\n            column: column,\n            error: error,\n            line: line,\n            msg: msg,\n            url: url,\n        });\n        if (_oldOnErrorHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnErrorHandler.apply(this, arguments);\n        }\n        return false;\n    };\n}\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n    _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n    global.onunhandledrejection = function (e) {\n        triggerHandlers('unhandledrejection', e);\n        if (_oldOnUnhandledRejectionHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n        }\n        return true;\n    };\n}\n//# sourceMappingURL=instrument.js.map\n\n/***/ }),\n\n/***/ 2746:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export resolve */\n/* unused harmony export relative */\n/* unused harmony export normalizePath */\n/* unused harmony export isAbsolute */\n/* unused harmony export join */\n/* unused harmony export dirname */\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = basename;\n// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js\n/** JSDoc */\nfunction normalizeArray(parts, allowAboveRoot) {\n    // if the path tries to go above the root, `up` ends up > 0\n    var up = 0;\n    for (var i = parts.length - 1; i >= 0; i--) {\n        var last = parts[i];\n        if (last === '.') {\n            parts.splice(i, 1);\n        }\n        else if (last === '..') {\n            parts.splice(i, 1);\n            // eslint-disable-next-line no-plusplus\n            up++;\n        }\n        else if (up) {\n            parts.splice(i, 1);\n            // eslint-disable-next-line no-plusplus\n            up--;\n        }\n    }\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\n        // eslint-disable-next-line no-plusplus\n        for (; up--; up) {\n            parts.unshift('..');\n        }\n    }\n    return parts;\n}\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe = /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^/]+?|)(\\.[^./]*|))(?:[/]*)$/;\n/** JSDoc */\nfunction splitPath(filename) {\n    var parts = splitPathRe.exec(filename);\n    return parts ? parts.slice(1) : [];\n}\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nfunction resolve() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n        var path = i >= 0 ? args[i] : '/';\n        // Skip empty entries\n        if (!path) {\n            continue;\n        }\n        resolvedPath = path + \"/\" + resolvedPath;\n        resolvedAbsolute = path.charAt(0) === '/';\n    }\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n    // Normalize the path\n    resolvedPath = normalizeArray(resolvedPath.split('/').filter(function (p) { return !!p; }), !resolvedAbsolute).join('/');\n    return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n/** JSDoc */\nfunction trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n        if (arr[start] !== '') {\n            break;\n        }\n    }\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n        if (arr[end] !== '') {\n            break;\n        }\n    }\n    if (start > end) {\n        return [];\n    }\n    return arr.slice(start, end - start + 1);\n}\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nfunction relative(from, to) {\n    /* eslint-disable no-param-reassign */\n    from = resolve(from).substr(1);\n    to = resolve(to).substr(1);\n    /* eslint-enable no-param-reassign */\n    var fromParts = trim(from.split('/'));\n    var toParts = trim(to.split('/'));\n    var length = Math.min(fromParts.length, toParts.length);\n    var samePartsLength = length;\n    for (var i = 0; i < length; i++) {\n        if (fromParts[i] !== toParts[i]) {\n            samePartsLength = i;\n            break;\n        }\n    }\n    var outputParts = [];\n    for (var i = samePartsLength; i < fromParts.length; i++) {\n        outputParts.push('..');\n    }\n    outputParts = outputParts.concat(toParts.slice(samePartsLength));\n    return outputParts.join('/');\n}\n// path.normalize(path)\n// posix version\n/** JSDoc */\nfunction normalizePath(path) {\n    var isPathAbsolute = isAbsolute(path);\n    var trailingSlash = path.substr(-1) === '/';\n    // Normalize the path\n    var normalizedPath = normalizeArray(path.split('/').filter(function (p) { return !!p; }), !isPathAbsolute).join('/');\n    if (!normalizedPath && !isPathAbsolute) {\n        normalizedPath = '.';\n    }\n    if (normalizedPath && trailingSlash) {\n        normalizedPath += '/';\n    }\n    return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n// posix version\n/** JSDoc */\nfunction isAbsolute(path) {\n    return path.charAt(0) === '/';\n}\n// posix version\n/** JSDoc */\nfunction join() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return normalizePath(args.join('/'));\n}\n/** JSDoc */\nfunction dirname(path) {\n    var result = splitPath(path);\n    var root = result[0];\n    var dir = result[1];\n    if (!root && !dir) {\n        // No dirname whatsoever\n        return '.';\n    }\n    if (dir) {\n        // It has a dirname, strip trailing slash\n        dir = dir.substr(0, dir.length - 1);\n    }\n    return root + dir;\n}\n/** JSDoc */\nfunction basename(path, ext) {\n    var f = splitPath(path)[2];\n    if (ext && f.substr(ext.length * -1) === ext) {\n        f = f.substr(0, f.length - ext.length);\n    }\n    return f;\n}\n//# sourceMappingURL=path.js.map\n\n/***/ }),\n\n/***/ 2747:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return PromiseBuffer; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__error__ = __webpack_require__(2601);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__syncpromise__ = __webpack_require__(2663);\n\n\n/** A simple queue that holds promises. */\nvar PromiseBuffer = /** @class */ (function () {\n    function PromiseBuffer(_limit) {\n        this._limit = _limit;\n        /** Internal set of queued Promises */\n        this._buffer = [];\n    }\n    /**\n     * Says if the buffer is ready to take more requests\n     */\n    PromiseBuffer.prototype.isReady = function () {\n        return this._limit === undefined || this.length() < this._limit;\n    };\n    /**\n     * Add a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns The original promise.\n     */\n    PromiseBuffer.prototype.add = function (task) {\n        var _this = this;\n        if (!this.isReady()) {\n            return __WEBPACK_IMPORTED_MODULE_1__syncpromise__[\"a\" /* SyncPromise */].reject(new __WEBPACK_IMPORTED_MODULE_0__error__[\"a\" /* SentryError */]('Not adding Promise due to buffer limit reached.'));\n        }\n        if (this._buffer.indexOf(task) === -1) {\n            this._buffer.push(task);\n        }\n        task\n            .then(function () { return _this.remove(task); })\n            .then(null, function () {\n            return _this.remove(task).then(null, function () {\n                // We have to add this catch here otherwise we have an unhandledPromiseRejection\n                // because it's a new Promise chain.\n            });\n        });\n        return task;\n    };\n    /**\n     * Remove a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns Removed promise.\n     */\n    PromiseBuffer.prototype.remove = function (task) {\n        var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n        return removedTask;\n    };\n    /**\n     * This function returns the number of unresolved promises in the queue.\n     */\n    PromiseBuffer.prototype.length = function () {\n        return this._buffer.length;\n    };\n    /**\n     * This will drain the whole queue, returns true if queue is empty or drained.\n     * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n     *\n     * @param timeout Number in ms to wait until it resolves with false.\n     */\n    PromiseBuffer.prototype.drain = function (timeout) {\n        var _this = this;\n        return new __WEBPACK_IMPORTED_MODULE_1__syncpromise__[\"a\" /* SyncPromise */](function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            __WEBPACK_IMPORTED_MODULE_1__syncpromise__[\"a\" /* SyncPromise */].all(_this._buffer)\n                .then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            })\n                .then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}());\n\n//# sourceMappingURL=promisebuffer.js.map\n\n/***/ }),\n\n/***/ 2748:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(module) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return dateTimestampInSeconds; });\n/* unused harmony export timestampInSeconds */\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"b\", function() { return timestampWithMs; });\n/* unused harmony export usingPerformanceAPI */\n/* unused harmony export browserPerformanceTimeOrigin */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__misc__ = __webpack_require__(2549);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node__ = __webpack_require__(2603);\n\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n    nowSeconds: function () { return Date.now() / 1000; },\n};\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n    var performance = Object(__WEBPACK_IMPORTED_MODULE_0__misc__[\"e\" /* getGlobalObject */])().performance;\n    if (!performance || !performance.now) {\n        return undefined;\n    }\n    // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n    //\n    // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n    // performance.now() gives a date arbitrarily in the past.\n    //\n    // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n    // undefined.\n    //\n    // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n    // interact with data coming out of performance entries.\n    //\n    // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n    // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n    // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n    // observed skews that can be as long as days, weeks or months.\n    //\n    // See https://github.com/getsentry/sentry-javascript/issues/2590.\n    //\n    // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n    // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n    // transactions of long-lived web pages.\n    var timeOrigin = Date.now() - performance.now();\n    return {\n        now: function () { return performance.now(); },\n        timeOrigin: timeOrigin,\n    };\n}\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n    try {\n        var perfHooks = Object(__WEBPACK_IMPORTED_MODULE_1__node__[\"a\" /* dynamicRequire */])(module, 'perf_hooks');\n        return perfHooks.performance;\n    }\n    catch (_) {\n        return undefined;\n    }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = Object(__WEBPACK_IMPORTED_MODULE_1__node__[\"b\" /* isNodeEnv */])() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },\n    };\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nvar dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nvar timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n// Re-exported with an old name for backwards-compatibility.\nvar timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nvar usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nvar browserPerformanceTimeOrigin = (function () {\n    var performance = Object(__WEBPACK_IMPORTED_MODULE_0__misc__[\"e\" /* getGlobalObject */])().performance;\n    if (!performance) {\n        return undefined;\n    }\n    if (performance.timeOrigin) {\n        return performance.timeOrigin;\n    }\n    // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n    // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n    // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n    // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n    // Date API.\n    // eslint-disable-next-line deprecation/deprecation\n    return (performance.timing && performance.timing.navigationStart) || Date.now();\n})();\n//# sourceMappingURL=time.js.map\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(126)(module)))\n\n/***/ }),\n\n/***/ 2749:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export API_VERSION */\n/* unused harmony export Hub */\n/* unused harmony export getMainCarrier */\n/* unused harmony export makeMain */\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = getCurrentHub;\n/* unused harmony export getActiveDomain */\n/* unused harmony export getHubFromCarrier */\n/* unused harmony export setHubOnCarrier */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__scope__ = __webpack_require__(2659);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__session__ = __webpack_require__(2664);\n\n\n\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nvar API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new __WEBPACK_IMPORTED_MODULE_2__scope__[\"a\" /* Scope */](); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        this.bindClient(client);\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var scope = __WEBPACK_IMPORTED_MODULE_2__scope__[\"a\" /* Scope */].clone(this.getScope());\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"P\" /* uuid4 */])());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"P\" /* uuid4 */])());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"P\" /* uuid4 */])());\n        this._invokeClient('captureEvent', event, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"j\" /* dateTimestampInSeconds */])();\n        var mergedBreadcrumb = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"i\" /* consoleSandbox */])(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"E\" /* logger */].warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        // End existing session if there's one\n        this.endSession();\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        var session = new __WEBPACK_IMPORTED_MODULE_3__session__[\"a\" /* Session */](Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), context));\n        if (scope) {\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            session.close();\n            if (client && client.captureSession) {\n                client.captureSession(session);\n            }\n            scope.setSession();\n        }\n    };\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args, [scope]));\n        }\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"E\" /* logger */].warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\n\n/** Returns the global shim registry. */\nfunction getMainCarrier() {\n    var carrier = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"p\" /* getGlobalObject */])();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nfunction makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nfunction getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"z\" /* isNodeEnv */])()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Returns the active domain, if one exists\n *\n * @returns The domain, or undefined if there is no active domain\n */\nfunction getActiveDomain() {\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n}\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var activeDomain = getActiveDomain();\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or it's an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, __WEBPACK_IMPORTED_MODULE_2__scope__[\"a\" /* Scope */].clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nfunction getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)\n        return carrier.__SENTRY__.hub;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nfunction setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map\n\n/***/ }),\n\n/***/ 2750:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return API; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_utils__ = __webpack_require__(2440);\n\nvar SENTRY_API_VERSION = '7';\n/** Helper class to provide urls to different Sentry endpoints. */\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn) {\n        this.dsn = dsn;\n        this._dsnObject = new __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"a\" /* Dsn */](dsn);\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns the prefix to construct Sentry ingestion API endpoints. */\n    API.prototype.getBaseApiEndpoint = function () {\n        var dsn = this._dsnObject;\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    /** Returns the store endpoint URL. */\n    API.prototype.getStoreEndpoint = function () {\n        return this._getIngestEndpoint('store');\n    };\n    /**\n     * Returns the store 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     */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        return this.getStoreEndpoint() + \"?\" + this._encodedAuth();\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     */\n    API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {\n        return this._getEnvelopeEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /** Returns only the path component for the store endpoint. */\n    API.prototype.getStoreEndpointPath = function () {\n        var dsn = this._dsnObject;\n        return (dsn.path ? \"/\" + dsn.path : '') + \"/api/\" + dsn.projectId + \"/store/\";\n    };\n    /**\n     * Returns an object that can be used in request headers.\n     * This is needed for node and the old /store endpoint in sentry\n     */\n    API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n        var dsn = this._dsnObject;\n        var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n        header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n        header.push(\"sentry_key=\" + dsn.user);\n        if (dsn.pass) {\n            header.push(\"sentry_secret=\" + dsn.pass);\n        }\n        return {\n            'Content-Type': 'application/json',\n            'X-Sentry-Auth': header.join(', '),\n        };\n    };\n    /** Returns the url to the report dialog endpoint. */\n    API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n        if (dialogOptions === void 0) { dialogOptions = {}; }\n        var dsn = this._dsnObject;\n        var endpoint = this.getBaseApiEndpoint() + \"embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\n            if (key === 'dsn') {\n                continue;\n            }\n            if (key === 'user') {\n                if (!dialogOptions.user) {\n                    continue;\n                }\n                if (dialogOptions.user.name) {\n                    encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n                }\n                if (dialogOptions.user.email) {\n                    encodedOptions.push(\"email=\" + encodeURIComponent(dialogOptions.user.email));\n                }\n            }\n            else {\n                encodedOptions.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(dialogOptions[key]));\n            }\n        }\n        if (encodedOptions.length) {\n            return endpoint + \"?\" + encodedOptions.join('&');\n        }\n        return endpoint;\n    };\n    /** Returns the envelope endpoint URL. */\n    API.prototype._getEnvelopeEndpoint = function () {\n        return this._getIngestEndpoint('envelope');\n    };\n    /** Returns the ingest API endpoint for target. */\n    API.prototype._getIngestEndpoint = function (target) {\n        var base = this.getBaseApiEndpoint();\n        var dsn = this._dsnObject;\n        return \"\" + base + dsn.projectId + \"/\" + target + \"/\";\n    };\n    /** Returns a URL-encoded string with auth config suitable for a query string. */\n    API.prototype._encodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            // We send only the minimum set of required information. See\n            // https://github.com/getsentry/sentry-javascript/issues/2572.\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        return Object(__WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"O\" /* urlEncode */])(auth);\n    };\n    return API;\n}());\n\n//# sourceMappingURL=api.js.map\n\n/***/ }),\n\n/***/ 2751:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return BaseClient; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_hub__ = __webpack_require__(2539);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__integration__ = __webpack_require__(2752);\n\n/* eslint-disable max-lines */\n\n\n\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\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 via the backend, 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<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nvar BaseClient = /** @class */ (function () {\n    /**\n     * Initializes this client instance.\n     *\n     * @param backendClass A constructor function to create the backend.\n     * @param options Options for the client.\n     */\n    function BaseClient(backendClass, options) {\n        /** Array of used integrations. */\n        this._integrations = {};\n        /** Number of call being processed */\n        this._processing = 0;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"a\" /* Dsn */](options.dsn);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._process(this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        var promisedEvent = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"B\" /* isPrimitive */])(message)\n            ? this._getBackend().eventFromMessage(String(message), level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        this._process(promisedEvent\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var eventId = hint && hint.event_id;\n        this._process(this._captureEvent(event, hint, scope).then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureSession = function (session) {\n        if (!session.release) {\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn('Discarded session because of missing release');\n        }\n        else {\n            this._sendSession(session);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getDsn = function () {\n        return this._dsn;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getOptions = function () {\n        return this._options;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.flush = function (timeout) {\n        var _this = this;\n        return this._isClientProcessing(timeout).then(function (ready) {\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return ready && transportFlushed; });\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.close = function (timeout) {\n        var _this = this;\n        return this.flush(timeout).then(function (result) {\n            _this.getOptions().enabled = false;\n            return result;\n        });\n    };\n    /**\n     * Sets up the integrations\n     */\n    BaseClient.prototype.setupIntegrations = function () {\n        if (this._isEnabled()) {\n            this._integrations = Object(__WEBPACK_IMPORTED_MODULE_4__integration__[\"a\" /* setupIntegrations */])(this._options);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        }\n        catch (_oO) {\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Updates existing session based on the provided event */\n    BaseClient.prototype._updateSessionFromEvent = function (session, event) {\n        var e_1, _a;\n        var crashed = false;\n        var errored = false;\n        var userAgent;\n        var exceptions = event.exception && event.exception.values;\n        if (exceptions) {\n            errored = true;\n            try {\n                for (var exceptions_1 = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"h\" /* __values */])(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {\n                    var ex = exceptions_1_1.value;\n                    var mechanism = ex.mechanism;\n                    if (mechanism && mechanism.handled === false) {\n                        crashed = true;\n                        break;\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        }\n        var user = event.user;\n        if (!session.userAgent) {\n            var headers = event.request ? event.request.headers : {};\n            for (var key in headers) {\n                if (key.toLowerCase() === 'user-agent') {\n                    userAgent = headers[key];\n                    break;\n                }\n            }\n        }\n        session.update(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, (crashed && { status: __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"a\" /* SessionStatus */].Crashed })), { user: user,\n            userAgent: userAgent, errors: session.errors + Number(errored || crashed) }));\n    };\n    /** Deliver captured session to Sentry */\n    BaseClient.prototype._sendSession = function (session) {\n        this._getBackend().sendSession(session);\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"d\" /* SyncPromise */](function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = setInterval(function () {\n                if (_this._processing == 0) {\n                    clearInterval(interval);\n                    resolve(true);\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        clearInterval(interval);\n                        resolve(false);\n                    }\n                }\n            }, tick);\n        });\n    };\n    /** Returns the current backend. */\n    BaseClient.prototype._getBackend = function () {\n        return this._backend;\n    };\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n    BaseClient.prototype._isEnabled = function () {\n        return this.getOptions().enabled !== false && this._dsn !== undefined;\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    BaseClient.prototype._prepareEvent = function (event, scope, hint) {\n        var _this = this;\n        var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;\n        var prepared = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"P\" /* uuid4 */])()), timestamp: event.timestamp || Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"j\" /* dateTimestampInSeconds */])() });\n        this._applyClientOptions(prepared);\n        this._applyIntegrationsMetadata(prepared);\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        var finalScope = scope;\n        if (hint && hint.captureContext) {\n            finalScope = __WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"a\" /* Scope */].clone(finalScope).update(hint.captureContext);\n        }\n        // We prepare the result here with a resolved Event.\n        var result = __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"d\" /* SyncPromise */].resolve(prepared);\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            // In case we have a hub we reassign it.\n            result = finalScope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n                return _this._normalizeEvent(evt, normalizeDepth);\n            }\n            return evt;\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    BaseClient.prototype._normalizeEvent = function (event, depth) {\n        if (!event) {\n            return null;\n        }\n        var normalized = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event), (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, b), (b.data && {\n                data: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"F\" /* normalize */])(b.data, depth),\n            }))); }),\n        })), (event.user && {\n            user: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"F\" /* normalize */])(event.user, depth),\n        })), (event.contexts && {\n            contexts: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"F\" /* normalize */])(event.contexts, depth),\n        })), (event.extra && {\n            extra: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"F\" /* normalize */])(event.extra, depth),\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) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            normalized.contexts.trace = event.contexts.trace;\n        }\n        return normalized;\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    BaseClient.prototype._applyClientOptions = function (event) {\n        var options = this.getOptions();\n        var environment = options.environment, release = options.release, dist = options.dist, _a = options.maxValueLength, maxValueLength = _a === void 0 ? 250 : _a;\n        if (!('environment' in event)) {\n            event.environment = 'environment' in options ? environment : 'production';\n        }\n        if (event.release === undefined && release !== undefined) {\n            event.release = release;\n        }\n        if (event.dist === undefined && dist !== undefined) {\n            event.dist = dist;\n        }\n        if (event.message) {\n            event.message = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"N\" /* truncate */])(event.message, maxValueLength);\n        }\n        var exception = event.exception && event.exception.values && event.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"N\" /* truncate */])(exception.value, maxValueLength);\n        }\n        var request = event.request;\n        if (request && request.url) {\n            request.url = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"N\" /* truncate */])(request.url, maxValueLength);\n        }\n    };\n    /**\n     * This function adds all used integrations to the SDK info in the event.\n     * @param sdkInfo The sdkInfo of the event that will be filled with all integrations.\n     */\n    BaseClient.prototype._applyIntegrationsMetadata = function (event) {\n        var sdkInfo = event.sdk;\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\n        }\n    };\n    /**\n     * Tells the backend to send this event\n     * @param event The Sentry event to send\n     */\n    BaseClient.prototype._sendEvent = function (event) {\n        this._getBackend().sendEvent(event);\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    BaseClient.prototype._captureEvent = function (event, hint, scope) {\n        return this._processEvent(event, hint, scope).then(function (finalEvent) {\n            return finalEvent.event_id;\n        }, function (reason) {\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].error(reason);\n            return undefined;\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    BaseClient.prototype._processEvent = function (event, hint, scope) {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"d\" /* SyncPromise */].reject(new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */]('SDK not enabled, will not send event.'));\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            return __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"d\" /* SyncPromise */].reject(new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */](\"Discarding event because it's not included in the random sample (sampling rate = \" + sampleRate + \")\"));\n        }\n        return this._prepareEvent(event, scope, hint)\n            .then(function (prepared) {\n            if (prepared === null) {\n                throw new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */]('An event processor returned null, will not send event.');\n            }\n            var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n            if (isInternalException || isTransaction || !beforeSend) {\n                return prepared;\n            }\n            var beforeSendResult = beforeSend(prepared, hint);\n            if (typeof beforeSendResult === 'undefined') {\n                throw new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */]('`beforeSend` method has to return `null` or a valid event.');\n            }\n            else if (Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"D\" /* isThenable */])(beforeSendResult)) {\n                return beforeSendResult.then(function (event) { return event; }, function (e) {\n                    throw new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */](\"beforeSend rejected with \" + e);\n                });\n            }\n            return beforeSendResult;\n        })\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                throw new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */]('`beforeSend` returned `null`, will not send event.');\n            }\n            var session = scope && scope.getSession && scope.getSession();\n            if (!isTransaction && session) {\n                _this._updateSessionFromEvent(session, processedEvent);\n            }\n            _this._sendEvent(processedEvent);\n            return processedEvent;\n        })\n            .then(null, function (reason) {\n            if (reason instanceof __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */]) {\n                throw reason;\n            }\n            _this.captureException(reason, {\n                data: {\n                    __sentry__: true,\n                },\n                originalException: reason,\n            });\n            throw new __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"c\" /* SentryError */](\"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     * Occupies the client with processing and event\n     */\n    BaseClient.prototype._process = function (promise) {\n        var _this = this;\n        this._processing += 1;\n        promise.then(function (value) {\n            _this._processing -= 1;\n            return value;\n        }, function (reason) {\n            _this._processing -= 1;\n            return reason;\n        });\n    };\n    return BaseClient;\n}());\n\n//# sourceMappingURL=baseclient.js.map\n\n/***/ }),\n\n/***/ 2752:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export installedIntegrations */\n/* unused harmony export getIntegrationsToSetup */\n/* unused harmony export setupIntegration */\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = setupIntegrations;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_hub__ = __webpack_require__(2539);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n\n\n\nvar installedIntegrations = [];\n/** Gets integration to install */\nfunction getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) { return i.name; });\n        var pickedIntegrationsNames_1 = [];\n        // Leave only unique default integrations, that were not overridden with provided user integrations\n        defaultIntegrations.forEach(function (defaultIntegration) {\n            if (userIntegrationsNames_1.indexOf(defaultIntegration.name) === -1 &&\n                pickedIntegrationsNames_1.indexOf(defaultIntegration.name) === -1) {\n                integrations.push(defaultIntegration);\n                pickedIntegrationsNames_1.push(defaultIntegration.name);\n            }\n        });\n        // Don't add same user integration twice\n        userIntegrations.forEach(function (userIntegration) {\n            if (pickedIntegrationsNames_1.indexOf(userIntegration.name) === -1) {\n                integrations.push(userIntegration);\n                pickedIntegrationsNames_1.push(userIntegration.name);\n            }\n        });\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    else {\n        integrations = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(defaultIntegrations);\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) { return i.name; });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));\n    }\n    return integrations;\n}\n/** Setup given integration */\nfunction setupIntegration(integration) {\n    if (installedIntegrations.indexOf(integration.name) !== -1) {\n        return;\n    }\n    integration.setupOnce(__WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"b\" /* addGlobalEventProcessor */], __WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"c\" /* getCurrentHub */]);\n    installedIntegrations.push(integration.name);\n    __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].log(\"Integration installed: \" + integration.name);\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(options) {\n    var integrations = {};\n    getIntegrationsToSetup(options).forEach(function (integration) {\n        integrations[integration.name] = integration;\n        setupIntegration(integration);\n    });\n    return integrations;\n}\n//# sourceMappingURL=integration.js.map\n\n/***/ }),\n\n/***/ 2753:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return BaseBackend; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__transports_noop__ = __webpack_require__(2665);\n\n\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nvar BaseBackend = /** @class */ (function () {\n    /** Creates a new backend instance. */\n    function BaseBackend(options) {\n        this._options = options;\n        if (!this._options.dsn) {\n            __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"E\" /* logger */].warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"c\" /* SentryError */]('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"c\" /* SentryError */]('Backend has to implement `eventFromMessage` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendEvent = function (event) {\n        this._transport.sendEvent(event).then(null, function (reason) {\n            __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"E\" /* logger */].error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendSession = function (session) {\n        if (!this._transport.sendSession) {\n            __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"E\" /* logger */].warn(\"Dropping session because custom transport doesn't implement sendSession\");\n            return;\n        }\n        this._transport.sendSession(session).then(null, function (reason) {\n            __WEBPACK_IMPORTED_MODULE_0__sentry_utils__[\"E\" /* logger */].error(\"Error while sending session: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    /**\n     * Sets up the transport so it can be used later to send requests.\n     */\n    BaseBackend.prototype._setupTransport = function () {\n        return new __WEBPACK_IMPORTED_MODULE_1__transports_noop__[\"a\" /* NoopTransport */]();\n    };\n    return BaseBackend;\n}());\n\n//# sourceMappingURL=basebackend.js.map\n\n/***/ }),\n\n/***/ 2754:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"b\"] = sessionToSentryRequest;\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = eventToSentryRequest;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n\n/** Creates a SentryRequest from an event. */\nfunction sessionToSentryRequest(session, api) {\n    var envelopeHeaders = JSON.stringify({\n        sent_at: new Date().toISOString(),\n    });\n    var itemHeaders = JSON.stringify({\n        type: 'session',\n    });\n    return {\n        body: envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + JSON.stringify(session),\n        type: 'session',\n        url: api.getEnvelopeEndpointWithUrlEncodedAuth(),\n    };\n}\n/** Creates a SentryRequest from an event. */\nfunction eventToSentryRequest(event, api) {\n    // since JS has no Object.prototype.pop()\n    var _a = event.tags || {}, samplingMethod = _a.__sentry_samplingMethod, sampleRate = _a.__sentry_sampleRate, otherTags = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"f\" /* __rest */])(_a, [\"__sentry_samplingMethod\", \"__sentry_sampleRate\"]);\n    event.tags = otherTags;\n    var useEnvelope = event.type === 'transaction';\n    var req = {\n        body: JSON.stringify(event),\n        type: event.type || 'event',\n        url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),\n    };\n    // https://develop.sentry.dev/sdk/envelopes/\n    // Since we don't need to manipulate envelopes nor store them, there is no\n    // exported concept of an Envelope with operations including serialization and\n    // deserialization. Instead, we only implement a minimal subset of the spec to\n    // serialize events inline here.\n    if (useEnvelope) {\n        var envelopeHeaders = JSON.stringify({\n            event_id: event.event_id,\n            sent_at: new Date().toISOString(),\n        });\n        var itemHeaders = JSON.stringify({\n            type: event.type,\n            // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and\n            // explicitly-set sampling decisions). Are we good with that?\n            sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n        });\n        // The trailing newline is optional. We intentionally don't send it to avoid\n        // sending unnecessary bytes.\n        //\n        // const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}\\n`;\n        var envelope = envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + req.body;\n        req.body = envelope;\n    }\n    return req;\n}\n//# sourceMappingURL=request.js.map\n\n/***/ }),\n\n/***/ 2755:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = initAndBind;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_hub__ = __webpack_require__(2539);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n\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(clientClass, options) {\n    if (options.debug === true) {\n        __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"E\" /* logger */].enable();\n    }\n    var hub = Object(__WEBPACK_IMPORTED_MODULE_0__sentry_hub__[\"c\" /* getCurrentHub */])();\n    var client = new clientClass(options);\n    hub.bindClient(client);\n}\n//# sourceMappingURL=sdk.js.map\n\n/***/ }),\n\n/***/ 2756:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__functiontostring__ = __webpack_require__(2757);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"FunctionToString\", function() { return __WEBPACK_IMPORTED_MODULE_0__functiontostring__[\"a\"]; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__inboundfilters__ = __webpack_require__(2758);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"InboundFilters\", function() { return __WEBPACK_IMPORTED_MODULE_1__inboundfilters__[\"a\"]; });\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ 2757:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return FunctionToString; });\nvar originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\nvar FunctionToString = /** @class */ (function () {\n    function FunctionToString() {\n        /**\n         * @inheritDoc\n         */\n        this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.prototype.setupOnce = function () {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        originalFunctionToString = Function.prototype.toString;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        Function.prototype.toString = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var context = this.__sentry_original__ || this;\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}());\n\n//# sourceMappingURL=functiontostring.js.map\n\n/***/ }),\n\n/***/ 2758:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return InboundFilters; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_hub__ = __webpack_require__(2539);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n\n\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/** Inbound filters configurable by the user */\nvar InboundFilters = /** @class */ (function () {\n    function InboundFilters(_options) {\n        if (_options === void 0) { _options = {}; }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"b\" /* addGlobalEventProcessor */])(function (event) {\n            var hub = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_hub__[\"c\" /* getCurrentHub */])();\n            if (!hub) {\n                return event;\n            }\n            var self = hub.getIntegration(InboundFilters);\n            if (self) {\n                var client = hub.getClient();\n                var clientOptions = client ? client.getOptions() : {};\n                var options = self._mergeOptions(clientOptions);\n                if (self._shouldDropEvent(event, options)) {\n                    return null;\n                }\n            }\n            return event;\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._shouldDropEvent = function (event, options) {\n        if (this._isSentryError(event, options)) {\n            __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"n\" /* getEventDescription */])(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"n\" /* getEventDescription */])(event));\n            return true;\n        }\n        if (this._isDeniedUrl(event, options)) {\n            __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].warn(\"Event dropped due to being matched by `denyUrls` option.\\nEvent: \" + Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"n\" /* getEventDescription */])(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isAllowedUrl(event, options)) {\n            __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].warn(\"Event dropped due to not being matched by `allowUrls` option.\\nEvent: \" + Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"n\" /* getEventDescription */])(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isSentryError = function (event, options) {\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return ((event &&\n                event.exception &&\n                event.exception.values &&\n                event.exception.values[0] &&\n                event.exception.values[0].type === 'SentryError') ||\n                false);\n        }\n        catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (!options.ignoreErrors || !options.ignoreErrors.length) {\n            return false;\n        }\n        return this._getPossibleEventMessages(event).some(function (message) {\n            // Not sure why TypeScript complains here...\n            return options.ignoreErrors.some(function (pattern) { return Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"y\" /* isMatchingPattern */])(message, pattern); });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isDeniedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.denyUrls || !options.denyUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.denyUrls.some(function (pattern) { return Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"y\" /* isMatchingPattern */])(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isAllowedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.allowUrls || !options.allowUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.allowUrls.some(function (pattern) { return Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"y\" /* isMatchingPattern */])(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) { clientOptions = {}; }\n        return {\n            allowUrls: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),\n            denyUrls: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),\n            ignoreErrors: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n        };\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getPossibleEventMessages = function (event) {\n        if (event.message) {\n            return [event.message];\n        }\n        if (event.exception) {\n            try {\n                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            }\n            catch (oO) {\n                __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].error(\"Cannot extract message for event \" + Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"n\" /* getEventDescription */])(event));\n                return [];\n            }\n        }\n        return [];\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getEventFilterUrl = function (event) {\n        try {\n            if (event.stacktrace) {\n                var frames_1 = event.stacktrace.frames;\n                return (frames_1 && frames_1[frames_1.length - 1].filename) || null;\n            }\n            if (event.exception) {\n                var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n                return (frames_2 && frames_2[frames_2.length - 1].filename) || null;\n            }\n            return null;\n        }\n        catch (oO) {\n            __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"E\" /* logger */].error(\"Cannot extract url for event \" + Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"n\" /* getEventDescription */])(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}());\n\n//# sourceMappingURL=inboundfilters.js.map\n\n/***/ }),\n\n/***/ 2759:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return BrowserBackend; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__eventbuilder__ = __webpack_require__(2607);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__transports__ = __webpack_require__(2668);\n\n\n\n\n\n\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"c\" /* __extends */])(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        return Object(__WEBPACK_IMPORTED_MODULE_4__eventbuilder__[\"a\" /* eventFromException */])(this._options, exception, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"b\" /* Severity */].Info; }\n        return Object(__WEBPACK_IMPORTED_MODULE_4__eventbuilder__[\"b\" /* eventFromMessage */])(this._options, message, level, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, this._options.transportOptions), { dsn: this._options.dsn });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"K\" /* supportsFetch */])()) {\n            return new __WEBPACK_IMPORTED_MODULE_5__transports__[\"a\" /* FetchTransport */](transportOptions);\n        }\n        return new __WEBPACK_IMPORTED_MODULE_5__transports__[\"b\" /* XHRTransport */](transportOptions);\n    };\n    return BrowserBackend;\n}(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"b\" /* BaseBackend */]));\n\n//# sourceMappingURL=backend.js.map\n\n/***/ }),\n\n/***/ 2760:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return FetchTransport; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__base__ = __webpack_require__(2609);\n\n\n\n\nvar global = Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"p\" /* getGlobalObject */])();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"c\" /* __extends */])(FetchTransport, _super);\n    function FetchTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"h\" /* eventToSentryRequest */])(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"k\" /* sessionToSentryRequest */])(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var options = {\n            body: sentryRequest.body,\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"L\" /* supportsReferrerPolicy */])() ? 'origin' : ''),\n        };\n        if (this.options.fetchParameters !== undefined) {\n            Object.assign(options, this.options.fetchParameters);\n        }\n        if (this.options.headers !== undefined) {\n            options.headers = this.options.headers;\n        }\n        return this._buffer.add(new __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"d\" /* SyncPromise */](function (resolve, reject) {\n            global\n                .fetch(sentryRequest.url, options)\n                .then(function (response) {\n                var headers = {\n                    'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                    'retry-after': response.headers.get('Retry-After'),\n                };\n                _this._handleResponse({\n                    requestType: sentryRequest.type,\n                    response: response,\n                    headers: headers,\n                    resolve: resolve,\n                    reject: reject,\n                });\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(__WEBPACK_IMPORTED_MODULE_3__base__[\"a\" /* BaseTransport */]));\n\n//# sourceMappingURL=fetch.js.map\n\n/***/ }),\n\n/***/ 2761:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return XHRTransport; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__base__ = __webpack_require__(2609);\n\n\n\n\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"c\" /* __extends */])(XHRTransport, _super);\n    function XHRTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"h\" /* eventToSentryRequest */])(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"k\" /* sessionToSentryRequest */])(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer.add(new __WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"d\" /* SyncPromise */](function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState === 4) {\n                    var headers = {\n                        'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                        'retry-after': request.getResponseHeader('Retry-After'),\n                    };\n                    _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });\n                }\n            };\n            request.open('POST', sentryRequest.url);\n            for (var header in _this.options.headers) {\n                if (_this.options.headers.hasOwnProperty(header)) {\n                    request.setRequestHeader(header, _this.options.headers[header]);\n                }\n            }\n            request.send(sentryRequest.body);\n        }));\n    };\n    return XHRTransport;\n}(__WEBPACK_IMPORTED_MODULE_3__base__[\"a\" /* BaseTransport */]));\n\n//# sourceMappingURL=xhr.js.map\n\n/***/ }),\n\n/***/ 2762:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return GlobalHandlers; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__eventbuilder__ = __webpack_require__(2607);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__helpers__ = __webpack_require__(2550);\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n\n\n\n\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        var _this = this;\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (data) {\n                var error = data.error;\n                var currentHub = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || Object(__WEBPACK_IMPORTED_MODULE_5__helpers__[\"b\" /* shouldIgnoreOnError */])() || isFailedOwnDelivery) {\n                    return;\n                }\n                var client = currentHub.getClient();\n                var event = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"B\" /* isPrimitive */])(error)\n                    ? _this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n                    : _this._enhanceEventWithInitialFrame(Object(__WEBPACK_IMPORTED_MODULE_4__eventbuilder__[\"c\" /* eventFromUnknownInput */])(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: false,\n                    }), data.url, data.line, data.column);\n                Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"e\" /* addExceptionMechanism */])(event, {\n                    handled: false,\n                    type: 'onerror',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n            },\n            type: 'error',\n        });\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        var _this = this;\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (e) {\n                var error = e;\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                }\n                catch (_oO) {\n                    // no-empty\n                }\n                var currentHub = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || Object(__WEBPACK_IMPORTED_MODULE_5__helpers__[\"b\" /* shouldIgnoreOnError */])() || isFailedOwnDelivery) {\n                    return true;\n                }\n                var client = currentHub.getClient();\n                var event = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"B\" /* isPrimitive */])(error)\n                    ? _this._eventFromRejectionWithPrimitive(error)\n                    : Object(__WEBPACK_IMPORTED_MODULE_4__eventbuilder__[\"c\" /* eventFromUnknownInput */])(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: true,\n                    });\n                event.level = __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"b\" /* Severity */].Error;\n                Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"e\" /* addExceptionMechanism */])(event, {\n                    handled: false,\n                    type: 'onunhandledrejection',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n                return;\n            },\n            type: 'unhandledrejection',\n        });\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (msg, url, line, column) {\n        var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n        // If 'message' is ErrorEvent, get real message from inside\n        var message = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"v\" /* isErrorEvent */])(msg) ? msg.message : msg;\n        var name;\n        if (Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"C\" /* isString */])(message)) {\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 || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\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     */\n    GlobalHandlers.prototype._eventFromRejectionWithPrimitive = function (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    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];\n        var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n        var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n        var filename = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"C\" /* isString */])(url) && url.length > 0 ? url : Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"q\" /* getLocationHref */])();\n        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\n\n//# sourceMappingURL=globalhandlers.js.map\n\n/***/ }),\n\n/***/ 2763:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return TryCatch; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__helpers__ = __webpack_require__(2550);\n\n\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/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function TryCatch(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n        this._options = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        var global = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"p\" /* getGlobalObject */])();\n        if (this._options.setTimeout) {\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.setInterval) {\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.requestAnimationFrame) {\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        if (this._options.eventTarget) {\n            var eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(this._wrapEventTarget.bind(this));\n        }\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var originalCallback = args[0];\n            args[0] = Object(__WEBPACK_IMPORTED_MODULE_2__helpers__[\"c\" /* wrap */])(originalCallback, {\n                mechanism: {\n                    data: { function: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"o\" /* getFunctionName */])(original) },\n                    handled: true,\n                    type: 'instrument',\n                },\n            });\n            return original.apply(this, args);\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TryCatch.prototype._wrapRAF = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function (callback) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return original.call(this, Object(__WEBPACK_IMPORTED_MODULE_2__helpers__[\"c\" /* wrap */])(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"o\" /* getFunctionName */])(original),\n                    },\n                    handled: true,\n                    type: 'instrument',\n                },\n            }));\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var global = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"p\" /* getGlobalObject */])();\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = Object(__WEBPACK_IMPORTED_MODULE_2__helpers__[\"c\" /* wrap */])(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"o\" /* getFunctionName */])(fn),\n                                    target: target,\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    }\n                }\n                catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, \n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                Object(__WEBPACK_IMPORTED_MODULE_2__helpers__[\"c\" /* wrap */])(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"o\" /* getFunctionName */])(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }), options);\n            };\n        });\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (eventName, fn, options) {\n                var _a;\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 = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__sentry_wrapped__;\n                    if (originalEventHandler) {\n                        originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n                    }\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    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in xhr && typeof xhr[prop] === 'function') {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"m\" /* fill */])(xhr, prop, function (original) {\n                        var wrapOptions = {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"o\" /* getFunctionName */])(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        };\n                        // If Instrument integration has been called before TryCatch, get the name of original function\n                        if (original.__sentry_original__) {\n                            wrapOptions.mechanism.data.handler = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"o\" /* getFunctionName */])(original.__sentry_original__);\n                        }\n                        // Otherwise wrap directly\n                        return Object(__WEBPACK_IMPORTED_MODULE_2__helpers__[\"c\" /* wrap */])(original, wrapOptions);\n                    });\n                }\n            });\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\n\n//# sourceMappingURL=trycatch.js.map\n\n/***/ }),\n\n/***/ 2764:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return Breadcrumbs; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_types__ = __webpack_require__(2493);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\n\n\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Create a breadcrumb of `sentry` from the events themselves\n     */\n    Breadcrumbs.prototype.addSentryBreadcrumb = function (event) {\n        if (!this._options.sentry) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb({\n            category: \"sentry.\" + (event.type === 'transaction' ? 'transaction' : 'event'),\n            event_id: event.event_id,\n            level: event.level,\n            message: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"n\" /* getEventDescription */])(event),\n        }, {\n            event: event,\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    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"g\" /* addInstrumentationHandler */])({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console',\n            },\n            level: __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"b\" /* Severity */].fromString(handlerData.level),\n            message: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"J\" /* safeJoin */])(handlerData.args, ' '),\n        };\n        if (handlerData.level === 'assert') {\n            if (handlerData.args[0] === false) {\n                breadcrumb.message = \"Assertion failed: \" + (Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"J\" /* safeJoin */])(handlerData.args.slice(1), ' ') || 'console.assert');\n                breadcrumb.data.arguments = handlerData.args.slice(1);\n            }\n            else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level,\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"r\" /* htmlTreeAsString */])(handlerData.event.target)\n                : Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"r\" /* htmlTreeAsString */])(handlerData.event);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: handlerData.event,\n            name: handlerData.name,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._xhrBreadcrumb = function (handlerData) {\n        if (handlerData.endTimestamp) {\n            // We only capture complete, non-sentry requests\n            if (handlerData.xhr.__sentry_own_request__) {\n                return;\n            }\n            var _a = handlerData.xhr.__sentry_xhr__ || {}, method = _a.method, url = _a.url, status_code = _a.status_code, body = _a.body;\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb({\n                category: 'xhr',\n                data: {\n                    method: method,\n                    url: url,\n                    status_code: status_code,\n                },\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n                input: body,\n            });\n            return;\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\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        if (handlerData.error) {\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb({\n                category: 'fetch',\n                data: handlerData.fetchData,\n                level: __WEBPACK_IMPORTED_MODULE_2__sentry_types__[\"b\" /* Severity */].Error,\n                type: 'http',\n            }, {\n                data: handlerData.error,\n                input: handlerData.args,\n            });\n        }\n        else {\n            Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb({\n                category: 'fetch',\n                data: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, handlerData.fetchData), { status_code: handlerData.response.status }),\n                type: 'http',\n            }, {\n                input: handlerData.args,\n                response: handlerData.response,\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from history API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"p\" /* getGlobalObject */])();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"I\" /* parseUrl */])(global.location.href);\n        var parsedFrom = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"I\" /* parseUrl */])(from);\n        var parsedTo = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"I\" /* parseUrl */])(to);\n        // Initial pushState doesn't provide `from` information\n        if (!parsedFrom.path) {\n            parsedFrom = parsedLoc;\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        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\n\n//# sourceMappingURL=breadcrumbs.js.map\n\n/***/ }),\n\n/***/ 2765:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return LinkedErrors; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__parsers__ = __webpack_require__(2667);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__tracekit__ = __webpack_require__(2608);\n\n\n\n\n\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"e\" /* addGlobalEventProcessor */])(function (event, hint) {\n            var self = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().getIntegration(LinkedErrors);\n            if (self) {\n                return self._handler(event, hint);\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"x\" /* isInstanceOf */])(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"x\" /* isInstanceOf */])(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = Object(__WEBPACK_IMPORTED_MODULE_4__tracekit__[\"a\" /* computeStackTrace */])(error[key]);\n        var exception = Object(__WEBPACK_IMPORTED_MODULE_3__parsers__[\"c\" /* exceptionFromStacktrace */])(stacktrace);\n        return this._walkErrorTree(error[key], key, Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\n\n//# sourceMappingURL=linkederrors.js.map\n\n/***/ }),\n\n/***/ 2766:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return UserAgent; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_utils__ = __webpack_require__(2440);\n\n\n\nvar global = Object(__WEBPACK_IMPORTED_MODULE_2__sentry_utils__[\"p\" /* getGlobalObject */])();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"e\" /* addGlobalEventProcessor */])(function (event) {\n            var _a, _b, _c;\n            if (Object(__WEBPACK_IMPORTED_MODULE_1__sentry_core__[\"i\" /* getCurrentHub */])().getIntegration(UserAgent)) {\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                // grab as much info as exists and add it to the event\n                var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global.location) === null || _b === void 0 ? void 0 : _b.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));\n                var request = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, (url && { url: url })), { headers: headers });\n                return Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event), { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\n\n//# sourceMappingURL=useragent.js.map\n\n/***/ }),\n\n/***/ 2767:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return defaultIntegrations; });\n/* unused harmony export init */\n/* unused harmony export showReportDialog */\n/* unused harmony export lastEventId */\n/* unused harmony export forceLoad */\n/* unused harmony export onLoad */\n/* unused harmony export flush */\n/* unused harmony export close */\n/* unused harmony export wrap */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__client__ = __webpack_require__(2666);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__helpers__ = __webpack_require__(2550);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__integrations__ = __webpack_require__(2610);\n\n\n\n\n\nvar defaultIntegrations = [\n    new __WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"d\" /* Integrations */].InboundFilters(),\n    new __WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"d\" /* Integrations */].FunctionToString(),\n    new __WEBPACK_IMPORTED_MODULE_4__integrations__[\"TryCatch\"](),\n    new __WEBPACK_IMPORTED_MODULE_4__integrations__[\"Breadcrumbs\"](),\n    new __WEBPACK_IMPORTED_MODULE_4__integrations__[\"GlobalHandlers\"](),\n    new __WEBPACK_IMPORTED_MODULE_4__integrations__[\"LinkedErrors\"](),\n    new __WEBPACK_IMPORTED_MODULE_4__integrations__[\"UserAgent\"](),\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 === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"p\" /* getGlobalObject */])();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    if (options.autoSessionTracking === undefined) {\n        options.autoSessionTracking = false;\n    }\n    Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"j\" /* initAndBind */])(__WEBPACK_IMPORTED_MODULE_2__client__[\"a\" /* BrowserClient */], options);\n    if (options.autoSessionTracking) {\n        startSessionTracking();\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) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        options.eventId = Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"i\" /* getCurrentHub */])().lastEventId();\n    }\n    var client = Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"i\" /* getCurrentHub */])().getClient();\n    if (client) {\n        client.showReportDialog(options);\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 Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"i\" /* getCurrentHub */])().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n    // Noop\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 * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nfunction flush(timeout) {\n    var client = Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"i\" /* getCurrentHub */])().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"d\" /* SyncPromise */].reject(false);\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nfunction close(timeout) {\n    var client = Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"i\" /* getCurrentHub */])().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return __WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"d\" /* SyncPromise */].reject(false);\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction wrap(fn) {\n    return Object(__WEBPACK_IMPORTED_MODULE_3__helpers__[\"c\" /* wrap */])(fn)();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n    var window = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_utils__[\"p\" /* getGlobalObject */])();\n    var hub = Object(__WEBPACK_IMPORTED_MODULE_0__sentry_core__[\"i\" /* getCurrentHub */])();\n    /**\n     * We should be using `Promise.all([windowLoaded, firstContentfulPaint])` here,\n     * but, as always, it's not available in the IE10-11. Thanks IE.\n     */\n    var loadResolved = document.readyState === 'complete';\n    var fcpResolved = false;\n    var possiblyEndSession = function () {\n        if (fcpResolved && loadResolved) {\n            hub.endSession();\n        }\n    };\n    var resolveWindowLoaded = function () {\n        loadResolved = true;\n        possiblyEndSession();\n        window.removeEventListener('load', resolveWindowLoaded);\n    };\n    hub.startSession();\n    if (!loadResolved) {\n        // IE doesn't support `{ once: true }` for event listeners, so we have to manually\n        // attach and then detach it once completed.\n        window.addEventListener('load', resolveWindowLoaded);\n    }\n    try {\n        var po = new PerformanceObserver(function (entryList, po) {\n            entryList.getEntries().forEach(function (entry) {\n                if (entry.name === 'first-contentful-paint' && entry.startTime < firstHiddenTime_1) {\n                    po.disconnect();\n                    fcpResolved = true;\n                    possiblyEndSession();\n                }\n            });\n        });\n        // There's no need to even attach this listener if `PerformanceObserver` constructor will fail,\n        // so we do it below here.\n        var firstHiddenTime_1 = document.visibilityState === 'hidden' ? 0 : Infinity;\n        document.addEventListener('visibilitychange', function (event) {\n            firstHiddenTime_1 = Math.min(firstHiddenTime_1, event.timeStamp);\n        }, { once: true });\n        po.observe({\n            type: 'paint',\n            buffered: true,\n        });\n    }\n    catch (e) {\n        fcpResolved = true;\n        possiblyEndSession();\n    }\n}\n//# sourceMappingURL=sdk.js.map\n\n/***/ }),\n\n/***/ 2768:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export init */\n/* unused harmony export getActiveTransaction */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_browser__ = __webpack_require__(2578);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__sentry_core__ = __webpack_require__(2450);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__sentry_utils__ = __webpack_require__(2440);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__eventprocessor__ = __webpack_require__(2769);\n\n/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n\n\n\n// Mappings from operation to corresponding lifecycle hook.\nvar HOOKS = {\n    activate: ['activated', 'deactivated'],\n    create: ['beforeCreate', 'created'],\n    destroy: ['beforeDestroy', 'destroyed'],\n    mount: ['beforeMount', 'mounted'],\n    update: ['beforeUpdate', 'updated'],\n};\nvar COMPONENT_NAME_REGEXP = /(?:^|[-_/])(\\w)/g;\nvar ROOT_COMPONENT_NAME = 'root';\nvar ANONYMOUS_COMPONENT_NAME = 'anonymous component';\n/**\n * Inits the Vue SDK\n */\nfunction init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = __WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"f\" /* defaultIntegrations */];\n    }\n    if (options.release === undefined) {\n        var window_1 = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"p\" /* getGlobalObject */])();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    var finalOptions = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ \n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        Vue: Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"p\" /* getGlobalObject */])().Vue, attachProps: true, logErrors: false, tracing: false }, options), { tracingOptions: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({ hooks: ['activate', 'mount', 'update'], timeout: 2000, trackComponents: false }, options.tracingOptions) });\n    Object(__WEBPACK_IMPORTED_MODULE_2__sentry_core__[\"j\" /* initAndBind */])(__WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"a\" /* BrowserClient */], finalOptions);\n    if (finalOptions.Vue === undefined) {\n        __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn('No Vue instance was provided. Also there is no Vue instance on the `window` object.');\n        __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn('We will only capture global unhandled errors.');\n    }\n    else {\n        var vueHelper = new VueHelper(finalOptions);\n        vueHelper.setup();\n    }\n    Object(__WEBPACK_IMPORTED_MODULE_4__eventprocessor__[\"a\" /* createVueEventProcessor */])();\n}\n/** JSDoc */\nvar VueHelper = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function VueHelper(options) {\n        var _this = this;\n        /**\n         * Cache holding already processed component names\n         */\n        this._componentsCache = {};\n        /** Keep it as attribute function, to keep correct `this` binding inside the hooks callbacks  */\n        // eslint-disable-next-line @typescript-eslint/typedef\n        this._applyTracingHooks = function (vm) {\n            // Don't attach twice, just in case\n            if (vm.$options.$_sentryPerfHook) {\n                return;\n            }\n            vm.$options.$_sentryPerfHook = true;\n            var name = _this._getComponentName(vm);\n            var rootMount = name === ROOT_COMPONENT_NAME;\n            var spans = {};\n            // Render hook starts after once event is emitted,\n            // but it ends before the second event of the same type.\n            //\n            // Because of this, we start measuring inside the first event,\n            // but finish it before it triggers, to skip the event emitter timing itself.\n            var rootHandler = function (hook) {\n                var now = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"M\" /* timestampWithMs */])();\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (_this._rootSpan) {\n                    _this._finishRootSpan(now);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        // Create an activity on the first event call. There'll be no second call, as rootSpan will be in place,\n                        // thus new event handler won't be attached.\n                        var activeTransaction = getActiveTransaction();\n                        if (activeTransaction) {\n                            _this._rootSpan = activeTransaction.startChild({\n                                description: 'Application Render',\n                                op: 'Vue',\n                            });\n                        }\n                    });\n                }\n            };\n            var childHandler = function (hook, operation) {\n                // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n                var shouldTrack = Array.isArray(_this._options.tracingOptions.trackComponents)\n                    ? _this._options.tracingOptions.trackComponents.indexOf(name) > -1\n                    : _this._options.tracingOptions.trackComponents;\n                var childOf = _this._rootSpan || getActiveTransaction();\n                if (!childOf || !shouldTrack) {\n                    return;\n                }\n                var now = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"M\" /* timestampWithMs */])();\n                var span = spans[operation];\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (span) {\n                    span.finish();\n                    _this._finishRootSpan(now);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        if (childOf) {\n                            spans[operation] = childOf.startChild({\n                                description: \"Vue <\" + name + \">\",\n                                op: operation,\n                            });\n                        }\n                    });\n                }\n            };\n            // Each component has it's own scope, so all activities are only related to one of them\n            _this._options.tracingOptions.hooks.forEach(function (operation) {\n                // Retrieve corresponding hooks from Vue lifecycle.\n                // eg. mount => ['beforeMount', 'mounted']\n                var internalHooks = HOOKS[operation];\n                if (!internalHooks) {\n                    __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn(\"Unknown hook: \" + operation);\n                    return;\n                }\n                internalHooks.forEach(function (internalHook) {\n                    var handler = rootMount\n                        ? rootHandler.bind(_this, internalHook)\n                        : childHandler.bind(_this, internalHook, operation);\n                    var currentValue = vm.$options[internalHook];\n                    if (Array.isArray(currentValue)) {\n                        vm.$options[internalHook] = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])([handler], currentValue);\n                    }\n                    else if (typeof currentValue === 'function') {\n                        vm.$options[internalHook] = [handler, currentValue];\n                    }\n                    else {\n                        vm.$options[internalHook] = [handler];\n                    }\n                });\n            });\n        };\n        this._options = options;\n    }\n    /**\n     * Attaches the error handler and starts tracing\n     */\n    VueHelper.prototype.setup = function () {\n        this._attachErrorHandler();\n        if ('tracesSampleRate' in this._options || 'tracesSampler' in this._options) {\n            this._startTracing();\n        }\n    };\n    /**\n     * Extract component name from the ViewModel\n     */\n    VueHelper.prototype._getComponentName = function (vm) {\n        // Such level of granularity is most likely not necessary, but better safe than sorry. — Kamil\n        if (!vm) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$root === vm) {\n            return ROOT_COMPONENT_NAME;\n        }\n        if (!vm.$options) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$options.name) {\n            return vm.$options.name;\n        }\n        if (vm.$options._componentTag) {\n            return vm.$options._componentTag;\n        }\n        // injected by vue-loader\n        if (vm.$options.__file) {\n            var unifiedFile = vm.$options.__file.replace(/^[a-zA-Z]:/, '').replace(/\\\\/g, '/');\n            var filename = Object(__WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"h\" /* basename */])(unifiedFile, '.vue');\n            return (this._componentsCache[filename] ||\n                (this._componentsCache[filename] = filename.replace(COMPONENT_NAME_REGEXP, function (_, c) {\n                    return c ? c.toUpperCase() : '';\n                })));\n        }\n        return ANONYMOUS_COMPONENT_NAME;\n    };\n    /** Finish top-level span and activity with a debounce configured using `timeout` option */\n    VueHelper.prototype._finishRootSpan = function (timestamp) {\n        var _this = this;\n        if (this._rootSpanTimer) {\n            clearTimeout(this._rootSpanTimer);\n        }\n        this._rootSpanTimer = setTimeout(function () {\n            // We should always finish the span, only should pop activity if using @sentry/apm\n            if (_this._rootSpan) {\n                _this._rootSpan.finish(timestamp);\n                _this._rootSpan = undefined;\n            }\n        }, this._options.tracingOptions.timeout);\n    };\n    /** Inject configured tracing hooks into Vue's component lifecycles */\n    VueHelper.prototype._startTracing = function () {\n        var applyTracingHooks = this._applyTracingHooks;\n        var appliedTracingHooks = setTimeout(function () {\n            __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn(\"Didn't apply tracing hooks, make sure you call Sentry.init before initialzing Vue!\");\n        }, 500);\n        this._options.Vue.mixin({\n            beforeCreate: function () {\n                clearTimeout(appliedTracingHooks);\n                applyTracingHooks(this);\n            },\n        });\n    };\n    /** Inject Sentry's handler into owns Vue's error handler  */\n    VueHelper.prototype._attachErrorHandler = function () {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var currentErrorHandler = this._options.Vue.config.errorHandler;\n        this._options.Vue.config.errorHandler = function (error, vm, info) {\n            var metadata = {};\n            if (vm) {\n                try {\n                    metadata.componentName = _this._getComponentName(vm);\n                    if (_this._options.attachProps) {\n                        metadata.propsData = vm.$options.propsData;\n                    }\n                }\n                catch (_oO) {\n                    __WEBPACK_IMPORTED_MODULE_3__sentry_utils__[\"E\" /* logger */].warn('Unable to extract metadata from Vue component.');\n                }\n            }\n            if (info) {\n                metadata.lifecycleHook = info;\n            }\n            // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n            setTimeout(function () {\n                Object(__WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"g\" /* getCurrentHub */])().withScope(function (scope) {\n                    scope.setContext('vue', metadata);\n                    Object(__WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"g\" /* getCurrentHub */])().captureException(error);\n                });\n            });\n            if (typeof currentErrorHandler === 'function') {\n                currentErrorHandler.call(_this._options.Vue, error, vm, info);\n            }\n            if (_this._options.logErrors) {\n                if (_this._options.Vue.util) {\n                    _this._options.Vue.util.warn(\"Error in \" + info + \": \\\"\" + error.toString() + \"\\\"\", vm);\n                }\n                // eslint-disable-next-line no-console\n                console.error(error);\n            }\n        };\n    };\n    return VueHelper;\n}());\n/** Grabs active transaction off scope, if any */\nfunction getActiveTransaction() {\n    var _a;\n    return (_a = Object(__WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"g\" /* getCurrentHub */])()\n        .getScope()) === null || _a === void 0 ? void 0 : _a.getTransaction();\n}\n//# sourceMappingURL=sdk.js.map\n\n/***/ }),\n\n/***/ 2769:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (immutable) */ __webpack_exports__[\"a\"] = createVueEventProcessor;\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(14);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__sentry_browser__ = __webpack_require__(2578);\n\n\n/**\n * A global side effect that makes sure Sentry events that user\n * `@sentry/react` will correctly have Sentry events associated\n * with it.\n */\nfunction createVueEventProcessor() {\n    Object(__WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"c\" /* addGlobalEventProcessor */])(function (event) {\n        event.sdk = Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])(Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __assign */])({}, event.sdk), { name: 'sentry.javascript.vue', packages: Object(__WEBPACK_IMPORTED_MODULE_0_tslib__[\"g\" /* __spread */])(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/vue',\n                    version: __WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"b\" /* SDK_VERSION */],\n                },\n            ]), version: __WEBPACK_IMPORTED_MODULE_1__sentry_browser__[\"b\" /* SDK_VERSION */] });\n        return event;\n    });\n}\n//# sourceMappingURL=eventprocessor.js.map\n\n/***/ }),\n\n/***/ 2770:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export vueRouterInstrumentation */\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__sentry_browser__ = __webpack_require__(2578);\n\nvar firstLoad = true;\n/**\n * Creates routing instrumentation for Vue Router v2\n *\n * @param router The Vue Router instance that is used\n */\nfunction vueRouterInstrumentation(router) {\n    return function (startTransaction, startTransactionOnPageLoad, startTransactionOnLocationChange) {\n        if (startTransactionOnPageLoad === void 0) { startTransactionOnPageLoad = true; }\n        if (startTransactionOnLocationChange === void 0) { startTransactionOnLocationChange = true; }\n        router.onError(function (error) { return Object(__WEBPACK_IMPORTED_MODULE_0__sentry_browser__[\"d\" /* captureException */])(error); });\n        var tags = {\n            'routing.instrumentation': 'vue-router',\n        };\n        router.beforeEach(function (to, _from, next) {\n            var data = {\n                params: to.params,\n                query: to.query,\n            };\n            if (startTransactionOnPageLoad && firstLoad) {\n                startTransaction({\n                    name: to.name || to.path,\n                    op: 'pageload',\n                    tags: tags,\n                    data: data,\n                });\n            }\n            if (startTransactionOnLocationChange && !firstLoad) {\n                startTransaction({\n                    name: to.name || to.matched[0].path || to.path,\n                    op: 'navigation',\n                    tags: tags,\n                    data: data,\n                });\n            }\n            firstLoad = false;\n            next();\n        });\n    };\n}\n//# sourceMappingURL=vuerouter.js.map\n\n/***/ }),\n\n/***/ 2771:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nvar render = function() {\n  var _vm = this\n  var _h = _vm.$createElement\n  var _c = _vm._self._c || _h\n  return _c(\n    \"div\",\n    [\n      _c(\n        \"b-modal\",\n        {\n          attrs: {\n            centered: \"\",\n            \"cancel-disabled\": \"\",\n            \"no-close-on-esc\": \"\",\n            \"no-close-on-backdrop\": \"\",\n            \"hide-header-close\": \"\",\n            title: _vm.getErrorTitle,\n            \"hide-footer\": \"\"\n          },\n          model: {\n            value: _vm.modalShow,\n            callback: function($$v) {\n              _vm.modalShow = $$v\n            },\n            expression: \"modalShow\"\n          }\n        },\n        [\n          !_vm.supportChatVisible\n            ? _c(\"div\", { staticClass: \"text-center\" }, [\n                _c(\"div\", { staticClass: \"mx-auto error-img\" }, [\n                  _c(\"img\", {\n                    attrs: {\n                      width: \"96px\",\n                      height: \"96px\",\n                      src: _vm.getErrorImg\n                    }\n                  })\n                ]),\n                _vm._v(\" \"),\n                _c(\"p\", {\n                  staticClass: \"text-center\",\n                  class: { \"text-danger\": !_vm.customError },\n                  domProps: { innerHTML: _vm._s(_vm.getErrorMsg) }\n                }),\n                _vm._v(\" \"),\n                !_vm.customError\n                  ? _c(\"div\", [\n                      _c(\n                        \"a\",\n                        {\n                          staticClass: \"clickable small\",\n                          on: { click: _vm.toggleShowDetailedError }\n                        },\n                        [\n                          _vm._v(\n                            _vm._s(\n                              _vm.showDetailedError\n                                ? _vm.$t(\"hide-detailed-error\")\n                                : _vm.$t(\"show-detailed-error\")\n                            )\n                          )\n                        ]\n                      ),\n                      _vm._v(\" \"),\n                      _vm.showDetailedError\n                        ? _c(\"div\", { staticClass: \"code-format mt-2\" }, [\n                            _vm._v(\"\\n          Error: \"),\n                            _c(\"b\", [_vm._v(_vm._s(_vm.opentok.error.title))]),\n                            _c(\"br\"),\n                            _vm._v(\n                              \"\\n          \" +\n                                _vm._s(_vm.opentok.error.msg) +\n                                \"\\n        \"\n                            )\n                          ])\n                        : _vm._e()\n                    ])\n                  : _vm._e(),\n                _vm._v(\" \"),\n                _vm.getCustomErrorBtnMsg !== \"\"\n                  ? _c(\n                      \"div\",\n                      { staticClass: \"col text-center pt-3\" },\n                      [\n                        (_vm.smallToken = !\"\" && !_vm.getCustomErrorBtnMsg)\n                          ? _c(\n                              \"b-button\",\n                              {\n                                attrs: {\n                                  center: \"\",\n                                  \"align-h\": \"center\",\n                                  variant: \"outline-\" + _vm.getErrorColorVariant\n                                },\n                                on: { click: _vm.pageReload }\n                              },\n                              [\n                                _c(\"b-icon\", {\n                                  attrs: {\n                                    icon: \"arrow-counterclockwise\",\n                                    \"aria-hidden\": \"true\"\n                                  }\n                                }),\n                                _vm._v(\" \" + _vm._s(_vm.$t(\"retry\")))\n                              ],\n                              1\n                            )\n                          : _vm._e(),\n                        _vm._v(\" \"),\n                        _vm.getCustomErrorBtnMsg\n                          ? _c(\n                              \"b-button\",\n                              {\n                                attrs: {\n                                  center: \"\",\n                                  \"align-h\": \"center\",\n                                  variant: \"outline-\" + _vm.getErrorColorVariant\n                                },\n                                on: { click: _vm.doCustomErrorAction }\n                              },\n                              [\n                                _vm._v(\n                                  \"\\n          \" +\n                                    _vm._s(_vm.getCustomErrorBtnMsg) +\n                                    \"\\n        \"\n                                )\n                              ]\n                            )\n                          : _vm._e()\n                      ],\n                      1\n                    )\n                  : _vm._e()\n              ])\n            : _c(\"div\", [_c(\"hubspot-chat\")], 1),\n          _vm._v(\" \"),\n          _c(\n            \"div\",\n            { staticClass: \"text-center mt-4\" },\n            [\n              _c(\n                \"b-button\",\n                {\n                  attrs: { variant: \"outline-info\", size: \"sm\" },\n                  on: {\n                    click: function($event) {\n                      return _vm.$helpers.openSupportChat()\n                    }\n                  }\n                },\n                [\n                  _vm._v(\n                    _vm._s(\n                      _vm.supportChatVisible\n                        ? _vm.$t(\"back\")\n                        : _vm.$t(\"contact-by-chat-tech-problems\")\n                    )\n                  )\n                ]\n              )\n            ],\n            1\n          )\n        ]\n      )\n    ],\n    1\n  )\n}\nvar staticRenderFns = []\nrender._withStripped = true\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\n/* harmony default export */ __webpack_exports__[\"a\"] = (esExports);\nif (false) {\n  module.hot.accept()\n  if (module.hot.data) {\n    require(\"vue-hot-reload-api\")      .rerender(\"data-v-23316cdb\", esExports)\n  }\n}\n\n/***/ })\n\n});\n\n\n// WEBPACK FOOTER //\n// static-appopensalud/js/45.65d5988866b3909a4295.js","var disposed = false\nfunction injectStyle (ssrContext) {\n  if (disposed) return\n  require(\"!!vue-style-loader!css-loader?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!less-loader?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector?type=styles&index=0!./HubspotChat.vue\")\n}\nvar normalizeComponent = require(\"!../../../node_modules/vue-loader/lib/component-normalizer\")\n/* script */\nexport * from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./HubspotChat.vue\"\nimport __vue_script__ from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./HubspotChat.vue\"\n/* template */\nimport __vue_template__ from \"!!../../../node_modules/vue-loader/lib/template-compiler/index?{\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"hasScoped\\\":false,\\\"transformToRequire\\\":{\\\"video\\\":[\\\"src\\\",\\\"poster\\\"],\\\"source\\\":\\\"src\\\",\\\"img\\\":\\\"src\\\",\\\"image\\\":\\\"xlink:href\\\"},\\\"buble\\\":{\\\"transforms\\\":{}}}!../../../node_modules/vue-loader/lib/selector?type=template&index=0!./HubspotChat.vue\"\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __vue_script__,\n  __vue_template__,\n  __vue_template_functional__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\nComponent.options.__file = \"src/components/public/HubspotChat.vue\"\n\n/* hot reload */\nif (module.hot) {(function () {\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), false)\n  if (!hotAPI.compatible) return\n  module.hot.accept()\n  if (!module.hot.data) {\n    hotAPI.createRecord(\"data-v-3e33ba39\", Component.options)\n  } else {\n    hotAPI.reload(\"data-v-3e33ba39\", Component.options)\n  }\n  module.hot.dispose(function (data) {\n    disposed = true\n  })\n})()}\n\nexport default Component.exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/public/HubspotChat.vue\n// module id = 1258\n// module chunks = 27 28 34 43 45","var disposed = false\nfunction injectStyle (ssrContext) {\n  if (disposed) return\n  require(\"!!vue-style-loader!css-loader?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!sass-loader?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector?type=styles&index=0!./Error.vue\")\n}\nvar normalizeComponent = require(\"!../../../node_modules/vue-loader/lib/component-normalizer\")\n/* script */\nexport * from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./Error.vue\"\nimport __vue_script__ from \"!!babel-loader!../../../node_modules/vue-loader/lib/selector?type=script&index=0!./Error.vue\"\n/* template */\nimport __vue_template__ from \"!!../../../node_modules/vue-loader/lib/template-compiler/index?{\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"hasScoped\\\":false,\\\"transformToRequire\\\":{\\\"video\\\":[\\\"src\\\",\\\"poster\\\"],\\\"source\\\":\\\"src\\\",\\\"img\\\":\\\"src\\\",\\\"image\\\":\\\"xlink:href\\\"},\\\"buble\\\":{\\\"transforms\\\":{}}}!../../../node_modules/vue-loader/lib/selector?type=template&index=0!./Error.vue\"\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n  __vue_script__,\n  __vue_template__,\n  __vue_template_functional__,\n  __vue_styles__,\n  __vue_scopeId__,\n  __vue_module_identifier__\n)\nComponent.options.__file = \"src/components/video-launcher/Error.vue\"\n\n/* hot reload */\nif (module.hot) {(function () {\n  var hotAPI = require(\"vue-hot-reload-api\")\n  hotAPI.install(require(\"vue\"), false)\n  if (!hotAPI.compatible) return\n  module.hot.accept()\n  if (!module.hot.data) {\n    hotAPI.createRecord(\"data-v-23316cdb\", Component.options)\n  } else {\n    hotAPI.reload(\"data-v-23316cdb\", Component.options)\n  }\n  module.hot.dispose(function (data) {\n    disposed = true\n  })\n})()}\n\nexport default Component.exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/video-launcher/Error.vue\n// module id = 2351\n// module chunks = 28 43 45","export * from './async';\nexport * from './browser';\nexport * from './dsn';\nexport * from './error';\nexport * from './instrument';\nexport * from './is';\nexport * from './logger';\nexport * from './memo';\nexport * from './misc';\nexport * from './node';\nexport * from './object';\nexport * from './path';\nexport * from './promisebuffer';\nexport * from './stacktrace';\nexport * from './string';\nexport * from './supports';\nexport * from './syncpromise';\nexport * from './time';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/index.js\n// module id = 2440\n// module chunks = 28 43 45","export { addBreadcrumb, captureException, captureEvent, captureMessage, configureScope, startTransaction, setContext, setExtra, setExtras, setTag, setTags, setUser, withScope, } from '@sentry/minimal';\nexport { addGlobalEventProcessor, getCurrentHub, getHubFromCarrier, Hub, makeMain, Scope } from '@sentry/hub';\nexport { API } from './api';\nexport { BaseClient } from './baseclient';\nexport { BaseBackend } from './basebackend';\nexport { eventToSentryRequest, sessionToSentryRequest } from './request';\nexport { initAndBind } from './sdk';\nexport { NoopTransport } from './transports/noop';\nimport * as Integrations from './integrations';\nexport { Integrations };\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/index.js\n// module id = 2450\n// module chunks = 28 43 45","export { LogLevel } from './loglevel';\nexport { SessionStatus } from './session';\nexport { Severity } from './severity';\nexport { Status } from './status';\nexport { TransactionSamplingMethod, } from './transaction';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/types/esm/index.js\n// module id = 2493\n// module chunks = 28 43 45","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat) {\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat) {\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat) {\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat, base) {\n    try {\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/is.js\n// module id = 2524\n// module chunks = 28 43 45","export { addGlobalEventProcessor, Scope } from './scope';\nexport { Session } from './session';\nexport { getActiveDomain, getCurrentHub, getHubFromCarrier, getMainCarrier, Hub, makeMain, setHubOnCarrier, } from './hub';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/index.js\n// module id = 2539\n// module chunks = 28 43 45","import { isNodeEnv } from './node';\nimport { snipLine } from './string';\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // eslint-disable-next-line no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // eslint-disable-next-line no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // eslint-disable-next-line no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // eslint-disable-next-line no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore Mechanism has no index signature\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\n}\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { linesOfContext = 5; }\n    var lineno = frame.lineno || 0;\n    var maxLines = lines.length;\n    var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return snipLine(line, 0); });\n    frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return snipLine(line, 0); });\n}\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath) {\n    // eslint-disable-next-line no-useless-escape\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n//# sourceMappingURL=misc.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/misc.js\n// module id = 2549\n// module chunks = 28 43 45","import { __assign } from \"tslib\";\nimport { API, captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, logger } from '@sentry/utils';\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nexport function ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\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.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(fn, options, before) {\n    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\n        }\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    /* eslint-disable prefer-rest-params */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        try {\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            if (fn.handleEvent) {\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                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                return fn.handleEvent.apply(this, wrappedArguments);\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        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = __assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = __assign(__assign({}, processedEvent.extra), { arguments: args });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    /* eslint-enable prefer-rest-params */\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    }\n    catch (_oO) { } // eslint-disable-line no-empty\n    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\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: function () {\n                    return fn.name;\n                },\n            });\n        }\n        // eslint-disable-next-line no-empty\n    }\n    catch (_oO) { }\n    return sentryWrapped;\n}\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        logger.error(\"Missing eventId option in showReportDialog call\");\n        return;\n    }\n    if (!options.dsn) {\n        logger.error(\"Missing dsn option in showReportDialog call\");\n        return;\n    }\n    var script = document.createElement('script');\n    script.async = true;\n    script.src = new API(options.dsn).getReportDialogEndpoint(options);\n    if (options.onLoad) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        script.onload = options.onLoad;\n    }\n    (document.head || document.body).appendChild(script);\n}\n//# sourceMappingURL=helpers.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/helpers.js\n// module id = 2550\n// module chunks = 28 43 45","<template>\r\n  <div id=\"support-chat-container\"></div>\r\n</template>\r\n\r\n<script>\r\nimport { getSmartsuppKey } from '@/constants/vendorKeys'\r\n\r\nexport default {\r\n  methods: {\r\n    loadScriptAsync: function (id) {\r\n      return new Promise((resolve, reject) => {\r\n        if (!document.getElementById(id)) {\r\n          var tag = document.createElement('script')\r\n          tag.text = `var _smartsupp = _smartsupp || {}; _smartsupp.key = '${getSmartsuppKey}';          window.smartsupp||(function(d) {            var s,c,o=smartsupp=function(){ o._.push(arguments)};o._=[];            s=d.getElementsByTagName('script')[0];c=d.createElement('script');            c.type='text/javascript';c.charset='utf-8';c.async=true;            c.src='https://www.smartsuppchat.com/loader.js?';s.parentNode.insertBefore(c,s);          })(document);`\r\n          /* tag.src = uri */\r\n          tag.type = 'text/javascript'\r\n          /* tag.async = true\r\n          tag.defer = true */\r\n          tag.setAttribute('id', id)\r\n          tag.onload = () => {\r\n            resolve()\r\n          }\r\n          document.head.appendChild(tag)\r\n        } else {\r\n          resolve()\r\n        }\r\n      })\r\n    }\r\n  },\r\n  mounted () {\r\n    // const _this = this\r\n    let vh = window.innerHeight * 0.01\r\n    document.documentElement.style.setProperty('--vh', `${vh}px`)\r\n    this.loadScriptAsync('smartsupp-script-loader').then(() => {\r\n      this.loading = false\r\n      let chatBtn = null\r\n      setTimeout(() => {\r\n        chatBtn = document.getElementById('chat-application')\r\n        if (chatBtn) {\r\n          chatBtn.click()\r\n        }\r\n      }, 2000)\r\n    })\r\n  },\r\n  created () {\r\n    /* window.hsConversationsSettings = {\r\n      loadImmediately: true,\r\n      inlineEmbedSelector: '#support-chat-container',\r\n      enableWidgetCookieBanner: false,\r\n      disableAttachment: false\r\n    } */\r\n  }\r\n}\r\n</script>\r\n\r\n<style lang=\"less\">\r\n  #hubspot-conversations-inline-iframe {\r\n    height: calc(var(--vh, 1vh) * 100) !important;\r\n    height: 100vh;\r\n    width: 100%;\r\n    border: 0px;\r\n  }\r\n</style>\n\n\n// WEBPACK FOOTER //\n// src/components/public/HubspotChat.vue","import { __assign } from \"tslib\";\nexport * from './exports';\nimport { Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nimport * as BrowserIntegrations from './integrations';\nimport * as Transports from './transports';\nvar windowIntegrations = {};\n// This block is needed to add compatibility with the integrations packages when used with a CDN\nvar _window = getGlobalObject();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\nvar INTEGRATIONS = __assign(__assign(__assign({}, windowIntegrations), CoreIntegrations), BrowserIntegrations);\nexport { INTEGRATIONS as Integrations, Transports };\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/index.js\n// module id = 2578\n// module chunks = 28 43 45","import { __extends } from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    __extends(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.name = _newTarget.prototype.constructor.name;\n        setPrototypeOf(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/error.js\n// module id = 2601\n// module chunks = 28 43 45","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { consoleSandbox, getGlobalObject } from './misc';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' '));\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };\n//# sourceMappingURL=logger.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/logger.js\n// module id = 2602\n// module chunks = 28 43 45","import { isString } from './is';\nimport { normalize } from './object';\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function dynamicRequire(mod, request) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return mod.require(request);\n}\n/** Default request keys that'll be used to extract data from the request */\nvar DEFAULT_REQUEST_KEYS = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];\n/**\n * Normalizes data from the request object, accounting for framework differences.\n *\n * @param req The request object from which to extract data\n * @param keys An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_KEYS if not\n * provided.\n * @returns An object containing normalized request data\n */\nexport function extractNodeRequestData(req, keys) {\n    if (keys === void 0) { keys = DEFAULT_REQUEST_KEYS; }\n    // make sure we can safely use dynamicRequire below\n    if (!isNodeEnv()) {\n        throw new Error(\"Can't get node request data outside of a node environment\");\n    }\n    var requestData = {};\n    // headers:\n    //   node, express: req.headers\n    //   koa: req.header\n    var headers = (req.headers || req.header || {});\n    // method:\n    //   node, express, koa: req.method\n    var method = req.method;\n    // host:\n    //   express: req.hostname in > 4 and req.host in < 4\n    //   koa: req.host\n    //   node: req.headers.host\n    var host = req.hostname || req.host || headers.host || '<no host>';\n    // protocol:\n    //   node: <n/a>\n    //   express, koa: req.protocol\n    var protocol = req.protocol === 'https' || req.secure || (req.socket || {}).encrypted\n        ? 'https'\n        : 'http';\n    // url (including path and query string):\n    //   node, express: req.originalUrl\n    //   koa: req.url\n    var originalUrl = (req.originalUrl || req.url || '');\n    // absolute url\n    var absoluteUrl = protocol + \"://\" + host + originalUrl;\n    keys.forEach(function (key) {\n        switch (key) {\n            case 'headers':\n                requestData.headers = headers;\n                break;\n            case 'method':\n                requestData.method = method;\n                break;\n            case 'url':\n                requestData.url = absoluteUrl;\n                break;\n            case 'cookies':\n                // cookies:\n                //   node, express, koa: req.headers.cookie\n                //   vercel, sails.js, express (w/ cookie middleware): req.cookies\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.cookies = req.cookies || dynamicRequire(module, 'cookie').parse(headers.cookie || '');\n                break;\n            case 'query_string':\n                // query string:\n                //   node: req.url (raw)\n                //   express, koa: req.query\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.query_string = dynamicRequire(module, 'url').parse(originalUrl || '', false).query;\n                break;\n            case 'data':\n                if (method === 'GET' || method === 'HEAD') {\n                    break;\n                }\n                // body data:\n                //   node, express, koa: req.body\n                if (req.body !== undefined) {\n                    requestData.data = isString(req.body) ? req.body : JSON.stringify(normalize(req.body));\n                }\n                break;\n            default:\n                if ({}.hasOwnProperty.call(req, key)) {\n                    requestData[key] = req[key];\n                }\n        }\n    });\n    return requestData;\n}\n//# sourceMappingURL=node.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/node.js\n// module id = 2603\n// module chunks = 28 43 45","import { __values } from \"tslib\";\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName } from './stacktrace';\nimport { truncate } from './string';\n/**\n * Wrap a given object method with a higher-order function\n *\n * @param source An object that contains a method to be wrapped.\n * @param name A name of method to be wrapped.\n * @param replacementFactory A function that should be used to wrap a given method, returning the wrapped method which\n * will be substituted in for `source[name]`.\n * @returns void\n */\nexport function fill(source, name, replacementFactory) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacementFactory(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    if (typeof wrapped === 'function') {\n        try {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all its attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (isError(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (isEvent(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = isElement(event_1.target)\n                ? htmlTreeAsString(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = isElement(event_1.currentTarget)\n                ? htmlTreeAsString(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // eslint-disable-next-line no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nexport function normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/**\n * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,\n * booleans, null, and undefined.\n *\n * @param value The value to stringify\n * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or\n *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,\n *  unchanged.\n */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return isPrimitive(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n        return '[SyntheticEvent]';\n    }\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + getFunctionName(value) + \"]\";\n    }\n    // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable\n    if (typeof value === 'symbol') {\n        return \"[\" + String(value) + \"]\";\n    }\n    if (typeof value === 'bigint') {\n        return \"[BigInt: \" + String(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new Memo(); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // If value implements `toJSON` method, call it and return early\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (isPrimitive(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function normalize(input, depth) {\n    try {\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\n    }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return truncate(serialized, maxLength);\n    }\n    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (isPlainObject(val)) {\n        var obj = val;\n        var rv = {};\n        try {\n            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof obj[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(obj[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n//# sourceMappingURL=object.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/object.js\n// module id = 2604\n// module chunks = 28 43 45","var defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn) {\n    try {\n        if (!fn || typeof fn !== 'function') {\n            return defaultFunctionName;\n        }\n        return fn.name || defaultFunctionName;\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        return defaultFunctionName;\n    }\n}\n//# sourceMappingURL=stacktrace.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/stacktrace.js\n// module id = 2605\n// module chunks = 28 43 45","import { isRegExp, isString } from './is';\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        // eslint-disable-next-line no-param-reassign\n        colno = ll;\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value, pattern) {\n    if (!isString(value)) {\n        return false;\n    }\n    if (isRegExp(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n//# sourceMappingURL=string.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/string.js\n// module id = 2606\n// module chunks = 28 43 45","import { __assign } from \"tslib\";\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, SyncPromise, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nexport function eventFromException(options, exception, hint) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    addExceptionMechanism(event, {\n        handled: true,\n        type: 'generic',\n    });\n    event.level = Severity.Error;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(options, message, level, hint) {\n    if (level === void 0) { level = Severity.Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event;\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        // eslint-disable-next-line no-param-reassign\n        exception = errorEvent.error;\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isDOMError(exception) || isDOMException(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name, code, and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\n        var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        addExceptionTypeValue(event, message);\n        if ('code' in domException) {\n            event.tags = __assign(__assign({}, event.tags), { 'DOMException.code': \"\" + domException.code });\n        }\n        return event;\n    }\n    if (isError(exception)) {\n        // we have a real Error object, do nothing\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, options.rejection);\n        addExceptionMechanism(event, {\n            synthetic: true,\n        });\n        return event;\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(exception, syntheticException, options);\n    addExceptionTypeValue(event, \"\" + exception, undefined);\n    addExceptionMechanism(event, {\n        synthetic: true,\n    });\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromString(input, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/eventbuilder.js\n// module id = 2607\n// module chunks = 28 43 45","/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\nimport { __assign } from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\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 gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\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/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function computeStackTrace(ex) {\n    var stack = null;\n    var popSize = 0;\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            popSize = ex.framesToPop;\n        }\n        else if (reactMinifiedRegexp.test(ex.message)) {\n            popSize = 1;\n        }\n    }\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex) {\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\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            element = {\n                // working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n                // prefix here seems like the quickest solution for now.\n                url: parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: isNative ? [parts[2]] : [],\n                line: parts[3] ? +parts[3] : null,\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\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            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            element = {\n                url: parts[3],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\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;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return __assign(__assign({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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//# sourceMappingURL=tracekit.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/tracekit.js\n// module id = 2608\n// module chunks = 28 43 45","import { __values } from \"tslib\";\nimport { API } from '@sentry/core';\nimport { Status, } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = new PromiseBuffer(30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._api = new API(this.options.dsn);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new SentryError('Transport Class has to implement `sendEvent` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    /**\n     * Handle Sentry repsonse for promise-based transports.\n     */\n    BaseTransport.prototype._handleResponse = function (_a) {\n        var requestType = _a.requestType, response = _a.response, headers = _a.headers, resolve = _a.resolve, reject = _a.reject;\n        var status = Status.fromHttpCode(response.status);\n        /**\n         * \"The name is case-insensitive.\"\n         * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n         */\n        var limited = this._handleRateLimit(headers);\n        if (limited)\n            logger.warn(\"Too many requests, backing off until: \" + this._disabledUntil(requestType));\n        if (status === Status.Success) {\n            resolve({ status: status });\n            return;\n        }\n        reject(response);\n    };\n    /**\n     * Gets the time that given category is disabled until for rate limiting\n     */\n    BaseTransport.prototype._disabledUntil = function (category) {\n        return this._rateLimits[category] || this._rateLimits.all;\n    };\n    /**\n     * Checks if a category is rate limited\n     */\n    BaseTransport.prototype._isRateLimited = function (category) {\n        return this._disabledUntil(category) > new Date(Date.now());\n    };\n    /**\n     * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n     */\n    BaseTransport.prototype._handleRateLimit = function (headers) {\n        var e_1, _a, e_2, _b;\n        var now = Date.now();\n        var rlHeader = headers['x-sentry-rate-limits'];\n        var raHeader = headers['retry-after'];\n        if (rlHeader) {\n            try {\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 ms\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                for (var _c = __values(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {\n                    var limit = _d.value;\n                    var parameters = limit.split(':', 2);\n                    var headerDelay = parseInt(parameters[0], 10);\n                    var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n                    try {\n                        for (var _e = (e_2 = void 0, __values(parameters[1].split(';'))), _f = _e.next(); !_f.done; _f = _e.next()) {\n                            var category = _f.value;\n                            this._rateLimits[category || 'all'] = new Date(now + delay);\n                        }\n                    }\n                    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                    finally {\n                        try {\n                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                        }\n                        finally { if (e_2) throw e_2.error; }\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            return true;\n        }\n        else if (raHeader) {\n            this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));\n            return true;\n        }\n        return false;\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/base.js\n// module id = 2609\n// module chunks = 28 43 45","export { GlobalHandlers } from './globalhandlers';\nexport { TryCatch } from './trycatch';\nexport { Breadcrumbs } from './breadcrumbs';\nexport { LinkedErrors } from './linkederrors';\nexport { UserAgent } from './useragent';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/index.js\n// module id = 2610\n// module chunks = 28 43 45","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/less-loader/dist/cjs.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./HubspotChat.vue\");\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = require(\"!../../../node_modules/vue-style-loader/lib/addStylesClient.js\")(\"447d1b86\", content, false, {});\n// Hot Module Replacement\nif(module.hot) {\n // When the styles change, update the <style> tags\n if(!content.locals) {\n   module.hot.accept(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/less-loader/dist/cjs.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./HubspotChat.vue\", function() {\n     var newContent = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-3e33ba39\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/less-loader/dist/cjs.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./HubspotChat.vue\");\n     if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n     update(newContent);\n   });\n }\n // When the module is disposed, remove the <style> tags\n module.hot.dispose(function() { update(); });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-style-loader!./node_modules/css-loader?{\"sourceMap\":false}!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-3e33ba39\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/less-loader/dist/cjs.js?{\"sourceMap\":false}!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/components/public/HubspotChat.vue\n// module id = 2653\n// module chunks = 27 28 34 43 45","exports = module.exports = require(\"../../../node_modules/css-loader/lib/css-base.js\")(false);\n// imports\n\n\n// module\nexports.push([module.id, \"\\n#hubspot-conversations-inline-iframe {\\n  height: calc(var(--vh, 1vh) * 100) !important;\\n  height: 100vh;\\n  width: 100%;\\n  border: 0px;\\n}\\n\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/css-loader?{\"sourceMap\":false}!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-3e33ba39\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/less-loader/dist/cjs.js?{\"sourceMap\":false}!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/components/public/HubspotChat.vue\n// module id = 2654\n// module chunks = 27 28 34 43 45","var render = function() {\n  var _vm = this\n  var _h = _vm.$createElement\n  var _c = _vm._self._c || _h\n  return _c(\"div\", { attrs: { id: \"support-chat-container\" } })\n}\nvar staticRenderFns = []\nrender._withStripped = true\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\nexport default esExports\nif (module.hot) {\n  module.hot.accept()\n  if (module.hot.data) {\n    require(\"vue-hot-reload-api\")      .rerender(\"data-v-3e33ba39\", esExports)\n  }\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/lib/template-compiler?{\"id\":\"data-v-3e33ba39\",\"hasScoped\":false,\"transformToRequire\":{\"video\":[\"src\",\"poster\"],\"source\":\"src\",\"img\":\"src\",\"image\":\"xlink:href\"},\"buble\":{\"transforms\":{}}}!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./src/components/public/HubspotChat.vue\n// module id = 2655\n// module chunks = 27 28 34 43 45","<template>\r\n    <div>\r\n      <b-modal v-model=\"modalShow\" centered cancel-disabled no-close-on-esc no-close-on-backdrop hide-header-close :title=\"getErrorTitle\" hide-footer>\r\n        <div v-if=\"!supportChatVisible\" class=\"text-center\">\r\n          <div class=\"mx-auto error-img\"><img width=\"96px\" height=\"96px\" :src=\"getErrorImg\"/></div>\r\n          <p :class=\"{ 'text-danger': !customError }\" class=\"text-center\" v-html=\"getErrorMsg\"></p>\r\n          <div v-if=\"!customError\">\r\n            <a @click=\"toggleShowDetailedError\" class=\"clickable small\">{{ showDetailedError ? $t('hide-detailed-error') : $t('show-detailed-error') }}</a>\r\n            <div class=\"code-format mt-2\" v-if=\"showDetailedError\">\r\n              Error: <b>{{ opentok.error.title }}</b><br>\r\n              {{ opentok.error.msg }}\r\n            </div>\r\n          </div>\r\n          <div class=\"col text-center pt-3\" v-if=\"getCustomErrorBtnMsg !== ''\">\r\n            <b-button v-if=\"smallToken =! '' && !getCustomErrorBtnMsg\" center v-on:click=\"pageReload\" align-h=\"center\" :variant=\"`outline-${getErrorColorVariant}`\"><b-icon icon=\"arrow-counterclockwise\" aria-hidden=\"true\"></b-icon> {{ $t('retry') }}</b-button>\r\n            <b-button v-if=\"getCustomErrorBtnMsg\" center align-h=\"center\" :variant=\"`outline-${getErrorColorVariant}`\" v-on:click=\"doCustomErrorAction\">\r\n              {{ getCustomErrorBtnMsg }}\r\n            </b-button>\r\n          </div>\r\n        </div>\r\n        <div v-else>\r\n          <hubspot-chat></hubspot-chat>\r\n        </div>\r\n        <div class=\"text-center mt-4\">\r\n          <b-button variant=\"outline-info\" @click=\"$helpers.openSupportChat()\" size=\"sm\">{{ supportChatVisible ? $t('back') : $t('contact-by-chat-tech-problems') }}</b-button>\r\n        </div>\r\n      </b-modal>\r\n    </div>\r\n</template>\r\n\r\n<script>\r\nimport { BIcon, BIconArrowCounterclockwise, BModal, BButton } from 'bootstrap-vue'\r\nimport HubspotChat from '@/components/public/HubspotChat'\r\nimport filters from '@/plugins/filters'\r\nimport * as Sentry from '@sentry/vue'\r\nimport { mapState } from 'vuex'\r\n\r\nexport default {\r\n  name: 'Error',\r\n  components: {\r\n    BIcon,\r\n    BIconArrowCounterclockwise,\r\n    BModal,\r\n    BButton,\r\n    'hubspot-chat': HubspotChat\r\n  },\r\n  props: {\r\n    customError: {\r\n      type: String,\r\n      required: false\r\n    }\r\n  },\r\n  data () {\r\n    return {\r\n      modalShow: false,\r\n      smallToken: '',\r\n      showDetailedError: false,\r\n      supportChatVisible: false\r\n    }\r\n  },\r\n  created () {\r\n    let logErrorMsg = this.customError\r\n    if (this.opentok && this.opentok.error && this.opentok.error.title) {\r\n      logErrorMsg = this.opentok.error.title\r\n    }\r\n    Sentry.captureMessage(`Error video: ${logErrorMsg}`)\r\n\r\n    if (!this.customError) {\r\n      this.$store.commit('video/setOpentokError', {\r\n        title: this.$route.query.error_title,\r\n        msg: this.$route.query.error_msg\r\n      })\r\n      this.$root.$emit('bv::show::modal', 'modal-1', '#btnShow')\r\n      this.smallToken = this.$route.query.token\r\n    } else {\r\n      this.smallToken = this.$store.state.video.smallToken\r\n    }\r\n    this.modalShow = true\r\n  },\r\n  methods: {\r\n    pageReload: function () {\r\n      history.back()\r\n    },\r\n    toggleShowDetailedError () {\r\n      this.showDetailedError = !this.showDetailedError\r\n    },\r\n    doCustomErrorAction () {\r\n      switch (this.customError) {\r\n        case 'VideoSessionFinishedException':\r\n          this.$helpers.goToPatientWebApp(`appointments/preview/${this.appointment.id}`)\r\n          break\r\n        case 'VideoSessionFinishedWithReportException':\r\n          this.$helpers.goToPatientWebApp(`appointments/report/${this.appointment.id}`)\r\n          break\r\n        case 'PaymentNotFoundException':\r\n          this.$helpers.goToPatientWebApp(`appointments/pay/${this.appointment.id}/${this.appointment.price}`)\r\n          break\r\n        default:\r\n          return null\r\n      }\r\n    }\r\n  },\r\n  computed: {\r\n\t\t...mapState('video', ['opentok', 'appointment']),\r\n    getErrorTitle () {\r\n      const i18nMsgKey = `errors.${this.customError}.title${this.$store.getters['session/userIsProfessional'] ? '_professional' : ''}`\r\n      if (this.$te(i18nMsgKey)) {\r\n        return this.$t(i18nMsgKey)\r\n      } else {\r\n        return this.$t('dialog-title-error')\r\n      }\r\n    },\r\n    getErrorMsg () {\r\n      const i18nMsgKey = !this.customError ? `errors.${this.opentok.error.title}` : `errors.${this.customError}.msg${this.$store.getters['session/userIsProfessional'] ? '_professional' : ''}`\r\n      if (this.$te(i18nMsgKey) && !!this.appointment) {\r\n        const appointmentDate = filters.beautifyDate(this.appointment.fromDateTime)\r\n        return !this.customError ? this.$t(i18nMsgKey) : this.$t(i18nMsgKey, { date: appointmentDate })\r\n      } else {\r\n        return this.$t('errorVideoConnection')\r\n      }\r\n    },\r\n    getErrorImg () {\r\n      let img = this.customError\r\n      switch (this.customError) {\r\n        case 'VideoSessionFinishedException':\r\n        case 'VideoSessionFinishedWithReportException':\r\n        case 'VideoSessionWaitingReportException':\r\n          img = 'VideoSessionFinishedException'\r\n          break\r\n        case 'VideoSessionExpiredException':\r\n          img = 'VideoSessionNoLongerAccessibleException'\r\n          break\r\n        default:\r\n          return '/static-appopensalud/img/icons/unplugged-icon-red-fill.svg'\r\n      }\r\n      return this.customError ? `/static-appopensalud/img/icons/errors/${img}.svg` : '/static-appopensalud/img/icons/unplugged-icon-red-fill.svg'\r\n    },\r\n    getCustomErrorBtnMsg () {\r\n      switch (this.customError) {\r\n        case 'VideoSessionFinishedException':\r\n        case 'VideoSessionFinishedWithReportException':\r\n          return this.$t('go-to-consultation')\r\n        case 'PaymentNotFoundException':\r\n          return this.$t('pay-consultation')\r\n        case 'VideoSessionExpiredException':\r\n        case 'VideoSessionNoLongerAccessibleException':\r\n        case 'VideoSessionNotYetAccessibleException':\r\n        case 'VideoSessionWaitingReportException':\r\n          return ''\r\n        default:\r\n          return null\r\n      }\r\n    },\r\n    getErrorColorVariant () {\r\n      switch (this.customError) {\r\n        case 'VideoSessionNoLongerAccessibleException':\r\n        case 'VideoSessionNotYetAccessibleException':\r\n        case 'VideoSessionWaitingReportException':\r\n        case 'VideoSessionFinishedException':\r\n        case 'VideoSessionExpiredException':\r\n        case 'VideoSessionFinishedWithReportException':\r\n        case 'PaymentNotFoundException':\r\n          return 'primary'\r\n        default:\r\n          return 'danger'\r\n      }\r\n    }\r\n  }\r\n}\r\n</script>\r\n\r\n<!-- Add \"scoped\" attribute to limit CSS to this component only -->\r\n<style lang=\"scss\">\r\nh1,\r\nh2 {\r\n  font-weight: normal;\r\n}\r\n\r\nul {\r\n  list-style-type: none;\r\n  padding: 0;\r\n}\r\n\r\nli {\r\n  display: inline-block;\r\n  margin: 0 10px;\r\n}\r\n\r\na {\r\n  color: #35495e;\r\n}\r\n\r\n.code-format {\r\n  display: block;\r\n  font-family: 'Source Code Pro', monospace;\r\n  background-color: lightgray;\r\n  border: 1px solid gray;\r\n  font-size: 12px;\r\n  padding: 10px;\r\n}\r\n\r\n.error-img {\r\n  width: 96px;\r\n  margin: 20px 0 40px 0;\r\n}\r\n</style>\r\n\n\n\n// WEBPACK FOOTER //\n// src/components/video-launcher/Error.vue","import { __assign, __read, __spread } from \"tslib\";\nimport { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = __spread(scope._breadcrumbs);\n            newScope._tags = __assign({}, scope._tags);\n            newScope._extra = __assign({}, scope._extra);\n            newScope._contexts = __assign({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._session = scope._session;\n            newScope._transactionName = scope._transactionName;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = __spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = __assign(__assign({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = __assign(__assign({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = __assign(__assign({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = __assign(__assign({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        var _a, _b, _c, _d;\n        // often, this span will be a transaction, but it's not guaranteed to be\n        var span = this.getSpan();\n        // try it the new way first\n        if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {\n            return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;\n        }\n        // fallback to the old way (known bug: this only finds transactions with sampled = true)\n        if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {\n            return span.spanRecorder.spans[0];\n        }\n        // neither way found a transaction\n        return undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = __assign(__assign({}, this._tags), captureContext._tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext._extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext._contexts);\n            if (captureContext._user && Object.keys(captureContext._user).length) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n        }\n        else if (isPlainObject(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = __assign(__assign({}, this._tags), captureContext.tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext.extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transactionName = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._session = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : __spread(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        var _a;\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = __assign(__assign({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = __assign(__assign({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = __assign(__assign({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = __assign(__assign({}, this._contexts), event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transactionName) {\n            event.transaction = this._transactionName;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relys on that.\n        if (this._span) {\n            event.contexts = __assign({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;\n            if (transactionName) {\n                event.tags = __assign({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        // We need this check for this._notifyingListeners to be able to work on scope during updates\n        // If this check is not here we'll produce endless recursion when something is done with the scope\n        // during the callback.\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            this._scopeListeners.forEach(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\n        }\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/scope.js\n// module id = 2659\n// module chunks = 28 43 45","import { isString } from './is';\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        // eslint-disable-next-line no-plusplus\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var allowedAttrs = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < allowedAttrs.length; i++) {\n        key = allowedAttrs[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n//# sourceMappingURL=browser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/browser.js\n// module id = 2660\n// module chunks = 28 43 45","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\nexport { Memo };\n//# sourceMappingURL=memo.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/memo.js\n// module id = 2661\n// module chunks = 28 43 45","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent() {\n    try {\n        new ErrorEvent('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function 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    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException() {\n    try {\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch() {\n    if (!('fetch' in getGlobalObject())) {\n        return false;\n    }\n    try {\n        new Headers();\n        new Request('');\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch() {\n    if (!supportsFetch()) {\n        return false;\n    }\n    var global = getGlobalObject();\n    // Fast path to avoid DOM I/O\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\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    var result = false;\n    var doc = global.document;\n    // eslint-disable-next-line deprecation/deprecation\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                // eslint-disable-next-line @typescript-eslint/unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver() {\n    return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy() {\n    // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function 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    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var chrome = global.chrome;\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/supports.js\n// module id = 2662\n// module chunks = 28 43 45","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (isThenable(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler.done) {\n                    return;\n                }\n                if (_this._state === States.RESOLVED) {\n                    if (handler.onfulfilled) {\n                        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                        handler.onfulfilled(_this._value);\n                    }\n                }\n                if (_this._state === States.REJECTED) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                }\n                handler.done = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                done: false,\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/syncpromise.js\n// module id = 2663\n// module chunks = 28 43 45","import { SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, uuid4 } from '@sentry/utils';\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = uuid4();\n        this.timestamp = Date.now();\n        this.started = Date.now();\n        this.duration = 0;\n        this.status = SessionStatus.Ok;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || Date.now();\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : uuid4();\n        }\n        if (context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            this.duration = this.timestamp - this.started;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === SessionStatus.Ok) {\n            this.update({ status: SessionStatus.Exited });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return dropUndefinedKeys({\n            sid: \"\" + this.sid,\n            init: true,\n            started: new Date(this.started).toISOString(),\n            timestamp: new Date(this.timestamp).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: dropUndefinedKeys({\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            }),\n        });\n    };\n    return Session;\n}());\nexport { Session };\n//# sourceMappingURL=session.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/session.js\n// module id = 2664\n// module chunks = 28 43 45","import { Status } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n/** Noop transport */\nvar NoopTransport = /** @class */ (function () {\n    function NoopTransport() {\n    }\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.sendEvent = function (_) {\n        return SyncPromise.resolve({\n            reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n            status: Status.Skipped,\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.close = function (_) {\n        return SyncPromise.resolve(true);\n    };\n    return NoopTransport;\n}());\nexport { NoopTransport };\n//# sourceMappingURL=noop.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/transports/noop.js\n// module id = 2665\n// module chunks = 28 43 45","import { __assign, __extends, __read, __spread } from \"tslib\";\nimport { BaseClient } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { injectReportDialog } from './helpers';\nimport { Breadcrumbs } from './integrations';\nimport { SDK_NAME, SDK_VERSION } from './version';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    __extends(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        return _super.call(this, BrowserBackend, options) || this;\n    }\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = getGlobalObject().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            logger.error('Trying to call showReportDialog with Sentry Client disabled');\n            return;\n        }\n        injectReportDialog(__assign(__assign({}, options), { dsn: options.dsn || this.getDsn() }));\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = __assign(__assign({}, event.sdk), { name: SDK_NAME, packages: __spread(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: SDK_VERSION,\n                },\n            ]), version: SDK_VERSION });\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._sendEvent = function (event) {\n        var integration = this.getIntegration(Breadcrumbs);\n        if (integration) {\n            integration.addSentryBreadcrumb(event);\n        }\n        _super.prototype._sendEvent.call(this, event);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/client.js\n// module id = 2666\n// module chunks = 28 43 45","import { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\nimport { computeStackTrace } from './tracekit';\nvar STACKTRACE_LIMIT = 50;\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nexport function eventFromPlainObject(exception, syntheticException, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\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    // 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    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .slice(0, STACKTRACE_LIMIT)\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/parsers.js\n// module id = 2667\n// module chunks = 28 43 45","export { BaseTransport } from './base';\nexport { FetchTransport } from './fetch';\nexport { XHRTransport } from './xhr';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/index.js\n// module id = 2668\n// module chunks = 28 43 45","export var SDK_NAME = 'sentry.javascript.browser';\nexport var SDK_VERSION = '5.30.0';\n//# sourceMappingURL=version.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/version.js\n// module id = 2669\n// module chunks = 28 43 45","// style-loader: Adds some css to the DOM by adding a <style> tag\n\n// load the styles\nvar content = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Error.vue\");\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = require(\"!../../../node_modules/vue-style-loader/lib/addStylesClient.js\")(\"4dc5969a\", content, false, {});\n// Hot Module Replacement\nif(module.hot) {\n // When the styles change, update the <style> tags\n if(!content.locals) {\n   module.hot.accept(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Error.vue\", function() {\n     var newContent = require(\"!!../../../node_modules/css-loader/index.js?{\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-23316cdb\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../node_modules/sass-loader/dist/cjs.js?{\\\"data\\\":\\\"@import \\\\\\\"static-appopensalud/css/scss/shared.scss\\\\\\\";\\\",\\\"sourceMap\\\":false}!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Error.vue\");\n     if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n     update(newContent);\n   });\n }\n // When the module is disposed, remove the <style> tags\n module.hot.dispose(function() { update(); });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-style-loader!./node_modules/css-loader?{\"sourceMap\":false}!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-23316cdb\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/sass-loader/dist/cjs.js?{\"data\":\"@import /\"static-appopensalud/css/scss/shared.scss/\";\",\"sourceMap\":false}!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/components/video-launcher/Error.vue\n// module id = 2732\n// module chunks = 28 43 45","exports = module.exports = require(\"../../../node_modules/css-loader/lib/css-base.js\")(false);\n// imports\n\n\n// module\nexports.push([module.id, \"\\n.overline-typescale{font-size:12px;letter-spacing:1.25px;font-weight:lighter;text-transform:uppercase\\n}\\n.slide-down-enter-active,.slide-down-leave-active{-webkit-transition:all 0.5s ease;transition:all 0.5s ease\\n}\\n.slide-down-enter,.slide-down-leave-to{-webkit-transform:translateY(-100%);transform:translateY(-100%);opacity:0\\n}\\n.slide-fade-left-enter-active,.slide-fade-left-leave-active{-webkit-transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:opacity 0.3s ease, -webkit-transform 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease;transition:transform 0.3s ease, opacity 0.3s ease, -webkit-transform 0.3s ease\\n}\\n.slide-fade-left-enter,.slide-fade-left-leave-to{-webkit-transform:translateX(100%);transform:translateX(100%);opacity:0\\n}\\n.fade-enter-active{-webkit-transition:opacity 0.3s ease;transition:opacity 0.3s ease\\n}\\n.fade-enter,.fade-leave-to{opacity:0\\n}\\nh1,h2{font-weight:normal\\n}\\nul{list-style-type:none;padding:0\\n}\\nli{display:inline-block;margin:0 10px\\n}\\na{color:#35495e\\n}\\n.code-format{display:block;font-family:'Source Code Pro', monospace;background-color:lightgray;border:1px solid gray;font-size:12px;padding:10px\\n}\\n.error-img{width:96px;margin:20px 0 40px 0\\n}\\n\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/css-loader?{\"sourceMap\":false}!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-23316cdb\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/sass-loader/dist/cjs.js?{\"data\":\"@import /\"static-appopensalud/css/scss/shared.scss/\";\",\"sourceMap\":false}!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/components/video-launcher/Error.vue\n// module id = 2733\n// module chunks = 28 43 45","export { addGlobalEventProcessor, addBreadcrumb, captureException, captureEvent, captureMessage, configureScope, getHubFromCarrier, getCurrentHub, Hub, Scope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope, } from '@sentry/browser';\nexport { init } from './sdk';\nexport { vueRouterInstrumentation } from './vuerouter';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/esm/index.js\n// module id = 2734\n// module chunks = 28 43 45","export { Severity, Status, } from '@sentry/types';\nexport { addGlobalEventProcessor, addBreadcrumb, captureException, captureEvent, captureMessage, configureScope, getHubFromCarrier, getCurrentHub, Hub, makeMain, Scope, startTransaction, setContext, setExtra, setExtras, setTag, setTags, setUser, withScope, } from '@sentry/core';\nexport { BrowserClient } from './client';\nexport { injectReportDialog } from './helpers';\nexport { eventFromException, eventFromMessage } from './eventbuilder';\nexport { defaultIntegrations, forceLoad, init, lastEventId, onLoad, showReportDialog, flush, close, wrap } from './sdk';\nexport { SDK_NAME, SDK_VERSION } from './version';\n//# sourceMappingURL=exports.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/exports.js\n// module id = 2735\n// module chunks = 28 43 45","/** Console logging verbosity for the SDK. */\nexport var LogLevel;\n(function (LogLevel) {\n    /** No logs will be generated. */\n    LogLevel[LogLevel[\"None\"] = 0] = \"None\";\n    /** Only SDK internal errors will be logged. */\n    LogLevel[LogLevel[\"Error\"] = 1] = \"Error\";\n    /** Information useful for debugging the SDK will be logged. */\n    LogLevel[LogLevel[\"Debug\"] = 2] = \"Debug\";\n    /** All SDK actions will be logged. */\n    LogLevel[LogLevel[\"Verbose\"] = 3] = \"Verbose\";\n})(LogLevel || (LogLevel = {}));\n//# sourceMappingURL=loglevel.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/types/esm/loglevel.js\n// module id = 2736\n// module chunks = 28 43 45","/**\n * Session Status\n */\nexport var SessionStatus;\n(function (SessionStatus) {\n    /** JSDoc */\n    SessionStatus[\"Ok\"] = \"ok\";\n    /** JSDoc */\n    SessionStatus[\"Exited\"] = \"exited\";\n    /** JSDoc */\n    SessionStatus[\"Crashed\"] = \"crashed\";\n    /** JSDoc */\n    SessionStatus[\"Abnormal\"] = \"abnormal\";\n})(SessionStatus || (SessionStatus = {}));\n//# sourceMappingURL=session.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/types/esm/session.js\n// module id = 2737\n// module chunks = 28 43 45","/** JSDoc */\n// eslint-disable-next-line import/export\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/types/esm/severity.js\n// module id = 2738\n// module chunks = 28 43 45","/** The status of an event. */\n// eslint-disable-next-line import/export\nexport var Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/types/esm/status.js\n// module id = 2739\n// module chunks = 28 43 45","export var TransactionSamplingMethod;\n(function (TransactionSamplingMethod) {\n    TransactionSamplingMethod[\"Explicit\"] = \"explicitly_set\";\n    TransactionSamplingMethod[\"Sampler\"] = \"client_sampler\";\n    TransactionSamplingMethod[\"Rate\"] = \"client_rate\";\n    TransactionSamplingMethod[\"Inheritance\"] = \"inheritance\";\n})(TransactionSamplingMethod || (TransactionSamplingMethod = {}));\n//# sourceMappingURL=transaction.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/types/esm/transaction.js\n// module id = 2740\n// module chunks = 28 43 45","import { __assign, __read, __spread } from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return hub[method].apply(hub, __spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param level Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    // This is necessary to provide explicit scopes upgrade, without changing the original\n    // arity of the `captureMessage(message, level)` method.\n    var level = typeof captureContext === 'string' ? captureContext : undefined;\n    var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, __assign({ originalException: message, syntheticException: syntheticException }, context));\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, __spread(['_invokeClient', method], args));\n}\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(context, customSamplingContext) {\n    return callOnHub('startTransaction', __assign({}, context), customSamplingContext);\n}\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/minimal/esm/index.js\n// module id = 2741\n// module chunks = 28 43 45","import { __read } from \"tslib\";\nimport { SentryError } from './error';\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\n    }\n    /**\n     * Renders the string representation of this Dsn.\n     *\n     * By default, this will render the public representation without the password\n     * component. To get the deprecated private representation, set `withPassword`\n     * to true.\n     *\n     * @param withPassword When set to true, the password will be included.\n     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, user = _a.user;\n        return (protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') +\n            (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId));\n    };\n    /** Parses a string into this Dsn. */\n    Dsn.prototype._fromString = function (str) {\n        var match = DSN_REGEX.exec(str);\n        if (!match) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        var _a = __read(match.slice(1), 6), protocol = _a[0], user = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];\n        var path = '';\n        var projectId = lastPath;\n        var split = projectId.split('/');\n        if (split.length > 1) {\n            path = split.slice(0, -1).join('/');\n            projectId = split.pop();\n        }\n        if (projectId) {\n            var projectMatch = projectId.match(/^\\d+/);\n            if (projectMatch) {\n                projectId = projectMatch[0];\n            }\n        }\n        this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, user: user });\n    };\n    /** Maps Dsn components into this instance. */\n    Dsn.prototype._fromComponents = function (components) {\n        this.protocol = components.protocol;\n        this.user = components.user;\n        this.pass = components.pass || '';\n        this.host = components.host;\n        this.port = components.port || '';\n        this.path = components.path || '';\n        this.projectId = components.projectId;\n    };\n    /** Validates this Dsn and throws on error. */\n    Dsn.prototype._validate = function () {\n        var _this = this;\n        ['protocol', 'user', 'host', 'projectId'].forEach(function (component) {\n            if (!_this[component]) {\n                throw new SentryError(ERROR_MESSAGE + \": \" + component + \" missing\");\n            }\n        });\n        if (!this.projectId.match(/^\\d+$/)) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid projectId \" + this.projectId);\n        }\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid protocol \" + this.protocol);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid port \" + this.port);\n        }\n    };\n    return Dsn;\n}());\nexport { Dsn };\n//# sourceMappingURL=dsn.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/dsn.js\n// module id = 2743\n// module chunks = 28 43 45","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n/**\n * setPrototypeOf polyfill using __proto__\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore __proto__ does not exist on obj\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore typescript complains about indexing so we remove\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/polyfill.js\n// module id = 2744\n// module chunks = 28 43 45","import { __assign, __values } from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nvar global = getGlobalObject();\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 */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\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            logger.warn('unknown instrumentation type:', type);\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 */\nexport function addInstrumentationHandler(handler) {\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = __values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + getFunctionName(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        fill(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!supportsNativeFetch()) {\n        return;\n    }\n    fill(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var handlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', __assign({}, handlerData));\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), error: error }));\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n                //       it means the sentry.javascript SDK caught an error invoking your application code.\n                //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n                throw error;\n            });\n        };\n    });\n}\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { 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/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { 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/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.\n    var requestKeys = [];\n    var requestValues = [];\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var url = args[1];\n            xhr.__sentry_xhr__ = {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            if (isString(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                xhr.__sentry_own_request__ = true;\n            }\n            var onreadystatechangeHandler = function () {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    try {\n                        var requestPos = requestKeys.indexOf(xhr);\n                        if (requestPos !== -1) {\n                            // Make sure to pop both key and value to keep it in sync.\n                            requestKeys.splice(requestPos);\n                            var args_1 = requestValues.splice(requestPos)[0];\n                            if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {\n                                xhr.__sentry_xhr__.body = args_1[0];\n                            }\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', {\n                        args: args,\n                        endTimestamp: Date.now(),\n                        startTimestamp: Date.now(),\n                        xhr: xhr,\n                    });\n                }\n            };\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n            }\n            return originalOpen.apply(xhr, args);\n        };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            requestKeys.push(this);\n            requestValues.push(args);\n            triggerHandlers('xhr', {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: this,\n            });\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!supportsHistory()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\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: from,\n            to: to,\n        });\n        if (oldOnPopState) {\n            return oldOnPopState.apply(this, args);\n        }\n    };\n    /** @hidden */\n    function historyReplacementFunction(originalHistoryFunction) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\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: from,\n                    to: to,\n                });\n            }\n            return originalHistoryFunction.apply(this, args);\n        };\n    }\n    fill(global.history, 'pushState', historyReplacementFunction);\n    fill(global.history, 'replaceState', historyReplacementFunction);\n}\n/** JSDoc */\nfunction instrumentDOM() {\n    if (!('document' in global)) {\n        return;\n    }\n    // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n    // to the document. Do this before we instrument addEventListener.\n    global.document.addEventListener('click', domEventHandler('click', triggerHandlers.bind(null, 'dom')), false);\n    global.document.addEventListener('keypress', keypressEventHandler(triggerHandlers.bind(null, 'dom')), false);\n    // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n    ['EventTarget', 'Node'].forEach(function (target) {\n        /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line no-prototype-builtins\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                if (fn && fn.handleEvent) {\n                    if (eventName === 'click') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                domEventHandler('click', triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                    if (eventName === 'keypress') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                keypressEventHandler(triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                }\n                else {\n                    if (eventName === 'click') {\n                        domEventHandler('click', triggerHandlers.bind(null, 'dom'), true)(this);\n                    }\n                    if (eventName === 'keypress') {\n                        keypressEventHandler(triggerHandlers.bind(null, 'dom'))(this);\n                    }\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    original.call(this, eventName, fn.__sentry_wrapped__, options);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n    });\n}\nvar debounceDuration = 1000;\nvar debounceTimer = 0;\nvar keypressTimeout;\nvar lastCapturedEvent;\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param name the event name (e.g. \"click\")\n * @param handler function that will be triggered\n * @param debounce decides whether it should wait till another event loop\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction domEventHandler(name, handler, debounce) {\n    if (debounce === void 0) { debounce = false; }\n    return function (event) {\n        // reset keypress timeout; e.g. triggering a 'click' after\n        // a 'keypress' will reset the keypress debounce so that a new\n        // set of keypresses can be recorded\n        keypressTimeout = undefined;\n        // It's possible this handler might trigger multiple times for the same\n        // event (e.g. event propagation through node ancestors). Ignore if we've\n        // already captured the event.\n        if (!event || lastCapturedEvent === event) {\n            return;\n        }\n        lastCapturedEvent = event;\n        if (debounceTimer) {\n            clearTimeout(debounceTimer);\n        }\n        if (debounce) {\n            debounceTimer = setTimeout(function () {\n                handler({ event: event, name: name });\n            });\n        }\n        else {\n            handler({ event: event, name: name });\n        }\n    };\n}\n/**\n * Wraps addEventListener to capture keypress UI events\n * @param handler function that will be triggered\n * @returns wrapped keypress events handler\n * @hidden\n */\nfunction keypressEventHandler(handler) {\n    // TODO: if somehow user switches keypress target before\n    //       debounce timeout is triggered, we will only capture\n    //       a single breadcrumb from the FIRST target (acceptable?)\n    return function (event) {\n        var target;\n        try {\n            target = event.target;\n        }\n        catch (e) {\n            // just accessing event properties can throw an exception in some rare circumstances\n            // see: https://github.com/getsentry/raven-js/issues/838\n            return;\n        }\n        var tagName = target && target.tagName;\n        // only consider keypress events on actual input elements\n        // this will disregard keypresses targeting body (e.g. tabbing\n        // through elements, hotkeys, etc)\n        if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {\n            return;\n        }\n        // record first keypress in a series, but ignore subsequent\n        // keypresses until debounce clears\n        if (!keypressTimeout) {\n            domEventHandler('input', handler)(event);\n        }\n        clearTimeout(keypressTimeout);\n        keypressTimeout = setTimeout(function () {\n            keypressTimeout = undefined;\n        }, debounceDuration);\n    };\n}\nvar _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n    _oldOnErrorHandler = global.onerror;\n    global.onerror = function (msg, url, line, column, error) {\n        triggerHandlers('error', {\n            column: column,\n            error: error,\n            line: line,\n            msg: msg,\n            url: url,\n        });\n        if (_oldOnErrorHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnErrorHandler.apply(this, arguments);\n        }\n        return false;\n    };\n}\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n    _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n    global.onunhandledrejection = function (e) {\n        triggerHandlers('unhandledrejection', e);\n        if (_oldOnUnhandledRejectionHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n        }\n        return true;\n    };\n}\n//# sourceMappingURL=instrument.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/instrument.js\n// module id = 2745\n// module chunks = 28 43 45","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js\n/** JSDoc */\nfunction normalizeArray(parts, allowAboveRoot) {\n    // if the path tries to go above the root, `up` ends up > 0\n    var up = 0;\n    for (var i = parts.length - 1; i >= 0; i--) {\n        var last = parts[i];\n        if (last === '.') {\n            parts.splice(i, 1);\n        }\n        else if (last === '..') {\n            parts.splice(i, 1);\n            // eslint-disable-next-line no-plusplus\n            up++;\n        }\n        else if (up) {\n            parts.splice(i, 1);\n            // eslint-disable-next-line no-plusplus\n            up--;\n        }\n    }\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\n        // eslint-disable-next-line no-plusplus\n        for (; up--; up) {\n            parts.unshift('..');\n        }\n    }\n    return parts;\n}\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe = /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^/]+?|)(\\.[^./]*|))(?:[/]*)$/;\n/** JSDoc */\nfunction splitPath(filename) {\n    var parts = splitPathRe.exec(filename);\n    return parts ? parts.slice(1) : [];\n}\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nexport function resolve() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n        var path = i >= 0 ? args[i] : '/';\n        // Skip empty entries\n        if (!path) {\n            continue;\n        }\n        resolvedPath = path + \"/\" + resolvedPath;\n        resolvedAbsolute = path.charAt(0) === '/';\n    }\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n    // Normalize the path\n    resolvedPath = normalizeArray(resolvedPath.split('/').filter(function (p) { return !!p; }), !resolvedAbsolute).join('/');\n    return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n/** JSDoc */\nfunction trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n        if (arr[start] !== '') {\n            break;\n        }\n    }\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n        if (arr[end] !== '') {\n            break;\n        }\n    }\n    if (start > end) {\n        return [];\n    }\n    return arr.slice(start, end - start + 1);\n}\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nexport function relative(from, to) {\n    /* eslint-disable no-param-reassign */\n    from = resolve(from).substr(1);\n    to = resolve(to).substr(1);\n    /* eslint-enable no-param-reassign */\n    var fromParts = trim(from.split('/'));\n    var toParts = trim(to.split('/'));\n    var length = Math.min(fromParts.length, toParts.length);\n    var samePartsLength = length;\n    for (var i = 0; i < length; i++) {\n        if (fromParts[i] !== toParts[i]) {\n            samePartsLength = i;\n            break;\n        }\n    }\n    var outputParts = [];\n    for (var i = samePartsLength; i < fromParts.length; i++) {\n        outputParts.push('..');\n    }\n    outputParts = outputParts.concat(toParts.slice(samePartsLength));\n    return outputParts.join('/');\n}\n// path.normalize(path)\n// posix version\n/** JSDoc */\nexport function normalizePath(path) {\n    var isPathAbsolute = isAbsolute(path);\n    var trailingSlash = path.substr(-1) === '/';\n    // Normalize the path\n    var normalizedPath = normalizeArray(path.split('/').filter(function (p) { return !!p; }), !isPathAbsolute).join('/');\n    if (!normalizedPath && !isPathAbsolute) {\n        normalizedPath = '.';\n    }\n    if (normalizedPath && trailingSlash) {\n        normalizedPath += '/';\n    }\n    return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n// posix version\n/** JSDoc */\nexport function isAbsolute(path) {\n    return path.charAt(0) === '/';\n}\n// posix version\n/** JSDoc */\nexport function join() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return normalizePath(args.join('/'));\n}\n/** JSDoc */\nexport function dirname(path) {\n    var result = splitPath(path);\n    var root = result[0];\n    var dir = result[1];\n    if (!root && !dir) {\n        // No dirname whatsoever\n        return '.';\n    }\n    if (dir) {\n        // It has a dirname, strip trailing slash\n        dir = dir.substr(0, dir.length - 1);\n    }\n    return root + dir;\n}\n/** JSDoc */\nexport function basename(path, ext) {\n    var f = splitPath(path)[2];\n    if (ext && f.substr(ext.length * -1) === ext) {\n        f = f.substr(0, f.length - ext.length);\n    }\n    return f;\n}\n//# sourceMappingURL=path.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/path.js\n// module id = 2746\n// module chunks = 28 43 45","import { SentryError } from './error';\nimport { SyncPromise } from './syncpromise';\n/** A simple queue that holds promises. */\nvar PromiseBuffer = /** @class */ (function () {\n    function PromiseBuffer(_limit) {\n        this._limit = _limit;\n        /** Internal set of queued Promises */\n        this._buffer = [];\n    }\n    /**\n     * Says if the buffer is ready to take more requests\n     */\n    PromiseBuffer.prototype.isReady = function () {\n        return this._limit === undefined || this.length() < this._limit;\n    };\n    /**\n     * Add a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns The original promise.\n     */\n    PromiseBuffer.prototype.add = function (task) {\n        var _this = this;\n        if (!this.isReady()) {\n            return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n        }\n        if (this._buffer.indexOf(task) === -1) {\n            this._buffer.push(task);\n        }\n        task\n            .then(function () { return _this.remove(task); })\n            .then(null, function () {\n            return _this.remove(task).then(null, function () {\n                // We have to add this catch here otherwise we have an unhandledPromiseRejection\n                // because it's a new Promise chain.\n            });\n        });\n        return task;\n    };\n    /**\n     * Remove a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns Removed promise.\n     */\n    PromiseBuffer.prototype.remove = function (task) {\n        var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n        return removedTask;\n    };\n    /**\n     * This function returns the number of unresolved promises in the queue.\n     */\n    PromiseBuffer.prototype.length = function () {\n        return this._buffer.length;\n    };\n    /**\n     * This will drain the whole queue, returns true if queue is empty or drained.\n     * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n     *\n     * @param timeout Number in ms to wait until it resolves with false.\n     */\n    PromiseBuffer.prototype.drain = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            SyncPromise.all(_this._buffer)\n                .then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            })\n                .then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}());\nexport { PromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/promisebuffer.js\n// module id = 2747\n// module chunks = 28 43 45","import { getGlobalObject } from './misc';\nimport { dynamicRequire, isNodeEnv } from './node';\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n    nowSeconds: function () { return Date.now() / 1000; },\n};\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        return undefined;\n    }\n    // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n    //\n    // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n    // performance.now() gives a date arbitrarily in the past.\n    //\n    // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n    // undefined.\n    //\n    // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n    // interact with data coming out of performance entries.\n    //\n    // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n    // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n    // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n    // observed skews that can be as long as days, weeks or months.\n    //\n    // See https://github.com/getsentry/sentry-javascript/issues/2590.\n    //\n    // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n    // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n    // transactions of long-lived web pages.\n    var timeOrigin = Date.now() - performance.now();\n    return {\n        now: function () { return performance.now(); },\n        timeOrigin: timeOrigin,\n    };\n}\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n    try {\n        var perfHooks = dynamicRequire(module, 'perf_hooks');\n        return perfHooks.performance;\n    }\n    catch (_) {\n        return undefined;\n    }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },\n    };\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n// Re-exported with an old name for backwards-compatibility.\nexport var timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport var usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport var browserPerformanceTimeOrigin = (function () {\n    var performance = getGlobalObject().performance;\n    if (!performance) {\n        return undefined;\n    }\n    if (performance.timeOrigin) {\n        return performance.timeOrigin;\n    }\n    // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n    // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n    // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n    // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n    // Date API.\n    // eslint-disable-next-line deprecation/deprecation\n    return (performance.timing && performance.timing.navigationStart) || Date.now();\n})();\n//# sourceMappingURL=time.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/utils/esm/time.js\n// module id = 2748\n// module chunks = 28 43 45","import { __assign, __read, __spread } from \"tslib\";\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, isNodeEnv, logger, uuid4 } from '@sentry/utils';\nimport { Scope } from './scope';\nimport { Session } from './session';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        this.bindClient(client);\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var scope = Scope.clone(this.getScope());\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = dateTimestampInSeconds();\n        var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        // End existing session if there's one\n        this.endSession();\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        var session = new Session(__assign(__assign({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), context));\n        if (scope) {\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            session.close();\n            if (client && client.captureSession) {\n                client.captureSession(session);\n            }\n            scope.setSession();\n        }\n    };\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, __spread(args, [scope]));\n        }\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/** Returns the global shim registry. */\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Returns the active domain, if one exists\n *\n * @returns The domain, or undefined if there is no active domain\n */\nexport function getActiveDomain() {\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n}\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var activeDomain = getActiveDomain();\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or it's an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)\n        return carrier.__SENTRY__.hub;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/hub/esm/hub.js\n// module id = 2749\n// module chunks = 28 43 45","import { Dsn, urlEncode } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/** Helper class to provide urls to different Sentry endpoints. */\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn) {\n        this.dsn = dsn;\n        this._dsnObject = new Dsn(dsn);\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns the prefix to construct Sentry ingestion API endpoints. */\n    API.prototype.getBaseApiEndpoint = function () {\n        var dsn = this._dsnObject;\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    /** Returns the store endpoint URL. */\n    API.prototype.getStoreEndpoint = function () {\n        return this._getIngestEndpoint('store');\n    };\n    /**\n     * Returns the store 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     */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        return this.getStoreEndpoint() + \"?\" + this._encodedAuth();\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     */\n    API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {\n        return this._getEnvelopeEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /** Returns only the path component for the store endpoint. */\n    API.prototype.getStoreEndpointPath = function () {\n        var dsn = this._dsnObject;\n        return (dsn.path ? \"/\" + dsn.path : '') + \"/api/\" + dsn.projectId + \"/store/\";\n    };\n    /**\n     * Returns an object that can be used in request headers.\n     * This is needed for node and the old /store endpoint in sentry\n     */\n    API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n        var dsn = this._dsnObject;\n        var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n        header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n        header.push(\"sentry_key=\" + dsn.user);\n        if (dsn.pass) {\n            header.push(\"sentry_secret=\" + dsn.pass);\n        }\n        return {\n            'Content-Type': 'application/json',\n            'X-Sentry-Auth': header.join(', '),\n        };\n    };\n    /** Returns the url to the report dialog endpoint. */\n    API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n        if (dialogOptions === void 0) { dialogOptions = {}; }\n        var dsn = this._dsnObject;\n        var endpoint = this.getBaseApiEndpoint() + \"embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\n            if (key === 'dsn') {\n                continue;\n            }\n            if (key === 'user') {\n                if (!dialogOptions.user) {\n                    continue;\n                }\n                if (dialogOptions.user.name) {\n                    encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n                }\n                if (dialogOptions.user.email) {\n                    encodedOptions.push(\"email=\" + encodeURIComponent(dialogOptions.user.email));\n                }\n            }\n            else {\n                encodedOptions.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(dialogOptions[key]));\n            }\n        }\n        if (encodedOptions.length) {\n            return endpoint + \"?\" + encodedOptions.join('&');\n        }\n        return endpoint;\n    };\n    /** Returns the envelope endpoint URL. */\n    API.prototype._getEnvelopeEndpoint = function () {\n        return this._getIngestEndpoint('envelope');\n    };\n    /** Returns the ingest API endpoint for target. */\n    API.prototype._getIngestEndpoint = function (target) {\n        var base = this.getBaseApiEndpoint();\n        var dsn = this._dsnObject;\n        return \"\" + base + dsn.projectId + \"/\" + target + \"/\";\n    };\n    /** Returns a URL-encoded string with auth config suitable for a query string. */\n    API.prototype._encodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            // We send only the minimum set of required information. See\n            // https://github.com/getsentry/sentry-javascript/issues/2572.\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        return urlEncode(auth);\n    };\n    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/api.js\n// module id = 2750\n// module chunks = 28 43 45","import { __assign, __values } from \"tslib\";\n/* eslint-disable max-lines */\nimport { Scope } from '@sentry/hub';\nimport { SessionStatus, } from '@sentry/types';\nimport { dateTimestampInSeconds, Dsn, isPrimitive, isThenable, logger, normalize, SentryError, SyncPromise, truncate, uuid4, } from '@sentry/utils';\nimport { setupIntegrations } from './integration';\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\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 via the backend, 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<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nvar BaseClient = /** @class */ (function () {\n    /**\n     * Initializes this client instance.\n     *\n     * @param backendClass A constructor function to create the backend.\n     * @param options Options for the client.\n     */\n    function BaseClient(backendClass, options) {\n        /** Array of used integrations. */\n        this._integrations = {};\n        /** Number of call being processed */\n        this._processing = 0;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new Dsn(options.dsn);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._process(this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(String(message), level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        this._process(promisedEvent\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var eventId = hint && hint.event_id;\n        this._process(this._captureEvent(event, hint, scope).then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureSession = function (session) {\n        if (!session.release) {\n            logger.warn('Discarded session because of missing release');\n        }\n        else {\n            this._sendSession(session);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getDsn = function () {\n        return this._dsn;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getOptions = function () {\n        return this._options;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.flush = function (timeout) {\n        var _this = this;\n        return this._isClientProcessing(timeout).then(function (ready) {\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return ready && transportFlushed; });\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.close = function (timeout) {\n        var _this = this;\n        return this.flush(timeout).then(function (result) {\n            _this.getOptions().enabled = false;\n            return result;\n        });\n    };\n    /**\n     * Sets up the integrations\n     */\n    BaseClient.prototype.setupIntegrations = function () {\n        if (this._isEnabled()) {\n            this._integrations = setupIntegrations(this._options);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Updates existing session based on the provided event */\n    BaseClient.prototype._updateSessionFromEvent = function (session, event) {\n        var e_1, _a;\n        var crashed = false;\n        var errored = false;\n        var userAgent;\n        var exceptions = event.exception && event.exception.values;\n        if (exceptions) {\n            errored = true;\n            try {\n                for (var exceptions_1 = __values(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {\n                    var ex = exceptions_1_1.value;\n                    var mechanism = ex.mechanism;\n                    if (mechanism && mechanism.handled === false) {\n                        crashed = true;\n                        break;\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        }\n        var user = event.user;\n        if (!session.userAgent) {\n            var headers = event.request ? event.request.headers : {};\n            for (var key in headers) {\n                if (key.toLowerCase() === 'user-agent') {\n                    userAgent = headers[key];\n                    break;\n                }\n            }\n        }\n        session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { user: user,\n            userAgent: userAgent, errors: session.errors + Number(errored || crashed) }));\n    };\n    /** Deliver captured session to Sentry */\n    BaseClient.prototype._sendSession = function (session) {\n        this._getBackend().sendSession(session);\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = setInterval(function () {\n                if (_this._processing == 0) {\n                    clearInterval(interval);\n                    resolve(true);\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        clearInterval(interval);\n                        resolve(false);\n                    }\n                }\n            }, tick);\n        });\n    };\n    /** Returns the current backend. */\n    BaseClient.prototype._getBackend = function () {\n        return this._backend;\n    };\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n    BaseClient.prototype._isEnabled = function () {\n        return this.getOptions().enabled !== false && this._dsn !== undefined;\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    BaseClient.prototype._prepareEvent = function (event, scope, hint) {\n        var _this = this;\n        var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;\n        var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });\n        this._applyClientOptions(prepared);\n        this._applyIntegrationsMetadata(prepared);\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        var finalScope = scope;\n        if (hint && hint.captureContext) {\n            finalScope = Scope.clone(finalScope).update(hint.captureContext);\n        }\n        // We prepare the result here with a resolved Event.\n        var result = SyncPromise.resolve(prepared);\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            // In case we have a hub we reassign it.\n            result = finalScope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n                return _this._normalizeEvent(evt, normalizeDepth);\n            }\n            return evt;\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    BaseClient.prototype._normalizeEvent = function (event, depth) {\n        if (!event) {\n            return null;\n        }\n        var normalized = __assign(__assign(__assign(__assign(__assign({}, event), (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (__assign(__assign({}, b), (b.data && {\n                data: normalize(b.data, depth),\n            }))); }),\n        })), (event.user && {\n            user: normalize(event.user, depth),\n        })), (event.contexts && {\n            contexts: normalize(event.contexts, depth),\n        })), (event.extra && {\n            extra: normalize(event.extra, depth),\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) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            normalized.contexts.trace = event.contexts.trace;\n        }\n        return normalized;\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    BaseClient.prototype._applyClientOptions = function (event) {\n        var options = this.getOptions();\n        var environment = options.environment, release = options.release, dist = options.dist, _a = options.maxValueLength, maxValueLength = _a === void 0 ? 250 : _a;\n        if (!('environment' in event)) {\n            event.environment = 'environment' in options ? environment : 'production';\n        }\n        if (event.release === undefined && release !== undefined) {\n            event.release = release;\n        }\n        if (event.dist === undefined && dist !== undefined) {\n            event.dist = dist;\n        }\n        if (event.message) {\n            event.message = truncate(event.message, maxValueLength);\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        var request = event.request;\n        if (request && request.url) {\n            request.url = truncate(request.url, maxValueLength);\n        }\n    };\n    /**\n     * This function adds all used integrations to the SDK info in the event.\n     * @param sdkInfo The sdkInfo of the event that will be filled with all integrations.\n     */\n    BaseClient.prototype._applyIntegrationsMetadata = function (event) {\n        var sdkInfo = event.sdk;\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\n        }\n    };\n    /**\n     * Tells the backend to send this event\n     * @param event The Sentry event to send\n     */\n    BaseClient.prototype._sendEvent = function (event) {\n        this._getBackend().sendEvent(event);\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    BaseClient.prototype._captureEvent = function (event, hint, scope) {\n        return this._processEvent(event, hint, scope).then(function (finalEvent) {\n            return finalEvent.event_id;\n        }, function (reason) {\n            logger.error(reason);\n            return undefined;\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    BaseClient.prototype._processEvent = function (event, hint, scope) {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));\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            return SyncPromise.reject(new SentryError(\"Discarding event because it's not included in the random sample (sampling rate = \" + sampleRate + \")\"));\n        }\n        return this._prepareEvent(event, scope, hint)\n            .then(function (prepared) {\n            if (prepared === null) {\n                throw new SentryError('An event processor returned null, will not send event.');\n            }\n            var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n            if (isInternalException || isTransaction || !beforeSend) {\n                return prepared;\n            }\n            var beforeSendResult = beforeSend(prepared, hint);\n            if (typeof beforeSendResult === 'undefined') {\n                throw new SentryError('`beforeSend` method has to return `null` or a valid event.');\n            }\n            else if (isThenable(beforeSendResult)) {\n                return beforeSendResult.then(function (event) { return event; }, function (e) {\n                    throw new SentryError(\"beforeSend rejected with \" + e);\n                });\n            }\n            return beforeSendResult;\n        })\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                throw new SentryError('`beforeSend` returned `null`, will not send event.');\n            }\n            var session = scope && scope.getSession && scope.getSession();\n            if (!isTransaction && session) {\n                _this._updateSessionFromEvent(session, processedEvent);\n            }\n            _this._sendEvent(processedEvent);\n            return processedEvent;\n        })\n            .then(null, function (reason) {\n            if (reason instanceof SentryError) {\n                throw reason;\n            }\n            _this.captureException(reason, {\n                data: {\n                    __sentry__: true,\n                },\n                originalException: reason,\n            });\n            throw new SentryError(\"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     * Occupies the client with processing and event\n     */\n    BaseClient.prototype._process = function (promise) {\n        var _this = this;\n        this._processing += 1;\n        promise.then(function (value) {\n            _this._processing -= 1;\n            return value;\n        }, function (reason) {\n            _this._processing -= 1;\n            return reason;\n        });\n    };\n    return BaseClient;\n}());\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/baseclient.js\n// module id = 2751\n// module chunks = 28 43 45","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\nexport var installedIntegrations = [];\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && __spread(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) { return i.name; });\n        var pickedIntegrationsNames_1 = [];\n        // Leave only unique default integrations, that were not overridden with provided user integrations\n        defaultIntegrations.forEach(function (defaultIntegration) {\n            if (userIntegrationsNames_1.indexOf(defaultIntegration.name) === -1 &&\n                pickedIntegrationsNames_1.indexOf(defaultIntegration.name) === -1) {\n                integrations.push(defaultIntegration);\n                pickedIntegrationsNames_1.push(defaultIntegration.name);\n            }\n        });\n        // Don't add same user integration twice\n        userIntegrations.forEach(function (userIntegration) {\n            if (pickedIntegrationsNames_1.indexOf(userIntegration.name) === -1) {\n                integrations.push(userIntegration);\n                pickedIntegrationsNames_1.push(userIntegration.name);\n            }\n        });\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    else {\n        integrations = __spread(defaultIntegrations);\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) { return i.name; });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, __spread(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));\n    }\n    return integrations;\n}\n/** Setup given integration */\nexport function setupIntegration(integration) {\n    if (installedIntegrations.indexOf(integration.name) !== -1) {\n        return;\n    }\n    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n    installedIntegrations.push(integration.name);\n    logger.log(\"Integration installed: \" + integration.name);\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 */\nexport function setupIntegrations(options) {\n    var integrations = {};\n    getIntegrationsToSetup(options).forEach(function (integration) {\n        integrations[integration.name] = integration;\n        setupIntegration(integration);\n    });\n    return integrations;\n}\n//# sourceMappingURL=integration.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integration.js\n// module id = 2752\n// module chunks = 28 43 45","import { logger, SentryError } from '@sentry/utils';\nimport { NoopTransport } from './transports/noop';\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nvar BaseBackend = /** @class */ (function () {\n    /** Creates a new backend instance. */\n    function BaseBackend(options) {\n        this._options = options;\n        if (!this._options.dsn) {\n            logger.warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new SentryError('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new SentryError('Backend has to implement `eventFromMessage` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendEvent = function (event) {\n        this._transport.sendEvent(event).then(null, function (reason) {\n            logger.error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendSession = function (session) {\n        if (!this._transport.sendSession) {\n            logger.warn(\"Dropping session because custom transport doesn't implement sendSession\");\n            return;\n        }\n        this._transport.sendSession(session).then(null, function (reason) {\n            logger.error(\"Error while sending session: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    /**\n     * Sets up the transport so it can be used later to send requests.\n     */\n    BaseBackend.prototype._setupTransport = function () {\n        return new NoopTransport();\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/basebackend.js\n// module id = 2753\n// module chunks = 28 43 45","import { __rest } from \"tslib\";\n/** Creates a SentryRequest from an event. */\nexport function sessionToSentryRequest(session, api) {\n    var envelopeHeaders = JSON.stringify({\n        sent_at: new Date().toISOString(),\n    });\n    var itemHeaders = JSON.stringify({\n        type: 'session',\n    });\n    return {\n        body: envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + JSON.stringify(session),\n        type: 'session',\n        url: api.getEnvelopeEndpointWithUrlEncodedAuth(),\n    };\n}\n/** Creates a SentryRequest from an event. */\nexport function eventToSentryRequest(event, api) {\n    // since JS has no Object.prototype.pop()\n    var _a = event.tags || {}, samplingMethod = _a.__sentry_samplingMethod, sampleRate = _a.__sentry_sampleRate, otherTags = __rest(_a, [\"__sentry_samplingMethod\", \"__sentry_sampleRate\"]);\n    event.tags = otherTags;\n    var useEnvelope = event.type === 'transaction';\n    var req = {\n        body: JSON.stringify(event),\n        type: event.type || 'event',\n        url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),\n    };\n    // https://develop.sentry.dev/sdk/envelopes/\n    // Since we don't need to manipulate envelopes nor store them, there is no\n    // exported concept of an Envelope with operations including serialization and\n    // deserialization. Instead, we only implement a minimal subset of the spec to\n    // serialize events inline here.\n    if (useEnvelope) {\n        var envelopeHeaders = JSON.stringify({\n            event_id: event.event_id,\n            sent_at: new Date().toISOString(),\n        });\n        var itemHeaders = JSON.stringify({\n            type: event.type,\n            // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and\n            // explicitly-set sampling decisions). Are we good with that?\n            sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n        });\n        // The trailing newline is optional. We intentionally don't send it to avoid\n        // sending unnecessary bytes.\n        //\n        // const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}\\n`;\n        var envelope = envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + req.body;\n        req.body = envelope;\n    }\n    return req;\n}\n//# sourceMappingURL=request.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/request.js\n// module id = 2754\n// module chunks = 28 43 45","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\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 */\nexport function initAndBind(clientClass, options) {\n    if (options.debug === true) {\n        logger.enable();\n    }\n    var hub = getCurrentHub();\n    var client = new clientClass(options);\n    hub.bindClient(client);\n}\n//# sourceMappingURL=sdk.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/sdk.js\n// module id = 2755\n// module chunks = 28 43 45","export { FunctionToString } from './functiontostring';\nexport { InboundFilters } from './inboundfilters';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integrations/index.js\n// module id = 2756\n// module chunks = 28 43 45","var originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\nvar FunctionToString = /** @class */ (function () {\n    function FunctionToString() {\n        /**\n         * @inheritDoc\n         */\n        this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.prototype.setupOnce = function () {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        originalFunctionToString = Function.prototype.toString;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        Function.prototype.toString = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var context = this.__sentry_original__ || this;\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}());\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integrations/functiontostring.js\n// module id = 2757\n// module chunks = 28 43 45","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils';\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/** Inbound filters configurable by the user */\nvar InboundFilters = /** @class */ (function () {\n    function InboundFilters(_options) {\n        if (_options === void 0) { _options = {}; }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var hub = getCurrentHub();\n            if (!hub) {\n                return event;\n            }\n            var self = hub.getIntegration(InboundFilters);\n            if (self) {\n                var client = hub.getClient();\n                var clientOptions = client ? client.getOptions() : {};\n                var options = self._mergeOptions(clientOptions);\n                if (self._shouldDropEvent(event, options)) {\n                    return null;\n                }\n            }\n            return event;\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._shouldDropEvent = function (event, options) {\n        if (this._isSentryError(event, options)) {\n            logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isDeniedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `denyUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isAllowedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `allowUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isSentryError = function (event, options) {\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return ((event &&\n                event.exception &&\n                event.exception.values &&\n                event.exception.values[0] &&\n                event.exception.values[0].type === 'SentryError') ||\n                false);\n        }\n        catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (!options.ignoreErrors || !options.ignoreErrors.length) {\n            return false;\n        }\n        return this._getPossibleEventMessages(event).some(function (message) {\n            // Not sure why TypeScript complains here...\n            return options.ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isDeniedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.denyUrls || !options.denyUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.denyUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isAllowedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.allowUrls || !options.allowUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.allowUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) { clientOptions = {}; }\n        return {\n            allowUrls: __spread((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),\n            denyUrls: __spread((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),\n            ignoreErrors: __spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n        };\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getPossibleEventMessages = function (event) {\n        if (event.message) {\n            return [event.message];\n        }\n        if (event.exception) {\n            try {\n                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            }\n            catch (oO) {\n                logger.error(\"Cannot extract message for event \" + getEventDescription(event));\n                return [];\n            }\n        }\n        return [];\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getEventFilterUrl = function (event) {\n        try {\n            if (event.stacktrace) {\n                var frames_1 = event.stacktrace.frames;\n                return (frames_1 && frames_1[frames_1.length - 1].filename) || null;\n            }\n            if (event.exception) {\n                var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n                return (frames_2 && frames_2[frames_2.length - 1].filename) || null;\n            }\n            return null;\n        }\n        catch (oO) {\n            logger.error(\"Cannot extract url for event \" + getEventDescription(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}());\nexport { InboundFilters };\n//# sourceMappingURL=inboundfilters.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/core/esm/integrations/inboundfilters.js\n// module id = 2758\n// module chunks = 28 43 45","import { __assign, __extends } from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    __extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        return eventFromException(this._options, exception, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        return eventFromMessage(this._options, message, level, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            return new FetchTransport(transportOptions);\n        }\n        return new XHRTransport(transportOptions);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/backend.js\n// module id = 2759\n// module chunks = 28 43 45","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { getGlobalObject, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    __extends(FetchTransport, _super);\n    function FetchTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var options = {\n            body: sentryRequest.body,\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),\n        };\n        if (this.options.fetchParameters !== undefined) {\n            Object.assign(options, this.options.fetchParameters);\n        }\n        if (this.options.headers !== undefined) {\n            options.headers = this.options.headers;\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            global\n                .fetch(sentryRequest.url, options)\n                .then(function (response) {\n                var headers = {\n                    'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                    'retry-after': response.headers.get('Retry-After'),\n                };\n                _this._handleResponse({\n                    requestType: sentryRequest.type,\n                    response: response,\n                    headers: headers,\n                    resolve: resolve,\n                    reject: reject,\n                });\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/fetch.js\n// module id = 2760\n// module chunks = 28 43 45","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    __extends(XHRTransport, _super);\n    function XHRTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState === 4) {\n                    var headers = {\n                        'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                        'retry-after': request.getResponseHeader('Retry-After'),\n                    };\n                    _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });\n                }\n            };\n            request.open('POST', sentryRequest.url);\n            for (var header in _this.options.headers) {\n                if (_this.options.headers.hasOwnProperty(header)) {\n                    request.setRequestHeader(header, _this.options.headers[header]);\n                }\n            }\n            request.send(sentryRequest.body);\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/transports/xhr.js\n// module id = 2761\n// module chunks = 28 43 45","import { __assign } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addInstrumentationHandler, getLocationHref, isErrorEvent, isPrimitive, isString, logger, } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = __assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        var _this = this;\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (data) {\n                var error = data.error;\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n                    : _this._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: false,\n                    }), data.url, data.line, data.column);\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onerror',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n            },\n            type: 'error',\n        });\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        var _this = this;\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (e) {\n                var error = e;\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                }\n                catch (_oO) {\n                    // no-empty\n                }\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return true;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromRejectionWithPrimitive(error)\n                    : eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: true,\n                    });\n                event.level = Severity.Error;\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onunhandledrejection',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n                return;\n            },\n            type: 'unhandledrejection',\n        });\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (msg, url, line, column) {\n        var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n        // If 'message' is ErrorEvent, get real message from inside\n        var message = isErrorEvent(msg) ? msg.message : msg;\n        var name;\n        if (isString(message)) {\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 || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\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     */\n    GlobalHandlers.prototype._eventFromRejectionWithPrimitive = function (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    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];\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        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/globalhandlers.js\n// module id = 2762\n// module chunks = 28 43 45","import { __assign } from \"tslib\";\nimport { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\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/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function TryCatch(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n        this._options = __assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        var global = getGlobalObject();\n        if (this._options.setTimeout) {\n            fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.setInterval) {\n            fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.requestAnimationFrame) {\n            fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        if (this._options.eventTarget) {\n            var eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(this._wrapEventTarget.bind(this));\n        }\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\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    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TryCatch.prototype._wrapRAF = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function (callback) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return original.call(this, 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    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var global = getGlobalObject();\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: getFunctionName(fn),\n                                    target: target,\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    }\n                }\n                catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, \n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                wrap(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: getFunctionName(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }), options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (eventName, fn, options) {\n                var _a;\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 = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__sentry_wrapped__;\n                    if (originalEventHandler) {\n                        originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n                    }\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    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in xhr && typeof xhr[prop] === 'function') {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\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                        // If Instrument integration has been called before TryCatch, get the name of original function\n                        if (original.__sentry_original__) {\n                            wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\n                        }\n                        // Otherwise wrap directly\n                        return wrap(original, wrapOptions);\n                    });\n                }\n            });\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/trycatch.js\n// module id = 2763\n// module chunks = 28 43 45","import { __assign, __read, __spread } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, parseUrl, safeJoin, } from '@sentry/utils';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = __assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Create a breadcrumb of `sentry` from the events themselves\n     */\n    Breadcrumbs.prototype.addSentryBreadcrumb = function (event) {\n        if (!this._options.sentry) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"sentry.\" + (event.type === 'transaction' ? 'transaction' : 'event'),\n            event_id: event.event_id,\n            level: event.level,\n            message: getEventDescription(event),\n        }, {\n            event: event,\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    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console',\n            },\n            level: Severity.fromString(handlerData.level),\n            message: safeJoin(handlerData.args, ' '),\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            }\n            else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        getCurrentHub().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level,\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? htmlTreeAsString(handlerData.event.target)\n                : htmlTreeAsString(handlerData.event);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: handlerData.event,\n            name: handlerData.name,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._xhrBreadcrumb = function (handlerData) {\n        if (handlerData.endTimestamp) {\n            // We only capture complete, non-sentry requests\n            if (handlerData.xhr.__sentry_own_request__) {\n                return;\n            }\n            var _a = handlerData.xhr.__sentry_xhr__ || {}, method = _a.method, url = _a.url, status_code = _a.status_code, body = _a.body;\n            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: {\n                    method: method,\n                    url: url,\n                    status_code: status_code,\n                },\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n                input: body,\n            });\n            return;\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\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        if (handlerData.error) {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: handlerData.fetchData,\n                level: Severity.Error,\n                type: 'http',\n            }, {\n                data: handlerData.error,\n                input: handlerData.args,\n            });\n        }\n        else {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: __assign(__assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),\n                type: 'http',\n            }, {\n                input: handlerData.args,\n                response: handlerData.response,\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from history API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = getGlobalObject();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = parseUrl(global.location.href);\n        var parsedFrom = parseUrl(from);\n        var parsedTo = parseUrl(to);\n        // Initial pushState doesn't provide `from` information\n        if (!parsedFrom.path) {\n            parsedFrom = parsedLoc;\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        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/breadcrumbs.js\n// module id = 2764\n// module chunks = 28 43 45","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event, hint) {\n            var self = getCurrentHub().getIntegration(LinkedErrors);\n            if (self) {\n                return self._handler(event, hint);\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = __spread(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = computeStackTrace(error[key]);\n        var exception = exceptionFromStacktrace(stacktrace);\n        return this._walkErrorTree(error[key], key, __spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/linkederrors.js\n// module id = 2765\n// module chunks = 28 43 45","import { __assign } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var _a, _b, _c;\n            if (getCurrentHub().getIntegration(UserAgent)) {\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                // grab as much info as exists and add it to the event\n                var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global.location) === null || _b === void 0 ? void 0 : _b.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = __assign(__assign(__assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));\n                var request = __assign(__assign({}, (url && { url: url })), { headers: headers });\n                return __assign(__assign({}, event), { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\nexport { UserAgent };\n//# sourceMappingURL=useragent.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/integrations/useragent.js\n// module id = 2766\n// module chunks = 28 43 45","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject, SyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [\n    new CoreIntegrations.InboundFilters(),\n    new CoreIntegrations.FunctionToString(),\n    new TryCatch(),\n    new Breadcrumbs(),\n    new GlobalHandlers(),\n    new LinkedErrors(),\n    new UserAgent(),\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 */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    if (options.autoSessionTracking === undefined) {\n        options.autoSessionTracking = false;\n    }\n    initAndBind(BrowserClient, options);\n    if (options.autoSessionTracking) {\n        startSessionTracking();\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 */\nexport function showReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        options.eventId = getCurrentHub().lastEventId();\n    }\n    var client = getCurrentHub().getClient();\n    if (client) {\n        client.showReportDialog(options);\n    }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId() {\n    return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad() {\n    // Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback) {\n    callback();\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function flush(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function close(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return SyncPromise.reject(false);\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn) {\n    return internalWrap(fn)();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n    var window = getGlobalObject();\n    var hub = getCurrentHub();\n    /**\n     * We should be using `Promise.all([windowLoaded, firstContentfulPaint])` here,\n     * but, as always, it's not available in the IE10-11. Thanks IE.\n     */\n    var loadResolved = document.readyState === 'complete';\n    var fcpResolved = false;\n    var possiblyEndSession = function () {\n        if (fcpResolved && loadResolved) {\n            hub.endSession();\n        }\n    };\n    var resolveWindowLoaded = function () {\n        loadResolved = true;\n        possiblyEndSession();\n        window.removeEventListener('load', resolveWindowLoaded);\n    };\n    hub.startSession();\n    if (!loadResolved) {\n        // IE doesn't support `{ once: true }` for event listeners, so we have to manually\n        // attach and then detach it once completed.\n        window.addEventListener('load', resolveWindowLoaded);\n    }\n    try {\n        var po = new PerformanceObserver(function (entryList, po) {\n            entryList.getEntries().forEach(function (entry) {\n                if (entry.name === 'first-contentful-paint' && entry.startTime < firstHiddenTime_1) {\n                    po.disconnect();\n                    fcpResolved = true;\n                    possiblyEndSession();\n                }\n            });\n        });\n        // There's no need to even attach this listener if `PerformanceObserver` constructor will fail,\n        // so we do it below here.\n        var firstHiddenTime_1 = document.visibilityState === 'hidden' ? 0 : Infinity;\n        document.addEventListener('visibilitychange', function (event) {\n            firstHiddenTime_1 = Math.min(firstHiddenTime_1, event.timeStamp);\n        }, { once: true });\n        po.observe({\n            type: 'paint',\n            buffered: true,\n        });\n    }\n    catch (e) {\n        fcpResolved = true;\n        possiblyEndSession();\n    }\n}\n//# sourceMappingURL=sdk.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/node_modules/@sentry/browser/esm/sdk.js\n// module id = 2767\n// module chunks = 28 43 45","import { __assign, __read, __spread } from \"tslib\";\n/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { BrowserClient, defaultIntegrations, getCurrentHub } from '@sentry/browser';\nimport { initAndBind } from '@sentry/core';\nimport { basename, getGlobalObject, logger, timestampWithMs } from '@sentry/utils';\nimport { createVueEventProcessor } from './eventprocessor';\n// Mappings from operation to corresponding lifecycle hook.\nvar HOOKS = {\n    activate: ['activated', 'deactivated'],\n    create: ['beforeCreate', 'created'],\n    destroy: ['beforeDestroy', 'destroyed'],\n    mount: ['beforeMount', 'mounted'],\n    update: ['beforeUpdate', 'updated'],\n};\nvar COMPONENT_NAME_REGEXP = /(?:^|[-_/])(\\w)/g;\nvar ROOT_COMPONENT_NAME = 'root';\nvar ANONYMOUS_COMPONENT_NAME = 'anonymous component';\n/**\n * Inits the Vue SDK\n */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    var finalOptions = __assign(__assign({ \n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        Vue: getGlobalObject().Vue, attachProps: true, logErrors: false, tracing: false }, options), { tracingOptions: __assign({ hooks: ['activate', 'mount', 'update'], timeout: 2000, trackComponents: false }, options.tracingOptions) });\n    initAndBind(BrowserClient, finalOptions);\n    if (finalOptions.Vue === undefined) {\n        logger.warn('No Vue instance was provided. Also there is no Vue instance on the `window` object.');\n        logger.warn('We will only capture global unhandled errors.');\n    }\n    else {\n        var vueHelper = new VueHelper(finalOptions);\n        vueHelper.setup();\n    }\n    createVueEventProcessor();\n}\n/** JSDoc */\nvar VueHelper = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function VueHelper(options) {\n        var _this = this;\n        /**\n         * Cache holding already processed component names\n         */\n        this._componentsCache = {};\n        /** Keep it as attribute function, to keep correct `this` binding inside the hooks callbacks  */\n        // eslint-disable-next-line @typescript-eslint/typedef\n        this._applyTracingHooks = function (vm) {\n            // Don't attach twice, just in case\n            if (vm.$options.$_sentryPerfHook) {\n                return;\n            }\n            vm.$options.$_sentryPerfHook = true;\n            var name = _this._getComponentName(vm);\n            var rootMount = name === ROOT_COMPONENT_NAME;\n            var spans = {};\n            // Render hook starts after once event is emitted,\n            // but it ends before the second event of the same type.\n            //\n            // Because of this, we start measuring inside the first event,\n            // but finish it before it triggers, to skip the event emitter timing itself.\n            var rootHandler = function (hook) {\n                var now = timestampWithMs();\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (_this._rootSpan) {\n                    _this._finishRootSpan(now);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        // Create an activity on the first event call. There'll be no second call, as rootSpan will be in place,\n                        // thus new event handler won't be attached.\n                        var activeTransaction = getActiveTransaction();\n                        if (activeTransaction) {\n                            _this._rootSpan = activeTransaction.startChild({\n                                description: 'Application Render',\n                                op: 'Vue',\n                            });\n                        }\n                    });\n                }\n            };\n            var childHandler = function (hook, operation) {\n                // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n                var shouldTrack = Array.isArray(_this._options.tracingOptions.trackComponents)\n                    ? _this._options.tracingOptions.trackComponents.indexOf(name) > -1\n                    : _this._options.tracingOptions.trackComponents;\n                var childOf = _this._rootSpan || getActiveTransaction();\n                if (!childOf || !shouldTrack) {\n                    return;\n                }\n                var now = timestampWithMs();\n                var span = spans[operation];\n                // On the first handler call (before), it'll be undefined, as `$once` will add it in the future.\n                // However, on the second call (after), it'll be already in place.\n                if (span) {\n                    span.finish();\n                    _this._finishRootSpan(now);\n                }\n                else {\n                    vm.$once(\"hook:\" + hook, function () {\n                        if (childOf) {\n                            spans[operation] = childOf.startChild({\n                                description: \"Vue <\" + name + \">\",\n                                op: operation,\n                            });\n                        }\n                    });\n                }\n            };\n            // Each component has it's own scope, so all activities are only related to one of them\n            _this._options.tracingOptions.hooks.forEach(function (operation) {\n                // Retrieve corresponding hooks from Vue lifecycle.\n                // eg. mount => ['beforeMount', 'mounted']\n                var internalHooks = HOOKS[operation];\n                if (!internalHooks) {\n                    logger.warn(\"Unknown hook: \" + operation);\n                    return;\n                }\n                internalHooks.forEach(function (internalHook) {\n                    var handler = rootMount\n                        ? rootHandler.bind(_this, internalHook)\n                        : childHandler.bind(_this, internalHook, operation);\n                    var currentValue = vm.$options[internalHook];\n                    if (Array.isArray(currentValue)) {\n                        vm.$options[internalHook] = __spread([handler], currentValue);\n                    }\n                    else if (typeof currentValue === 'function') {\n                        vm.$options[internalHook] = [handler, currentValue];\n                    }\n                    else {\n                        vm.$options[internalHook] = [handler];\n                    }\n                });\n            });\n        };\n        this._options = options;\n    }\n    /**\n     * Attaches the error handler and starts tracing\n     */\n    VueHelper.prototype.setup = function () {\n        this._attachErrorHandler();\n        if ('tracesSampleRate' in this._options || 'tracesSampler' in this._options) {\n            this._startTracing();\n        }\n    };\n    /**\n     * Extract component name from the ViewModel\n     */\n    VueHelper.prototype._getComponentName = function (vm) {\n        // Such level of granularity is most likely not necessary, but better safe than sorry. — Kamil\n        if (!vm) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$root === vm) {\n            return ROOT_COMPONENT_NAME;\n        }\n        if (!vm.$options) {\n            return ANONYMOUS_COMPONENT_NAME;\n        }\n        if (vm.$options.name) {\n            return vm.$options.name;\n        }\n        if (vm.$options._componentTag) {\n            return vm.$options._componentTag;\n        }\n        // injected by vue-loader\n        if (vm.$options.__file) {\n            var unifiedFile = vm.$options.__file.replace(/^[a-zA-Z]:/, '').replace(/\\\\/g, '/');\n            var filename = basename(unifiedFile, '.vue');\n            return (this._componentsCache[filename] ||\n                (this._componentsCache[filename] = filename.replace(COMPONENT_NAME_REGEXP, function (_, c) {\n                    return c ? c.toUpperCase() : '';\n                })));\n        }\n        return ANONYMOUS_COMPONENT_NAME;\n    };\n    /** Finish top-level span and activity with a debounce configured using `timeout` option */\n    VueHelper.prototype._finishRootSpan = function (timestamp) {\n        var _this = this;\n        if (this._rootSpanTimer) {\n            clearTimeout(this._rootSpanTimer);\n        }\n        this._rootSpanTimer = setTimeout(function () {\n            // We should always finish the span, only should pop activity if using @sentry/apm\n            if (_this._rootSpan) {\n                _this._rootSpan.finish(timestamp);\n                _this._rootSpan = undefined;\n            }\n        }, this._options.tracingOptions.timeout);\n    };\n    /** Inject configured tracing hooks into Vue's component lifecycles */\n    VueHelper.prototype._startTracing = function () {\n        var applyTracingHooks = this._applyTracingHooks;\n        var appliedTracingHooks = setTimeout(function () {\n            logger.warn(\"Didn't apply tracing hooks, make sure you call Sentry.init before initialzing Vue!\");\n        }, 500);\n        this._options.Vue.mixin({\n            beforeCreate: function () {\n                clearTimeout(appliedTracingHooks);\n                applyTracingHooks(this);\n            },\n        });\n    };\n    /** Inject Sentry's handler into owns Vue's error handler  */\n    VueHelper.prototype._attachErrorHandler = function () {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var currentErrorHandler = this._options.Vue.config.errorHandler;\n        this._options.Vue.config.errorHandler = function (error, vm, info) {\n            var metadata = {};\n            if (vm) {\n                try {\n                    metadata.componentName = _this._getComponentName(vm);\n                    if (_this._options.attachProps) {\n                        metadata.propsData = vm.$options.propsData;\n                    }\n                }\n                catch (_oO) {\n                    logger.warn('Unable to extract metadata from Vue component.');\n                }\n            }\n            if (info) {\n                metadata.lifecycleHook = info;\n            }\n            // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n            setTimeout(function () {\n                getCurrentHub().withScope(function (scope) {\n                    scope.setContext('vue', metadata);\n                    getCurrentHub().captureException(error);\n                });\n            });\n            if (typeof currentErrorHandler === 'function') {\n                currentErrorHandler.call(_this._options.Vue, error, vm, info);\n            }\n            if (_this._options.logErrors) {\n                if (_this._options.Vue.util) {\n                    _this._options.Vue.util.warn(\"Error in \" + info + \": \\\"\" + error.toString() + \"\\\"\", vm);\n                }\n                // eslint-disable-next-line no-console\n                console.error(error);\n            }\n        };\n    };\n    return VueHelper;\n}());\n/** Grabs active transaction off scope, if any */\nexport function getActiveTransaction() {\n    var _a;\n    return (_a = getCurrentHub()\n        .getScope()) === null || _a === void 0 ? void 0 : _a.getTransaction();\n}\n//# sourceMappingURL=sdk.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/esm/sdk.js\n// module id = 2768\n// module chunks = 28 43 45","import { __assign, __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, SDK_VERSION } from '@sentry/browser';\n/**\n * A global side effect that makes sure Sentry events that user\n * `@sentry/react` will correctly have Sentry events associated\n * with it.\n */\nexport function createVueEventProcessor() {\n    addGlobalEventProcessor(function (event) {\n        event.sdk = __assign(__assign({}, event.sdk), { name: 'sentry.javascript.vue', packages: __spread(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/vue',\n                    version: SDK_VERSION,\n                },\n            ]), version: SDK_VERSION });\n        return event;\n    });\n}\n//# sourceMappingURL=eventprocessor.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/esm/eventprocessor.js\n// module id = 2769\n// module chunks = 28 43 45","import { captureException } from '@sentry/browser';\nvar firstLoad = true;\n/**\n * Creates routing instrumentation for Vue Router v2\n *\n * @param router The Vue Router instance that is used\n */\nexport function vueRouterInstrumentation(router) {\n    return function (startTransaction, startTransactionOnPageLoad, startTransactionOnLocationChange) {\n        if (startTransactionOnPageLoad === void 0) { startTransactionOnPageLoad = true; }\n        if (startTransactionOnLocationChange === void 0) { startTransactionOnLocationChange = true; }\n        router.onError(function (error) { return captureException(error); });\n        var tags = {\n            'routing.instrumentation': 'vue-router',\n        };\n        router.beforeEach(function (to, _from, next) {\n            var data = {\n                params: to.params,\n                query: to.query,\n            };\n            if (startTransactionOnPageLoad && firstLoad) {\n                startTransaction({\n                    name: to.name || to.path,\n                    op: 'pageload',\n                    tags: tags,\n                    data: data,\n                });\n            }\n            if (startTransactionOnLocationChange && !firstLoad) {\n                startTransaction({\n                    name: to.name || to.matched[0].path || to.path,\n                    op: 'navigation',\n                    tags: tags,\n                    data: data,\n                });\n            }\n            firstLoad = false;\n            next();\n        });\n    };\n}\n//# sourceMappingURL=vuerouter.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@sentry/vue/esm/vuerouter.js\n// module id = 2770\n// module chunks = 28 43 45","var render = function() {\n  var _vm = this\n  var _h = _vm.$createElement\n  var _c = _vm._self._c || _h\n  return _c(\n    \"div\",\n    [\n      _c(\n        \"b-modal\",\n        {\n          attrs: {\n            centered: \"\",\n            \"cancel-disabled\": \"\",\n            \"no-close-on-esc\": \"\",\n            \"no-close-on-backdrop\": \"\",\n            \"hide-header-close\": \"\",\n            title: _vm.getErrorTitle,\n            \"hide-footer\": \"\"\n          },\n          model: {\n            value: _vm.modalShow,\n            callback: function($$v) {\n              _vm.modalShow = $$v\n            },\n            expression: \"modalShow\"\n          }\n        },\n        [\n          !_vm.supportChatVisible\n            ? _c(\"div\", { staticClass: \"text-center\" }, [\n                _c(\"div\", { staticClass: \"mx-auto error-img\" }, [\n                  _c(\"img\", {\n                    attrs: {\n                      width: \"96px\",\n                      height: \"96px\",\n                      src: _vm.getErrorImg\n                    }\n                  })\n                ]),\n                _vm._v(\" \"),\n                _c(\"p\", {\n                  staticClass: \"text-center\",\n                  class: { \"text-danger\": !_vm.customError },\n                  domProps: { innerHTML: _vm._s(_vm.getErrorMsg) }\n                }),\n                _vm._v(\" \"),\n                !_vm.customError\n                  ? _c(\"div\", [\n                      _c(\n                        \"a\",\n                        {\n                          staticClass: \"clickable small\",\n                          on: { click: _vm.toggleShowDetailedError }\n                        },\n                        [\n                          _vm._v(\n                            _vm._s(\n                              _vm.showDetailedError\n                                ? _vm.$t(\"hide-detailed-error\")\n                                : _vm.$t(\"show-detailed-error\")\n                            )\n                          )\n                        ]\n                      ),\n                      _vm._v(\" \"),\n                      _vm.showDetailedError\n                        ? _c(\"div\", { staticClass: \"code-format mt-2\" }, [\n                            _vm._v(\"\\n          Error: \"),\n                            _c(\"b\", [_vm._v(_vm._s(_vm.opentok.error.title))]),\n                            _c(\"br\"),\n                            _vm._v(\n                              \"\\n          \" +\n                                _vm._s(_vm.opentok.error.msg) +\n                                \"\\n        \"\n                            )\n                          ])\n                        : _vm._e()\n                    ])\n                  : _vm._e(),\n                _vm._v(\" \"),\n                _vm.getCustomErrorBtnMsg !== \"\"\n                  ? _c(\n                      \"div\",\n                      { staticClass: \"col text-center pt-3\" },\n                      [\n                        (_vm.smallToken = !\"\" && !_vm.getCustomErrorBtnMsg)\n                          ? _c(\n                              \"b-button\",\n                              {\n                                attrs: {\n                                  center: \"\",\n                                  \"align-h\": \"center\",\n                                  variant: \"outline-\" + _vm.getErrorColorVariant\n                                },\n                                on: { click: _vm.pageReload }\n                              },\n                              [\n                                _c(\"b-icon\", {\n                                  attrs: {\n                                    icon: \"arrow-counterclockwise\",\n                                    \"aria-hidden\": \"true\"\n                                  }\n                                }),\n                                _vm._v(\" \" + _vm._s(_vm.$t(\"retry\")))\n                              ],\n                              1\n                            )\n                          : _vm._e(),\n                        _vm._v(\" \"),\n                        _vm.getCustomErrorBtnMsg\n                          ? _c(\n                              \"b-button\",\n                              {\n                                attrs: {\n                                  center: \"\",\n                                  \"align-h\": \"center\",\n                                  variant: \"outline-\" + _vm.getErrorColorVariant\n                                },\n                                on: { click: _vm.doCustomErrorAction }\n                              },\n                              [\n                                _vm._v(\n                                  \"\\n          \" +\n                                    _vm._s(_vm.getCustomErrorBtnMsg) +\n                                    \"\\n        \"\n                                )\n                              ]\n                            )\n                          : _vm._e()\n                      ],\n                      1\n                    )\n                  : _vm._e()\n              ])\n            : _c(\"div\", [_c(\"hubspot-chat\")], 1),\n          _vm._v(\" \"),\n          _c(\n            \"div\",\n            { staticClass: \"text-center mt-4\" },\n            [\n              _c(\n                \"b-button\",\n                {\n                  attrs: { variant: \"outline-info\", size: \"sm\" },\n                  on: {\n                    click: function($event) {\n                      return _vm.$helpers.openSupportChat()\n                    }\n                  }\n                },\n                [\n                  _vm._v(\n                    _vm._s(\n                      _vm.supportChatVisible\n                        ? _vm.$t(\"back\")\n                        : _vm.$t(\"contact-by-chat-tech-problems\")\n                    )\n                  )\n                ]\n              )\n            ],\n            1\n          )\n        ]\n      )\n    ],\n    1\n  )\n}\nvar staticRenderFns = []\nrender._withStripped = true\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\nexport default esExports\nif (module.hot) {\n  module.hot.accept()\n  if (module.hot.data) {\n    require(\"vue-hot-reload-api\")      .rerender(\"data-v-23316cdb\", esExports)\n  }\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/lib/template-compiler?{\"id\":\"data-v-23316cdb\",\"hasScoped\":false,\"transformToRequire\":{\"video\":[\"src\",\"poster\"],\"source\":\"src\",\"img\":\"src\",\"image\":\"xlink:href\"},\"buble\":{\"transforms\":{}}}!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./src/components/video-launcher/Error.vue\n// module id = 2771\n// module chunks = 28 43 45"],"sourceRoot":""}