{"version":3,"sources":["webpack:///article-video-loop-bundle-v2-b6f6769c83bf51fb0f0a.js","webpack:///webpack/bootstrap ef783f40e3a096e0ced5","webpack:///./node_modules/@sentry/utils/esm/index.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/axios/lib/utils.js","webpack:///./node_modules/@sentry/core/esm/index.js","webpack:///./node_modules/@sentry/types/esm/index.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/hub/esm/index.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/domready/ready.js","webpack:///./src/lib/nodelistToArray.js","webpack:///./src/lib/uuid.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/browser/esm/tracekit.js","webpack:///./node_modules/@sentry/browser/esm/transports/base.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/axios/index.js","webpack:///./node_modules/axios/lib/helpers/bind.js","webpack:///./node_modules/axios/lib/helpers/buildURL.js","webpack:///./node_modules/axios/lib/cancel/isCancel.js","webpack:///./node_modules/axios/lib/defaults.js","webpack:///./node_modules/axios/lib/adapters/xhr.js","webpack:///./node_modules/axios/lib/core/createError.js","webpack:///./node_modules/axios/lib/core/mergeConfig.js","webpack:///./node_modules/axios/lib/cancel/Cancel.js","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/core/esm/transports/noop.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/browser/esm/parsers.js","webpack:///./node_modules/@sentry/browser/esm/transports/index.js","webpack:///./node_modules/@sentry/browser/esm/version.js","webpack:///./node_modules/@sentry/browser/esm/integrations/index.js","webpack:///./src/article/client.videoLoop.js","webpack:///./node_modules/@nrk/dh-basis-levende-stillbilde/dh-basis-levende-stillbilde.esm.js","webpack:///./node_modules/@nrk/dh-basis-levende-stillbilde/node_modules/@nrk/dh-basis-common/dh-basis-common.esm.js","webpack:///./node_modules/axios/lib/axios.js","webpack:///./node_modules/axios/lib/core/Axios.js","webpack:///./node_modules/axios/lib/core/InterceptorManager.js","webpack:///./node_modules/axios/lib/core/dispatchRequest.js","webpack:///./node_modules/axios/lib/core/transformData.js","webpack:///./node_modules/axios/lib/helpers/normalizeHeaderName.js","webpack:///./node_modules/axios/lib/core/settle.js","webpack:///./node_modules/axios/lib/core/enhanceError.js","webpack:///./node_modules/axios/lib/core/buildFullPath.js","webpack:///./node_modules/axios/lib/helpers/isAbsoluteURL.js","webpack:///./node_modules/axios/lib/helpers/combineURLs.js","webpack:///./node_modules/axios/lib/helpers/parseHeaders.js","webpack:///./node_modules/axios/lib/helpers/isURLSameOrigin.js","webpack:///./node_modules/axios/lib/helpers/cookies.js","webpack:///./node_modules/axios/lib/cancel/CancelToken.js","webpack:///./node_modules/axios/lib/helpers/spread.js","webpack:///./node_modules/@nrk/dh-basis-common/dh-basis-common.esm.js","webpack:///./src/article/components/VideoLoop.css","webpack:///./node_modules/@sentry/browser/esm/index.js","webpack:///./node_modules/@sentry/browser/esm/exports.js","webpack:///./node_modules/@sentry/types/esm/loglevel.js","webpack:///./node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/types/esm/span.js","webpack:///./node_modules/@sentry/types/esm/status.js","webpack:///./node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/utils/esm/async.js","webpack:///./node_modules/@sentry/utils/esm/polyfill.js","webpack:///./node_modules/@sentry/utils/esm/path.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/core/esm/basebackend.js","webpack:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/core/esm/integrations/index.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/browser/esm/backend.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js","webpack:///./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/browser/esm/integrations/useragent.js","webpack:///./node_modules/@webcomponents/custom-elements/custom-elements.min.js","webpack:///./node_modules/intersection-observer/intersection-observer.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","value","_async","keys","forEach","key","_error","_is","_logger","_memo","_misc","_object","_path","_promisebuffer","_string","_supports","_syncpromise","_instrument","_dsn","__extends","b","__","this","constructor","extendStatics","create","__rest","e","t","indexOf","getOwnPropertySymbols","length","propertyIsEnumerable","__decorate","decorators","target","desc","arguments","r","getOwnPropertyDescriptor","Reflect","_typeof","decorate","__param","paramIndex","decorator","__metadata","metadataKey","metadataValue","metadata","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","result","done","then","apply","__generator","body","verb","v","op","f","TypeError","_","y","label","ops","pop","trys","push","g","sent","throw","return","Symbol","iterator","__exportStar","__values","__read","ar","error","__spread","concat","__spreadArrays","il","Array","k","a","j","jl","__await","__asyncGenerator","q","resume","settle","fulfill","shift","asyncIterator","__asyncDelegator","__asyncValues","__makeTemplateObject","cooked","raw","__importStar","mod","default","__importDefault","obj","setPrototypeOf","__proto__","__assign","_assign","assign","isArray","val","toString","isUndefined","isBuffer","isArrayBuffer","isFormData","FormData","isArrayBufferView","ArrayBuffer","isView","buffer","isString","isNumber","isObject","isDate","isFile","isBlob","isFunction","isStream","pipe","isURLSearchParams","URLSearchParams","trim","str","replace","isStandardBrowserEnv","navigator","product","window","document","fn","merge","assignValue","deepMerge","extend","bind","Integrations","NoopTransport","initAndBind","BaseBackend","BaseClient","API","Scope","Hub","getHubFromCarrier","getCurrentHub","addGlobalEventProcessor","withScope","setUser","setTags","setTag","setExtras","setExtra","setContext","configureScope","captureMessage","captureEvent","captureException","addBreadcrumb","undefined","_minimal","_hub","_api","_baseclient","_basebackend","_sdk","_noop","_integrations","newObj","_loglevel","LogLevel","_severity","Severity","_span","SpanStatus","_status","Status","isError","wat","isInstanceOf","Error","isErrorEvent","isDOMError","isDOMException","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","_scope","getMainCarrier","makeMain","setHubOnCarrier","process","global","dynamicRequire","request","require","isNodeEnv","getGlobalObject","self","fallbackGlobalObject","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","Math","random","parseUrl","url","match","query","fragment","host","path","protocol","relative","getEventDescription","event","message","exception","values","type","event_id","consoleSandbox","callback","levels","originalConsole","console","wrappedLevels","level","__sentry_original__","addExceptionTypeValue","addExceptionMechanism","mechanism","_oO","getLocationHref","location","href","oO","htmlTreeAsString","elem","currentElem","out","height","len","sepLength","nextStr","_htmlElementAsString","parentNode","reverse","join","el","className","classes","attr","tagName","toLowerCase","id","split","attrWhitelist","getAttribute","timestampWithMs","Date","getTime","parseSemver","input","SEMVER_REGEXP","major","parseInt","minor","patch","buildmetadata","isNaN","prerelease","parseRetryAfterHeader","now","header","defaultRetryAfter","headerDelay","headerDate","parse","getFunctionName","defaultFunctionName","addContextToFrame","lines","frame","linesOfContext","lineno","maxLines","sourceLine","max","min","pre_context","slice","map","line","snipLine","context_line","colno","post_context","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","setTimeout","runClearTimeout","marker","cachedClearTimeout","clearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","timeout","run","Item","array","noop","nextTick","args","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","definition","listener","fns","doc","hack","documentElement","doScroll","loaded","test","readyState","addEventListener","removeEventListener","nodelistToArray","nodeList","uuid","substr","SentryError","_tslib","tslib_1","_polyfill","_super","_newTarget","_this","logger","PREFIX","Logger","_enabled","disable","enable","log","_i","warn","__SENTRY__","truncate","newLine","ll","start","end","safeJoin","delimiter","output","String","isMatchingPattern","pattern","computeStackTrace","ex","stack","popSize","framesToPop","computeStackTraceFromStacktraceProp","popFrames","computeStackTraceFromStackProp","extractMessage","failed","isEval","submatch","parts","element","chrome","exec","isNative","chromeEval","func","UNKNOWN_FUNCTION","column","winjs","gecko","geckoEval","columnNumber","stacktrace","opera10Regex","opera11Regex","BaseTransport","_core","_utils","options","_buffer","PromiseBuffer","dsn","getStoreEndpointWithUrlEncodedAuth","sendEvent","close","drain","shouldIgnoreOnError","ignoreOnError","ignoreNextOnError","wrap","before","__sentry__","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","handleEvent","scope","addEventProcessor","processedEvent","extra","defineProperties","encode","encodeURIComponent","utils","params","paramsSerializer","serializedParams","toISOString","JSON","stringify","hashmarkIndex","__CANCEL__","setContentTypeIfUnset","headers","normalizeHeaderName","DEFAULT_CONTENT_TYPE","Content-Type","defaults","adapter","XMLHttpRequest","transformRequest","data","transformResponse","xsrfCookieName","xsrfHeaderName","maxContentLength","validateStatus","status","common","Accept","method","buildURL","buildFullPath","parseHeaders","isURLSameOrigin","createError","config","requestData","requestHeaders","auth","username","password","Authorization","btoa","fullPath","baseURL","open","toUpperCase","onreadystatechange","responseURL","responseHeaders","getAllResponseHeaders","responseData","responseType","response","responseText","statusText","onabort","onerror","ontimeout","timeoutErrorMessage","cookies","xsrfValue","withCredentials","read","setRequestHeader","onDownloadProgress","onUploadProgress","upload","cancelToken","promise","cancel","abort","send","enhanceError","code","config1","config2","valueFromConfig2Keys","mergeDeepPropertiesKeys","defaultToConfig2Keys","prop","axiosKeys","otherKeys","filter","Cancel","getGlobalEventProcessors","globalEventProcessors","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_context","addScopeListener","_notifyScopeListeners","_notifyEventProcessors","processors","hint","index","SyncPromise","processor","final","user","tags","_a","extras","setFingerprint","fingerprint","_fingerprint","setLevel","_level","setTransaction","transaction","_transaction","context","setSpan","span","getSpan","clone","newScope","clear","breadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","clearBreadcrumbs","_applyFingerprint","applyToEvent","contexts","breadcrumbs","Function","eval","Memo","_hasWeakSet","WeakSet","_inner","memoize","has","add","unmemoize","delete","splice","fill","source","replacement","original","wrapped","_Oo","urlEncode","getWalkSource","err","event_1","currentTarget","CustomEvent","detail","utf8Length","encodeURI","jsonSize","normalizeToSize","depth","maxSize","serialized","normalize","serializeValue","normalized","normalizeValue","_events","walk","memo","Infinity","toJSON","acc","innerKey","extractExceptionKeysForMessage","maxLength","sort","includedKeys","States","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","reason","REJECTED","state","_value","_executeHandlers","_attachHandler","handler","onrejected","onfulfilled","all","collection","counter","resolvedCollection","item","catch","finally","onfinally","isRejected","supportsErrorEvent","ErrorEvent","supportsDOMError","DOMError","supportsDOMException","DOMException","supportsFetch","Headers","Request","Response","isNativeFetch","supportsNativeFetch","fetch","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsReportingObserver","supportsReferrerPolicy","referrerPolicy","supportsHistory","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","_types","Skipped","BrowserClient","_backend","_version","BrowserBackend","_prepareEvent","platform","sdk","packages","showReportDialog","_isEnabled","getDsn","eventId","script","async","src","getReportDialogEndpoint","onLoad","onload","eventFromUnknownInput","syntheticException","_parsers","eventFromStacktrace","_tracekit","domException","name_1","eventFromString","objectException","eventFromPlainObject","rejection","synthetic","attachStacktrace","frames_1","prepareFramesForEvent","frames","exceptionFromStacktrace","__serialized__","localStack","firstFrameFunction","lastFrameFunction","filename","function","in_app","STACKTRACE_LIMIT","_base","_fetch","FetchTransport","_xhr","XHRTransport","SDK_NAME","SDK_VERSION","_globalhandlers","GlobalHandlers","_trycatch","TryCatch","Breadcrumbs","_linkederrors","LinkedErrors","_useragent","UserAgent","_interopRequireDefault","init","isDhSentryInitiated","initSentry","initCustomElements","_nodelistToArray","getElementsByClassName","rootElementClassName","isInitialized","_uuid","mount","preloadedState","insideCover","querySelector","captionEl","replaceChild","headingCaption","altText","byline","videoWrapperElement","_dhBasisCommon","ElementIntersectionObserver","intersections","elementViewportPosition","VIEWPORT_POSITION_ATTR","isIntersecting","setAttribute","captionContainer","innerHTML","_VideoLoop2","Sentry","sampleRate","customElements","define","_dhBasisLevendeStillbilde2","_domready","_domready2","_dhBasisLevendeStillbilde","_VideoLoop","_browser","_classCallCheck","instance","Constructor","_possibleConstructorReturn","ReferenceError","_inherits","subClass","superClass","writable","_CustomElement","construct","HTMLElement","_createClass","props","descriptor","protoProps","staticProps","isVisible","child","offsetWidth","offsetHeight","LevendeStillbilde","_CustomElement2","getPrototypeOf","_disconnecting","_handlePlayChange","isPaused","visibleVideoElement","paused","_updatePlayState","_shouldPlay","_playVideo","_pauseVideo","_handleResize","_preload","_setVideoAttributes","_setEventListeners","_removeEventListeners","prevValue","newValue","reducedMotion","testReducedMotion","valueChanged","_this2","videoElements","_this3","disableForcedAttributes","viewportPosition","_this4","videoElement","autoplayBlocked","play","pause","find","toArray","querySelectorAll","hasAttribute","set","removeAttribute","toggleAttribute","_toConsumableArray","arr2","from","asyncGeneratorStep","gen","_next","_throw","info","_asyncToGenerator","_defineProperty","ownKeys","enumerableOnly","symbols","sym","_objectSpread2","getOwnPropertyDescriptors","_objectWithoutPropertiesLoose","excluded","sourceKeys","_objectWithoutProperties","sourceSymbolKeys","boolValue","nextValue","addStyle","nodeName","css","getElementById","insertAdjacentHTML","dispatchEvent","ignore","bubbles","cancelable","createEvent","initCustomEvent","easeOutQuint","matchMedia","matches","pngFragment","aspectRatios","ratio","sizes","quality","jpgFragment","size","createQuery","imageObjects","images","getImageIds","createBase","getImage","some","image","reduce","format","advanced","IMAGE_PROPS","_ref","_ref$format","transformId","containsJpg","containsPng","transformBackId","res","fromEntries","items","_ref6","_slicedToArray","traverse","entries","_ref2","_ref7","_ref3","_ref8","prefetchImageData","_x","_x2","_prefetchImageData","_callee2","regeneratorRuntime","_context2","prev","startsWith","gqlApiUrl","abrupt","gqlApi","stop","mergeImageProps","imageUrls","_ref4","_ref9","imageProps","mergeVideoloopProps","_mergeVideoloopProps","_callee4","objects","_context4","_callee3","_context3","t0","t1","t2","getVideoSrc","t3","t4","videos","_x4","accumulator","current","_getVideoSrc","_callee5","videoObj","hasVideoUrl","basePath","_context5","getVideos","extractBasePathFromUrl","video","getTypeFromHeight","poster","stillFileName","aspectRatio","displayAspectRatio","sources","mp4","videoFileName","decodedUrl","lastIndexOf","_x3","_getVideos","_callee6","videoPayload","_context6","getVideoPayload","movingStills","_axios2","mergeMapProps","_mergeMapProps","_callee7","rest","_context7","getMapDefinition","_getMapDefinition","_callee8","_context8","fromEntries$1","_ref10","mergeMediaProps","_mergeMediaProps","_callee10","imageData","mergedOptions","imageDataStored","mergedProps","mappedEntries","_context10","defaultOptions","_callee9","_ref11","mergedArray","_context9","withinRange","MAX_SAFE_INTEGER","withinStops","currentTime","stops","targetStop","nrOfStops","uniqueStops","unique","targetTime","closest","VerticalScroll","HorizontalScroll","sliceIterator","_arr","_n","_d","_s","_axios","defaultConfig","rootMargin","threshold","elements","onChange","intersectionObserver","IntersectionObserver","entry","idx","intersectionRatio","elm","observe","unobserve","disconnect","proto","msMatchesSelector","webkitMatchesSelector","parentElement","container","top","duration","scrollTop","distance","startTime","loop","timeElapsed","requestAnimationFrame","left","scrollLeft","npm_package_name","npm_package_version","_callee","_ref5","errors","variables","User-Agent","createInstance","Axios","mergeConfig","axios","instanceConfig","CancelToken","isCancel","promises","spread","interceptors","InterceptorManager","dispatchRequest","chain","interceptor","unshift","getUri","handlers","use","eject","h","throwIfCancellationRequested","throwIfRequested","transformData","normalizedName","isAxiosError","description","number","fileName","lineNumber","isAbsoluteURL","combineURLs","requestedURL","relativeURL","ignoreDuplicateOf","parsed","resolveURL","msie","urlParsingNode","search","hash","hostname","port","pathname","charAt","originURL","userAgent","requestURL","write","expires","domain","secure","cookie","toGMTString","RegExp","decodeURIComponent","remove","resolvePromise","token","standaloneVideo","small","medium","large","horizontalVideo","verticalVideo","videoLoop","videoLoop__fallbackImage","wrapper","videoLoop--played","_interopRequireWildcard","Transports","_exports","BrowserIntegrations","_transports","windowIntegrations","_window","INTEGRATIONS","_client","defaultIntegrations","forceLoad","lastEventId","flush","fromString","Debug","Info","Warning","Fatal","Critical","Log","fromHttpCode","httpStatus","Ok","Unauthenticated","PermissionDenied","NotFound","AlreadyExists","FailedPrecondition","ResourceExhausted","InvalidArgument","Unimplemented","Unavailable","DealineExceeded","InternalError","UnknownError","Success","RateLimit","Invalid","Failed","Unknown","callOnHub","hub","originalException","_callOnClient","forget","setProtoOf","mixinProperties","normalizeArray","allowAboveRoot","up","last","splitPath","splitPathRe","resolvedPath","resolvedAbsolute","to","fromParts","toParts","samePartsLength","outputParts","normalizePath","isPathAbsolute","isAbsolute","trailingSlash","normalizedPath","dirname","root","basename","ext","_limit","isReady","task","capturedSetTimeout","instrument","instrumented","instrumentConsole","instrumentDOM","instrumentXHR","instrumentFetch","instrumentHistory","addInstrumentationHandler","triggerHandlers","e_1","_b","_c","e_1_1","originalConsoleLevel","originalFetch","commonHandlerData","fetchData","getFetchMethod","getFetchUrl","startTimestamp","endTimestamp","fetchArgs","xhrproto","originalOpen","__sentry_xhr__","__sentry_own_request__","originalSend","onreadystatechangeHandler","xhr","status_code","readyStateArgs","historyReplacementFunction","originalHistoryFunction","lastHref","oldOnPopState","onpopstate","domEventHandler","keypressEventHandler","eventName","innerOriginal","debounce","keypressTimeout","lastCapturedEvent","debounceTimer","isContentEditable","debounceDuration","Dsn","DSN_REGEX","_fromString","_fromComponents","_validate","withPassword","pass","projectId","lastPath","components","component","carrier","extensions","registry","oldHub","hasHubOnCarrier","isOlderThan","API_VERSION","getHubFromActiveDomain","activeDomain","active","registryHubTopStack","getStackTop","client","_stack","_invokeClient","bindClient","pushScope","getStack","parentScope","getClient","popScope","getScope","_lastEventId","finalHint","getOptions","beforeBreadcrumb","finalBreadcrumb","getIntegration","integration","startSpan","spanOrSpanContext","forceNoChild","_callExtensionMethod","traceHeaders","sentry","webpackPolyfill","deprecate","paths","children","_dsnObject","getStoreEndpoint","_getBaseUrl","getStoreEndpointPath","sentry_key","sentry_version","getRequestHeaders","clientName","clientVersion","X-Sentry-Auth","dialogOptions","endpoint","encodedOptions","email","_integration","backendClass","_processing","_options","setupIntegrations","_getBackend","eventFromException","_processEvent","finalEvent","eventFromMessage","_isClientProcessing","clearInterval","interval","getTransport","transportFlushed","ready","enabled","getIntegrations","ticked","setInterval","environment","release","dist","maxValueLength","normalizeDepth","prepared","_addIntegrations","evt","_normalizeEvent","sdkInfo","integrationsArray","integrations","beforeSend","beforeSendResult","_handleAsyncBeforeSend","getIntegrationsToSetup","userIntegrations","userIntegrationsNames_1","pickedIntegrationsNames_1","defaultIntegration","userIntegration","integrationsNames","setupIntegration","installedIntegrations","setupOnce","_transport","_setupTransport","_exception","_hint","_message","clientClass","debug","_functiontostring","FunctionToString","_inboundfilters","InboundFilters","originalFunctionToString","DEFAULT_IGNORE_ERRORS","clientOptions","_mergeOptions","_shouldDropEvent","_isSentryError","_isIgnoredError","_isBlacklistedUrl","_getEventFilterUrl","_isWhitelistedUrl","ignoreInternal","ignoreErrors","_getPossibleEventMessages","blacklistUrls","whitelistUrls","frames_2","_eventbuilder","transportOptions","transport","handled","_disabledUntil","getResponseHeader","window_1","SENTRY_RELEASE","_helpers","_global","_oldOnErrorHandler","_oldOnUnhandledRejectionHandler","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","onunhandledrejection","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","msg","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","_eventFromIncompleteRejection","ERROR_TYPES_RE","groups","_ignoreOnError","_wrapTimeFunction","originalCallback","_wrapRAF","_wrapEventTarget","_wrapXHR","wrapOptions","addSentryBreadcrumb","serializedData","category","dom","_consoleBreadcrumb","handlerData","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","filterUrl","_historyBreadcrumb","parsedLoc","parsedFrom","parsedTo","DEFAULT_KEY","DEFAULT_LIMIT","_key","limit","_handler","linkedErrors","_walkErrorTree","ra","qa","I","isConnected","sa","__CE_isImportDocument","Document","ShadowRoot","J","firstChild","nextSibling","nodeType","Node","ELEMENT_NODE","K","L","localName","import","Set","__CE_shadowRoot","M","ta","N","MutationObserver","childList","subtree","ua","va","wa","O","Map","xa","SyntaxError","za","w","observedAttributes","constructorFunction","connectedCallback","disconnectedCallback","adoptedCallback","attributeChangedCallback","constructionStack","ya","upgrade","__CE_state","Q","R","S","T","noDocumentConstructionObserver","shadyDomFastWalk","U","ShadyDOM","inUse","nativeMethods","Aa","Ba","V","W","__CE_patched","X","Y","__CE_registry","__CE_documentLoadHandled","ownerDocument","defaultView","__CE_definition","hasAttributes","Ca","namespaceURI","HTMLUnknownElement","sourceURL","initErrorEvent","preventDefault","defaultPrevented","Ea","Da","na","Z","DocumentFragment","prepend","append","Fa","aa","ba","ca","Ga","TEXT_NODE","childNodes","u","x","COMMENT_NODE","textContent","createTextNode","Ha","ja","ka","la","ma","Ia","previousSibling","lastChild","z","H","content","B","A","E","D","C","F","oa","G","pa","fa","ha","ia","Ja","da","ea","createElementNS","importNode","cloneNode","insertBefore","attachShadow","getAttributeNS","setAttributeNS","removeAttributeNS","insertAdjacentElement","after","replaceWith","contains","addedNodes","whenDefined","polyfillWrapFlushCallback","CustomElementRegistry","polyfillDefineLazy","forcePolyfill","__CE_installPolyfill","getFrameElement","frameElement","IntersectionObserverEntry","time","rootBounds","ensureDOMRect","boundingClientRect","intersectionRect","getEmptyRect","targetRect","targetArea","width","intersectionArea","Number","toFixed","opt_options","_checkForIntersections","throttle","THROTTLE_TIMEOUT","_callback","_observationTargets","_queuedEntries","_rootMarginValues","_parseRootMargin","thresholds","_initThresholds","margin","unit","_monitoringDocuments","_monitoringUnsubscribes","performance","timer","addEvent","node","opt_useCapture","attachEvent","removeEvent","detatchEvent","computeRectIntersection","rect1","rect2","bottom","right","getBoundingClientRect","rect","convertFromParentRect","parentBoundingRect","parentIntersectionRect","containsDeep","parent","getParentNode","assignedSlot","startDoc","crossOriginUpdater","crossOriginRect","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","observer","_resetCrossOriginUpdater","_registerInstance","_monitorIntersections","_unmonitorIntersections","_unregisterInstance","_unmonitorAllIntersections","takeRecords","records","opt_threshold","opt_rootMargin","marginString","margins","parseFloat","win","monitoringInterval","domObserver","attributes","characterData","rootDoc","itemDoc","unsubscribe","unsubscribes","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","newEntry","_hasCrossedThreshold","getComputedStyle","display","atRoot","parentRect","parentComputedStyle","frameRect","frameIntersect","overflow","html","clientWidth","clientHeight","_expandRectByRootMargin","newRect","oldRatio","newRatio"],"mappings":"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","file":"article-video-loop-bundle-v2-b6f6769c83bf51fb0f0a.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"/static/\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 41);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _async = __webpack_require__(70);\n\nObject.keys(_async).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _async[key];\n    }\n  });\n});\n\nvar _error = __webpack_require__(12);\n\nObject.keys(_error).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _error[key];\n    }\n  });\n});\n\nvar _is = __webpack_require__(5);\n\nObject.keys(_is).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _is[key];\n    }\n  });\n});\n\nvar _logger = __webpack_require__(13);\n\nObject.keys(_logger).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _logger[key];\n    }\n  });\n});\n\nvar _memo = __webpack_require__(30);\n\nObject.keys(_memo).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _memo[key];\n    }\n  });\n});\n\nvar _misc = __webpack_require__(7);\n\nObject.keys(_misc).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _misc[key];\n    }\n  });\n});\n\nvar _object = __webpack_require__(31);\n\nObject.keys(_object).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _object[key];\n    }\n  });\n});\n\nvar _path = __webpack_require__(72);\n\nObject.keys(_path).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _path[key];\n    }\n  });\n});\n\nvar _promisebuffer = __webpack_require__(73);\n\nObject.keys(_promisebuffer).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _promisebuffer[key];\n    }\n  });\n});\n\nvar _string = __webpack_require__(14);\n\nObject.keys(_string).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _string[key];\n    }\n  });\n});\n\nvar _supports = __webpack_require__(33);\n\nObject.keys(_supports).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _supports[key];\n    }\n  });\n});\n\nvar _syncpromise = __webpack_require__(32);\n\nObject.keys(_syncpromise).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _syncpromise[key];\n    }\n  });\n});\n\nvar _instrument = __webpack_require__(74);\n\nObject.keys(_instrument).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _instrument[key];\n    }\n  });\n});\n\nvar _dsn = __webpack_require__(75);\n\nObject.keys(_dsn).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _dsn[key];\n    }\n  });\n});\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.__extends = __extends;\nexports.__rest = __rest;\nexports.__decorate = __decorate;\nexports.__param = __param;\nexports.__metadata = __metadata;\nexports.__awaiter = __awaiter;\nexports.__generator = __generator;\nexports.__exportStar = __exportStar;\nexports.__values = __values;\nexports.__read = __read;\nexports.__spread = __spread;\nexports.__spreadArrays = __spreadArrays;\nexports.__await = __await;\nexports.__asyncGenerator = __asyncGenerator;\nexports.__asyncDelegator = __asyncDelegator;\nexports.__asyncValues = __asyncValues;\nexports.__makeTemplateObject = __makeTemplateObject;\nexports.__importStar = __importStar;\nexports.__importDefault = __importDefault;\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\n/* global Reflect, Promise */\n\nvar _extendStatics = function extendStatics(d, b) {\n    _extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {\n        d.__proto__ = b;\n    } || function (d, b) {\n        for (var p in b) {\n            if (b.hasOwnProperty(p)) d[p] = b[p];\n        }\n    };\n    return _extendStatics(d, b);\n};\n\nfunction __extends(d, b) {\n    _extendStatics(d, b);\n    function __() {\n        this.constructor = d;\n    }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nvar _assign = function __assign() {\n    exports.__assign = _assign = Object.assign || function __assign(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) {\n                if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n            }\n        }\n        return t;\n    };\n    return _assign.apply(this, arguments);\n};\n\nexports.__assign = _assign;\nfunction __rest(s, e) {\n    var t = {};\n    for (var p in s) {\n        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\n    }if (s != null && typeof Object.getOwnPropertySymbols === \"function\") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];\n    }\n    return t;\n}\n\nfunction __decorate(decorators, target, key, desc) {\n    var c = arguments.length,\n        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,\n        d;\n    if ((typeof Reflect === \"undefined\" ? \"undefined\" : _typeof(Reflect)) === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {\n        if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    }return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nfunction __param(paramIndex, decorator) {\n    return function (target, key) {\n        decorator(target, key, paramIndex);\n    };\n}\n\nfunction __metadata(metadataKey, metadataValue) {\n    if ((typeof Reflect === \"undefined\" ? \"undefined\" : _typeof(Reflect)) === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nfunction __awaiter(thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) {\n            try {\n                step(generator.next(value));\n            } catch (e) {\n                reject(e);\n            }\n        }\n        function rejected(value) {\n            try {\n                step(generator[\"throw\"](value));\n            } catch (e) {\n                reject(e);\n            }\n        }\n        function step(result) {\n            result.done ? resolve(result.value) : new P(function (resolve) {\n                resolve(result.value);\n            }).then(fulfilled, rejected);\n        }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n}\n\nfunction __generator(thisArg, body) {\n    var _ = { label: 0, sent: function sent() {\n            if (t[0] & 1) throw t[1];return t[1];\n        }, trys: [], ops: [] },\n        f,\n        y,\n        t,\n        g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () {\n        return this;\n    }), g;\n    function verb(n) {\n        return function (v) {\n            return step([n, v]);\n        };\n    }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) {\n            try {\n                if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n                if (y = 0, t) op = [op[0] & 2, t.value];\n                switch (op[0]) {\n                    case 0:case 1:\n                        t = op;break;\n                    case 4:\n                        _.label++;return { value: op[1], done: false };\n                    case 5:\n                        _.label++;y = op[1];op = [0];continue;\n                    case 7:\n                        op = _.ops.pop();_.trys.pop();continue;\n                    default:\n                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n                            _ = 0;continue;\n                        }\n                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n                            _.label = op[1];break;\n                        }\n                        if (op[0] === 6 && _.label < t[1]) {\n                            _.label = t[1];t = op;break;\n                        }\n                        if (t && _.label < t[2]) {\n                            _.label = t[2];_.ops.push(op);break;\n                        }\n                        if (t[2]) _.ops.pop();\n                        _.trys.pop();continue;\n                }\n                op = body.call(thisArg, _);\n            } catch (e) {\n                op = [6, e];y = 0;\n            } finally {\n                f = t = 0;\n            }\n        }if (op[0] & 5) throw op[1];return { value: op[0] ? op[1] : void 0, done: true };\n    }\n}\n\nfunction __exportStar(m, exports) {\n    for (var p in m) {\n        if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n    }\n}\n\nfunction __values(o) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator],\n        i = 0;\n    if (m) return m.call(o);\n    return {\n        next: function next() {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n}\n\nfunction __read(o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o),\n        r,\n        ar = [],\n        e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {\n            ar.push(r.value);\n        }\n    } catch (error) {\n        e = { error: error };\n    } finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        } finally {\n            if (e) throw e.error;\n        }\n    }\n    return ar;\n}\n\nfunction __spread() {\n    for (var ar = [], i = 0; i < arguments.length; i++) {\n        ar = ar.concat(__read(arguments[i]));\n    }return ar;\n}\n\nfunction __spreadArrays() {\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) {\n        s += arguments[i].length;\n    }for (var r = Array(s), k = 0, i = 0; i < il; i++) {\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) {\n            r[k] = a[j];\n        }\n    }return r;\n};\n\nfunction __await(v) {\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nfunction __asyncGenerator(thisArg, _arguments, generator) {\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n    var g = generator.apply(thisArg, _arguments || []),\n        i,\n        q = [];\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () {\n        return this;\n    }, i;\n    function verb(n) {\n        if (g[n]) i[n] = function (v) {\n            return new Promise(function (a, b) {\n                q.push([n, v, a, b]) > 1 || resume(n, v);\n            });\n        };\n    }\n    function resume(n, v) {\n        try {\n            step(g[n](v));\n        } catch (e) {\n            settle(q[0][3], e);\n        }\n    }\n    function step(r) {\n        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);\n    }\n    function fulfill(value) {\n        resume(\"next\", value);\n    }\n    function reject(value) {\n        resume(\"throw\", value);\n    }\n    function settle(f, v) {\n        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);\n    }\n}\n\nfunction __asyncDelegator(o) {\n    var i, p;\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) {\n        throw e;\n    }), verb(\"return\"), i[Symbol.iterator] = function () {\n        return this;\n    }, i;\n    function verb(n, f) {\n        i[n] = o[n] ? function (v) {\n            return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v;\n        } : f;\n    }\n}\n\nfunction __asyncValues(o) {\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n    var m = o[Symbol.asyncIterator],\n        i;\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () {\n        return this;\n    }, i);\n    function verb(n) {\n        i[n] = o[n] && function (v) {\n            return new Promise(function (resolve, reject) {\n                v = o[n](v), settle(resolve, reject, v.done, v.value);\n            });\n        };\n    }\n    function settle(resolve, reject, d, v) {\n        Promise.resolve(v).then(function (v) {\n            resolve({ value: v, done: d });\n        }, reject);\n    }\n}\n\nfunction __makeTemplateObject(cooked, raw) {\n    if (Object.defineProperty) {\n        Object.defineProperty(cooked, \"raw\", { value: raw });\n    } else {\n        cooked.raw = raw;\n    }\n    return cooked;\n};\n\nfunction __importStar(mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) {\n        if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n    }result.default = mod;\n    return result;\n}\n\nfunction __importDefault(mod) {\n    return mod && mod.__esModule ? mod : { default: mod };\n}\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar bind = __webpack_require__(20);\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n  return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n  return typeof FormData !== 'undefined' && val instanceof FormData;\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = val && val.buffer && val.buffer instanceof ArrayBuffer;\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n  return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n  return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n  return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n */\nfunction isStandardBrowserEnv() {\n  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' || navigator.product === 'NativeScript' || navigator.product === 'NS')) {\n    return false;\n  }\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge() /* obj1, obj2, obj3, ... */{\n  var result = {};\n  function assignValue(val, key) {\n    if (_typeof(result[key]) === 'object' && (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object') {\n      result[key] = merge(result[key], val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Function equal to merge with the difference being that no reference\n * to original objects is kept.\n *\n * @see merge\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction deepMerge() /* obj1, obj2, obj3, ... */{\n  var result = {};\n  function assignValue(val, key) {\n    if (_typeof(result[key]) === 'object' && (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object') {\n      result[key] = deepMerge(result[key], val);\n    } else if ((typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object') {\n      result[key] = deepMerge({}, val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isBuffer: isBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  deepMerge: deepMerge,\n  extend: extend,\n  trim: trim\n};\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Integrations = exports.NoopTransport = exports.initAndBind = exports.BaseBackend = exports.BaseClient = exports.API = exports.Scope = exports.Hub = exports.getHubFromCarrier = exports.getCurrentHub = exports.addGlobalEventProcessor = exports.withScope = exports.setUser = exports.setTags = exports.setTag = exports.setExtras = exports.setExtra = exports.setContext = exports.configureScope = exports.captureMessage = exports.captureEvent = exports.captureException = exports.addBreadcrumb = undefined;\n\nvar _minimal = __webpack_require__(69);\n\nObject.defineProperty(exports, 'addBreadcrumb', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.addBreadcrumb;\n  }\n});\nObject.defineProperty(exports, 'captureException', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.captureException;\n  }\n});\nObject.defineProperty(exports, 'captureEvent', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.captureEvent;\n  }\n});\nObject.defineProperty(exports, 'captureMessage', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.captureMessage;\n  }\n});\nObject.defineProperty(exports, 'configureScope', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.configureScope;\n  }\n});\nObject.defineProperty(exports, 'setContext', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.setContext;\n  }\n});\nObject.defineProperty(exports, 'setExtra', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.setExtra;\n  }\n});\nObject.defineProperty(exports, 'setExtras', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.setExtras;\n  }\n});\nObject.defineProperty(exports, 'setTag', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.setTag;\n  }\n});\nObject.defineProperty(exports, 'setTags', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.setTags;\n  }\n});\nObject.defineProperty(exports, 'setUser', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.setUser;\n  }\n});\nObject.defineProperty(exports, 'withScope', {\n  enumerable: true,\n  get: function get() {\n    return _minimal.withScope;\n  }\n});\n\nvar _hub = __webpack_require__(6);\n\nObject.defineProperty(exports, 'addGlobalEventProcessor', {\n  enumerable: true,\n  get: function get() {\n    return _hub.addGlobalEventProcessor;\n  }\n});\nObject.defineProperty(exports, 'getCurrentHub', {\n  enumerable: true,\n  get: function get() {\n    return _hub.getCurrentHub;\n  }\n});\nObject.defineProperty(exports, 'getHubFromCarrier', {\n  enumerable: true,\n  get: function get() {\n    return _hub.getHubFromCarrier;\n  }\n});\nObject.defineProperty(exports, 'Hub', {\n  enumerable: true,\n  get: function get() {\n    return _hub.Hub;\n  }\n});\nObject.defineProperty(exports, 'Scope', {\n  enumerable: true,\n  get: function get() {\n    return _hub.Scope;\n  }\n});\n\nvar _api = __webpack_require__(78);\n\nObject.defineProperty(exports, 'API', {\n  enumerable: true,\n  get: function get() {\n    return _api.API;\n  }\n});\n\nvar _baseclient = __webpack_require__(79);\n\nObject.defineProperty(exports, 'BaseClient', {\n  enumerable: true,\n  get: function get() {\n    return _baseclient.BaseClient;\n  }\n});\n\nvar _basebackend = __webpack_require__(81);\n\nObject.defineProperty(exports, 'BaseBackend', {\n  enumerable: true,\n  get: function get() {\n    return _basebackend.BaseBackend;\n  }\n});\n\nvar _sdk = __webpack_require__(82);\n\nObject.defineProperty(exports, 'initAndBind', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.initAndBind;\n  }\n});\n\nvar _noop = __webpack_require__(34);\n\nObject.defineProperty(exports, 'NoopTransport', {\n  enumerable: true,\n  get: function get() {\n    return _noop.NoopTransport;\n  }\n});\n\nvar _integrations = __webpack_require__(83);\n\nvar Integrations = _interopRequireWildcard(_integrations);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nexports.Integrations = Integrations;\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _loglevel = __webpack_require__(65);\n\nObject.defineProperty(exports, 'LogLevel', {\n  enumerable: true,\n  get: function get() {\n    return _loglevel.LogLevel;\n  }\n});\n\nvar _severity = __webpack_require__(66);\n\nObject.defineProperty(exports, 'Severity', {\n  enumerable: true,\n  get: function get() {\n    return _severity.Severity;\n  }\n});\n\nvar _span = __webpack_require__(67);\n\nObject.defineProperty(exports, 'SpanStatus', {\n  enumerable: true,\n  get: function get() {\n    return _span.SpanStatus;\n  }\n});\n\nvar _status = __webpack_require__(68);\n\nObject.defineProperty(exports, 'Status', {\n  enumerable: true,\n  get: function get() {\n    return _status.Status;\n  }\n});\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.isError = isError;\nexports.isErrorEvent = isErrorEvent;\nexports.isDOMError = isDOMError;\nexports.isDOMException = isDOMException;\nexports.isString = isString;\nexports.isPrimitive = isPrimitive;\nexports.isPlainObject = isPlainObject;\nexports.isEvent = isEvent;\nexports.isElement = isElement;\nexports.isRegExp = isRegExp;\nexports.isThenable = isThenable;\nexports.isSyntheticEvent = isSyntheticEvent;\nexports.isInstanceOf = isInstanceOf;\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)\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 === 'undefined' ? 'undefined' : _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    // tslint:disable-next-line:strict-type-predicates\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    // tslint:disable-next-line:strict-type-predicates\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    // tslint:disable:no-unsafe-any\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n    // tslint:enable:no-unsafe-any\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    // tslint:disable-next-line:no-unsafe-any\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        // tslint:disable-next-line:no-unsafe-any\n        return wat instanceof base;\n    } catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _scope = __webpack_require__(28);\n\nObject.defineProperty(exports, 'addGlobalEventProcessor', {\n  enumerable: true,\n  get: function get() {\n    return _scope.addGlobalEventProcessor;\n  }\n});\nObject.defineProperty(exports, 'Scope', {\n  enumerable: true,\n  get: function get() {\n    return _scope.Scope;\n  }\n});\n\nvar _hub = __webpack_require__(76);\n\nObject.defineProperty(exports, 'getCurrentHub', {\n  enumerable: true,\n  get: function get() {\n    return _hub.getCurrentHub;\n  }\n});\nObject.defineProperty(exports, 'getHubFromCarrier', {\n  enumerable: true,\n  get: function get() {\n    return _hub.getHubFromCarrier;\n  }\n});\nObject.defineProperty(exports, 'getMainCarrier', {\n  enumerable: true,\n  get: function get() {\n    return _hub.getMainCarrier;\n  }\n});\nObject.defineProperty(exports, 'Hub', {\n  enumerable: true,\n  get: function get() {\n    return _hub.Hub;\n  }\n});\nObject.defineProperty(exports, 'makeMain', {\n  enumerable: true,\n  get: function get() {\n    return _hub.makeMain;\n  }\n});\nObject.defineProperty(exports, 'setHubOnCarrier', {\n  enumerable: true,\n  get: function get() {\n    return _hub.setHubOnCarrier;\n  }\n});\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process, global) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.dynamicRequire = dynamicRequire;\nexports.isNodeEnv = isNodeEnv;\nexports.getGlobalObject = getGlobalObject;\nexports.uuid4 = uuid4;\nexports.parseUrl = parseUrl;\nexports.getEventDescription = getEventDescription;\nexports.consoleSandbox = consoleSandbox;\nexports.addExceptionTypeValue = addExceptionTypeValue;\nexports.addExceptionMechanism = addExceptionMechanism;\nexports.getLocationHref = getLocationHref;\nexports.htmlTreeAsString = htmlTreeAsString;\nexports.timestampWithMs = timestampWithMs;\nexports.parseSemver = parseSemver;\nexports.parseRetryAfterHeader = parseRetryAfterHeader;\nexports.getFunctionName = getFunctionName;\nexports.addContextToFrame = addContextToFrame;\n\nvar _is = __webpack_require__(5);\n\nvar _string = __webpack_require__(14);\n\n/**\n * Requires a module which is protected _against bundler minification.\n *\n * @param request The module path to resolve\n */\nfunction dynamicRequire(mod, request) {\n    // tslint:disable-next-line: no-unsafe-any\n    return mod.require(request);\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    // tslint:disable:strict-type-predicates\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nfunction getGlobalObject() {\n    return isNodeEnv() ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : 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        // tslint:disable-next-line:no-bitwise\n        arr[3] = arr[3] & 0xfff | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // tslint:disable-next-line:no-bitwise\n        arr[4] = arr[4] & 0x3fff | 0x8000;\n        var pad = function pad(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        // tslint:disable-next-line:no-bitwise\n        var r = Math.random() * 16 | 0;\n        // tslint: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    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\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) {\n        mechanism = {};\n    }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore\n        // tslint:disable: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\n            event.exception.values[0].mechanism[key] = mechanism[key];\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    } catch (oO) {\n        return '';\n    }\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        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    } 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    className = elem.className;\n    if (className && (0, _is.isString)(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var attrWhitelist = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < attrWhitelist.length; i++) {\n        key = attrWhitelist[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n/**\n * Returns a timestamp in seconds with milliseconds precision.\n */\nfunction timestampWithMs() {\n    return new Date().getTime() / 1000;\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}\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    } catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        return defaultFunctionName;\n    }\n}\n/**\n * 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) {\n        linesOfContext = 5;\n    }\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.slice(Math.max(0, sourceLine - linesOfContext), sourceLine).map(function (line) {\n        return (0, _string.snipLine)(line, 0);\n    });\n    frame.context_line = (0, _string.snipLine)(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines.slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext).map(function (line) {\n        return (0, _string.snipLine)(line, 0);\n    });\n}\n//# sourceMappingURL=misc.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8), __webpack_require__(29)))\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout() {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n})();\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while (len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n    return [];\n};\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n    return '/';\n};\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function () {\n    return 0;\n};\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/*!\n  * domready (c) Dustin Diaz 2014 - License MIT\n  */\n!function (name, definition) {\n\n  if (true) module.exports = definition();else if (typeof define == 'function' && _typeof(define.amd) == 'object') define(definition);else this[name] = definition();\n}('domready', function () {\n\n  var fns = [],\n      _listener,\n      doc = document,\n      hack = doc.documentElement.doScroll,\n      domContentLoaded = 'DOMContentLoaded',\n      loaded = (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState);\n\n  if (!loaded) doc.addEventListener(domContentLoaded, _listener = function listener() {\n    doc.removeEventListener(domContentLoaded, _listener);\n    loaded = 1;\n    while (_listener = fns.shift()) {\n      _listener();\n    }\n  });\n\n  return function (fn) {\n    loaded ? setTimeout(fn, 0) : fns.push(fn);\n  };\n});\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.nodelistToArray = nodelistToArray;\nfunction nodelistToArray(nodeList) {\n  return [].slice.call(nodeList);\n}\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.uuid = uuid;\nfunction uuid() {\n  return \"_\" + Math.random().toString(36).substr(2, 9);\n}\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.SentryError = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _polyfill = __webpack_require__(71);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */function (_super) {\n    tslib_1.__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        // tslint:disable:no-unsafe-any\n        _this.name = _newTarget.prototype.constructor.name;\n        (0, _polyfill.setPrototypeOf)(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error);\nexports.SentryError = SentryError;\n//# sourceMappingURL=error.js.map\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.logger = undefined;\n\nvar _misc = __webpack_require__(7);\n\n// TODO: Implement different loggers for different environments\nvar global = (0, _misc.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        (0, _misc.consoleSandbox)(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' ')); // tslint:disable-line:no-console\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        (0, _misc.consoleSandbox)(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' ')); // tslint:disable-line:no-console\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        (0, _misc.consoleSandbox)(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' ')); // tslint:disable-line:no-console\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());\nexports.logger = logger;\n//# sourceMappingURL=logger.js.map\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.truncate = truncate;\nexports.snipLine = snipLine;\nexports.safeJoin = safeJoin;\nexports.isMatchingPattern = isMatchingPattern;\n\nvar _is = __webpack_require__(5);\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\n * @returns string Encoded\n */\nfunction truncate(str, max) {\n    if (max === void 0) {\n        max = 0;\n    }\n    // tslint:disable-next-line:strict-type-predicates\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        colno = ll; // tslint:disable-line:no-parameter-reassignment\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 */\nfunction safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // tslint:disable-next-line: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        } 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 ((0, _is.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/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.computeStackTrace = computeStackTrace;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\n// tslint:disable:object-literal-sort-keys\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).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js))(?::(\\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/** JSDoc */\nfunction computeStackTrace(ex) {\n    // tslint:disable:no-unsafe-any\n    var stack = null;\n    var popSize = ex && ex.framesToPop;\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    } catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\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// tslint:disable-next-line:cyclomatic-complexity\nfunction computeStackTraceFromStackProp(ex) {\n    // tslint:disable:no-conditional-assignment\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        } 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        } 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            } 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        } 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 */\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        // tslint:disable:no-conditional-assignment\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        } 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 tslib_1.__assign({}, stacktrace, { stack: stacktrace.stack.slice(popSize) });\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 */\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/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.BaseTransport = undefined;\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\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 _utils.PromiseBuffer(30);\n        this.url = new _core.API(this.options.dsn).getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new _utils.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    return BaseTransport;\n}();\nexports.BaseTransport = BaseTransport;\n//# sourceMappingURL=base.js.map\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.shouldIgnoreOnError = shouldIgnoreOnError;\nexports.ignoreNextOnError = ignoreNextOnError;\nexports.wrap = wrap;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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) {\n        options = {};\n    }\n    // tslint:disable-next-line:strict-type-predicates\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    } 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    var sentryWrapped = function sentryWrapped() {\n        var args = Array.prototype.slice.call(arguments);\n        // tslint:disable:no-unsafe-any\n        try {\n            // tslint:disable-next-line:strict-type-predicates\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            var wrappedArguments = args.map(function (arg) {\n                return wrap(arg, options);\n            });\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                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            // tslint:enable:no-unsafe-any\n        } catch (ex) {\n            ignoreNextOnError();\n            (0, _core.withScope)(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = tslib_1.__assign({}, event);\n                    if (options.mechanism) {\n                        (0, _utils.addExceptionTypeValue)(processedEvent, undefined, undefined);\n                        (0, _utils.addExceptionMechanism)(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = tslib_1.__assign({}, processedEvent.extra, { arguments: args });\n                    return processedEvent;\n                });\n                (0, _core.captureException)(ex);\n            });\n            throw ex;\n        }\n    };\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    } catch (_oO) {} // tslint: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 get() {\n                    return fn.name;\n                }\n            });\n        }\n    } catch (_oO) {\n        /*no-empty*/\n    }\n    return sentryWrapped;\n}\n//# sourceMappingURL=helpers.js.map\n\n/***/ }),\n/* 18 */,\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(45);\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\nfunction encode(val) {\n  return encodeURIComponent(val).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      } else {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    var hashmarkIndex = url.indexOf('#');\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nvar utils = __webpack_require__(2);\nvar normalizeHeaderName = __webpack_require__(50);\n\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = __webpack_require__(24);\n  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {\n    // For node use HTTP adapter\n    adapter = __webpack_require__(24);\n  }\n  return adapter;\n}\n\nvar defaults = {\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Accept');\n    normalizeHeaderName(headers, 'Content-Type');\n    if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n    if (utils.isObject(data)) {\n      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n      return JSON.stringify(data);\n    }\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    /*eslint no-param-reassign:0*/\n    if (typeof data === 'string') {\n      try {\n        data = JSON.parse(data);\n      } catch (e) {/* Ignore */}\n    }\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  }\n};\n\ndefaults.headers = {\n  common: {\n    'Accept': 'application/json, text/plain, */*'\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\nvar settle = __webpack_require__(51);\nvar buildURL = __webpack_require__(21);\nvar buildFullPath = __webpack_require__(53);\nvar parseHeaders = __webpack_require__(56);\nvar isURLSameOrigin = __webpack_require__(57);\nvar createError = __webpack_require__(25);\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n\n    if (utils.isFormData(requestData)) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password || '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    var fullPath = buildFullPath(config.baseURL, config.url);\n    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    // Listen for ready state\n    request.onreadystatechange = function handleLoad() {\n      if (!request || request.readyState !== 4) {\n        return;\n      }\n\n      // The request errored out and we didn't get a response, this will be\n      // handled by onerror instead\n      // With one exception: request that using file: protocol, most browsers\n      // will return status as 0 even though it's a successful request\n      if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n        return;\n      }\n\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n      var response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(resolve, reject, response);\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(createError('Request aborted', config, 'ECONNABORTED', request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(createError('Network Error', config, null, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';\n      if (config.timeoutErrorMessage) {\n        timeoutErrorMessage = config.timeoutErrorMessage;\n      }\n      reject(createError(timeoutErrorMessage, config, 'ECONNABORTED', request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      var cookies = __webpack_require__(58);\n\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(config.withCredentials)) {\n      request.withCredentials = !!config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (config.responseType) {\n      try {\n        request.responseType = config.responseType;\n      } catch (e) {\n        // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.\n        // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.\n        if (config.responseType !== 'json') {\n          throw e;\n        }\n      }\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken) {\n      // Handle cancellation\n      config.cancelToken.promise.then(function onCanceled(cancel) {\n        if (!request) {\n          return;\n        }\n\n        request.abort();\n        reject(cancel);\n        // Clean up request\n        request = null;\n      });\n    }\n\n    if (requestData === undefined) {\n      requestData = null;\n    }\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar enhanceError = __webpack_require__(52);\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, request, response) {\n  var error = new Error(message);\n  return enhanceError(error, config, code, request, response);\n};\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n * @returns {Object} New object resulting from merging config2 to config1\n */\nmodule.exports = function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  var config = {};\n\n  var valueFromConfig2Keys = ['url', 'method', 'params', 'data'];\n  var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy'];\n  var defaultToConfig2Keys = ['baseURL', 'url', 'transformRequest', 'transformResponse', 'paramsSerializer', 'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName', 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent', 'httpsAgent', 'cancelToken', 'socketPath'];\n\n  utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {\n    if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    }\n  });\n\n  utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {\n    if (utils.isObject(config2[prop])) {\n      config[prop] = utils.deepMerge(config1[prop], config2[prop]);\n    } else if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    } else if (utils.isObject(config1[prop])) {\n      config[prop] = utils.deepMerge(config1[prop]);\n    } else if (typeof config1[prop] !== 'undefined') {\n      config[prop] = config1[prop];\n    }\n  });\n\n  utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {\n    if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    } else if (typeof config1[prop] !== 'undefined') {\n      config[prop] = config1[prop];\n    }\n  });\n\n  var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys);\n\n  var otherKeys = Object.keys(config2).filter(function filterAxiosKeys(key) {\n    return axiosKeys.indexOf(key) === -1;\n  });\n\n  utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {\n    if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    } else if (typeof config1[prop] !== 'undefined') {\n      config[prop] = config1[prop];\n    }\n  });\n\n  return config;\n};\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\n\nfunction Cancel(message) {\n  this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n  return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Scope = undefined;\nexports.addGlobalEventProcessor = addGlobalEventProcessor;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _utils = __webpack_require__(0);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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._context = {};\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     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            setTimeout(function () {\n                _this._scopeListeners.forEach(function (callback) {\n                    callback(_this);\n                });\n                _this._notifyingListeners = false;\n            });\n        }\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) {\n            index = 0;\n        }\n        return new _utils.SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            // tslint:disable-next-line:strict-type-predicates\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            } else {\n                var result = processor(tslib_1.__assign({}, event), hint);\n                if ((0, _utils.isThenable)(result)) {\n                    result.then(function (final) {\n                        return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve);\n                    }).then(null, reject);\n                } else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1).then(resolve).then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = tslib_1.__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 = tslib_1.__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 = tslib_1.__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 = tslib_1.__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.setTransaction = function (transaction) {\n        this._transaction = transaction;\n        if (this._span) {\n            this._span.transaction = transaction;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        this._context = tslib_1.__assign({}, this._context, (_a = {}, _a[key] = context, _a));\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     * Internal getter for Span, used in Hub.\n     * @hidden\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\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 = tslib_1.__spread(scope._breadcrumbs);\n            newScope._tags = tslib_1.__assign({}, scope._tags);\n            newScope._extra = tslib_1.__assign({}, scope._extra);\n            newScope._context = tslib_1.__assign({}, scope._context);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._transaction = scope._transaction;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = tslib_1.__spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._context = {};\n        this._level = undefined;\n        this._transaction = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: (0, _utils.timestampWithMs)() }, breadcrumb);\n        this._breadcrumbs = maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0 ? tslib_1.__spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs) : tslib_1.__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 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 ? Array.isArray(event.fingerprint) ? event.fingerprint : [event.fingerprint] : [];\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    /**\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        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = tslib_1.__assign({}, this._extra, event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = tslib_1.__assign({}, this._tags, event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = tslib_1.__assign({}, this._user, event.user);\n        }\n        if (this._context && Object.keys(this._context).length) {\n            event.contexts = tslib_1.__assign({}, this._context, event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transaction) {\n            event.transaction = this._transaction;\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = tslib_1.__spread(event.breadcrumbs || [], this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(tslib_1.__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    return Scope;\n}();\nexports.Scope = Scope;\n/**\n * Retruns the global event processors.\n */\n\nfunction getGlobalEventProcessors() {\n    var global = (0, _utils.getGlobalObject)();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\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/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n// tslint:disable:no-unsafe-any\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */function () {\n    function Memo() {\n        // tslint:disable-next-line\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        // tslint:disable-next-line: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        } 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}();\nexports.Memo = Memo;\n//# sourceMappingURL=memo.js.map\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.fill = fill;\nexports.urlEncode = urlEncode;\nexports.normalizeToSize = normalizeToSize;\nexports.walk = walk;\nexports.normalize = normalize;\nexports.extractExceptionKeysForMessage = extractExceptionKeysForMessage;\n\nvar _is = __webpack_require__(5);\n\nvar _memo = __webpack_require__(30);\n\nvar _misc = __webpack_require__(7);\n\nvar _string = __webpack_require__(14);\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 replacement A function that should be used to wrap a given method.\n * @returns void\n */\nfunction fill(source, name, replacement) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacement(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    // tslint:disable-next-line:strict-type-predicates\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        } 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).map(\n    // tslint:disable-next-line:no-unsafe-any\n    function (key) {\n        return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]);\n    }).join('&');\n}\n/**\n * Transforms any object into an object literal with all it's attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if ((0, _is.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 ((0, _is.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 = (0, _is.isElement)(event_1.target) ? (0, _misc.htmlTreeAsString)(event_1.target) : Object.prototype.toString.call(event_1.target);\n        } catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = (0, _is.isElement)(event_1.currentTarget) ? (0, _misc.htmlTreeAsString)(event_1.currentTarget) : Object.prototype.toString.call(event_1.currentTarget);\n        } catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        // tslint:disable-next-line:strict-type-predicates\n        if (typeof CustomEvent !== 'undefined' && (0, _is.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    // tslint: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) {\n        depth = 3;\n    }\n    if (maxSize === void 0) {\n        maxSize = 100 * 1024;\n    }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/** Transforms any input value into a string form, either primitive value or a type of the input */\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 (0, _is.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 */\n// tslint:disable-next-line:cyclomatic-complexity\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && (typeof value === 'undefined' ? 'undefined' : _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 ((0, _is.isSyntheticEvent)(value)) {\n        return '[SyntheticEvent]';\n    }\n    // tslint:disable-next-line:no-tautology-expression\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: \" + (0, _misc.getFunctionName)(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 */\nfunction walk(key, value, depth, memo) {\n    if (depth === void 0) {\n        depth = +Infinity;\n    }\n    if (memo === void 0) {\n        memo = new _memo.Memo();\n    }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    // If value implements `toJSON` method, call it and return early\n    // tslint:disable:no-unsafe-any\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    // tslint:enable:no-unsafe-any\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 ((0, _is.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 */\nfunction normalize(input, depth) {\n    try {\n        // tslint:disable-next-line:no-unsafe-any\n        return JSON.parse(JSON.stringify(input, function (key, value) {\n            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 */\nfunction extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) {\n        maxLength = 40;\n    }\n    // tslint:disable:strict-type-predicates\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 (0, _string.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 (0, _string.truncate)(serialized, maxLength);\n    }\n    return '';\n}\n//# sourceMappingURL=object.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.SyncPromise = undefined;\n\nvar _is = __webpack_require__(5);\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 ((0, _is.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            if (_this._state === States.REJECTED) {\n                _this._handlers.forEach(function (handler) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                });\n            } else {\n                _this._handlers.forEach(function (handler) {\n                    if (handler.onfulfilled) {\n                        // tslint:disable-next-line:no-unsafe-any\n                        handler.onfulfilled(_this._value);\n                    }\n                });\n            }\n            _this._handlers = [];\n        };\n        try {\n            executor(this._resolve, this._reject);\n        } catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\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).then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\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                onfulfilled: function onfulfilled(result) {\n                    if (!_onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(_onfulfilled(result));\n                        return;\n                    } catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function onrejected(reason) {\n                    if (!_onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(_onrejected(reason));\n                        return;\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) {\n            return val;\n        }, 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                // tslint:disable-next-line:no-unsafe-any\n                resolve(val);\n            });\n        });\n    };\n    return SyncPromise;\n}();\nexports.SyncPromise = SyncPromise;\n//# sourceMappingURL=syncpromise.js.map\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.supportsErrorEvent = supportsErrorEvent;\nexports.supportsDOMError = supportsDOMError;\nexports.supportsDOMException = supportsDOMException;\nexports.supportsFetch = supportsFetch;\nexports.supportsNativeFetch = supportsNativeFetch;\nexports.supportsReportingObserver = supportsReportingObserver;\nexports.supportsReferrerPolicy = supportsReferrerPolicy;\nexports.supportsHistory = supportsHistory;\n\nvar _logger = __webpack_require__(13);\n\nvar _misc = __webpack_require__(7);\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        // tslint:disable:no-unused-expression\n        new ErrorEvent('');\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n    try {\n        // It really needs 1 argument, not 0.\n        // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n        // 1 argument required, but only 0 present.\n        // @ts-ignore\n        // tslint:disable:no-unused-expression\n        new DOMError('');\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n    try {\n        // tslint:disable:no-unused-expression\n        new DOMException('');\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n    if (!('fetch' in (0, _misc.getGlobalObject)())) {\n        return false;\n    }\n    try {\n        // tslint:disable-next-line:no-unused-expression\n        new Headers();\n        // tslint:disable-next-line:no-unused-expression\n        new Request('');\n        // tslint:disable-next-line:no-unused-expression\n        new Response();\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * 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 = (0, _misc.getGlobalObject)();\n    // Fast path to avoid DOM I/O\n    // tslint:disable-next-line:no-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    if (doc) {\n        var sandbox = doc.createElement('iframe');\n        sandbox.hidden = true;\n        try {\n            doc.head.appendChild(sandbox);\n            if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                // tslint:disable-next-line:no-unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        } catch (err) {\n            _logger.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    // tslint:disable-next-line: no-unsafe-any\n    return 'ReportingObserver' in (0, _misc.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        // tslint:disable:no-unused-expression\n        new Request('_', {\n            referrerPolicy: 'origin'\n        });\n        return true;\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 = (0, _misc.getGlobalObject)();\n    var chrome = global.chrome;\n    // tslint:disable-next-line:no-unsafe-any\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\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/* 34 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.NoopTransport = undefined;\n\nvar _types = __webpack_require__(4);\n\nvar _utils = __webpack_require__(0);\n\n/** Noop transport */\nvar NoopTransport = /** @class */function () {\n    function NoopTransport() {}\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.sendEvent = function (_) {\n        return _utils.SyncPromise.resolve({\n            reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n            status: _types.Status.Skipped\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.close = function (_) {\n        return _utils.SyncPromise.resolve(true);\n    };\n    return NoopTransport;\n}();\nexports.NoopTransport = NoopTransport;\n//# sourceMappingURL=noop.js.map\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.BrowserClient = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\n\nvar _backend = __webpack_require__(86);\n\nvar _version = __webpack_require__(39);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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    tslib_1.__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) {\n            options = {};\n        }\n        return _super.call(this, _backend.BrowserBackend, options) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = tslib_1.__assign({}, event.sdk, { name: _version.SDK_NAME, packages: tslib_1.__spread(event.sdk && event.sdk.packages || [], [{\n                name: 'npm:@sentry/browser',\n                version: _version.SDK_VERSION\n            }]), version: _version.SDK_VERSION });\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\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) {\n            options = {};\n        }\n        // doesn't work without a document (React Native)\n        var document = (0, _utils.getGlobalObject)().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            _utils.logger.error('Trying to call showReportDialog with Sentry Client is disabled');\n            return;\n        }\n        var dsn = options.dsn || this.getDsn();\n        if (!options.eventId) {\n            _utils.logger.error('Missing `eventId` option in showReportDialog call');\n            return;\n        }\n        if (!dsn) {\n            _utils.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 _core.API(dsn).getReportDialogEndpoint(options);\n        if (options.onLoad) {\n            script.onload = options.onLoad;\n        }\n        (document.head || document.body).appendChild(script);\n    };\n    return BrowserClient;\n}(_core.BaseClient);\nexports.BrowserClient = BrowserClient;\n//# sourceMappingURL=client.js.map\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.eventFromUnknownInput = eventFromUnknownInput;\nexports.eventFromString = eventFromString;\n\nvar _utils = __webpack_require__(0);\n\nvar _parsers = __webpack_require__(37);\n\nvar _tracekit = __webpack_require__(15);\n\n/** JSDoc */\nfunction eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) {\n        options = {};\n    }\n    var event;\n    if ((0, _utils.isErrorEvent)(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        exception = errorEvent.error; // tslint:disable-line:no-parameter-reassignment\n        event = (0, _parsers.eventFromStacktrace)((0, _tracekit.computeStackTrace)(exception));\n        return event;\n    }\n    if ((0, _utils.isDOMError)(exception) || (0, _utils.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 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 || ((0, _utils.isDOMError)(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        (0, _utils.addExceptionTypeValue)(event, message);\n        return event;\n    }\n    if ((0, _utils.isError)(exception)) {\n        // we have a real Error object, do nothing\n        event = (0, _parsers.eventFromStacktrace)((0, _tracekit.computeStackTrace)(exception));\n        return event;\n    }\n    if ((0, _utils.isPlainObject)(exception) || (0, _utils.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 = (0, _parsers.eventFromPlainObject)(objectException, syntheticException, options.rejection);\n        (0, _utils.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    (0, _utils.addExceptionTypeValue)(event, \"\" + exception, undefined);\n    (0, _utils.addExceptionMechanism)(event, {\n        synthetic: true\n    });\n    return event;\n}\n// this._options.attachStacktrace\n/** JSDoc */\nfunction eventFromString(input, syntheticException, options) {\n    if (options === void 0) {\n        options = {};\n    }\n    var event = {\n        message: input\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = (0, _tracekit.computeStackTrace)(syntheticException);\n        var frames_1 = (0, _parsers.prepareFramesForEvent)(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map\n\n/***/ }),\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.exceptionFromStacktrace = exceptionFromStacktrace;\nexports.eventFromPlainObject = eventFromPlainObject;\nexports.eventFromStacktrace = eventFromStacktrace;\nexports.prepareFramesForEvent = prepareFramesForEvent;\n\nvar _utils = __webpack_require__(0);\n\nvar _tracekit = __webpack_require__(15);\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    // tslint:disable-next-line:strict-type-predicates\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                type: (0, _utils.isEvent)(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + (0, _utils.extractExceptionKeysForMessage)(exception)\n            }]\n        },\n        extra: {\n            __serialized__: (0, _utils.normalizeToSize)(exception)\n        }\n    };\n    if (syntheticException) {\n        var stacktrace = (0, _tracekit.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.map(function (frame) {\n        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    }).slice(0, STACKTRACE_LIMIT).reverse();\n}\n//# sourceMappingURL=parsers.js.map\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _base = __webpack_require__(16);\n\nObject.defineProperty(exports, 'BaseTransport', {\n  enumerable: true,\n  get: function get() {\n    return _base.BaseTransport;\n  }\n});\n\nvar _fetch = __webpack_require__(87);\n\nObject.defineProperty(exports, 'FetchTransport', {\n  enumerable: true,\n  get: function get() {\n    return _fetch.FetchTransport;\n  }\n});\n\nvar _xhr = __webpack_require__(88);\n\nObject.defineProperty(exports, 'XHRTransport', {\n  enumerable: true,\n  get: function get() {\n    return _xhr.XHRTransport;\n  }\n});\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar SDK_NAME = exports.SDK_NAME = 'sentry.javascript.browser';\nvar SDK_VERSION = exports.SDK_VERSION = '5.12.1';\n//# sourceMappingURL=version.js.map\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _globalhandlers = __webpack_require__(90);\n\nObject.defineProperty(exports, 'GlobalHandlers', {\n  enumerable: true,\n  get: function get() {\n    return _globalhandlers.GlobalHandlers;\n  }\n});\n\nvar _trycatch = __webpack_require__(91);\n\nObject.defineProperty(exports, 'TryCatch', {\n  enumerable: true,\n  get: function get() {\n    return _trycatch.TryCatch;\n  }\n});\n\nvar _breadcrumbs = __webpack_require__(92);\n\nObject.defineProperty(exports, 'Breadcrumbs', {\n  enumerable: true,\n  get: function get() {\n    return _breadcrumbs.Breadcrumbs;\n  }\n});\n\nvar _linkederrors = __webpack_require__(93);\n\nObject.defineProperty(exports, 'LinkedErrors', {\n  enumerable: true,\n  get: function get() {\n    return _linkederrors.LinkedErrors;\n  }\n});\n\nvar _useragent = __webpack_require__(94);\n\nObject.defineProperty(exports, 'UserAgent', {\n  enumerable: true,\n  get: function get() {\n    return _useragent.UserAgent;\n  }\n});\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(42);\n\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _domready = __webpack_require__(9);\n\nvar _domready2 = _interopRequireDefault(_domready);\n\nvar _nodelistToArray = __webpack_require__(10);\n\nvar _uuid = __webpack_require__(11);\n\nvar _dhBasisLevendeStillbilde = __webpack_require__(43);\n\nvar _dhBasisLevendeStillbilde2 = _interopRequireDefault(_dhBasisLevendeStillbilde);\n\nvar _dhBasisCommon = __webpack_require__(61);\n\nvar _VideoLoop = __webpack_require__(62);\n\nvar _VideoLoop2 = _interopRequireDefault(_VideoLoop);\n\nvar _browser = __webpack_require__(63);\n\nvar Sentry = _interopRequireWildcard(_browser);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar rootElementClassName = 'article-levende-stillbilde-root';\n\nwindow[rootElementClassName] = window[rootElementClassName] || {};\nwindow.isDhSentryInitiated = false;\n\nvar VIEWPORT_POSITION_ATTR = 'data-viewport-position';\n\nfunction init() {\n  if (!window.isDhSentryInitiated) {\n    initSentry();\n  }\n  initCustomElements();\n\n  var elementsArray = (0, _nodelistToArray.nodelistToArray)(document.getElementsByClassName(rootElementClassName));\n  elementsArray.filter(function (el) {\n    return !isInitialized(el);\n  }).forEach(function (el) {\n    el.id = (0, _uuid.uuid)();\n    window[rootElementClassName][el.id] = true;\n\n    // Extract preloaded state sent from server\n    var preloadedState = JSON.parse(el.getAttribute('data-preloaded-state'));\n    mount(el, preloadedState);\n  });\n}\n\nfunction mount(el, preloadedState) {\n  try {\n    // Checks to see whether or not the video element is inside the a feature article cover\n    var insideCover = Boolean(document.querySelector('.article-feature__cover #' + el.id));\n    var captionEl = document.querySelector('#' + el.id + ' [data-caption]');\n    if (insideCover && captionEl) {\n      captionEl.parentNode.replaceChild(headingCaption(preloadedState.altText, preloadedState.byline), captionEl);\n    }\n\n    var videoWrapperElement = el.querySelector('.dh-video-wrapper');\n\n    // eslint-disable-next-line no-unused-vars\n    var elementObserver = new _dhBasisCommon.ElementIntersectionObserver([videoWrapperElement], function (intersections) {\n      var element = intersections[0];\n      var elementViewportPosition = videoWrapperElement.getAttribute(VIEWPORT_POSITION_ATTR);\n      if (element.isIntersecting && elementViewportPosition === 'OUT-OF-VIEWPORT') {\n        videoWrapperElement.setAttribute(VIEWPORT_POSITION_ATTR, 'IN-VIEWPORT');\n      }\n      if (!element.isIntersecting && elementViewportPosition === 'IN-VIEWPORT') {\n        videoWrapperElement.setAttribute(VIEWPORT_POSITION_ATTR, 'OUT-OF-VIEWPORT');\n      }\n    });\n  } catch (err) {\n    // fail silently\n  }\n}\n\nfunction headingCaption(altText, byline) {\n  var captionContainer = document.createElement('div');\n  captionContainer.innerHTML = '<span class=\\'nrk-sr\\'>' + altText + '</span><span>' + byline + '</span>';\n  captionContainer.setAttribute('class', _VideoLoop2.default['byline']);\n  captionContainer.setAttribute('data-caption', true);\n  return captionContainer;\n}\n\nfunction initSentry() {\n  Sentry.init({\n    dsn: 'https://61a06075b4944857a732bd9ae155c639@sentry.io/2432586',\n    sampleRate: 0.3\n  });\n  window.isDhSentryInitiated = true;\n}\n\nfunction initCustomElements() {\n  if (typeof customElements.get('dh-lvs-basis-levende-stillbilde') === 'undefined') {\n    customElements.define('dh-lvs-basis-levende-stillbilde', _dhBasisLevendeStillbilde2.default);\n  }\n}\n\nfunction isInitialized(el) {\n  return el.id && window[rootElementClassName][el.id];\n}\n\n(0, _domready2.default)(function () {\n  if (!('customElements' in window)) {\n    __webpack_require__(95);\n  }\n  if (!('IntersectionObserver' in window)) {\n    __webpack_require__(96);\n  }\n  init();\n});\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _dhBasisCommon = __webpack_require__(44);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nfunction _CustomElement() {\n  return Reflect.construct(HTMLElement, [], this.__proto__.constructor);\n}\n\n;\nObject.setPrototypeOf(_CustomElement.prototype, HTMLElement.prototype);\nObject.setPrototypeOf(_CustomElement, HTMLElement);\n\n\nvar STATE_ATTR = 'data-state';\nvar VIEWPORT_POSITION_ATTR = 'data-viewport-position';\nvar DISABLE_FORCED_ATTRIBUTES_ATTR = 'disable-forced-attributes';\nvar IS_PAUSED = 'is-paused';\nvar AUTOPLAY_BLOCKED = 'autoplay-blocked';\n\nvar isVisible = function isVisible(child) {\n  return child.offsetWidth > 0 || child.offsetHeight > 0;\n};\n\nvar LevendeStillbilde = function (_CustomElement2) {\n  _inherits(LevendeStillbilde, _CustomElement2);\n\n  function LevendeStillbilde() {\n    _classCallCheck(this, LevendeStillbilde);\n\n    var _this = _possibleConstructorReturn(this, (LevendeStillbilde.__proto__ || Object.getPrototypeOf(LevendeStillbilde)).apply(this, arguments));\n\n    _this._disconnecting = false;\n\n    _this._handlePlayChange = function () {\n      _this.isPaused = _this.visibleVideoElement.paused;\n    };\n\n    _this._updatePlayState = function () {\n      if (!_this.visibleVideoElement) {\n        return;\n      }\n\n      if (_this._shouldPlay()) {\n        _this._playVideo();\n      } else {\n        _this._pauseVideo();\n      }\n    };\n\n    _this._handleResize = function () {\n      _this._updatePlayState();\n\n      _this._preload();\n    };\n    return _this;\n  }\n\n  _createClass(LevendeStillbilde, [{\n    key: 'connectedCallback',\n    value: function connectedCallback() {\n      this._setVideoAttributes();\n\n      this._setEventListeners();\n\n      this._updatePlayState();\n    }\n  }, {\n    key: 'disconnectedCallback',\n    value: function disconnectedCallback() {\n      this._disconnecting = true;\n\n      this._removeEventListeners();\n    }\n  }, {\n    key: 'attributeChangedCallback',\n    value: function attributeChangedCallback(name, prevValue, newValue) {\n      var reducedMotion = (0, _dhBasisCommon.testReducedMotion)();\n      var valueChanged = prevValue !== newValue;\n\n      if ((name === STATE_ATTR || name === VIEWPORT_POSITION_ATTR) && !reducedMotion) {\n        if (valueChanged) {\n          this._updatePlayState();\n\n          if (name === VIEWPORT_POSITION_ATTR && newValue === 'IN-VIEWPORT') {\n            this._preload();\n          }\n        }\n      }\n    }\n  }, {\n    key: '_setEventListeners',\n    value: function _setEventListeners() {\n      var _this2 = this;\n\n      window.addEventListener('resize', this._handleResize);\n      this.videoElements.forEach(function (el) {\n        el.addEventListener('pause', _this2._handlePlayChange);\n        el.addEventListener('play', _this2._handlePlayChange);\n        el.addEventListener('loadedmetadata', _this2._updatePlayState);\n      });\n    }\n  }, {\n    key: '_removeEventListeners',\n    value: function _removeEventListeners() {\n      var _this3 = this;\n\n      window.removeEventListener('resize', this._handleResize);\n      this.videoElements.forEach(function (el) {\n        el.removeEventListener('pause', _this3._handlePlayChange);\n        el.removeEventListener('play', _this3._handlePlayChange);\n        el.removeEventListener('loadedmetadata', _this3._updatePlayState);\n      });\n    }\n  }, {\n    key: '_setVideoAttributes',\n    value: function _setVideoAttributes() {\n      if (!this.disableForcedAttributes) {\n        this.videoElements.forEach(function (el) {\n          el.setAttribute('playsInline', '');\n          el.setAttribute('loop', '');\n          el.setAttribute('disableRemotePlayback', '');\n          el.setAttribute('x-webkit-airplay', 'deny');\n        });\n      }\n    }\n  }, {\n    key: '_shouldPlay',\n    value: function _shouldPlay() {\n      return this.visibleVideoElement.readyState >= 1 && this.state === 'ACTIVE' && this.viewportPosition === 'IN-VIEWPORT';\n    }\n  }, {\n    key: '_preload',\n    value: function _preload() {\n      if (this.visibleVideoElement.getAttribute('preload') !== 'auto') {\n        this.visibleVideoElement.setAttribute('preload', 'auto');\n      }\n    }\n  }, {\n    key: '_playVideo',\n    value: function _playVideo() {\n      var _this4 = this;\n\n      var videoElement = this.visibleVideoElement;\n\n      if (videoElement.paused && !this.autoplayBlocked) {\n        var playPromise = videoElement.play() || Promise.resolve();\n        playPromise.catch(function (e) {\n          console.error(e);\n          _this4.autoplayBlocked = true;\n        });\n      }\n    }\n  }, {\n    key: '_pauseVideo',\n    value: function _pauseVideo() {\n      var videoElement = this.visibleVideoElement;\n\n      if (!videoElement.paused) {\n        videoElement.pause();\n      }\n    }\n  }, {\n    key: 'visibleVideoElement',\n    get: function get() {\n      return this.videoElements.find(isVisible);\n    }\n  }, {\n    key: 'videoElements',\n    get: function get() {\n      return (0, _dhBasisCommon.toArray)(this.querySelectorAll('video'));\n    }\n  }, {\n    key: 'disableForcedAttributes',\n    get: function get() {\n      return this.hasAttribute(DISABLE_FORCED_ATTRIBUTES_ATTR);\n    }\n  }, {\n    key: 'state',\n    get: function get() {\n      return this.getAttribute(STATE_ATTR);\n    },\n    set: function set(val) {\n      this.setAttribute(STATE_ATTR, val);\n    }\n  }, {\n    key: 'isPaused',\n    get: function get() {\n      return this.getAttribute(IS_PAUSED);\n    },\n    set: function set(val) {\n      if (val) {\n        this.setAttribute(IS_PAUSED, '');\n      } else {\n        this.removeAttribute(IS_PAUSED);\n      }\n    }\n  }, {\n    key: 'autoplayBlocked',\n    get: function get() {\n      return this.hasAttribute(AUTOPLAY_BLOCKED) || false;\n    },\n    set: function set(val) {\n      (0, _dhBasisCommon.toggleAttribute)(this, AUTOPLAY_BLOCKED, val);\n    }\n  }, {\n    key: 'viewportPosition',\n    get: function get() {\n      return this.getAttribute(VIEWPORT_POSITION_ATTR);\n    },\n    set: function set(val) {\n      this.setAttribute(VIEWPORT_POSITION_ATTR, val);\n    }\n  }], [{\n    key: 'observedAttributes',\n    get: function get() {\n      return [STATE_ATTR, DISABLE_FORCED_ATTRIBUTES_ATTR, VIEWPORT_POSITION_ATTR];\n    }\n  }]);\n\n  return LevendeStillbilde;\n}(_CustomElement);\n\nexports.default = LevendeStillbilde;\n//# sourceMappingURL=dh-basis-levende-stillbilde.esm.js.map\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.withinStops = exports.withinRange = exports.toggleAttribute = exports.toArray = exports.testReducedMotion = exports.setAttribute = exports.mergeVideoloopProps = exports.mergeMediaProps = exports.mergeMapProps = exports.mergeImageProps = exports.dispatchEvent = exports.closest = exports.addStyle = exports.VerticalScroll = exports.HorizontalScroll = exports.ElementIntersectionObserver = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _axios = __webpack_require__(19);\n\nvar _axios2 = _interopRequireDefault(_axios);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n/* eslint-disable compat/compat */\nvar defaultConfig = {\n  rootMargin: '0px 0px 0px 0px',\n  threshold: [0, 0.5, 1]\n};\n\nvar ElementIntersectionObserver = function () {\n  function ElementIntersectionObserver(elements, onChange, config) {\n    var _this = this;\n\n    _classCallCheck(this, ElementIntersectionObserver);\n\n    this.intersections = void 0;\n    this.elements = void 0;\n    this.elements = elements.slice(0);\n    this.intersections = elements.map(function (target) {\n      return {\n        target: target,\n        isIntersecting: false,\n        ratio: null\n      };\n    });\n    this.intersectionObserver = new IntersectionObserver(function (entries) {\n      var intersections = _this.intersections.slice(0);\n      entries.forEach(function (entry) {\n        var idx = elements.indexOf(entry.target);\n        intersections.splice(idx, 1, {\n          target: entry.target,\n          isIntersecting: entry.isIntersecting,\n          ratio: entry.intersectionRatio\n        });\n      });\n      _this.intersections = intersections;\n      onChange(_this.intersections);\n    }, _objectSpread2({}, defaultConfig, {}, config));\n    elements.forEach(function (elm) {\n      return _this.intersectionObserver.observe(elm);\n    });\n  }\n\n  _createClass(ElementIntersectionObserver, [{\n    key: \"disconnect\",\n    value: function disconnect() {\n      var _this2 = this;\n\n      // Unregister trigger elements\n      this.elements.forEach(function (elm) {\n        return _this2.intersectionObserver.unobserve(elm);\n      }); // Disconnect intersection observer\n\n      this.intersectionObserver.disconnect();\n    }\n  }]);\n\n  return ElementIntersectionObserver;\n}();\n\nfunction toggleAttribute(el, name, boolValue) {\n  if (!el) {\n    return;\n  }\n\n  var nextValue;\n\n  if (typeof boolValue !== 'undefined') {\n    nextValue = !!boolValue;\n  } else {\n    nextValue = el.hasAttribute(name);\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, '');\n  } else {\n    el.removeAttribute(name);\n  }\n}\nfunction setAttribute(el, name, nextValue) {\n  if (!el) {\n    return;\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, nextValue);\n  } else {\n    el.removeAttribute(name);\n  }\n}\nvar closest = function () {\n  var proto = typeof window === 'undefined' ? {} : window.Element.prototype;\n  var match = proto.matches || proto.msMatchesSelector || proto.webkitMatchesSelector;\n\n  if (proto.closest) {\n    return function (el, css) {\n      return el.closest(css);\n    };\n  } else {\n    return function (el, css) {\n      for (; el; el = el.parentElement) {\n        if (match.call(el, css)) return el;\n      }\n\n      return null;\n    };\n  }\n}();\nfunction addStyle(nodeName, css) {\n  var key = \"style-\".concat(nodeName.toLowerCase());\n  var min = css.replace(/\\/\\*[^!][^*]*\\*\\//g, '').replace(/\\s*(^|[:;,{}]|$)\\s*/g, '$1');\n  document.getElementById(key) || document.head.insertAdjacentHTML('afterbegin', \"<style id=\\\"\".concat(key, \"\\\">\").concat(min, \"</style>\"));\n}\nfunction toArray(nodeList) {\n  return [].slice.call(nodeList);\n}\nfunction dispatchEvent(element, name) {\n  var detail = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var ignore = \"prevent_recursive_dispatch_maximum_callstack\".concat(name);\n  var event;\n  if (element[ignore]) return true; // We are already processing this event, so skip sending a new one\n  else element[ignore] = true; // Add name to dispatching ignore\n\n  if (typeof window.CustomEvent === 'function') {\n    event = new window.CustomEvent(name, {\n      bubbles: true,\n      cancelable: true,\n      detail: detail\n    });\n  } else {\n    event = document.createEvent('CustomEvent');\n    event.initCustomEvent(name, true, true, detail);\n  } // IE reports incorrect event.defaultPrevented\n  // but correct return value on element.dispatchEvent\n\n\n  var result = element.dispatchEvent(event);\n  element[ignore] = null; // Remove name from dispatching ignore\n\n  return result; // Follow W3C standard for return value\n}\n\nfunction easeOutQuint(t) {\n  return 1 + --t * t * t * t * t;\n}\n\nvar VerticalScroll = function () {\n  function VerticalScroll(container) {\n    _classCallCheck(this, VerticalScroll);\n\n    this.container = void 0;\n    this.container = container;\n  }\n\n  _createClass(VerticalScroll, [{\n    key: \"to\",\n    value: function to(top) {\n      var _this3 = this;\n\n      var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n      var from = this.container.scrollTop;\n      var distance = top - from;\n      var startTime = null;\n\n      var loop = function loop(currentTime) {\n        if (!startTime) {\n          startTime = currentTime - 1;\n        }\n\n        var timeElapsed = currentTime - startTime;\n        _this3.container.scrollTop = from + distance * easeOutQuint(timeElapsed / duration);\n\n        if (timeElapsed < duration) {\n          window.requestAnimationFrame(loop);\n        } else {\n          _this3.container.scrollTop = top;\n        }\n      };\n\n      window.requestAnimationFrame(loop);\n    }\n  }]);\n\n  return VerticalScroll;\n}();\n\nvar HorizontalScroll = function () {\n  function HorizontalScroll(container) {\n    _classCallCheck(this, HorizontalScroll);\n\n    this.container = void 0;\n    this.container = container;\n  }\n\n  _createClass(HorizontalScroll, [{\n    key: \"to\",\n    value: function to(left) {\n      var _this4 = this;\n\n      var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n      var callback = arguments.length > 2 ? arguments[2] : undefined;\n      var from = this.container.scrollLeft;\n      var distance = left - from;\n      var startTime = null;\n\n      var loop = function loop(currentTime) {\n        if (!startTime) {\n          startTime = currentTime - 1;\n        }\n\n        var timeElapsed = currentTime - startTime;\n        _this4.container.scrollLeft = from + distance * easeOutQuint(timeElapsed / duration);\n\n        if (timeElapsed < duration) {\n          window.requestAnimationFrame(loop);\n        } else {\n          _this4.container.scrollLeft = left;\n          callback && callback();\n        }\n      };\n\n      window.requestAnimationFrame(loop);\n    }\n  }]);\n\n  return HorizontalScroll;\n}();\n\nfunction testReducedMotion() {\n  if (typeof window !== 'undefined') {\n    return !!window.matchMedia && window.matchMedia('(prefers-reduced-motion)').matches;\n  }\n\n  return false;\n}\n\nvar name = process.env.npm_package_name;\nvar version = process.env.npm_package_version;\n\nfunction createGqlApi() {\n  return {\n    get: function get(query, url) {\n      return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {\n        var _ref5, data, errors;\n\n        return regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                _context.next = 2;\n                return (0, _axios2.default)({\n                  method: 'POST',\n                  url: url,\n                  data: {\n                    query: query,\n                    variables: null\n                  },\n                  timeout: 7500,\n                  headers: {\n                    'User-Agent': \"\".concat(name, \"/\").concat(version, \" (node/isomorphic-fetch)\"),\n                    'Content-Type': 'application/json',\n                    Accept: 'application/json'\n                  }\n                }).then(function (res) {\n                  return res.data;\n                });\n\n              case 2:\n                _ref5 = _context.sent;\n                data = _ref5.data;\n                errors = _ref5.errors;\n\n                if (!(errors && errors.length)) {\n                  _context.next = 7;\n                  break;\n                }\n\n                throw Error(errors);\n\n              case 7:\n                return _context.abrupt(\"return\", transformResponse(data));\n\n              case 8:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }))();\n    }\n  };\n}\n\nvar gqlApi = createGqlApi();\n\nfunction pngFragment(options) {\n  var aspects = options.aspectRatios.map(function (ratio) {\n    var sizes = ratio.sizes.map(function (s) {\n      return \"w\".concat(s, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(s, \", format: png)\");\n    }).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsPng on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n\nfunction jpgFragment(options) {\n  var aspects = options.aspectRatios.map(function (ratio) {\n    var sizes = ratio.sizes.map(function (size) {\n      return \"w\".concat(size, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(size, \")\");\n    }).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsJpg on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n/**\n * Transforms a series of image sections to a Polopoly GraphQL API query\n */\n\nfunction createQuery(imageObjects, options) {\n  var images = getImageIds(imageObjects);\n  return \"\\n    \".concat(createBase(images, options), \"\\n    query {\\n      \").concat(images.map(getImage).join('\\n'), \"\\n    }\");\n}\nvar IMAGE_PROPS = ['vertical', 'horizontal'];\n\nfunction getImageIds(imageObjects) {\n  if (imageObjects.some(function (image) {\n    return !image;\n  })) {\n    throw new Error('Undefined image object');\n  }\n\n  return imageObjects.reduce(function (result, image) {\n    var format = image.format || image.advanced && image.advanced.format || 'jpg';\n    /* Image can be stored directly on image object */\n\n    if (image.id && !result.find(function (el) {\n      return el.id === image.id;\n    })) {\n      result.push({\n        id: image.id,\n        format: format\n      });\n    }\n    /* or on a predefined set of image properties */\n\n    IMAGE_PROPS.forEach(function (prop) {\n      var value = image[prop];\n\n      if (value && value.id && !result.find(function (el) {\n        return el.id === value.id;\n      })) {\n        result.push({\n          id: value.id,\n          format: format\n        });\n      }\n    });\n    return result;\n  }, []);\n}\n\nfunction getImage(_ref) {\n  var id = _ref.id,\n      _ref$format = _ref.format,\n      format = _ref$format === undefined ? 'jpg' : _ref$format;\n\n\n  if (format === 'png') {\n    return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n      ...imageCropsPng\\n    }\");\n  }\n\n  return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n    ...imageCropsJpg\\n  }\");\n}\n\nfunction createBase(imageObjects, options) {\n  var containsJpg = imageObjects.filter(function (el) {\n    return el.format === 'jpg';\n  }).length > 0;\n  var containsPng = imageObjects.filter(function (el) {\n    return el.format === 'png';\n  }).length > 0;\n  return \"\\n    \".concat(containsJpg ? jpgFragment(options) : '', \"\\n    \").concat(containsPng ? pngFragment(options) : '', \"\\n  \");\n}\n/**\n * Transforns a polopoly id to something that can be used as a key in a GraphQL query\n * Example: '1.14252981' -> 'id_1_14252981'\n */\n\nfunction transformId(id) {\n  return \"id\".concat(id.replace(/\\./g, '__'));\n}\n/**\n * Transforns an already transformed polopoly id back to a regular polopoly id\n * Example: ''id_1_14252981' -> 1.14252981'\n */\n\nfunction transformBackId(id) {\n  return id.replace('id', '').replace(/__/g, '.');\n}\n\nfunction transformResponse(response) {\n  return Object.keys(response).reduce(function (res, key) {\n    var transformedKey = transformBackId(key);\n    res[transformedKey] = response[key];\n    return res;\n  }, {});\n}\n\nfunction fromEntries(items) {\n  return [].concat(_toConsumableArray(items)).reduce(function (obj, _ref) {\n    var _ref6 = _slicedToArray(_ref, 2),\n        key = _ref6[0],\n        val = _ref6[1];\n\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nfunction traverse(obj, filter) {\n  var matches = [];\n\n  if (filter(obj)) {\n    /* Object is a match, returning */\n    matches.push(obj);\n  }\n\n  return [].concat(matches, _toConsumableArray(Object.entries(obj).filter(function (_ref2) {\n    var _ref7 = _slicedToArray(_ref2, 2),\n        _ = _ref7[0],\n        value = _ref7[1];\n\n    return !!value;\n  }).map(function (_ref3) {\n    var _ref8 = _slicedToArray(_ref3, 2),\n        _ = _ref8[0],\n        value = _ref8[1];\n\n    if (Array.isArray(value)) {\n      return value.map(function (item) {\n        return traverse(item, filter);\n      }).reduce(function (acc, val) {\n        return acc.concat(val);\n      }, []);\n    } else if ((typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) === 'object') {\n      return traverse(value, filter);\n    } else {\n      return null;\n    }\n  }).reduce(function (acc, val) {\n    return acc.concat(val);\n  }, []).filter(Boolean)));\n}\n/*\n * Traverses the props tree and fetches data for all image objects\n * */\n\nfunction prefetchImageData(_x, _x2) {\n  return _prefetchImageData.apply(this, arguments);\n}\n\nfunction _prefetchImageData() {\n  _prefetchImageData = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(props, options) {\n    var imageObjects, query;\n    return regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            imageObjects = traverse(props, function (value) {\n              return value.type && value.type.startsWith('image');\n            });\n\n            if (!(imageObjects.length > 0)) {\n              _context2.next = 6;\n              break;\n            }\n\n            if (options.gqlApiUrl) {\n              _context2.next = 4;\n              break;\n            }\n\n            throw new Error(\"Missing option 'gqlApiUrl'\");\n\n          case 4:\n            query = createQuery(imageObjects, options);\n            return _context2.abrupt(\"return\", gqlApi.get(query, options.gqlApiUrl));\n\n          case 6:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2, this);\n  }));\n  return _prefetchImageData.apply(this, arguments);\n}\n\nvar imageProps = ['vertical', 'horizontal'];\nfunction mergeImageProps(props, imageUrls) {\n  if ('id' in props) {\n    return _objectSpread2({}, props, {}, imageUrls[props.id]);\n  } else {\n    return fromEntries(Object.entries(props).map(function (_ref4) {\n      var _ref9 = _slicedToArray(_ref4, 2),\n          key = _ref9[0],\n          value = _ref9[1];\n\n      if (imageProps.indexOf(key) !== -1) {\n        return [key, mergeImageProps(value, imageUrls)];\n      } else {\n        return [key, value];\n      }\n    }));\n  }\n}\n\nfunction mergeVideoloopProps(_x) {\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction _mergeVideoloopProps() {\n  _mergeVideoloopProps = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(props) {\n    var objects;\n    return regeneratorRuntime.wrap(function _callee4$(_context4) {\n      while (1) {\n        switch (_context4.prev = _context4.next) {\n          case 0:\n            _context4.next = 2;\n            return Promise.all(Object.keys(props).map(\n            /*#__PURE__*/\n            function () {\n              var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(key) {\n                return regeneratorRuntime.wrap(function _callee3$(_context3) {\n                  while (1) {\n                    switch (_context3.prev = _context3.next) {\n                      case 0:\n                        if (!(key === 'horizontal' || key === 'vertical')) {\n                          _context3.next = 9;\n                          break;\n                        }\n\n                        _context3.t0 = _objectSpread2;\n                        _context3.t1 = {\n                          id: key\n                        };\n                        _context3.t2 = props[key];\n                        _context3.next = 6;\n                        return getVideoSrc(props[key]);\n\n                      case 6:\n                        _context3.t3 = _context3.sent;\n                        _context3.t4 = {\n                          videos: _context3.t3\n                        };\n                        return _context3.abrupt(\"return\", (0, _context3.t0)(_context3.t1, _context3.t2, _context3.t4));\n\n                      case 9:\n                      case \"end\":\n                        return _context3.stop();\n                    }\n                  }\n                }, _callee3, this);\n              }));\n\n              return function (_x4) {\n                return _ref2.apply(this, arguments);\n              };\n            }()));\n\n          case 2:\n            objects = _context4.sent;\n            return _context4.abrupt(\"return\", _objectSpread2({}, props, {}, objects.filter(Boolean).reduce(function (accumulator, current) {\n              accumulator[current.id] = current;\n              delete accumulator[current.id].id;\n              return accumulator;\n            }, {})));\n\n          case 4:\n          case \"end\":\n            return _context4.stop();\n        }\n      }\n    }, _callee4, this);\n  }));\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction getVideoSrc(_x2) {\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction _getVideoSrc() {\n  _getVideoSrc = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(videoObj) {\n    var hasVideoUrl, videos, basePath;\n    return regeneratorRuntime.wrap(function _callee5$(_context5) {\n      while (1) {\n        switch (_context5.prev = _context5.next) {\n          case 0:\n            hasVideoUrl = videoObj && videoObj !== 'null';\n\n            if (!hasVideoUrl) {\n              _context5.next = 9;\n              break;\n            }\n\n            _context5.next = 4;\n            return getVideos(videoObj.url);\n\n          case 4:\n            videos = _context5.sent;\n            basePath = extractBasePathFromUrl(videoObj.url);\n            return _context5.abrupt(\"return\", videos.map(function (video) {\n              return {\n                type: getTypeFromHeight(video.height),\n                poster: \"\".concat(basePath, \"/\").concat(video.stillFileName),\n                aspectRatio: video.displayAspectRatio,\n                height: video.height,\n                sources: {\n                  mp4: \"\".concat(basePath, \"/\").concat(video.videoFileName)\n                }\n              };\n            }));\n\n          case 9:\n            return _context5.abrupt(\"return\", null);\n\n          case 10:\n          case \"end\":\n            return _context5.stop();\n        }\n      }\n    }, _callee5, this);\n  }));\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction extractBasePathFromUrl(url) {\n  var decodedUrl = url.replace(/%2F/g, '/');\n  return decodedUrl.substr(0, decodedUrl.lastIndexOf('/'));\n}\n\nfunction getVideos(_x3) {\n  return _getVideos.apply(this, arguments);\n}\n\nfunction _getVideos() {\n  _getVideos = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6(url) {\n    var videoPayload;\n    return regeneratorRuntime.wrap(function _callee6$(_context6) {\n      while (1) {\n        switch (_context6.prev = _context6.next) {\n          case 0:\n            _context6.next = 2;\n            return getVideoPayload(url);\n\n          case 2:\n            videoPayload = _context6.sent;\n            return _context6.abrupt(\"return\", videoPayload.movingStills);\n\n          case 4:\n          case \"end\":\n            return _context6.stop();\n        }\n      }\n    }, _callee6, this);\n  }));\n  return _getVideos.apply(this, arguments);\n}\n\nfunction getVideoPayload(url) {\n  return _axios2.default.get(url, {\n    timeout: 2000\n  }).then(function (_ref) {\n    var data = _ref.data;\n\n    return data;\n  });\n}\n\nfunction getTypeFromHeight(height) {\n  switch (height) {\n    case 360:\n      return 'small';\n\n    case 720:\n      return 'medium';\n\n    case 1080:\n      return 'large';\n\n    default:\n      return 'large';\n  }\n}\n\nfunction mergeMapProps(_x) {\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction _mergeMapProps() {\n  _mergeMapProps = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(props) {\n    var id, rest;\n    return regeneratorRuntime.wrap(function _callee7$(_context7) {\n      while (1) {\n        switch (_context7.prev = _context7.next) {\n          case 0:\n            id = props.id, rest = _objectWithoutProperties(props, [\"id\"]);\n            _context7.t0 = _objectSpread2;\n            _context7.t1 = {\n              id: id\n            };\n            _context7.t2 = rest;\n            _context7.next = 6;\n            return getMapDefinition(id);\n\n          case 6:\n            _context7.t3 = _context7.sent;\n            _context7.t4 = {\n              definition: _context7.t3\n            };\n            return _context7.abrupt(\"return\", (0, _context7.t0)(_context7.t1, _context7.t2, _context7.t4));\n\n          case 9:\n          case \"end\":\n            return _context7.stop();\n        }\n      }\n    }, _callee7, this);\n  }));\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction getMapDefinition(_x2) {\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction _getMapDefinition() {\n  _getMapDefinition = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee8(id) {\n    return regeneratorRuntime.wrap(function _callee8$(_context8) {\n      while (1) {\n        switch (_context8.prev = _context8.next) {\n          case 0:\n            if (id) {\n              _context8.next = 2;\n              break;\n            }\n\n            return _context8.abrupt(\"return\");\n\n          case 2:\n            return _context8.abrupt(\"return\", _axios2.default.get(\"https://dh.nrk.no/atlas/v1/definition?id=\".concat(id), {\n              timeout: 2000\n            }).then(function (_ref) {\n              var data = _ref.data;\n\n              return data;\n            }));\n\n          case 3:\n          case \"end\":\n            return _context8.stop();\n        }\n      }\n    }, _callee8, this);\n  }));\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction fromEntries$1(items) {\n  return [].concat(_toConsumableArray(items)).reduce(function (obj, _ref) {\n    var _ref10 = _slicedToArray(_ref, 2),\n        key = _ref10[0],\n        val = _ref10[1];\n\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nvar defaultOptions = {\n  image: {\n    gqlApiUrl: 'https://www.nrk.no/api/graphql',\n    aspectRatios: [{\n      id: 'F11',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F34',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F169',\n      sizes: ['900', '1280', '2400']\n    }, {\n      id: 'original',\n      sizes: ['450', '768', '1280', '2400']\n    }]\n  }\n};\nfunction mergeMediaProps(_x, _x2, _x3) {\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nfunction _mergeMediaProps() {\n  _mergeMediaProps = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee10(props, options, imageData) {\n    var mergedOptions, type, imageDataStored, mergedProps, mappedEntries;\n    return regeneratorRuntime.wrap(function _callee10$(_context10) {\n      while (1) {\n        switch (_context10.prev = _context10.next) {\n          case 0:\n            mergedOptions = {\n              image: _objectSpread2({}, defaultOptions.image, {}, options === null || options === void 0 ? void 0 : options.image)\n            };\n            type = props.type;\n            _context10.t0 = imageData;\n\n            if (_context10.t0) {\n              _context10.next = 7;\n              break;\n            }\n\n            _context10.next = 6;\n            return prefetchImageData(props, mergedOptions.image);\n\n          case 6:\n            _context10.t0 = _context10.sent;\n\n          case 7:\n            imageDataStored = _context10.t0;\n            mergedProps = props;\n\n            if (!(type && type.startsWith('videoloop'))) {\n              _context10.next = 15;\n              break;\n            }\n\n            _context10.next = 12;\n            return mergeVideoloopProps(props);\n\n          case 12:\n            mergedProps = _context10.sent;\n            _context10.next = 25;\n            break;\n\n          case 15:\n            if (!(type && type.startsWith('image'))) {\n              _context10.next = 21;\n              break;\n            }\n\n            _context10.next = 18;\n            return mergeImageProps(props, imageDataStored);\n\n          case 18:\n            mergedProps = _context10.sent;\n            _context10.next = 25;\n            break;\n\n          case 21:\n            if (!(type && type.startsWith('map'))) {\n              _context10.next = 25;\n              break;\n            }\n\n            _context10.next = 24;\n            return mergeMapProps(props, imageDataStored);\n\n          case 24:\n            mergedProps = _context10.sent;\n\n          case 25:\n            _context10.next = 27;\n            return Promise.all(Object.entries(mergedProps).map(\n            /*#__PURE__*/\n            function () {\n              var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee9(_ref3) {\n                var _ref11, key, value, mergedArray;\n\n                return regeneratorRuntime.wrap(function _callee9$(_context9) {\n                  while (1) {\n                    switch (_context9.prev = _context9.next) {\n                      case 0:\n                        _ref11 = _slicedToArray(_ref3, 2), key = _ref11[0], value = _ref11[1];\n\n                        if (!Array.isArray(value)) {\n                          _context9.next = 8;\n                          break;\n                        }\n\n                        _context9.next = 4;\n                        return Promise.all(value.map(function (item) {\n                          return mergeMediaProps(item, options, imageDataStored);\n                        }));\n\n                      case 4:\n                        mergedArray = _context9.sent;\n                        return _context9.abrupt(\"return\", [key, mergedArray]);\n\n                      case 8:\n                        if (!((typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) === 'object' && value !== null)) {\n                          _context9.next = 16;\n                          break;\n                        }\n\n                        _context9.t0 = key;\n                        _context9.next = 12;\n                        return mergeMediaProps(value, options, imageDataStored);\n\n                      case 12:\n                        _context9.t1 = _context9.sent;\n                        return _context9.abrupt(\"return\", [_context9.t0, _context9.t1]);\n\n                      case 16:\n                        return _context9.abrupt(\"return\", [key, value]);\n\n                      case 17:\n                      case \"end\":\n                        return _context9.stop();\n                    }\n                  }\n                }, _callee9, this);\n              }));\n\n              return function (_x4) {\n                return _ref2.apply(this, arguments);\n              };\n            }()));\n\n          case 27:\n            mappedEntries = _context10.sent;\n            return _context10.abrupt(\"return\", fromEntries$1(mappedEntries));\n\n          case 29:\n          case \"end\":\n            return _context10.stop();\n        }\n      }\n    }, _callee10, this);\n  }));\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nvar MAX_SAFE_INTEGER = 9007199254740991;\nfunction withinRange(current) {\n  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MAX_SAFE_INTEGER;\n  return current >= start && current <= stop;\n}\nfunction withinStops(currentTime, stops, targetStop) {\n  var nrOfStops = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;\n  var uniqueStops = stops.filter(unique);\n  var targetTime = stops[targetStop];\n  var prevTime = uniqueStops[uniqueStops.indexOf(targetTime) - nrOfStops];\n  var nextTime = uniqueStops[uniqueStops.indexOf(targetTime) + nrOfStops];\n  return withinRange(currentTime, prevTime, nextTime);\n}\n\nfunction unique(value, index, self) {\n  return self.indexOf(value) === index;\n}\n\nexports.ElementIntersectionObserver = ElementIntersectionObserver;\nexports.HorizontalScroll = HorizontalScroll;\nexports.VerticalScroll = VerticalScroll;\nexports.addStyle = addStyle;\nexports.closest = closest;\nexports.dispatchEvent = dispatchEvent;\nexports.mergeImageProps = mergeImageProps;\nexports.mergeMapProps = mergeMapProps;\nexports.mergeMediaProps = mergeMediaProps;\nexports.mergeVideoloopProps = mergeVideoloopProps;\nexports.setAttribute = setAttribute;\nexports.testReducedMotion = testReducedMotion;\nexports.toArray = toArray;\nexports.toggleAttribute = toggleAttribute;\nexports.withinRange = withinRange;\nexports.withinStops = withinStops;\n//# sourceMappingURL=dh-basis-common.esm.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\nvar bind = __webpack_require__(20);\nvar Axios = __webpack_require__(46);\nvar mergeConfig = __webpack_require__(26);\nvar defaults = __webpack_require__(23);\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n  return createInstance(mergeConfig(axios.defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = __webpack_require__(27);\naxios.CancelToken = __webpack_require__(59);\naxios.isCancel = __webpack_require__(22);\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = __webpack_require__(60);\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\nvar buildURL = __webpack_require__(21);\nvar InterceptorManager = __webpack_require__(47);\nvar dispatchRequest = __webpack_require__(48);\nvar mergeConfig = __webpack_require__(26);\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof config === 'string') {\n    config = arguments[1] || {};\n    config.url = arguments[0];\n  } else {\n    config = config || {};\n  }\n\n  config = mergeConfig(this.defaults, config);\n\n  // Set config.method\n  if (config.method) {\n    config.method = config.method.toLowerCase();\n  } else if (this.defaults.method) {\n    config.method = this.defaults.method.toLowerCase();\n  } else {\n    config.method = 'get';\n  }\n\n  // Hook up interceptors middleware\n  var chain = [dispatchRequest, undefined];\n  var promise = Promise.resolve(config);\n\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    chain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    chain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  while (chain.length) {\n    promise = promise.then(chain.shift(), chain.shift());\n  }\n\n  return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n  config = mergeConfig(this.defaults, config);\n  return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\\?/, '');\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function (url, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function (url, data, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url,\n      data: data\n    }));\n  };\n});\n\nmodule.exports = Axios;\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\nvar transformData = __webpack_require__(49);\nvar isCancel = __webpack_require__(22);\nvar defaults = __webpack_require__(23);\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData(config.data, config.headers, config.transformRequest);\n\n  // Flatten headers\n  config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);\n\n  utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], function cleanHeaderConfig(method) {\n    delete config.headers[method];\n  });\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData(response.data, response.headers, config.transformResponse);\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData(reason.response.data, reason.response.headers, config.transformResponse);\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn(data, headers);\n  });\n\n  return data;\n};\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n\n/***/ }),\n/* 51 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar createError = __webpack_require__(25);\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  if (!validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(createError('Request failed with status code ' + response.status, response.config, null, response.request, response));\n  }\n};\n\n/***/ }),\n/* 52 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The error.\n */\n\nmodule.exports = function enhanceError(error, config, code, request, response) {\n  error.config = config;\n  if (code) {\n    error.code = code;\n  }\n\n  error.request = request;\n  error.response = response;\n  error.isAxiosError = true;\n\n  error.toJSON = function () {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: this.config,\n      code: this.code\n    };\n  };\n  return error;\n};\n\n/***/ }),\n/* 53 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar isAbsoluteURL = __webpack_require__(54);\nvar combineURLs = __webpack_require__(55);\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n * @returns {string} The combined full path\n */\nmodule.exports = function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n};\n\n/***/ }),\n/* 54 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\n\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return (/^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url)\n  );\n};\n\n/***/ }),\n/* 55 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\n\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return relativeURL ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '') : baseURL;\n};\n\n/***/ }),\n/* 56 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\n// Headers whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nvar ignoreDuplicateOf = ['age', 'authorization', 'content-length', 'content-type', 'etag', 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 'referer', 'retry-after', 'user-agent'];\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) {\n    return parsed;\n  }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {\n        return;\n      }\n      if (key === 'set-cookie') {\n        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);\n      } else {\n        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n      }\n    }\n  });\n\n  return parsed;\n};\n\n/***/ }),\n/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\nmodule.exports = utils.isStandardBrowserEnv() ?\n\n// Standard browser envs have full support of the APIs needed to test\n// whether the request URL is of the same origin as current location.\nfunction standardBrowserEnv() {\n  var msie = /(msie|trident)/i.test(navigator.userAgent);\n  var urlParsingNode = document.createElement('a');\n  var originURL;\n\n  /**\n  * Parse a URL to discover it's components\n  *\n  * @param {String} url The URL to be parsed\n  * @returns {Object}\n  */\n  function resolveURL(url) {\n    var href = url;\n\n    if (msie) {\n      // IE needs attribute set twice to normalize properties\n      urlParsingNode.setAttribute('href', href);\n      href = urlParsingNode.href;\n    }\n\n    urlParsingNode.setAttribute('href', href);\n\n    // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n    return {\n      href: urlParsingNode.href,\n      protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n      host: urlParsingNode.host,\n      search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n      hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n      hostname: urlParsingNode.hostname,\n      port: urlParsingNode.port,\n      pathname: urlParsingNode.pathname.charAt(0) === '/' ? urlParsingNode.pathname : '/' + urlParsingNode.pathname\n    };\n  }\n\n  originURL = resolveURL(window.location.href);\n\n  /**\n  * Determine if a URL shares the same origin as the current location\n  *\n  * @param {String} requestURL The URL to test\n  * @returns {boolean} True if URL shares the same origin, otherwise false\n  */\n  return function isURLSameOrigin(requestURL) {\n    var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;\n    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;\n  };\n}() :\n\n// Non standard browser envs (web workers, react-native) lack needed support.\nfunction nonStandardBrowserEnv() {\n  return function isURLSameOrigin() {\n    return true;\n  };\n}();\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar utils = __webpack_require__(2);\n\nmodule.exports = utils.isStandardBrowserEnv() ?\n\n// Standard browser envs support document.cookie\nfunction standardBrowserEnv() {\n  return {\n    write: function write(name, value, expires, path, domain, secure) {\n      var cookie = [];\n      cookie.push(name + '=' + encodeURIComponent(value));\n\n      if (utils.isNumber(expires)) {\n        cookie.push('expires=' + new Date(expires).toGMTString());\n      }\n\n      if (utils.isString(path)) {\n        cookie.push('path=' + path);\n      }\n\n      if (utils.isString(domain)) {\n        cookie.push('domain=' + domain);\n      }\n\n      if (secure === true) {\n        cookie.push('secure');\n      }\n\n      document.cookie = cookie.join('; ');\n    },\n\n    read: function read(name) {\n      var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n      return match ? decodeURIComponent(match[3]) : null;\n    },\n\n    remove: function remove(name) {\n      this.write(name, '', Date.now() - 86400000);\n    }\n  };\n}() :\n\n// Non standard browser env (web workers, react-native) lack needed support.\nfunction nonStandardBrowserEnv() {\n  return {\n    write: function write() {},\n    read: function read() {\n      return null;\n    },\n    remove: function remove() {}\n  };\n}();\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Cancel = __webpack_require__(27);\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new Cancel(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n\n/***/ }),\n/* 60 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\n\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n\n/***/ }),\n/* 61 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(process) {\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.withinRange = exports.toggleAttribute = exports.toArray = exports.testReducedMotion = exports.setAttribute = exports.mergeVideoloopProps = exports.mergeMediaProps = exports.mergeMapProps = exports.mergeImageProps = exports.dispatchEvent = exports.closest = exports.addStyle = exports.VerticalScroll = exports.HorizontalScroll = exports.ElementIntersectionObserver = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _axios = __webpack_require__(19);\n\nvar _axios2 = _interopRequireDefault(_axios);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(source, true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(source).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n/* eslint-disable compat/compat */\nvar defaultConfig = {\n  rootMargin: '0px 0px 0px 0px',\n  threshold: [0, 0.5, 1]\n};\n\nvar ElementIntersectionObserver = function () {\n  function ElementIntersectionObserver(elements, onChange, config) {\n    var _this = this;\n\n    _classCallCheck(this, ElementIntersectionObserver);\n\n    this.intersections = void 0;\n    this.elements = void 0;\n    this.elements = elements.slice(0);\n    this.intersections = elements.map(function (target) {\n      return {\n        target: target,\n        isIntersecting: false,\n        ratio: null\n      };\n    });\n    this.intersectionObserver = new IntersectionObserver(function (entries) {\n      var intersections = _this.intersections.slice(0);\n      entries.forEach(function (entry) {\n        var idx = elements.indexOf(entry.target);\n        intersections.splice(idx, 1, {\n          target: entry.target,\n          isIntersecting: entry.isIntersecting,\n          ratio: entry.intersectionRatio\n        });\n      });\n      _this.intersections = intersections;\n      onChange(_this.intersections);\n    }, _objectSpread2({}, defaultConfig, {}, config));\n    elements.forEach(function (elm) {\n      return _this.intersectionObserver.observe(elm);\n    });\n  }\n\n  _createClass(ElementIntersectionObserver, [{\n    key: \"disconnect\",\n    value: function disconnect() {\n      var _this2 = this;\n\n      // Unregister trigger elements\n      this.elements.forEach(function (elm) {\n        return _this2.intersectionObserver.unobserve(elm);\n      }); // Disconnect intersection observer\n\n      this.intersectionObserver.disconnect();\n    }\n  }]);\n\n  return ElementIntersectionObserver;\n}();\n\nfunction toggleAttribute(el, name, boolValue) {\n  if (!el) {\n    return;\n  }\n\n  var nextValue;\n\n  if (typeof boolValue !== 'undefined') {\n    nextValue = !!boolValue;\n  } else {\n    nextValue = el.hasAttribute(name);\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, '');\n  } else {\n    el.removeAttribute(name);\n  }\n}\nfunction setAttribute(el, name, nextValue) {\n  if (!el) {\n    return;\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, nextValue);\n  } else {\n    el.removeAttribute(name);\n  }\n}\nvar closest = function () {\n  var proto = typeof window === 'undefined' ? {} : window.Element.prototype;\n  var match = proto.matches || proto.msMatchesSelector || proto.webkitMatchesSelector;\n\n  if (proto.closest) {\n    return function (el, css) {\n      return el.closest(css);\n    };\n  } else {\n    return function (el, css) {\n      for (; el; el = el.parentElement) {\n        if (match.call(el, css)) return el;\n      }\n\n      return null;\n    };\n  }\n}();\nfunction addStyle(nodeName, css) {\n  var key = \"style-\".concat(nodeName.toLowerCase());\n  var min = css.replace(/\\/\\*[^!][^*]*\\*\\//g, '').replace(/\\s*(^|[:;,{}]|$)\\s*/g, '$1');\n  document.getElementById(key) || document.head.insertAdjacentHTML('afterbegin', \"<style id=\\\"\".concat(key, \"\\\">\").concat(min, \"</style>\"));\n}\nfunction toArray(nodeList) {\n  return [].slice.call(nodeList);\n}\nfunction dispatchEvent(element, name) {\n  var detail = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var ignore = \"prevent_recursive_dispatch_maximum_callstack\".concat(name);\n  var event;\n  if (element[ignore]) return true; // We are already processing this event, so skip sending a new one\n  else element[ignore] = true; // Add name to dispatching ignore\n\n  if (typeof window.CustomEvent === 'function') {\n    event = new window.CustomEvent(name, {\n      bubbles: true,\n      cancelable: true,\n      detail: detail\n    });\n  } else {\n    event = document.createEvent('CustomEvent');\n    event.initCustomEvent(name, true, true, detail);\n  } // IE reports incorrect event.defaultPrevented\n  // but correct return value on element.dispatchEvent\n\n\n  var result = element.dispatchEvent(event);\n  element[ignore] = null; // Remove name from dispatching ignore\n\n  return result; // Follow W3C standard for return value\n}\n\nfunction easeOutQuint(t) {\n  return 1 + --t * t * t * t * t;\n}\n\nvar VerticalScroll = function () {\n  function VerticalScroll(container) {\n    _classCallCheck(this, VerticalScroll);\n\n    this.container = void 0;\n    this.container = container;\n  }\n\n  _createClass(VerticalScroll, [{\n    key: \"to\",\n    value: function to(top) {\n      var _this3 = this;\n\n      var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n      var from = this.container.scrollTop;\n      var distance = top - from;\n      var startTime = null;\n\n      var loop = function loop(currentTime) {\n        if (!startTime) {\n          startTime = currentTime - 1;\n        }\n\n        var timeElapsed = currentTime - startTime;\n        _this3.container.scrollTop = from + distance * easeOutQuint(timeElapsed / duration);\n\n        if (timeElapsed < duration) {\n          window.requestAnimationFrame(loop);\n        } else {\n          _this3.container.scrollTop = top;\n        }\n      };\n\n      window.requestAnimationFrame(loop);\n    }\n  }]);\n\n  return VerticalScroll;\n}();\n\nvar HorizontalScroll = function () {\n  function HorizontalScroll(container) {\n    _classCallCheck(this, HorizontalScroll);\n\n    this.container = void 0;\n    this.container = container;\n  }\n\n  _createClass(HorizontalScroll, [{\n    key: \"to\",\n    value: function to(left) {\n      var _this4 = this;\n\n      var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n      var callback = arguments.length > 2 ? arguments[2] : undefined;\n      var from = this.container.scrollLeft;\n      var distance = left - from;\n      var startTime = null;\n\n      var loop = function loop(currentTime) {\n        if (!startTime) {\n          startTime = currentTime - 1;\n        }\n\n        var timeElapsed = currentTime - startTime;\n        _this4.container.scrollLeft = from + distance * easeOutQuint(timeElapsed / duration);\n\n        if (timeElapsed < duration) {\n          window.requestAnimationFrame(loop);\n        } else {\n          _this4.container.scrollLeft = left;\n          callback && callback();\n        }\n      };\n\n      window.requestAnimationFrame(loop);\n    }\n  }]);\n\n  return HorizontalScroll;\n}();\n\nfunction testReducedMotion() {\n  if (typeof window !== 'undefined') {\n    return !!window.matchMedia && window.matchMedia('(prefers-reduced-motion)').matches;\n  }\n\n  return false;\n}\n\nvar name = process.env.npm_package_name;\nvar version = process.env.npm_package_version;\n\nfunction createGqlApi() {\n  return {\n    get: function get(query, url) {\n      return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {\n        var _ref5, data, errors;\n\n        return regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                _context.next = 2;\n                return (0, _axios2.default)({\n                  method: 'POST',\n                  url: url,\n                  data: {\n                    query: query,\n                    variables: null\n                  },\n                  timeout: 7500,\n                  headers: {\n                    'User-Agent': \"\".concat(name, \"/\").concat(version, \" (node/isomorphic-fetch)\"),\n                    'Content-Type': 'application/json',\n                    Accept: 'application/json'\n                  }\n                }).then(function (res) {\n                  return res.data;\n                });\n\n              case 2:\n                _ref5 = _context.sent;\n                data = _ref5.data;\n                errors = _ref5.errors;\n\n                if (!(errors && errors.length)) {\n                  _context.next = 7;\n                  break;\n                }\n\n                throw Error(errors);\n\n              case 7:\n                return _context.abrupt(\"return\", transformResponse(data));\n\n              case 8:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }))();\n    }\n  };\n}\n\nvar gqlApi = createGqlApi();\n\nfunction pngFragment(options) {\n  var aspects = options.aspectRatios.map(function (ratio) {\n    var sizes = ratio.sizes.map(function (s) {\n      return \"w\".concat(s, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(s, \", format: png)\");\n    }).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsPng on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n\nfunction jpgFragment(options) {\n  var aspects = options.aspectRatios.map(function (ratio) {\n    var sizes = ratio.sizes.map(function (size) {\n      return \"w\".concat(size, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(size, \")\");\n    }).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsJpg on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n/**\n * Transforms a series of image sections to a Polopoly GraphQL API query\n */\n\nfunction createQuery(imageObjects, options) {\n  var images = getImageIds(imageObjects);\n  return \"\\n    \".concat(createBase(images, options), \"\\n    query {\\n      \").concat(images.map(getImage).join('\\n'), \"\\n    }\");\n}\nvar IMAGE_PROPS = ['vertical', 'horizontal'];\n\nfunction getImageIds(imageObjects) {\n  if (imageObjects.some(function (image) {\n    return !image;\n  })) {\n    throw new Error('Undefined image object');\n  }\n\n  return imageObjects.reduce(function (result, image) {\n    var format = image.advanced && image.advanced.format || 'jpg';\n    /* Image can be stored directly on image object */\n\n    if (image.id && !result.find(function (el) {\n      return el.id === image.id;\n    })) {\n      result.push({\n        id: image.id,\n        format: format\n      });\n    }\n    /* or on a predefined set of image properties */\n\n    IMAGE_PROPS.forEach(function (prop) {\n      var value = image[prop];\n\n      if (value && value.id && !result.find(function (el) {\n        return el.id === value.id;\n      })) {\n        result.push({\n          id: value.id,\n          format: format\n        });\n      }\n    });\n    return result;\n  }, []);\n}\n\nfunction getImage(_ref) {\n  var id = _ref.id,\n      _ref$format = _ref.format,\n      format = _ref$format === undefined ? 'jpg' : _ref$format;\n\n\n  if (format === 'png') {\n    return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n      ...imageCropsPng\\n    }\");\n  }\n\n  return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n    ...imageCropsJpg\\n  }\");\n}\n\nfunction createBase(imageObjects, options) {\n  var containsJpg = imageObjects.filter(function (el) {\n    return el.format === 'jpg';\n  }).length > 0;\n  var containsPng = imageObjects.filter(function (el) {\n    return el.format === 'png';\n  }).length > 0;\n  return \"\\n    \".concat(containsJpg ? jpgFragment(options) : '', \"\\n    \").concat(containsPng ? pngFragment(options) : '', \"\\n  \");\n}\n/**\n * Transforns a polopoly id to something that can be used as a key in a GraphQL query\n * Example: '1.14252981' -> 'id_1_14252981'\n */\n\nfunction transformId(id) {\n  return \"id\".concat(id.replace(/\\./g, '__'));\n}\n/**\n * Transforns an already transformed polopoly id back to a regular polopoly id\n * Example: ''id_1_14252981' -> 1.14252981'\n */\n\nfunction transformBackId(id) {\n  return id.replace('id', '').replace(/__/g, '.');\n}\n\nfunction transformResponse(response) {\n  return Object.keys(response).reduce(function (res, key) {\n    var transformedKey = transformBackId(key);\n    res[transformedKey] = response[key];\n    return res;\n  }, {});\n}\n\nfunction fromEntries(items) {\n  return [].concat(_toConsumableArray(items)).reduce(function (obj, _ref) {\n    var _ref6 = _slicedToArray(_ref, 2),\n        key = _ref6[0],\n        val = _ref6[1];\n\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nfunction traverse(obj, filter) {\n  if (filter(obj)) {\n    /* Object is a match, returning */\n    return [obj];\n  } else {\n    return Object.entries(obj).filter(function (_ref2) {\n      var _ref7 = _slicedToArray(_ref2, 2),\n          _ = _ref7[0],\n          value = _ref7[1];\n\n      return !!value;\n    }).map(function (_ref3) {\n      var _ref8 = _slicedToArray(_ref3, 2),\n          _ = _ref8[0],\n          value = _ref8[1];\n\n      if (Array.isArray(value)) {\n        return value.map(function (item) {\n          return traverse(item, filter);\n        }).reduce(function (acc, val) {\n          return acc.concat(val);\n        }, []);\n      } else if ((typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) === 'object') {\n        return traverse(value, filter);\n      } else {\n        return null;\n      }\n    }).reduce(function (acc, val) {\n      return acc.concat(val);\n    }, []).filter(Boolean);\n  }\n}\n/*\n * Traverses the props tree and fetches data for all image objects\n * */\n\nfunction prefetchImageData(_x, _x2) {\n  return _prefetchImageData.apply(this, arguments);\n}\n\nfunction _prefetchImageData() {\n  _prefetchImageData = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(props, options) {\n    var imageObjects, query;\n    return regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            imageObjects = traverse(props, function (value) {\n              return value.type === 'image';\n            });\n\n            if (!(imageObjects.length > 0)) {\n              _context2.next = 6;\n              break;\n            }\n\n            if (options.gqlApiUrl) {\n              _context2.next = 4;\n              break;\n            }\n\n            throw new Error(\"Missing option 'gqlApiUrl'\");\n\n          case 4:\n            query = createQuery(imageObjects, options);\n            return _context2.abrupt(\"return\", gqlApi.get(query, options.gqlApiUrl));\n\n          case 6:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2, this);\n  }));\n  return _prefetchImageData.apply(this, arguments);\n}\n\nvar imageProps = ['vertical', 'horizontal'];\nfunction mergeImageProps(props, imageUrls) {\n  if ('id' in props) {\n    return _objectSpread2({}, props, {}, imageUrls[props.id]);\n  } else {\n    return fromEntries(Object.entries(props).map(function (_ref4) {\n      var _ref9 = _slicedToArray(_ref4, 2),\n          key = _ref9[0],\n          value = _ref9[1];\n\n      if (imageProps.indexOf(key) !== -1) {\n        return [key, mergeImageProps(value, imageUrls)];\n      } else {\n        return [key, value];\n      }\n    }));\n  }\n}\n\nfunction mergeVideoloopProps(_x) {\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction _mergeVideoloopProps() {\n  _mergeVideoloopProps = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(props) {\n    var objects;\n    return regeneratorRuntime.wrap(function _callee4$(_context4) {\n      while (1) {\n        switch (_context4.prev = _context4.next) {\n          case 0:\n            _context4.next = 2;\n            return Promise.all(Object.keys(props).map(\n            /*#__PURE__*/\n            function () {\n              var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(key) {\n                return regeneratorRuntime.wrap(function _callee3$(_context3) {\n                  while (1) {\n                    switch (_context3.prev = _context3.next) {\n                      case 0:\n                        if (!(key === 'horizontal' || key === 'vertical')) {\n                          _context3.next = 9;\n                          break;\n                        }\n\n                        _context3.t0 = _objectSpread2;\n                        _context3.t1 = {\n                          id: key\n                        };\n                        _context3.t2 = props[key];\n                        _context3.next = 6;\n                        return getVideoSrc(props[key]);\n\n                      case 6:\n                        _context3.t3 = _context3.sent;\n                        _context3.t4 = {\n                          videos: _context3.t3\n                        };\n                        return _context3.abrupt(\"return\", (0, _context3.t0)(_context3.t1, _context3.t2, _context3.t4));\n\n                      case 9:\n                      case \"end\":\n                        return _context3.stop();\n                    }\n                  }\n                }, _callee3, this);\n              }));\n\n              return function (_x4) {\n                return _ref2.apply(this, arguments);\n              };\n            }()));\n\n          case 2:\n            objects = _context4.sent;\n            return _context4.abrupt(\"return\", _objectSpread2({}, props, {}, objects.filter(Boolean).reduce(function (accumulator, current) {\n              accumulator[current.id] = current;\n              delete accumulator[current.id].id;\n              return accumulator;\n            }, {})));\n\n          case 4:\n          case \"end\":\n            return _context4.stop();\n        }\n      }\n    }, _callee4, this);\n  }));\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction getVideoSrc(_x2) {\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction _getVideoSrc() {\n  _getVideoSrc = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(videoObj) {\n    var hasVideoUrl, videos, basePath;\n    return regeneratorRuntime.wrap(function _callee5$(_context5) {\n      while (1) {\n        switch (_context5.prev = _context5.next) {\n          case 0:\n            hasVideoUrl = videoObj && videoObj !== 'null';\n\n            if (!hasVideoUrl) {\n              _context5.next = 9;\n              break;\n            }\n\n            _context5.next = 4;\n            return getVideos(videoObj.url);\n\n          case 4:\n            videos = _context5.sent;\n            basePath = extractBasePathFromUrl(videoObj.url);\n            return _context5.abrupt(\"return\", videos.map(function (video) {\n              return {\n                type: getTypeFromHeight(video.height),\n                poster: \"\".concat(basePath, \"/\").concat(video.stillFileName),\n                aspectRatio: video.displayAspectRatio,\n                height: video.height,\n                sources: {\n                  mp4: \"\".concat(basePath, \"/\").concat(video.videoFileName)\n                }\n              };\n            }));\n\n          case 9:\n            return _context5.abrupt(\"return\", null);\n\n          case 10:\n          case \"end\":\n            return _context5.stop();\n        }\n      }\n    }, _callee5, this);\n  }));\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction extractBasePathFromUrl(url) {\n  var decodedUrl = url.replace(/%2F/g, '/');\n  return decodedUrl.substr(0, decodedUrl.lastIndexOf('/'));\n}\n\nfunction getVideos(_x3) {\n  return _getVideos.apply(this, arguments);\n}\n\nfunction _getVideos() {\n  _getVideos = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6(url) {\n    var videoPayload;\n    return regeneratorRuntime.wrap(function _callee6$(_context6) {\n      while (1) {\n        switch (_context6.prev = _context6.next) {\n          case 0:\n            _context6.next = 2;\n            return getVideoPayload(url);\n\n          case 2:\n            videoPayload = _context6.sent;\n            return _context6.abrupt(\"return\", videoPayload.movingStills);\n\n          case 4:\n          case \"end\":\n            return _context6.stop();\n        }\n      }\n    }, _callee6, this);\n  }));\n  return _getVideos.apply(this, arguments);\n}\n\nfunction getVideoPayload(url) {\n  return _axios2.default.get(url, {\n    timeout: 2000\n  }).then(function (_ref) {\n    var data = _ref.data;\n\n    return data;\n  });\n}\n\nfunction getTypeFromHeight(height) {\n  switch (height) {\n    case 360:\n      return 'small';\n\n    case 720:\n      return 'medium';\n\n    case 1080:\n      return 'large';\n\n    default:\n      return 'large';\n  }\n}\n\nfunction mergeMapProps(_x) {\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction _mergeMapProps() {\n  _mergeMapProps = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(props) {\n    var id, rest;\n    return regeneratorRuntime.wrap(function _callee7$(_context7) {\n      while (1) {\n        switch (_context7.prev = _context7.next) {\n          case 0:\n            id = props.id, rest = _objectWithoutProperties(props, [\"id\"]);\n            _context7.t0 = _objectSpread2;\n            _context7.t1 = {\n              id: id\n            };\n            _context7.t2 = rest;\n            _context7.next = 6;\n            return getMapDefinition(id);\n\n          case 6:\n            _context7.t3 = _context7.sent;\n            _context7.t4 = {\n              definition: _context7.t3\n            };\n            return _context7.abrupt(\"return\", (0, _context7.t0)(_context7.t1, _context7.t2, _context7.t4));\n\n          case 9:\n          case \"end\":\n            return _context7.stop();\n        }\n      }\n    }, _callee7, this);\n  }));\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction getMapDefinition(_x2) {\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction _getMapDefinition() {\n  _getMapDefinition = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee8(id) {\n    return regeneratorRuntime.wrap(function _callee8$(_context8) {\n      while (1) {\n        switch (_context8.prev = _context8.next) {\n          case 0:\n            if (id) {\n              _context8.next = 2;\n              break;\n            }\n\n            return _context8.abrupt(\"return\");\n\n          case 2:\n            return _context8.abrupt(\"return\", _axios2.default.get(\"https://dh.nrk.no/atlas/v1/definition?id=\".concat(id), {\n              timeout: 2000\n            }).then(function (_ref) {\n              var data = _ref.data;\n\n              return data;\n            }));\n\n          case 3:\n          case \"end\":\n            return _context8.stop();\n        }\n      }\n    }, _callee8, this);\n  }));\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction fromEntries$1(items) {\n  return [].concat(_toConsumableArray(items)).reduce(function (obj, _ref) {\n    var _ref10 = _slicedToArray(_ref, 2),\n        key = _ref10[0],\n        val = _ref10[1];\n\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nvar defaultOptions = {\n  image: {\n    gqlApiUrl: 'https://www.nrk.no/api/graphql',\n    aspectRatios: [{\n      id: 'F11',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F34',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F169',\n      sizes: ['900', '1280', '2400']\n    }, {\n      id: 'original',\n      sizes: ['450', '768', '1280', '2400']\n    }]\n  }\n};\nfunction mergeMediaProps(_x, _x2, _x3) {\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nfunction _mergeMediaProps() {\n  _mergeMediaProps = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee10(props, options, imageData) {\n    var mergedOptions, imageDataStored, mappedEntries;\n    return regeneratorRuntime.wrap(function _callee10$(_context10) {\n      while (1) {\n        switch (_context10.prev = _context10.next) {\n          case 0:\n            mergedOptions = {\n              image: _objectSpread2({}, defaultOptions.image, {}, options === null || options === void 0 ? void 0 : options.image)\n            };\n            _context10.t0 = imageData;\n\n            if (_context10.t0) {\n              _context10.next = 6;\n              break;\n            }\n\n            _context10.next = 5;\n            return prefetchImageData(props, mergedOptions.image);\n\n          case 5:\n            _context10.t0 = _context10.sent;\n\n          case 6:\n            imageDataStored = _context10.t0;\n\n            if (!(props.type === 'videoloop')) {\n              _context10.next = 11;\n              break;\n            }\n\n            return _context10.abrupt(\"return\", mergeVideoloopProps(props));\n\n          case 11:\n            if (!(props.type === 'image')) {\n              _context10.next = 15;\n              break;\n            }\n\n            return _context10.abrupt(\"return\", mergeImageProps(props, imageDataStored));\n\n          case 15:\n            if (!(props.type === 'map')) {\n              _context10.next = 19;\n              break;\n            }\n\n            return _context10.abrupt(\"return\", mergeMapProps(props, imageDataStored));\n\n          case 19:\n            _context10.next = 21;\n            return Promise.all(Object.entries(props).map(\n            /*#__PURE__*/\n            function () {\n              var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee9(_ref2) {\n                var _ref11, key, value, mergedArray;\n\n                return regeneratorRuntime.wrap(function _callee9$(_context9) {\n                  while (1) {\n                    switch (_context9.prev = _context9.next) {\n                      case 0:\n                        _ref11 = _slicedToArray(_ref2, 2), key = _ref11[0], value = _ref11[1];\n\n                        if (!Array.isArray(value)) {\n                          _context9.next = 8;\n                          break;\n                        }\n\n                        _context9.next = 4;\n                        return Promise.all(value.map(function (item) {\n                          return mergeMediaProps(item, options, imageDataStored);\n                        }));\n\n                      case 4:\n                        mergedArray = _context9.sent;\n                        return _context9.abrupt(\"return\", [key, mergedArray]);\n\n                      case 8:\n                        if (!((typeof value === \"undefined\" ? \"undefined\" : _typeof(value)) === 'object' && value !== null)) {\n                          _context9.next = 16;\n                          break;\n                        }\n\n                        _context9.t0 = key;\n                        _context9.next = 12;\n                        return mergeMediaProps(value, options, imageDataStored);\n\n                      case 12:\n                        _context9.t1 = _context9.sent;\n                        return _context9.abrupt(\"return\", [_context9.t0, _context9.t1]);\n\n                      case 16:\n                        return _context9.abrupt(\"return\", [key, value]);\n\n                      case 17:\n                      case \"end\":\n                        return _context9.stop();\n                    }\n                  }\n                }, _callee9, this);\n              }));\n\n              return function (_x4) {\n                return _ref3.apply(this, arguments);\n              };\n            }()));\n\n          case 21:\n            mappedEntries = _context10.sent;\n            return _context10.abrupt(\"return\", fromEntries$1(mappedEntries));\n\n          case 23:\n          case \"end\":\n            return _context10.stop();\n        }\n      }\n    }, _callee10, this);\n  }));\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nvar MAX_SAFE_INTEGER = 9007199254740991;\nfunction withinRange(current) {\n  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MAX_SAFE_INTEGER;\n  return current >= start && current <= stop;\n}\n\nexports.ElementIntersectionObserver = ElementIntersectionObserver;\nexports.HorizontalScroll = HorizontalScroll;\nexports.VerticalScroll = VerticalScroll;\nexports.addStyle = addStyle;\nexports.closest = closest;\nexports.dispatchEvent = dispatchEvent;\nexports.mergeImageProps = mergeImageProps;\nexports.mergeMapProps = mergeMapProps;\nexports.mergeMediaProps = mergeMediaProps;\nexports.mergeVideoloopProps = mergeVideoloopProps;\nexports.setAttribute = setAttribute;\nexports.testReducedMotion = testReducedMotion;\nexports.toArray = toArray;\nexports.toggleAttribute = toggleAttribute;\nexports.withinRange = withinRange;\n//# sourceMappingURL=dh-basis-common.esm.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8)))\n\n/***/ }),\n/* 62 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"standaloneVideo\":\"dh-video-standaloneVideo\",\"small\":\"dh-video-small\",\"medium\":\"dh-video-medium\",\"large\":\"dh-video-large\",\"horizontalVideo\":\"dh-video-horizontalVideo\",\"verticalVideo\":\"dh-video-verticalVideo\",\"videoLoop\":\"dh-video-videoLoop\",\"videoLoop__fallbackImage\":\"dh-video-videoLoop__fallbackImage\",\"wrapper\":\"dh-video-wrapper\",\"byline\":\"dh-video-byline\",\"videoLoop--played\":\"dh-video-videoLoop--played\"};\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Transports = exports.Integrations = undefined;\n\nvar _exports = __webpack_require__(64);\n\nObject.keys(_exports).forEach(function (key) {\n    if (key === \"default\" || key === \"__esModule\") return;\n    Object.defineProperty(exports, key, {\n        enumerable: true,\n        get: function get() {\n            return _exports[key];\n        }\n    });\n});\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\n\nvar _integrations = __webpack_require__(40);\n\nvar BrowserIntegrations = _interopRequireWildcard(_integrations);\n\nvar _transports = __webpack_require__(38);\n\nvar Transports = _interopRequireWildcard(_transports);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nvar windowIntegrations = {};\n// This block is needed to add compatibility with the integrations packages when used with a CDN\n// tslint:disable: no-unsafe-any\nvar _window = (0, _utils.getGlobalObject)();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\n// tslint:enable: no-unsafe-any\nvar INTEGRATIONS = tslib_1.__assign({}, windowIntegrations, _core.Integrations, BrowserIntegrations);\nexports.Integrations = INTEGRATIONS;\nexports.Transports = Transports;\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _types = __webpack_require__(4);\n\nObject.defineProperty(exports, 'Severity', {\n  enumerable: true,\n  get: function get() {\n    return _types.Severity;\n  }\n});\nObject.defineProperty(exports, 'Status', {\n  enumerable: true,\n  get: function get() {\n    return _types.Status;\n  }\n});\n\nvar _core = __webpack_require__(3);\n\nObject.defineProperty(exports, 'addGlobalEventProcessor', {\n  enumerable: true,\n  get: function get() {\n    return _core.addGlobalEventProcessor;\n  }\n});\nObject.defineProperty(exports, 'addBreadcrumb', {\n  enumerable: true,\n  get: function get() {\n    return _core.addBreadcrumb;\n  }\n});\nObject.defineProperty(exports, 'captureException', {\n  enumerable: true,\n  get: function get() {\n    return _core.captureException;\n  }\n});\nObject.defineProperty(exports, 'captureEvent', {\n  enumerable: true,\n  get: function get() {\n    return _core.captureEvent;\n  }\n});\nObject.defineProperty(exports, 'captureMessage', {\n  enumerable: true,\n  get: function get() {\n    return _core.captureMessage;\n  }\n});\nObject.defineProperty(exports, 'configureScope', {\n  enumerable: true,\n  get: function get() {\n    return _core.configureScope;\n  }\n});\nObject.defineProperty(exports, 'getHubFromCarrier', {\n  enumerable: true,\n  get: function get() {\n    return _core.getHubFromCarrier;\n  }\n});\nObject.defineProperty(exports, 'getCurrentHub', {\n  enumerable: true,\n  get: function get() {\n    return _core.getCurrentHub;\n  }\n});\nObject.defineProperty(exports, 'Hub', {\n  enumerable: true,\n  get: function get() {\n    return _core.Hub;\n  }\n});\nObject.defineProperty(exports, 'Scope', {\n  enumerable: true,\n  get: function get() {\n    return _core.Scope;\n  }\n});\nObject.defineProperty(exports, 'setContext', {\n  enumerable: true,\n  get: function get() {\n    return _core.setContext;\n  }\n});\nObject.defineProperty(exports, 'setExtra', {\n  enumerable: true,\n  get: function get() {\n    return _core.setExtra;\n  }\n});\nObject.defineProperty(exports, 'setExtras', {\n  enumerable: true,\n  get: function get() {\n    return _core.setExtras;\n  }\n});\nObject.defineProperty(exports, 'setTag', {\n  enumerable: true,\n  get: function get() {\n    return _core.setTag;\n  }\n});\nObject.defineProperty(exports, 'setTags', {\n  enumerable: true,\n  get: function get() {\n    return _core.setTags;\n  }\n});\nObject.defineProperty(exports, 'setUser', {\n  enumerable: true,\n  get: function get() {\n    return _core.setUser;\n  }\n});\nObject.defineProperty(exports, 'withScope', {\n  enumerable: true,\n  get: function get() {\n    return _core.withScope;\n  }\n});\n\nvar _client = __webpack_require__(35);\n\nObject.defineProperty(exports, 'BrowserClient', {\n  enumerable: true,\n  get: function get() {\n    return _client.BrowserClient;\n  }\n});\n\nvar _sdk = __webpack_require__(89);\n\nObject.defineProperty(exports, 'defaultIntegrations', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.defaultIntegrations;\n  }\n});\nObject.defineProperty(exports, 'forceLoad', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.forceLoad;\n  }\n});\nObject.defineProperty(exports, 'init', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.init;\n  }\n});\nObject.defineProperty(exports, 'lastEventId', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.lastEventId;\n  }\n});\nObject.defineProperty(exports, 'onLoad', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.onLoad;\n  }\n});\nObject.defineProperty(exports, 'showReportDialog', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.showReportDialog;\n  }\n});\nObject.defineProperty(exports, 'flush', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.flush;\n  }\n});\nObject.defineProperty(exports, 'close', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.close;\n  }\n});\nObject.defineProperty(exports, 'wrap', {\n  enumerable: true,\n  get: function get() {\n    return _sdk.wrap;\n  }\n});\n\nvar _version = __webpack_require__(39);\n\nObject.defineProperty(exports, 'SDK_NAME', {\n  enumerable: true,\n  get: function get() {\n    return _version.SDK_NAME;\n  }\n});\nObject.defineProperty(exports, 'SDK_VERSION', {\n  enumerable: true,\n  get: function get() {\n    return _version.SDK_VERSION;\n  }\n});\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/** Console logging verbosity for the SDK. */\nvar LogLevel = exports.LogLevel = undefined;\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 || (exports.LogLevel = LogLevel = {}));\n//# sourceMappingURL=loglevel.js.map\n\n/***/ }),\n/* 66 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/** JSDoc */\nvar Severity = exports.Severity = undefined;\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 || (exports.Severity = Severity = {}));\n// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\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 || (exports.Severity = Severity = {}));\n//# sourceMappingURL=severity.js.map\n\n/***/ }),\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/** The status of an Span. */\nvar SpanStatus = exports.SpanStatus = undefined;\n(function (SpanStatus) {\n    /** The operation completed successfully. */\n    SpanStatus[\"Ok\"] = \"ok\";\n    /** Deadline expired before operation could complete. */\n    SpanStatus[\"DealineExceeded\"] = \"deadline_exceeded\";\n    /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n    SpanStatus[\"Unauthenticated\"] = \"unauthenticated\";\n    /** 403 Forbidden */\n    SpanStatus[\"PermissionDenied\"] = \"permission_denied\";\n    /** 404 Not Found. Some requested entity (file or directory) was not found. */\n    SpanStatus[\"NotFound\"] = \"not_found\";\n    /** 429 Too Many Requests */\n    SpanStatus[\"ResourceExhausted\"] = \"resource_exhausted\";\n    /** Client specified an invalid argument. 4xx. */\n    SpanStatus[\"InvalidArgument\"] = \"invalid_argument\";\n    /** 501 Not Implemented */\n    SpanStatus[\"Unimplemented\"] = \"unimplemented\";\n    /** 503 Service Unavailable */\n    SpanStatus[\"Unavailable\"] = \"unavailable\";\n    /** Other/generic 5xx. */\n    SpanStatus[\"InternalError\"] = \"internal_error\";\n    /** Unknown. Any non-standard HTTP status code. */\n    SpanStatus[\"UnknownError\"] = \"unknown_error\";\n    /** The operation was cancelled (typically by the user). */\n    SpanStatus[\"Cancelled\"] = \"cancelled\";\n    /** Already exists (409) */\n    SpanStatus[\"AlreadyExists\"] = \"already_exists\";\n    /** Operation was rejected because the system is not in a state required for the operation's */\n    SpanStatus[\"FailedPrecondition\"] = \"failed_precondition\";\n    /** The operation was aborted, typically due to a concurrency issue. */\n    SpanStatus[\"Aborted\"] = \"aborted\";\n    /** Operation was attempted past the valid range. */\n    SpanStatus[\"OutOfRange\"] = \"out_of_range\";\n    /** Unrecoverable data loss or corruption */\n    SpanStatus[\"DataLoss\"] = \"data_loss\";\n})(SpanStatus || (exports.SpanStatus = SpanStatus = {}));\n// tslint:disable:no-unnecessary-qualifier no-namespace\n(function (SpanStatus) {\n    /**\n     * Converts a HTTP status code into a {@link SpanStatus}.\n     *\n     * @param httpStatus The HTTP response status code.\n     * @returns The span status or {@link SpanStatus.UnknownError}.\n     */\n    // tslint:disable-next-line:completed-docs\n    function fromHttpCode(httpStatus) {\n        if (httpStatus < 400) {\n            return SpanStatus.Ok;\n        }\n        if (httpStatus >= 400 && httpStatus < 500) {\n            switch (httpStatus) {\n                case 401:\n                    return SpanStatus.Unauthenticated;\n                case 403:\n                    return SpanStatus.PermissionDenied;\n                case 404:\n                    return SpanStatus.NotFound;\n                case 409:\n                    return SpanStatus.AlreadyExists;\n                case 413:\n                    return SpanStatus.FailedPrecondition;\n                case 429:\n                    return SpanStatus.ResourceExhausted;\n                default:\n                    return SpanStatus.InvalidArgument;\n            }\n        }\n        if (httpStatus >= 500 && httpStatus < 600) {\n            switch (httpStatus) {\n                case 501:\n                    return SpanStatus.Unimplemented;\n                case 503:\n                    return SpanStatus.Unavailable;\n                case 504:\n                    return SpanStatus.DealineExceeded;\n                default:\n                    return SpanStatus.InternalError;\n            }\n        }\n        return SpanStatus.UnknownError;\n    }\n    SpanStatus.fromHttpCode = fromHttpCode;\n})(SpanStatus || (exports.SpanStatus = SpanStatus = {}));\n//# sourceMappingURL=span.js.map\n\n/***/ }),\n/* 68 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/** The status of an event. */\nvar Status = exports.Status = undefined;\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 || (exports.Status = Status = {}));\n// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\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 || (exports.Status = Status = {}));\n//# sourceMappingURL=status.js.map\n\n/***/ }),\n/* 69 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.captureException = captureException;\nexports.captureMessage = captureMessage;\nexports.captureEvent = captureEvent;\nexports.configureScope = configureScope;\nexports.addBreadcrumb = addBreadcrumb;\nexports.setContext = setContext;\nexports.setExtras = setExtras;\nexports.setTags = setTags;\nexports.setExtra = setExtra;\nexports.setTag = setTag;\nexports.setUser = setUser;\nexports.withScope = withScope;\nexports._callOnClient = _callOnClient;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _hub = __webpack_require__(6);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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 */\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 = (0, _hub.getCurrentHub)();\n    if (hub && hub[method]) {\n        // tslint:disable-next-line:no-unsafe-any\n        return hub[method].apply(hub, tslib_1.__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 */\nfunction captureException(exception) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    } catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\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, level) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    } catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureMessage', message, level, {\n        originalException: message,\n        syntheticException: syntheticException\n    });\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event) {\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 normailzed.\n */\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 normailzed.\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 * @param key String key of tag\n * @param value String 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 */\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, tslib_1.__spread(['_invokeClient', method], args));\n}\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.forget = forget;\n/**\n * Consumes the promise and logs the error when it rejects.\n * @param promise A promise to forget.\n */\nfunction forget(promise) {\n    promise.then(null, function (e) {\n        // TODO: Use a better logging mechanism\n        console.error(e);\n    });\n}\n//# sourceMappingURL=async.js.map\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nvar setPrototypeOf = exports.setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties); // tslint:disable-line:no-unbound-method\n/**\n * setPrototypeOf polyfill using __proto__\n */\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map\n\n/***/ }),\n/* 72 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.resolve = resolve;\nexports.relative = relative;\nexports.normalizePath = normalizePath;\nexports.isAbsolute = isAbsolute;\nexports.join = join;\nexports.dirname = dirname;\nexports.basename = 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        } else if (last === '..') {\n            parts.splice(i, 1);\n            up++;\n        } else if (up) {\n            parts.splice(i, 1);\n            up--;\n        }\n    }\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\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) {\n        return !!p;\n    }), !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    // tslint:disable:no-parameter-reassignment\n    from = resolve(from).substr(1);\n    to = resolve(to).substr(1);\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) {\n        return !!p;\n    }), !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/* 73 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.PromiseBuffer = undefined;\n\nvar _error = __webpack_require__(12);\n\nvar _syncpromise = __webpack_require__(32);\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 _syncpromise.SyncPromise.reject(new _error.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.then(function () {\n            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.SyncPromise(function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            _syncpromise.SyncPromise.all(_this._buffer).then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            }).then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}();\nexports.PromiseBuffer = PromiseBuffer;\n//# sourceMappingURL=promisebuffer.js.map\n\n/***/ }),\n/* 74 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.addInstrumentationHandler = addInstrumentationHandler;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _is = __webpack_require__(5);\n\nvar _logger = __webpack_require__(13);\n\nvar _misc = __webpack_require__(7);\n\nvar _object = __webpack_require__(31);\n\nvar _supports = __webpack_require__(33);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/* tslint:disable:only-arrow-functions no-unsafe-any */\nvar global = (0, _misc.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 */\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        default:\n            _logger.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    // tslint:disable-next-line:strict-type-predicates\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 = tslib_1.__values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            } catch (e) {\n                _logger.logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + (0, _misc.getFunctionName)(handler) + \"\\nError: \" + e);\n            }\n        }\n    } catch (e_1_1) {\n        e_1 = { error: e_1_1 };\n    } finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        } finally {\n            if (e_1) throw e_1.error;\n        }\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        (0, _object.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 (!(0, _supports.supportsNativeFetch)()) {\n        return;\n    }\n    (0, _object.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 commonHandlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args)\n                },\n                startTimestamp: Date.now()\n            };\n            triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData));\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), error: error }));\n                throw error;\n            });\n        };\n    });\n}\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) {\n        fetchArgs = [];\n    }\n    if ('Request' in global && (0, _is.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) {\n        fetchArgs = [];\n    }\n    if (typeof fetchArgs[0] === 'string') {\n        return fetchArgs[0];\n    }\n    if ('Request' in global && (0, _is.isInstanceOf)(fetchArgs[0], Request)) {\n        return fetchArgs[0].url;\n    }\n    return String(fetchArgs[0]);\n}\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    var xhrproto = XMLHttpRequest.prototype;\n    (0, _object.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            var url = args[1];\n            this.__sentry_xhr__ = {\n                method: (0, _is.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            if ((0, _is.isString)(url) && this.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                this.__sentry_own_request__ = true;\n            }\n            return originalOpen.apply(this, args);\n        };\n    });\n    (0, _object.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            var xhr = this; // tslint:disable-line:no-this-assignment\n            var commonHandlerData = {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: xhr\n            };\n            triggerHandlers('xhr', tslib_1.__assign({}, commonHandlerData));\n            /**\n             * @hidden\n             */\n            function onreadystatechangeHandler() {\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                    } catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now() }));\n                }\n            }\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                (0, _object.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            } else {\n                // if onreadystatechange wasn't actually set by the page on this xhr, we\n                // are free to set our own and capture the breadcrumb\n                xhr.onreadystatechange = onreadystatechangeHandler;\n            }\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!(0, _supports.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    (0, _object.fill)(global.history, 'pushState', historyReplacementFunction);\n    (0, _object.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        var proto = global[target] && global[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        (0, _object.fill)(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                if (fn && fn.handleEvent) {\n                    if (eventName === 'click') {\n                        (0, _object.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                        (0, _object.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                } 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        (0, _object.fill)(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                } catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, 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) {\n        debounce = false;\n    }\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        } 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        } 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}\n//# sourceMappingURL=instrument.js.map\n\n/***/ }),\n/* 75 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Dsn = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _error = __webpack_require__(12);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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        } 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) {\n            withPassword = false;\n        }\n        // tslint:disable-next-line:no-this-assignment\n        var _a = this,\n            host = _a.host,\n            path = _a.path,\n            pass = _a.pass,\n            port = _a.port,\n            projectId = _a.projectId,\n            protocol = _a.protocol,\n            user = _a.user;\n        return protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') + (\"@\" + 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 _error.SentryError(ERROR_MESSAGE);\n        }\n        var _a = tslib_1.__read(match.slice(1), 6),\n            protocol = _a[0],\n            user = _a[1],\n            _b = _a[2],\n            pass = _b === void 0 ? '' : _b,\n            host = _a[3],\n            _c = _a[4],\n            port = _c === void 0 ? '' : _c,\n            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        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 _error.SentryError(ERROR_MESSAGE);\n            }\n        });\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new _error.SentryError(ERROR_MESSAGE);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new _error.SentryError(ERROR_MESSAGE);\n        }\n    };\n    return Dsn;\n}();\nexports.Dsn = Dsn;\n//# sourceMappingURL=dsn.js.map\n\n/***/ }),\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(module) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Hub = exports.API_VERSION = undefined;\nexports.getMainCarrier = getMainCarrier;\nexports.makeMain = makeMain;\nexports.getCurrentHub = getCurrentHub;\nexports.getHubFromCarrier = getHubFromCarrier;\nexports.setHubOnCarrier = setHubOnCarrier;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _utils = __webpack_require__(0);\n\nvar _scope = __webpack_require__(28);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be incresed when the global interface\n * changes a and new methods are introduced.\n *\n * @hidden\n */\nvar API_VERSION = exports.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) {\n            scope = new _scope.Scope();\n        }\n        if (_version === void 0) {\n            _version = API_VERSION;\n        }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [];\n        this._stack.push({ client: client, scope: scope });\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    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 top = this.getStackTop();\n        if (top && top.client && top.client[method]) {\n            (_a = top.client)[method].apply(_a, tslib_1.__spread(args, [top.scope]));\n        }\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    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var stack = this.getStack();\n        var parentScope = stack.length > 0 ? stack[stack.length - 1].scope : undefined;\n        var scope = _scope.Scope.clone(parentScope);\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        return this.getStack().pop() !== undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\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    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = this._lastEventId = (0, _utils.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            } catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException\n            };\n        }\n        this._invokeClient('captureException', exception, tslib_1.__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 = (0, _utils.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            } catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException\n            };\n        }\n        this._invokeClient('captureMessage', message, level, tslib_1.__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 = (0, _utils.uuid4)();\n        this._invokeClient('captureEvent', event, tslib_1.__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 top = this.getStackTop();\n        if (!top.scope || !top.client) {\n            return;\n        }\n        var _a = top.client.getOptions && top.client.getOptions() || {},\n            _b = _a.beforeBreadcrumb,\n            beforeBreadcrumb = _b === void 0 ? null : _b,\n            _c = _a.maxBreadcrumbs,\n            maxBreadcrumbs = _c === void 0 ? DEFAULT_BREADCRUMBS : _c;\n        if (maxBreadcrumbs <= 0) {\n            return;\n        }\n        var timestamp = (0, _utils.timestampWithMs)();\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb ? (0, _utils.consoleSandbox)(function () {\n            return beforeBreadcrumb(mergedBreadcrumb, hint);\n        }) : mergedBreadcrumb;\n        if (finalBreadcrumb === null) {\n            return;\n        }\n        top.scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setContext = function (name, context) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var top = this.getStackTop();\n        if (top.scope && top.client) {\n            callback(top.scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\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        }\n        try {\n            return client.getIntegration(integration);\n        } catch (_oO) {\n            _utils.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 (spanOrSpanContext, forceNoChild) {\n        if (forceNoChild === void 0) {\n            forceNoChild = false;\n        }\n        return this._callExtensionMethod('startSpan', spanOrSpanContext, forceNoChild);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore\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        // tslint:disable-next-line: strict-type-predicates\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        _utils.logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}();\nexports.Hub = Hub;\n/** Returns the global shim registry. */\n\nfunction getMainCarrier() {\n    var carrier = (0, _utils.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 ((0, _utils.isNodeEnv)()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Try to read the hub from an active domain, fallback to the registry if one doesnt exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        // We need to use `dynamicRequire` because `require` on it's own will be optimized by webpack.\n        // We do not want this to happen, we need to try to `require` the domain node module and fail if we are in browser\n        // for example so we do not have to shim it and use `getCurrentHub` universally.\n        var domain = (0, _utils.dynamicRequire)(module, 'domain');\n        var activeDomain = domain.active;\n        // If there 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 its 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.Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    } catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n        return true;\n    }\n    return false;\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    }\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    }\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(77)(module)))\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function (module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function () {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n\n/***/ }),\n/* 78 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.API = undefined;\n\nvar _utils = __webpack_require__(0);\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 _utils.Dsn(dsn);\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns a string with auth headers in the url to the store endpoint. */\n    API.prototype.getStoreEndpoint = function () {\n        return \"\" + this._getBaseUrl() + this.getStoreEndpointPath();\n    };\n    /** Returns the store endpoint with auth added in url encoded. */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION\n        };\n        // Auth is intentionally sent as part of query string (NOT as custom HTTP header)\n        // to avoid preflight CORS requests\n        return this.getStoreEndpoint() + \"?\" + (0, _utils.urlEncode)(auth);\n    };\n    /** Returns the base path of the url including the port. */\n    API.prototype._getBaseUrl = 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;\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    /** Returns an object that can be used in request headers. */\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_timestamp=\" + (0, _utils.timestampWithMs)()); // TODO: This can be removed\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) {\n            dialogOptions = {};\n        }\n        var dsn = this._dsnObject;\n        var endpoint = \"\" + this._getBaseUrl() + (dsn.path ? \"/\" + dsn.path : '') + \"/api/embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\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            } 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    return API;\n}();\nexports.API = API;\n//# sourceMappingURL=api.js.map\n\n/***/ }),\n/* 79 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.BaseClient = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _utils = __webpack_require__(0);\n\nvar _integration = __webpack_require__(80);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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        /** Is the client still processing a call? */\n        this._processing = false;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new _utils.Dsn(options.dsn);\n        }\n        if (this._isEnabled()) {\n            this._integrations = (0, _integration.setupIntegrations)(this._options);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._getBackend().eventFromException(exception, hint).then(function (event) {\n            return _this._processEvent(event, hint, scope);\n        }).then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        }).then(null, function (reason) {\n            _utils.logger.error(reason);\n            _this._processing = false;\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        this._processing = true;\n        var promisedEvent = (0, _utils.isPrimitive)(message) ? this._getBackend().eventFromMessage(\"\" + message, level, hint) : this._getBackend().eventFromException(message, hint);\n        promisedEvent.then(function (event) {\n            return _this._processEvent(event, hint, scope);\n        }).then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        }).then(null, function (reason) {\n            _utils.logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._processEvent(event, hint, scope).then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        }).then(null, function (reason) {\n            _utils.logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\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 (status) {\n            clearInterval(status.interval);\n            return _this._getBackend().getTransport().close(timeout).then(function (transportFlushed) {\n                return status.ready && transportFlushed;\n            });\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     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegrations = function () {\n        return this._integrations || {};\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        } catch (_oO) {\n            _utils.logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new _utils.SyncPromise(function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = 0;\n            clearInterval(interval);\n            interval = setInterval(function () {\n                if (!_this._processing) {\n                    resolve({\n                        interval: interval,\n                        ready: true\n                    });\n                } else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        resolve({\n                            interval: interval,\n                            ready: false\n                        });\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 informartion 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(),\n            environment = _a.environment,\n            release = _a.release,\n            dist = _a.dist,\n            _b = _a.maxValueLength,\n            maxValueLength = _b === void 0 ? 250 : _b,\n            _c = _a.normalizeDepth,\n            normalizeDepth = _c === void 0 ? 3 : _c;\n        var prepared = tslib_1.__assign({}, event);\n        if (prepared.environment === undefined && environment !== undefined) {\n            prepared.environment = environment;\n        }\n        if (prepared.release === undefined && release !== undefined) {\n            prepared.release = release;\n        }\n        if (prepared.dist === undefined && dist !== undefined) {\n            prepared.dist = dist;\n        }\n        if (prepared.message) {\n            prepared.message = (0, _utils.truncate)(prepared.message, maxValueLength);\n        }\n        var exception = prepared.exception && prepared.exception.values && prepared.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = (0, _utils.truncate)(exception.value, maxValueLength);\n        }\n        var request = prepared.request;\n        if (request && request.url) {\n            request.url = (0, _utils.truncate)(request.url, maxValueLength);\n        }\n        if (prepared.event_id === undefined) {\n            prepared.event_id = hint && hint.event_id ? hint.event_id : (0, _utils.uuid4)();\n        }\n        this._addIntegrations(prepared.sdk);\n        // We prepare the result here with a resolved Event.\n        var result = _utils.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 (scope) {\n            // In case we have a hub we reassign it.\n            result = scope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            // tslint:disable-next-line:strict-type-predicates\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        // tslint:disable:no-unsafe-any\n        return tslib_1.__assign({}, event, event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) {\n                return tslib_1.__assign({}, b, b.data && {\n                    data: (0, _utils.normalize)(b.data, depth)\n                });\n            })\n        }, event.user && {\n            user: (0, _utils.normalize)(event.user, depth)\n        }, event.contexts && {\n            contexts: (0, _utils.normalize)(event.contexts, depth)\n        }, event.extra && {\n            extra: (0, _utils.normalize)(event.extra, depth)\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._addIntegrations = function (sdkInfo) {\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\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 informartion 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        var _a = this.getOptions(),\n            beforeSend = _a.beforeSend,\n            sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return _utils.SyncPromise.reject('SDK not enabled, will not send event.');\n        }\n        // 1.0 === 100% events are sent\n        // 0.0 === 0% events are sent\n        if (typeof sampleRate === 'number' && Math.random() > sampleRate) {\n            return _utils.SyncPromise.reject('This event has been sampled, will not send event.');\n        }\n        return new _utils.SyncPromise(function (resolve, reject) {\n            _this._prepareEvent(event, scope, hint).then(function (prepared) {\n                if (prepared === null) {\n                    reject('An event processor returned null, will not send event.');\n                    return;\n                }\n                var finalEvent = prepared;\n                try {\n                    var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n                    if (isInternalException || !beforeSend) {\n                        _this._getBackend().sendEvent(finalEvent);\n                        resolve(finalEvent);\n                        return;\n                    }\n                    var beforeSendResult = beforeSend(prepared, hint);\n                    // tslint:disable-next-line:strict-type-predicates\n                    if (typeof beforeSendResult === 'undefined') {\n                        _utils.logger.error('`beforeSend` method has to return `null` or a valid event.');\n                    } else if ((0, _utils.isThenable)(beforeSendResult)) {\n                        _this._handleAsyncBeforeSend(beforeSendResult, resolve, reject);\n                    } else {\n                        finalEvent = beforeSendResult;\n                        if (finalEvent === null) {\n                            _utils.logger.log('`beforeSend` returned `null`, will not send event.');\n                            resolve(null);\n                            return;\n                        }\n                        // From here on we are really async\n                        _this._getBackend().sendEvent(finalEvent);\n                        resolve(finalEvent);\n                    }\n                } catch (exception) {\n                    _this.captureException(exception, {\n                        data: {\n                            __sentry__: true\n                        },\n                        originalException: exception\n                    });\n                    reject('`beforeSend` threw an error, will not send event.');\n                }\n            }).then(null, function () {\n                reject('`beforeSend` threw an error, will not send event.');\n            });\n        });\n    };\n    /**\n     * Resolves before send Promise and calls resolve/reject on parent SyncPromise.\n     */\n    BaseClient.prototype._handleAsyncBeforeSend = function (beforeSend, resolve, reject) {\n        var _this = this;\n        beforeSend.then(function (processedEvent) {\n            if (processedEvent === null) {\n                reject('`beforeSend` returned `null`, will not send event.');\n                return;\n            }\n            // From here on we are really async\n            _this._getBackend().sendEvent(processedEvent);\n            resolve(processedEvent);\n        }).then(null, function (e) {\n            reject(\"beforeSend rejected with \" + e);\n        });\n    };\n    return BaseClient;\n}();\nexports.BaseClient = BaseClient;\n//# sourceMappingURL=baseclient.js.map\n\n/***/ }),\n/* 80 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.installedIntegrations = undefined;\nexports.getIntegrationsToSetup = getIntegrationsToSetup;\nexports.setupIntegration = setupIntegration;\nexports.setupIntegrations = setupIntegrations;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _hub = __webpack_require__(6);\n\nvar _utils = __webpack_require__(0);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nvar installedIntegrations = exports.installedIntegrations = [];\n/** Gets integration to install */\nfunction getIntegrationsToSetup(options) {\n    var defaultIntegrations = options.defaultIntegrations && tslib_1.__spread(options.defaultIntegrations) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) {\n            return i.name;\n        });\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 && 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    } else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    } else {\n        integrations = tslib_1.__spread(defaultIntegrations);\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) {\n        return i.name;\n    });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, tslib_1.__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(_hub.addGlobalEventProcessor, _hub.getCurrentHub);\n    installedIntegrations.push(integration.name);\n    _utils.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/* 81 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.BaseBackend = undefined;\n\nvar _utils = __webpack_require__(0);\n\nvar _noop = __webpack_require__(34);\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            _utils.logger.warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\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 _noop.NoopTransport();\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new _utils.SentryError('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new _utils.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            _utils.logger.error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    return BaseBackend;\n}();\nexports.BaseBackend = BaseBackend;\n//# sourceMappingURL=basebackend.js.map\n\n/***/ }),\n/* 82 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.initAndBind = initAndBind;\n\nvar _hub = __webpack_require__(6);\n\nvar _utils = __webpack_require__(0);\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 instanciate.\n * @param options Options to pass to the client.\n */\nfunction initAndBind(clientClass, options) {\n    if (options.debug === true) {\n        _utils.logger.enable();\n    }\n    (0, _hub.getCurrentHub)().bindClient(new clientClass(options));\n}\n//# sourceMappingURL=sdk.js.map\n\n/***/ }),\n/* 83 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _functiontostring = __webpack_require__(84);\n\nObject.defineProperty(exports, 'FunctionToString', {\n  enumerable: true,\n  get: function get() {\n    return _functiontostring.FunctionToString;\n  }\n});\n\nvar _inboundfilters = __webpack_require__(85);\n\nObject.defineProperty(exports, 'InboundFilters', {\n  enumerable: true,\n  get: function get() {\n    return _inboundfilters.InboundFilters;\n  }\n});\n\n/***/ }),\n/* 84 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\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        originalFunctionToString = Function.prototype.toString;\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            // tslint:disable-next-line:no-unsafe-any\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}();\nexports.FunctionToString = FunctionToString;\n//# sourceMappingURL=functiontostring.js.map\n\n/***/ }),\n/* 85 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.InboundFilters = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _hub = __webpack_require__(6);\n\nvar _utils = __webpack_require__(0);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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) {\n            _options = {};\n        }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        (0, _hub.addGlobalEventProcessor)(function (event) {\n            var hub = (0, _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            _utils.logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + (0, _utils.getEventDescription)(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            _utils.logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + (0, _utils.getEventDescription)(event));\n            return true;\n        }\n        if (this._isBlacklistedUrl(event, options)) {\n            _utils.logger.warn(\"Event dropped due to being matched by `blacklistUrls` option.\\nEvent: \" + (0, _utils.getEventDescription)(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isWhitelistedUrl(event, options)) {\n            _utils.logger.warn(\"Event dropped due to not being matched by `whitelistUrls` option.\\nEvent: \" + (0, _utils.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 === void 0) {\n            options = {};\n        }\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return event && event.exception && event.exception.values && event.exception.values[0] && event.exception.values[0].type === 'SentryError' || false;\n        } catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (options === void 0) {\n            options = {};\n        }\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) {\n                return (0, _utils.isMatchingPattern)(message, pattern);\n            });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isBlacklistedUrl = function (event, options) {\n        if (options === void 0) {\n            options = {};\n        }\n        // TODO: Use Glob instead?\n        if (!options.blacklistUrls || !options.blacklistUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.blacklistUrls.some(function (pattern) {\n            return (0, _utils.isMatchingPattern)(url, pattern);\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isWhitelistedUrl = function (event, options) {\n        if (options === void 0) {\n            options = {};\n        }\n        // TODO: Use Glob instead?\n        if (!options.whitelistUrls || !options.whitelistUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.whitelistUrls.some(function (pattern) {\n            return (0, _utils.isMatchingPattern)(url, pattern);\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) {\n            clientOptions = {};\n        }\n        return {\n            blacklistUrls: tslib_1.__spread(this._options.blacklistUrls || [], clientOptions.blacklistUrls || []),\n            ignoreErrors: tslib_1.__spread(this._options.ignoreErrors || [], clientOptions.ignoreErrors || [], DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n            whitelistUrls: tslib_1.__spread(this._options.whitelistUrls || [], clientOptions.whitelistUrls || [])\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] || {},\n                    _b = _a.type,\n                    type = _b === void 0 ? '' : _b,\n                    _c = _a.value,\n                    value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            } catch (oO) {\n                _utils.logger.error(\"Cannot extract message for event \" + (0, _utils.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        } catch (oO) {\n            _utils.logger.error(\"Cannot extract url for event \" + (0, _utils.getEventDescription)(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}();\nexports.InboundFilters = InboundFilters;\n//# sourceMappingURL=inboundfilters.js.map\n\n/***/ }),\n/* 86 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.BrowserBackend = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _types = __webpack_require__(4);\n\nvar _utils = __webpack_require__(0);\n\nvar _eventbuilder = __webpack_require__(36);\n\nvar _transports = __webpack_require__(38);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */function (_super) {\n    tslib_1.__extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\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 = tslib_1.__assign({}, this._options.transportOptions, { dsn: this._options.dsn });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if ((0, _utils.supportsFetch)()) {\n            return new _transports.FetchTransport(transportOptions);\n        }\n        return new _transports.XHRTransport(transportOptions);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        var syntheticException = hint && hint.syntheticException || undefined;\n        var event = (0, _eventbuilder.eventFromUnknownInput)(exception, syntheticException, {\n            attachStacktrace: this._options.attachStacktrace\n        });\n        (0, _utils.addExceptionMechanism)(event, {\n            handled: true,\n            type: 'generic'\n        });\n        event.level = _types.Severity.Error;\n        if (hint && hint.event_id) {\n            event.event_id = hint.event_id;\n        }\n        return _utils.SyncPromise.resolve(event);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) {\n            level = _types.Severity.Info;\n        }\n        var syntheticException = hint && hint.syntheticException || undefined;\n        var event = (0, _eventbuilder.eventFromString)(message, syntheticException, {\n            attachStacktrace: this._options.attachStacktrace\n        });\n        event.level = level;\n        if (hint && hint.event_id) {\n            event.event_id = hint.event_id;\n        }\n        return _utils.SyncPromise.resolve(event);\n    };\n    return BrowserBackend;\n}(_core.BaseBackend);\nexports.BrowserBackend = BrowserBackend;\n//# sourceMappingURL=backend.js.map\n\n/***/ }),\n/* 87 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.FetchTransport = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _types = __webpack_require__(4);\n\nvar _utils = __webpack_require__(0);\n\nvar _base = __webpack_require__(16);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nvar global = (0, _utils.getGlobalObject)();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */function (_super) {\n    tslib_1.__extends(FetchTransport, _super);\n    function FetchTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429\n            });\n        }\n        var defaultOptions = {\n            body: JSON.stringify(event),\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: (0, _utils.supportsReferrerPolicy)() ? 'origin' : ''\n        };\n        if (this.options.headers !== undefined) {\n            defaultOptions.headers = this.options.headers;\n        }\n        return this._buffer.add(new _utils.SyncPromise(function (resolve, reject) {\n            global.fetch(_this.url, defaultOptions).then(function (response) {\n                var status = _types.Status.fromHttpCode(response.status);\n                if (status === _types.Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === _types.Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + (0, _utils.parseRetryAfterHeader)(now, response.headers.get('Retry-After')));\n                    _utils.logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(response);\n            }).catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(_base.BaseTransport);\nexports.FetchTransport = FetchTransport;\n//# sourceMappingURL=fetch.js.map\n\n/***/ }),\n/* 88 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.XHRTransport = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _types = __webpack_require__(4);\n\nvar _utils = __webpack_require__(0);\n\nvar _base = __webpack_require__(16);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/** `XHR` based transport */\nvar XHRTransport = /** @class */function (_super) {\n    tslib_1.__extends(XHRTransport, _super);\n    function XHRTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429\n            });\n        }\n        return this._buffer.add(new _utils.SyncPromise(function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState !== 4) {\n                    return;\n                }\n                var status = _types.Status.fromHttpCode(request.status);\n                if (status === _types.Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === _types.Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + (0, _utils.parseRetryAfterHeader)(now, request.getResponseHeader('Retry-After')));\n                    _utils.logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(request);\n            };\n            request.open('POST', _this.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(JSON.stringify(event));\n        }));\n    };\n    return XHRTransport;\n}(_base.BaseTransport);\nexports.XHRTransport = XHRTransport;\n//# sourceMappingURL=xhr.js.map\n\n/***/ }),\n/* 89 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.defaultIntegrations = undefined;\nexports.init = init;\nexports.showReportDialog = showReportDialog;\nexports.lastEventId = lastEventId;\nexports.forceLoad = forceLoad;\nexports.onLoad = onLoad;\nexports.flush = flush;\nexports.close = close;\nexports.wrap = wrap;\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\n\nvar _client = __webpack_require__(35);\n\nvar _helpers = __webpack_require__(17);\n\nvar _integrations = __webpack_require__(40);\n\nvar defaultIntegrations = exports.defaultIntegrations = [new _core.Integrations.InboundFilters(), new _core.Integrations.FunctionToString(), new _integrations.TryCatch(), new _integrations.Breadcrumbs(), new _integrations.GlobalHandlers(), new _integrations.LinkedErrors(), new _integrations.UserAgent()];\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) {\n        options = {};\n    }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = (0, _utils.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    (0, _core.initAndBind)(_client.BrowserClient, options);\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) {\n        options = {};\n    }\n    if (!options.eventId) {\n        options.eventId = (0, _core.getCurrentHub)().lastEventId();\n    }\n    var client = (0, _core.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 (0, _core.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 = (0, _core.getCurrentHub)().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return _utils.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 = (0, _core.getCurrentHub)().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return _utils.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 */\nfunction wrap(fn) {\n    return (0, _helpers.wrap)(fn)(); // tslint:disable-line:no-unsafe-any\n}\n//# sourceMappingURL=sdk.js.map\n\n/***/ }),\n/* 90 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.GlobalHandlers = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _types = __webpack_require__(4);\n\nvar _utils = __webpack_require__(0);\n\nvar _eventbuilder = __webpack_require__(36);\n\nvar _helpers = __webpack_require__(17);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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._global = (0, _utils.getGlobalObject)();\n        /** JSDoc */\n        this._oldOnErrorHandler = null;\n        /** JSDoc */\n        this._oldOnUnhandledRejectionHandler = null;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = tslib_1.__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            _utils.logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            _utils.logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        var self = this; // tslint:disable-line:no-this-assignment\n        this._oldOnErrorHandler = this._global.onerror;\n        this._global.onerror = function (msg, url, line, column, error) {\n            var currentHub = (0, _core.getCurrentHub)();\n            var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n            var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n            if (!hasIntegration || (0, _helpers.shouldIgnoreOnError)() || isFailedOwnDelivery) {\n                if (self._oldOnErrorHandler) {\n                    return self._oldOnErrorHandler.apply(this, arguments);\n                }\n                return false;\n            }\n            var client = currentHub.getClient();\n            var event = (0, _utils.isPrimitive)(error) ? self._eventFromIncompleteOnError(msg, url, line, column) : self._enhanceEventWithInitialFrame((0, _eventbuilder.eventFromUnknownInput)(error, undefined, {\n                attachStacktrace: client && client.getOptions().attachStacktrace,\n                rejection: false\n            }), url, line, column);\n            (0, _utils.addExceptionMechanism)(event, {\n                handled: false,\n                type: 'onerror'\n            });\n            currentHub.captureEvent(event, {\n                originalException: error\n            });\n            if (self._oldOnErrorHandler) {\n                return self._oldOnErrorHandler.apply(this, arguments);\n            }\n            return false;\n        };\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        var self = this; // tslint:disable-line:no-this-assignment\n        this._oldOnUnhandledRejectionHandler = this._global.onunhandledrejection;\n        this._global.onunhandledrejection = function (e) {\n            var error = e;\n            try {\n                error = e && 'reason' in e ? e.reason : e;\n            } catch (_oO) {\n                // no-empty\n            }\n            var currentHub = (0, _core.getCurrentHub)();\n            var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n            var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n            if (!hasIntegration || (0, _helpers.shouldIgnoreOnError)() || isFailedOwnDelivery) {\n                if (self._oldOnUnhandledRejectionHandler) {\n                    return self._oldOnUnhandledRejectionHandler.apply(this, arguments);\n                }\n                return true;\n            }\n            var client = currentHub.getClient();\n            var event = (0, _utils.isPrimitive)(error) ? self._eventFromIncompleteRejection(error) : (0, _eventbuilder.eventFromUnknownInput)(error, undefined, {\n                attachStacktrace: client && client.getOptions().attachStacktrace,\n                rejection: true\n            });\n            event.level = _types.Severity.Error;\n            (0, _utils.addExceptionMechanism)(event, {\n                handled: false,\n                type: 'onunhandledrejection'\n            });\n            currentHub.captureEvent(event, {\n                originalException: error\n            });\n            if (self._oldOnUnhandledRejectionHandler) {\n                return self._oldOnUnhandledRejectionHandler.apply(this, arguments);\n            }\n            return true;\n        };\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\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 = (0, _utils.isErrorEvent)(msg) ? msg.message : msg;\n        var name;\n        if ((0, _utils.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                    type: name || 'Error',\n                    value: message\n                }]\n            }\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\n    };\n    /**\n     * This function creates an Event from an TraceKitStackTrace that has part of it missing.\n     */\n    GlobalHandlers.prototype._eventFromIncompleteRejection = function (error) {\n        return {\n            exception: {\n                values: [{\n                    type: 'UnhandledRejection',\n                    value: \"Non-Error promise rejection captured with value: \" + error\n                }]\n            }\n        };\n    };\n    /** JSDoc */\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 = (0, _utils.isString)(url) && url.length > 0 ? url : (0, _utils.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}();\nexports.GlobalHandlers = GlobalHandlers;\n//# sourceMappingURL=globalhandlers.js.map\n\n/***/ }),\n/* 91 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.TryCatch = undefined;\n\nvar _utils = __webpack_require__(0);\n\nvar _helpers = __webpack_require__(17);\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */function () {\n    function TryCatch() {\n        /** JSDoc */\n        this._ignoreOnError = 0;\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n    }\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\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] = (0, _helpers.wrap)(originalCallback, {\n                mechanism: {\n                    data: { function: (0, _utils.getFunctionName)(original) },\n                    handled: true,\n                    type: 'instrument'\n                }\n            });\n            return original.apply(this, args);\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapRAF = function (original) {\n        return function (callback) {\n            return original((0, _helpers.wrap)(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: (0, _utils.getFunctionName)(original)\n                    },\n                    handled: true,\n                    type: 'instrument'\n                }\n            }));\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        var global = (0, _utils.getGlobalObject)();\n        var proto = global[target] && global[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        (0, _utils.fill)(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    // tslint:disable-next-line:no-unbound-method strict-type-predicates\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = (0, _helpers.wrap)(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: (0, _utils.getFunctionName)(fn),\n                                    target: target\n                                },\n                                handled: true,\n                                type: 'instrument'\n                            }\n                        });\n                    }\n                } catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, (0, _helpers.wrap)(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: (0, _utils.getFunctionName)(fn),\n                            target: target\n                        },\n                        handled: true,\n                        type: 'instrument'\n                    }\n                }), options);\n            };\n        });\n        (0, _utils.fill)(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                } catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        return function () {\n            var _this = this;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var xhr = this; // tslint:disable-line:no-this-assignment\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in _this && typeof _this[prop] === 'function') {\n                    (0, _utils.fill)(_this, prop, function (original) {\n                        return (0, _helpers.wrap)(original, {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: (0, _utils.getFunctionName)(original)\n                                },\n                                handled: true,\n                                type: 'instrument'\n                            }\n                        });\n                    });\n                }\n            });\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                (0, _utils.fill)(xhr, 'onreadystatechange', function (original) {\n                    var wrapOptions = {\n                        mechanism: {\n                            data: {\n                                function: 'onreadystatechange',\n                                handler: (0, _utils.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 = (0, _utils.getFunctionName)(original.__sentry_original__);\n                    }\n                    // Otherwise wrap directly\n                    return (0, _helpers.wrap)(original, wrapOptions);\n                });\n            }\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        this._ignoreOnError = this._ignoreOnError;\n        var global = (0, _utils.getGlobalObject)();\n        (0, _utils.fill)(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        (0, _utils.fill)(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        (0, _utils.fill)(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        if ('XMLHttpRequest' in global) {\n            (0, _utils.fill)(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'].forEach(this._wrapEventTarget.bind(this));\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}();\nexports.TryCatch = TryCatch;\n//# sourceMappingURL=trycatch.js.map\n\n/***/ }),\n/* 92 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Breadcrumbs = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _types = __webpack_require__(4);\n\nvar _utils = __webpack_require__(0);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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 = tslib_1.__assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console'\n            },\n            level: _types.Severity.fromString(handlerData.level),\n            message: (0, _utils.safeJoin)(handlerData.args, ' ')\n        };\n        if (handlerData.level === 'assert') {\n            if (handlerData.args[0] === false) {\n                breadcrumb.message = \"Assertion failed: \" + ((0, _utils.safeJoin)(handlerData.args.slice(1), ' ') || 'console.assert');\n                breadcrumb.data.arguments = handlerData.args.slice(1);\n            } else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        (0, _core.getCurrentHub)().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\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 ? (0, _utils.htmlTreeAsString)(handlerData.event.target) : (0, _utils.htmlTreeAsString)(handlerData.event);\n        } catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        (0, _core.getCurrentHub)().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target\n        }, {\n            event: event,\n            name: handlerData.name\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\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            (0, _core.getCurrentHub)().addBreadcrumb({\n                category: 'xhr',\n                data: handlerData.xhr.__sentry_xhr__,\n                type: 'http'\n            }, {\n                xhr: handlerData.xhr\n            });\n            return;\n        }\n        // We only capture issued sentry requests\n        if (handlerData.xhr.__sentry_own_request__) {\n            addSentryBreadcrumb(handlerData.args[0]);\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\n        }\n        var client = (0, _core.getCurrentHub)().getClient();\n        var dsn = client && client.getDsn();\n        if (dsn) {\n            var filterUrl = new _core.API(dsn).getStoreEndpoint();\n            // if Sentry key appears in URL, don't capture it as a request\n            // but rather as our own 'sentry' type breadcrumb\n            if (filterUrl && handlerData.fetchData.url.indexOf(filterUrl) !== -1 && handlerData.fetchData.method === 'POST' && handlerData.args[1] && handlerData.args[1].body) {\n                addSentryBreadcrumb(handlerData.args[1].body);\n                return;\n            }\n        }\n        if (handlerData.error) {\n            (0, _core.getCurrentHub)().addBreadcrumb({\n                category: 'fetch',\n                data: tslib_1.__assign({}, handlerData.fetchData, { status_code: handlerData.response.status }),\n                level: _types.Severity.Error,\n                type: 'http'\n            }, {\n                data: handlerData.error,\n                input: handlerData.args\n            });\n        } else {\n            (0, _core.getCurrentHub)().addBreadcrumb({\n                category: 'fetch',\n                data: tslib_1.__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    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = (0, _utils.getGlobalObject)();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = (0, _utils.parseUrl)(global.location.href);\n        var parsedFrom = (0, _utils.parseUrl)(from);\n        var parsedTo = (0, _utils.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            // tslint:disable-next-line:no-parameter-reassignment\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            // tslint:disable-next-line:no-parameter-reassignment\n            from = parsedFrom.relative;\n        }\n        (0, _core.getCurrentHub)().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to\n            }\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            (0, _utils.addInstrumentationHandler)({\n                callback: function callback() {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'console'\n            });\n        }\n        if (this._options.dom) {\n            (0, _utils.addInstrumentationHandler)({\n                callback: function callback() {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'dom'\n            });\n        }\n        if (this._options.xhr) {\n            (0, _utils.addInstrumentationHandler)({\n                callback: function callback() {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'xhr'\n            });\n        }\n        if (this._options.fetch) {\n            (0, _utils.addInstrumentationHandler)({\n                callback: function callback() {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'fetch'\n            });\n        }\n        if (this._options.history) {\n            (0, _utils.addInstrumentationHandler)({\n                callback: function callback() {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'history'\n            });\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}();\nexports.Breadcrumbs = Breadcrumbs;\n/**\n * Create a breadcrumb of `sentry` from the events themselves\n */\n\nfunction addSentryBreadcrumb(serializedData) {\n    // There's always something that can go wrong with deserialization...\n    try {\n        var event_1 = JSON.parse(serializedData);\n        (0, _core.getCurrentHub)().addBreadcrumb({\n            category: 'sentry',\n            event_id: event_1.event_id,\n            level: event_1.level || _types.Severity.fromString('error'),\n            message: (0, _utils.getEventDescription)(event_1)\n        }, {\n            event: event_1\n        });\n    } catch (_oO) {\n        _utils.logger.error('Error while adding sentry type breadcrumb');\n    }\n}\n//# sourceMappingURL=breadcrumbs.js.map\n\n/***/ }),\n/* 93 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.LinkedErrors = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\n\nvar _parsers = __webpack_require__(37);\n\nvar _tracekit = __webpack_require__(15);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\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) {\n            options = {};\n        }\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        (0, _core.addGlobalEventProcessor)(function (event, hint) {\n            var self = (0, _core.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 || !(0, _utils.isInstanceOf)(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = tslib_1.__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) {\n            stack = [];\n        }\n        if (!(0, _utils.isInstanceOf)(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = (0, _tracekit.computeStackTrace)(error[key]);\n        var exception = (0, _parsers.exceptionFromStacktrace)(stacktrace);\n        return this._walkErrorTree(error[key], key, tslib_1.__spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}();\nexports.LinkedErrors = LinkedErrors;\n//# sourceMappingURL=linkederrors.js.map\n\n/***/ }),\n/* 94 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.UserAgent = undefined;\n\nvar _tslib = __webpack_require__(1);\n\nvar tslib_1 = _interopRequireWildcard(_tslib);\n\nvar _core = __webpack_require__(3);\n\nvar _utils = __webpack_require__(0);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nvar global = (0, _utils.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        (0, _core.addGlobalEventProcessor)(function (event) {\n            if ((0, _core.getCurrentHub)().getIntegration(UserAgent)) {\n                if (!global.navigator || !global.location) {\n                    return event;\n                }\n                // Request Interface: https://docs.sentry.io/development/sdk-dev/event-payloads/request/\n                var request = event.request || {};\n                request.url = request.url || global.location.href;\n                request.headers = request.headers || {};\n                request.headers['User-Agent'] = global.navigator.userAgent;\n                return tslib_1.__assign({}, event, { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}();\nexports.UserAgent = UserAgent;\n//# sourceMappingURL=useragent.js.map\n\n/***/ }),\n/* 95 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n(function () {\n  /*\n  \n   Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n   This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n   The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n   The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n   Code distributed by Google as part of the polymer project is also\n   subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n  */\n  'use strict';\n  var n = window.Document.prototype.createElement,\n      p = window.Document.prototype.createElementNS,\n      aa = window.Document.prototype.importNode,\n      ba = window.Document.prototype.prepend,\n      ca = window.Document.prototype.append,\n      da = window.DocumentFragment.prototype.prepend,\n      ea = window.DocumentFragment.prototype.append,\n      q = window.Node.prototype.cloneNode,\n      r = window.Node.prototype.appendChild,\n      t = window.Node.prototype.insertBefore,\n      u = window.Node.prototype.removeChild,\n      v = window.Node.prototype.replaceChild,\n      x = Object.getOwnPropertyDescriptor(window.Node.prototype, \"textContent\"),\n      y = window.Element.prototype.attachShadow,\n      z = Object.getOwnPropertyDescriptor(window.Element.prototype, \"innerHTML\"),\n      A = window.Element.prototype.getAttribute,\n      B = window.Element.prototype.setAttribute,\n      C = window.Element.prototype.removeAttribute,\n      D = window.Element.prototype.getAttributeNS,\n      E = window.Element.prototype.setAttributeNS,\n      F = window.Element.prototype.removeAttributeNS,\n      G = window.Element.prototype.insertAdjacentElement,\n      fa = window.Element.prototype.insertAdjacentHTML,\n      ha = window.Element.prototype.prepend,\n      ia = window.Element.prototype.append,\n      ja = window.Element.prototype.before,\n      ka = window.Element.prototype.after,\n      la = window.Element.prototype.replaceWith,\n      ma = window.Element.prototype.remove,\n      na = window.HTMLElement,\n      H = Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, \"innerHTML\"),\n      oa = window.HTMLElement.prototype.insertAdjacentElement,\n      pa = window.HTMLElement.prototype.insertAdjacentHTML;var qa = new Set();\"annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph\".split(\" \").forEach(function (a) {\n    return qa.add(a);\n  });function ra(a) {\n    var b = qa.has(a);a = /^[a-z][.0-9_a-z]*-[\\-.0-9_a-z]*$/.test(a);return !b && a;\n  }var sa = document.contains ? document.contains.bind(document) : document.documentElement.contains.bind(document.documentElement);\n  function I(a) {\n    var b = a.isConnected;if (void 0 !== b) return b;if (sa(a)) return !0;for (; a && !(a.__CE_isImportDocument || a instanceof Document);) {\n      a = a.parentNode || (window.ShadowRoot && a instanceof ShadowRoot ? a.host : void 0);\n    }return !(!a || !(a.__CE_isImportDocument || a instanceof Document));\n  }function J(a) {\n    var b = a.children;if (b) return Array.prototype.slice.call(b);b = [];for (a = a.firstChild; a; a = a.nextSibling) {\n      a.nodeType === Node.ELEMENT_NODE && b.push(a);\n    }return b;\n  }\n  function K(a, b) {\n    for (; b && b !== a && !b.nextSibling;) {\n      b = b.parentNode;\n    }return b && b !== a ? b.nextSibling : null;\n  }\n  function L(a, b, c) {\n    for (var f = a; f;) {\n      if (f.nodeType === Node.ELEMENT_NODE) {\n        var d = f;b(d);var e = d.localName;if (\"link\" === e && \"import\" === d.getAttribute(\"rel\")) {\n          f = d.import;void 0 === c && (c = new Set());if (f instanceof Node && !c.has(f)) for (c.add(f), f = f.firstChild; f; f = f.nextSibling) {\n            L(f, b, c);\n          }f = K(a, d);continue;\n        } else if (\"template\" === e) {\n          f = K(a, d);continue;\n        }if (d = d.__CE_shadowRoot) for (d = d.firstChild; d; d = d.nextSibling) {\n          L(d, b, c);\n        }\n      }f = f.firstChild ? f.firstChild : K(a, f);\n    }\n  }function M(a, b, c) {\n    a[b] = c;\n  };function ta(a) {\n    var b = document;this.c = a;this.a = b;this.b = void 0;N(this.c, this.a);\"loading\" === this.a.readyState && (this.b = new MutationObserver(this.f.bind(this)), this.b.observe(this.a, { childList: !0, subtree: !0 }));\n  }function ua(a) {\n    a.b && a.b.disconnect();\n  }ta.prototype.f = function (a) {\n    var b = this.a.readyState;\"interactive\" !== b && \"complete\" !== b || ua(this);for (b = 0; b < a.length; b++) {\n      for (var c = a[b].addedNodes, f = 0; f < c.length; f++) {\n        N(this.c, c[f]);\n      }\n    }\n  };function va() {\n    var a = this;this.b = this.a = void 0;this.c = new Promise(function (b) {\n      a.b = b;a.a && b(a.a);\n    });\n  }function wa(a) {\n    if (a.a) throw Error(\"Already resolved.\");a.a = void 0;a.b && a.b(void 0);\n  };function O(a) {\n    this.f = new Map();this.g = new Map();this.l = new Map();this.i = !1;this.b = a;this.j = new Map();this.c = function (b) {\n      return b();\n    };this.a = !1;this.h = [];this.m = a.f ? new ta(a) : void 0;\n  }O.prototype.o = function (a, b) {\n    var c = this;if (!(b instanceof Function)) throw new TypeError(\"Custom element constructor getters must be functions.\");xa(this, a);this.f.set(a, b);this.h.push(a);this.a || (this.a = !0, this.c(function () {\n      return ya(c);\n    }));\n  };\n  O.prototype.define = function (a, b) {\n    var c = this;if (!(b instanceof Function)) throw new TypeError(\"Custom element constructors must be functions.\");xa(this, a);za(this, a, b);this.h.push(a);this.a || (this.a = !0, this.c(function () {\n      return ya(c);\n    }));\n  };function xa(a, b) {\n    if (!ra(b)) throw new SyntaxError(\"The element name '\" + b + \"' is not valid.\");if (P(a, b)) throw Error(\"A custom element with name '\" + b + \"' has already been defined.\");if (a.i) throw Error(\"A custom element is already being defined.\");\n  }\n  function za(a, b, c) {\n    a.i = !0;var f;try {\n      var d = function d(m) {\n        var w = e[m];if (void 0 !== w && !(w instanceof Function)) throw Error(\"The '\" + m + \"' callback must be a function.\");return w;\n      },\n          e = c.prototype;if (!(e instanceof Object)) throw new TypeError(\"The custom element constructor's prototype is not an object.\");var g = d(\"connectedCallback\");var h = d(\"disconnectedCallback\");var k = d(\"adoptedCallback\");var l = (f = d(\"attributeChangedCallback\")) && c.observedAttributes || [];\n    } catch (m) {\n      throw m;\n    } finally {\n      a.i = !1;\n    }c = { localName: b, constructorFunction: c,\n      connectedCallback: g, disconnectedCallback: h, adoptedCallback: k, attributeChangedCallback: f, observedAttributes: l, constructionStack: [] };a.g.set(b, c);a.l.set(c.constructorFunction, c);return c;\n  }O.prototype.upgrade = function (a) {\n    N(this.b, a);\n  };\n  function ya(a) {\n    if (!1 !== a.a) {\n      a.a = !1;for (var b = [], c = a.h, f = new Map(), d = 0; d < c.length; d++) {\n        f.set(c[d], []);\n      }N(a.b, document, { upgrade: function upgrade(k) {\n          if (void 0 === k.__CE_state) {\n            var l = k.localName,\n                m = f.get(l);m ? m.push(k) : a.g.has(l) && b.push(k);\n          }\n        } });for (d = 0; d < b.length; d++) {\n        Q(a.b, b[d]);\n      }for (d = 0; d < c.length; d++) {\n        for (var e = c[d], g = f.get(e), h = 0; h < g.length; h++) {\n          Q(a.b, g[h]);\n        }(e = a.j.get(e)) && wa(e);\n      }c.length = 0;\n    }\n  }O.prototype.get = function (a) {\n    if (a = P(this, a)) return a.constructorFunction;\n  };\n  O.prototype.whenDefined = function (a) {\n    if (!ra(a)) return Promise.reject(new SyntaxError(\"'\" + a + \"' is not a valid custom element name.\"));var b = this.j.get(a);if (b) return b.c;b = new va();this.j.set(a, b);var c = this.g.has(a) || this.f.has(a);a = -1 === this.h.indexOf(a);c && a && wa(b);return b.c;\n  };O.prototype.polyfillWrapFlushCallback = function (a) {\n    this.m && ua(this.m);var b = this.c;this.c = function (c) {\n      return a(function () {\n        return b(c);\n      });\n    };\n  };\n  function P(a, b) {\n    var c = a.g.get(b);if (c) return c;if (c = a.f.get(b)) {\n      a.f.delete(b);try {\n        return za(a, b, c());\n      } catch (f) {\n        R(f);\n      }\n    }\n  }window.CustomElementRegistry = O;O.prototype.define = O.prototype.define;O.prototype.upgrade = O.prototype.upgrade;O.prototype.get = O.prototype.get;O.prototype.whenDefined = O.prototype.whenDefined;O.prototype.polyfillDefineLazy = O.prototype.o;O.prototype.polyfillWrapFlushCallback = O.prototype.polyfillWrapFlushCallback;function S() {\n    var a = T && T.noDocumentConstructionObserver,\n        b = T && T.shadyDomFastWalk;this.b = [];this.c = [];this.a = !1;this.shadyDomFastWalk = b;this.f = !a;\n  }function U(a, b, c, f) {\n    var d = window.ShadyDOM;if (a.shadyDomFastWalk && d && d.inUse) {\n      if (b.nodeType === Node.ELEMENT_NODE && c(b), b.querySelectorAll) for (a = d.nativeMethods.querySelectorAll.call(b, \"*\"), b = 0; b < a.length; b++) {\n        c(a[b]);\n      }\n    } else L(b, c, f);\n  }function Aa(a, b) {\n    a.a = !0;a.b.push(b);\n  }function Ba(a, b) {\n    a.a = !0;a.c.push(b);\n  }function V(a, b) {\n    a.a && U(a, b, function (c) {\n      return W(a, c);\n    });\n  }\n  function W(a, b) {\n    if (a.a && !b.__CE_patched) {\n      b.__CE_patched = !0;for (var c = 0; c < a.b.length; c++) {\n        a.b[c](b);\n      }for (c = 0; c < a.c.length; c++) {\n        a.c[c](b);\n      }\n    }\n  }function X(a, b) {\n    var c = [];U(a, b, function (d) {\n      return c.push(d);\n    });for (b = 0; b < c.length; b++) {\n      var f = c[b];1 === f.__CE_state ? a.connectedCallback(f) : Q(a, f);\n    }\n  }function Y(a, b) {\n    var c = [];U(a, b, function (d) {\n      return c.push(d);\n    });for (b = 0; b < c.length; b++) {\n      var f = c[b];1 === f.__CE_state && a.disconnectedCallback(f);\n    }\n  }\n  function N(a, b, c) {\n    c = void 0 === c ? {} : c;var f = c.s,\n        d = c.upgrade || function (g) {\n      return Q(a, g);\n    },\n        e = [];U(a, b, function (g) {\n      a.a && W(a, g);if (\"link\" === g.localName && \"import\" === g.getAttribute(\"rel\")) {\n        var h = g.import;h instanceof Node && (h.__CE_isImportDocument = !0, h.__CE_registry = document.__CE_registry);h && \"complete\" === h.readyState ? h.__CE_documentLoadHandled = !0 : g.addEventListener(\"load\", function () {\n          var k = g.import;if (!k.__CE_documentLoadHandled) {\n            k.__CE_documentLoadHandled = !0;var l = new Set();f && (f.forEach(function (m) {\n              return l.add(m);\n            }), l.delete(k));N(a, k, { s: l, upgrade: d });\n          }\n        });\n      } else e.push(g);\n    }, f);for (b = 0; b < e.length; b++) {\n      d(e[b]);\n    }\n  }\n  function Q(a, b) {\n    try {\n      var c = b.ownerDocument,\n          f = c.__CE_registry;var d = f && (c.defaultView || c.__CE_isImportDocument) ? P(f, b.localName) : void 0;if (d && void 0 === b.__CE_state) {\n        d.constructionStack.push(b);try {\n          try {\n            if (new d.constructorFunction() !== b) throw Error(\"The custom element constructor did not produce the element being upgraded.\");\n          } finally {\n            d.constructionStack.pop();\n          }\n        } catch (k) {\n          throw b.__CE_state = 2, k;\n        }b.__CE_state = 1;b.__CE_definition = d;if (d.attributeChangedCallback && b.hasAttributes()) {\n          var e = d.observedAttributes;\n          for (d = 0; d < e.length; d++) {\n            var g = e[d],\n                h = b.getAttribute(g);null !== h && a.attributeChangedCallback(b, g, null, h, null);\n          }\n        }I(b) && a.connectedCallback(b);\n      }\n    } catch (k) {\n      R(k);\n    }\n  }S.prototype.connectedCallback = function (a) {\n    var b = a.__CE_definition;if (b.connectedCallback) try {\n      b.connectedCallback.call(a);\n    } catch (c) {\n      R(c);\n    }\n  };S.prototype.disconnectedCallback = function (a) {\n    var b = a.__CE_definition;if (b.disconnectedCallback) try {\n      b.disconnectedCallback.call(a);\n    } catch (c) {\n      R(c);\n    }\n  };\n  S.prototype.attributeChangedCallback = function (a, b, c, f, d) {\n    var e = a.__CE_definition;if (e.attributeChangedCallback && -1 < e.observedAttributes.indexOf(b)) try {\n      e.attributeChangedCallback.call(a, b, c, f, d);\n    } catch (g) {\n      R(g);\n    }\n  };\n  function Ca(a, b, c, f) {\n    var d = b.__CE_registry;if (d && (null === f || \"http://www.w3.org/1999/xhtml\" === f) && (d = P(d, c))) try {\n      var e = new d.constructorFunction();if (void 0 === e.__CE_state || void 0 === e.__CE_definition) throw Error(\"Failed to construct '\" + c + \"': The returned value was not constructed with the HTMLElement constructor.\");if (\"http://www.w3.org/1999/xhtml\" !== e.namespaceURI) throw Error(\"Failed to construct '\" + c + \"': The constructed element's namespace must be the HTML namespace.\");if (e.hasAttributes()) throw Error(\"Failed to construct '\" + c + \"': The constructed element must not have any attributes.\");if (null !== e.firstChild) throw Error(\"Failed to construct '\" + c + \"': The constructed element must not have any children.\");if (null !== e.parentNode) throw Error(\"Failed to construct '\" + c + \"': The constructed element must not have a parent node.\");if (e.ownerDocument !== b) throw Error(\"Failed to construct '\" + c + \"': The constructed element's owner document is incorrect.\");if (e.localName !== c) throw Error(\"Failed to construct '\" + c + \"': The constructed element's local name is incorrect.\");\n      return e;\n    } catch (g) {\n      return R(g), b = null === f ? n.call(b, c) : p.call(b, f, c), Object.setPrototypeOf(b, HTMLUnknownElement.prototype), b.__CE_state = 2, b.__CE_definition = void 0, W(a, b), b;\n    }b = null === f ? n.call(b, c) : p.call(b, f, c);W(a, b);return b;\n  }\n  function R(a) {\n    var b = a.message,\n        c = a.sourceURL || a.fileName || \"\",\n        f = a.line || a.lineNumber || 0,\n        d = a.column || a.columnNumber || 0,\n        e = void 0;void 0 === ErrorEvent.prototype.initErrorEvent ? e = new ErrorEvent(\"error\", { cancelable: !0, message: b, filename: c, lineno: f, colno: d, error: a }) : (e = document.createEvent(\"ErrorEvent\"), e.initErrorEvent(\"error\", !1, !0, b, c, f), e.preventDefault = function () {\n      Object.defineProperty(this, \"defaultPrevented\", { configurable: !0, get: function get() {\n          return !0;\n        } });\n    });void 0 === e.error && Object.defineProperty(e, \"error\", { configurable: !0, enumerable: !0, get: function get() {\n        return a;\n      } });window.dispatchEvent(e);e.defaultPrevented || console.error(a);\n  };var Da = new function () {}();function Ea(a) {\n    window.HTMLElement = function () {\n      function b() {\n        var c = this.constructor;var f = document.__CE_registry.l.get(c);if (!f) throw Error(\"Failed to construct a custom element: The constructor was not registered with `customElements`.\");var d = f.constructionStack;if (0 === d.length) return d = n.call(document, f.localName), Object.setPrototypeOf(d, c.prototype), d.__CE_state = 1, d.__CE_definition = f, W(a, d), d;var e = d.length - 1,\n            g = d[e];if (g === Da) throw Error(\"Failed to construct '\" + f.localName + \"': This element was already constructed.\");\n        d[e] = Da;Object.setPrototypeOf(g, c.prototype);W(a, g);return g;\n      }b.prototype = na.prototype;Object.defineProperty(b.prototype, \"constructor\", { writable: !0, configurable: !0, enumerable: !1, value: b });return b;\n    }();\n  };function Z(a, b, c) {\n    function f(d) {\n      return function (e) {\n        for (var g = [], h = 0; h < arguments.length; ++h) {\n          g[h] = arguments[h];\n        }h = [];for (var k = [], l = 0; l < g.length; l++) {\n          var m = g[l];m instanceof Element && I(m) && k.push(m);if (m instanceof DocumentFragment) for (m = m.firstChild; m; m = m.nextSibling) {\n            h.push(m);\n          } else h.push(m);\n        }d.apply(this, g);for (g = 0; g < k.length; g++) {\n          Y(a, k[g]);\n        }if (I(this)) for (g = 0; g < h.length; g++) {\n          k = h[g], k instanceof Element && X(a, k);\n        }\n      };\n    }void 0 !== c.prepend && M(b, \"prepend\", f(c.prepend));void 0 !== c.append && M(b, \"append\", f(c.append));\n  }\n  ;function Fa(a) {\n    M(Document.prototype, \"createElement\", function (b) {\n      return Ca(a, this, b, null);\n    });M(Document.prototype, \"importNode\", function (b, c) {\n      b = aa.call(this, b, !!c);this.__CE_registry ? N(a, b) : V(a, b);return b;\n    });M(Document.prototype, \"createElementNS\", function (b, c) {\n      return Ca(a, this, c, b);\n    });Z(a, Document.prototype, { prepend: ba, append: ca });\n  };function Ga(a) {\n    function b(c, f) {\n      Object.defineProperty(c, \"textContent\", { enumerable: f.enumerable, configurable: !0, get: f.get, set: function set(d) {\n          if (this.nodeType === Node.TEXT_NODE) f.set.call(this, d);else {\n            var e = void 0;if (this.firstChild) {\n              var g = this.childNodes,\n                  h = g.length;if (0 < h && I(this)) {\n                e = Array(h);for (var k = 0; k < h; k++) {\n                  e[k] = g[k];\n                }\n              }\n            }f.set.call(this, d);if (e) for (d = 0; d < e.length; d++) {\n              Y(a, e[d]);\n            }\n          }\n        } });\n    }M(Node.prototype, \"insertBefore\", function (c, f) {\n      if (c instanceof DocumentFragment) {\n        var d = J(c);c = t.call(this, c, f);if (I(this)) for (f = 0; f < d.length; f++) {\n          X(a, d[f]);\n        }return c;\n      }d = c instanceof Element && I(c);f = t.call(this, c, f);d && Y(a, c);I(this) && X(a, c);return f;\n    });M(Node.prototype, \"appendChild\", function (c) {\n      if (c instanceof DocumentFragment) {\n        var f = J(c);c = r.call(this, c);if (I(this)) for (var d = 0; d < f.length; d++) {\n          X(a, f[d]);\n        }return c;\n      }f = c instanceof Element && I(c);d = r.call(this, c);f && Y(a, c);I(this) && X(a, c);return d;\n    });M(Node.prototype, \"cloneNode\", function (c) {\n      c = q.call(this, !!c);this.ownerDocument.__CE_registry ? N(a, c) : V(a, c);return c;\n    });M(Node.prototype, \"removeChild\", function (c) {\n      var f = c instanceof Element && I(c),\n          d = u.call(this, c);f && Y(a, c);return d;\n    });M(Node.prototype, \"replaceChild\", function (c, f) {\n      if (c instanceof DocumentFragment) {\n        var d = J(c);c = v.call(this, c, f);if (I(this)) for (Y(a, f), f = 0; f < d.length; f++) {\n          X(a, d[f]);\n        }return c;\n      }d = c instanceof Element && I(c);var e = v.call(this, c, f),\n          g = I(this);g && Y(a, f);d && Y(a, c);g && X(a, c);return e;\n    });x && x.get ? b(Node.prototype, x) : Aa(a, function (c) {\n      b(c, { enumerable: !0, configurable: !0, get: function get() {\n          for (var f = [], d = this.firstChild; d; d = d.nextSibling) {\n            d.nodeType !== Node.COMMENT_NODE && f.push(d.textContent);\n          }return f.join(\"\");\n        }, set: function set(f) {\n          for (; this.firstChild;) {\n            u.call(this, this.firstChild);\n          }null != f && \"\" !== f && r.call(this, document.createTextNode(f));\n        } });\n    });\n  };function Ha(a) {\n    function b(f) {\n      return function (d) {\n        for (var e = [], g = 0; g < arguments.length; ++g) {\n          e[g] = arguments[g];\n        }g = [];for (var h = [], k = 0; k < e.length; k++) {\n          var l = e[k];l instanceof Element && I(l) && h.push(l);if (l instanceof DocumentFragment) for (l = l.firstChild; l; l = l.nextSibling) {\n            g.push(l);\n          } else g.push(l);\n        }f.apply(this, e);for (e = 0; e < h.length; e++) {\n          Y(a, h[e]);\n        }if (I(this)) for (e = 0; e < g.length; e++) {\n          h = g[e], h instanceof Element && X(a, h);\n        }\n      };\n    }var c = Element.prototype;void 0 !== ja && M(c, \"before\", b(ja));void 0 !== ka && M(c, \"after\", b(ka));void 0 !== la && M(c, \"replaceWith\", function (f) {\n      for (var d = [], e = 0; e < arguments.length; ++e) {\n        d[e] = arguments[e];\n      }e = [];for (var g = [], h = 0; h < d.length; h++) {\n        var k = d[h];k instanceof Element && I(k) && g.push(k);if (k instanceof DocumentFragment) for (k = k.firstChild; k; k = k.nextSibling) {\n          e.push(k);\n        } else e.push(k);\n      }h = I(this);la.apply(this, d);for (d = 0; d < g.length; d++) {\n        Y(a, g[d]);\n      }if (h) for (Y(a, this), d = 0; d < e.length; d++) {\n        g = e[d], g instanceof Element && X(a, g);\n      }\n    });void 0 !== ma && M(c, \"remove\", function () {\n      var f = I(this);ma.call(this);f && Y(a, this);\n    });\n  };function Ia(a) {\n    function b(d, e) {\n      Object.defineProperty(d, \"innerHTML\", { enumerable: e.enumerable, configurable: !0, get: e.get, set: function set(g) {\n          var h = this,\n              k = void 0;I(this) && (k = [], U(a, this, function (w) {\n            w !== h && k.push(w);\n          }));e.set.call(this, g);if (k) for (var l = 0; l < k.length; l++) {\n            var m = k[l];1 === m.__CE_state && a.disconnectedCallback(m);\n          }this.ownerDocument.__CE_registry ? N(a, this) : V(a, this);return g;\n        } });\n    }function c(d, e) {\n      M(d, \"insertAdjacentElement\", function (g, h) {\n        var k = I(h);g = e.call(this, g, h);k && Y(a, h);I(g) && X(a, h);return g;\n      });\n    }\n    function f(d, e) {\n      function g(h, k) {\n        for (var l = []; h !== k; h = h.nextSibling) {\n          l.push(h);\n        }for (k = 0; k < l.length; k++) {\n          N(a, l[k]);\n        }\n      }M(d, \"insertAdjacentHTML\", function (h, k) {\n        h = h.toLowerCase();if (\"beforebegin\" === h) {\n          var l = this.previousSibling;e.call(this, h, k);g(l || this.parentNode.firstChild, this);\n        } else if (\"afterbegin\" === h) l = this.firstChild, e.call(this, h, k), g(this.firstChild, l);else if (\"beforeend\" === h) l = this.lastChild, e.call(this, h, k), g(l || this.firstChild, null);else if (\"afterend\" === h) l = this.nextSibling, e.call(this, h, k), g(this.nextSibling, l);else throw new SyntaxError(\"The value provided (\" + String(h) + \") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.\");\n      });\n    }y && M(Element.prototype, \"attachShadow\", function (d) {\n      d = y.call(this, d);if (a.a && !d.__CE_patched) {\n        d.__CE_patched = !0;for (var e = 0; e < a.b.length; e++) {\n          a.b[e](d);\n        }\n      }return this.__CE_shadowRoot = d;\n    });z && z.get ? b(Element.prototype, z) : H && H.get ? b(HTMLElement.prototype, H) : Ba(a, function (d) {\n      b(d, { enumerable: !0, configurable: !0, get: function get() {\n          return q.call(this, !0).innerHTML;\n        }, set: function set(e) {\n          var g = \"template\" === this.localName,\n              h = g ? this.content : this,\n              k = p.call(document, this.namespaceURI, this.localName);for (k.innerHTML = e; 0 < h.childNodes.length;) {\n            u.call(h, h.childNodes[0]);\n          }for (e = g ? k.content : k; 0 < e.childNodes.length;) {\n            r.call(h, e.childNodes[0]);\n          }\n        } });\n    });M(Element.prototype, \"setAttribute\", function (d, e) {\n      if (1 !== this.__CE_state) return B.call(this, d, e);var g = A.call(this, d);B.call(this, d, e);e = A.call(this, d);a.attributeChangedCallback(this, d, g, e, null);\n    });M(Element.prototype, \"setAttributeNS\", function (d, e, g) {\n      if (1 !== this.__CE_state) return E.call(this, d, e, g);var h = D.call(this, d, e);E.call(this, d, e, g);g = D.call(this, d, e);a.attributeChangedCallback(this, e, h, g, d);\n    });M(Element.prototype, \"removeAttribute\", function (d) {\n      if (1 !== this.__CE_state) return C.call(this, d);var e = A.call(this, d);C.call(this, d);null !== e && a.attributeChangedCallback(this, d, e, null, null);\n    });M(Element.prototype, \"removeAttributeNS\", function (d, e) {\n      if (1 !== this.__CE_state) return F.call(this, d, e);var g = D.call(this, d, e);F.call(this, d, e);var h = D.call(this, d, e);g !== h && a.attributeChangedCallback(this, e, g, h, d);\n    });oa ? c(HTMLElement.prototype, oa) : G && c(Element.prototype, G);pa ? f(HTMLElement.prototype, pa) : fa && f(Element.prototype, fa);Z(a, Element.prototype, { prepend: ha, append: ia });Ha(a);\n  };var T = window.customElements;function Ja() {\n    var a = new S();Ea(a);Fa(a);Z(a, DocumentFragment.prototype, { prepend: da, append: ea });Ga(a);Ia(a);a = new O(a);document.__CE_registry = a;Object.defineProperty(window, \"customElements\", { configurable: !0, enumerable: !0, value: a });\n  }T && !T.forcePolyfill && \"function\" == typeof T.define && \"function\" == typeof T.get || Ja();window.__CE_installPolyfill = Ja;\n}).call(self);\n\n//# sourceMappingURL=custom-elements.min.js.map\n\n/***/ }),\n/* 96 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function () {\n  'use strict';\n\n  // Exit early if we're not running in a browser.\n\n  if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) !== 'object') {\n    return;\n  }\n\n  // Exit early if all IntersectionObserver and IntersectionObserverEntry\n  // features are natively supported.\n  if ('IntersectionObserver' in window && 'IntersectionObserverEntry' in window && 'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n    // Minimal polyfill for Edge 15's lack of `isIntersecting`\n    // See: https://github.com/w3c/IntersectionObserver/issues/211\n    if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n      Object.defineProperty(window.IntersectionObserverEntry.prototype, 'isIntersecting', {\n        get: function get() {\n          return this.intersectionRatio > 0;\n        }\n      });\n    }\n    return;\n  }\n\n  /**\n   * Returns the embedding frame element, if any.\n   * @param {!Document} doc\n   * @return {!Element}\n   */\n  function getFrameElement(doc) {\n    try {\n      return doc.defaultView && doc.defaultView.frameElement || null;\n    } catch (e) {\n      // Ignore the error.\n      return null;\n    }\n  }\n\n  /**\n   * A local reference to the root document.\n   */\n  var document = function (startDoc) {\n    var doc = startDoc;\n    var frame = getFrameElement(doc);\n    while (frame) {\n      doc = frame.ownerDocument;\n      frame = getFrameElement(doc);\n    }\n    return doc;\n  }(window.document);\n\n  /**\n   * An IntersectionObserver registry. This registry exists to hold a strong\n   * reference to IntersectionObserver instances currently observing a target\n   * element. Without this registry, instances without another reference may be\n   * garbage collected.\n   */\n  var registry = [];\n\n  /**\n   * The signal updater for cross-origin intersection. When not null, it means\n   * that the polyfill is configured to work in a cross-origin mode.\n   * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n   */\n  var crossOriginUpdater = null;\n\n  /**\n   * The current cross-origin intersection. Only used in the cross-origin mode.\n   * @type {DOMRect|ClientRect}\n   */\n  var crossOriginRect = null;\n\n  /**\n   * Creates the global IntersectionObserverEntry constructor.\n   * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n   * @param {Object} entry A dictionary of instance properties.\n   * @constructor\n   */\n  function IntersectionObserverEntry(entry) {\n    this.time = entry.time;\n    this.target = entry.target;\n    this.rootBounds = ensureDOMRect(entry.rootBounds);\n    this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\n    this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\n    this.isIntersecting = !!entry.intersectionRect;\n\n    // Calculates the intersection ratio.\n    var targetRect = this.boundingClientRect;\n    var targetArea = targetRect.width * targetRect.height;\n    var intersectionRect = this.intersectionRect;\n    var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n    // Sets intersection ratio.\n    if (targetArea) {\n      // Round the intersection ratio to avoid floating point math issues:\n      // https://github.com/w3c/IntersectionObserver/issues/324\n      this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n    } else {\n      // If area is zero and is intersecting, sets to 1, otherwise to 0\n      this.intersectionRatio = this.isIntersecting ? 1 : 0;\n    }\n  }\n\n  /**\n   * Creates the global IntersectionObserver constructor.\n   * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n   * @param {Function} callback The function to be invoked after intersection\n   *     changes have queued. The function is not invoked if the queue has\n   *     been emptied by calling the `takeRecords` method.\n   * @param {Object=} opt_options Optional configuration options.\n   * @constructor\n   */\n  function IntersectionObserver(callback, opt_options) {\n\n    var options = opt_options || {};\n\n    if (typeof callback != 'function') {\n      throw new Error('callback must be a function');\n    }\n\n    if (options.root && options.root.nodeType != 1) {\n      throw new Error('root must be an Element');\n    }\n\n    // Binds and throttles `this._checkForIntersections`.\n    this._checkForIntersections = throttle(this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n    // Private properties.\n    this._callback = callback;\n    this._observationTargets = [];\n    this._queuedEntries = [];\n    this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n    // Public properties.\n    this.thresholds = this._initThresholds(options.threshold);\n    this.root = options.root || null;\n    this.rootMargin = this._rootMarginValues.map(function (margin) {\n      return margin.value + margin.unit;\n    }).join(' ');\n\n    /** @private @const {!Array<!Document>} */\n    this._monitoringDocuments = [];\n    /** @private @const {!Array<function()>} */\n    this._monitoringUnsubscribes = [];\n  }\n\n  /**\n   * The minimum interval within which the document will be checked for\n   * intersection changes.\n   */\n  IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n  /**\n   * The frequency in which the polyfill polls for intersection changes.\n   * this can be updated on a per instance basis and must be set prior to\n   * calling `observe` on the first target.\n   */\n  IntersectionObserver.prototype.POLL_INTERVAL = null;\n\n  /**\n   * Use a mutation observer on the root element\n   * to detect intersection changes.\n   */\n  IntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n  /**\n   * Sets up the polyfill in the cross-origin mode. The result is the\n   * updater function that accepts two arguments: `boundingClientRect` and\n   * `intersectionRect` - just as these fields would be available to the\n   * parent via `IntersectionObserverEntry`. This function should be called\n   * each time the iframe receives intersection information from the parent\n   * window, e.g. via messaging.\n   * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n   */\n  IntersectionObserver._setupCrossOriginUpdater = function () {\n    if (!crossOriginUpdater) {\n      /**\n       * @param {DOMRect|ClientRect} boundingClientRect\n       * @param {DOMRect|ClientRect} intersectionRect\n       */\n      crossOriginUpdater = function crossOriginUpdater(boundingClientRect, intersectionRect) {\n        if (!boundingClientRect || !intersectionRect) {\n          crossOriginRect = getEmptyRect();\n        } else {\n          crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\n        }\n        registry.forEach(function (observer) {\n          observer._checkForIntersections();\n        });\n      };\n    }\n    return crossOriginUpdater;\n  };\n\n  /**\n   * Resets the cross-origin mode.\n   */\n  IntersectionObserver._resetCrossOriginUpdater = function () {\n    crossOriginUpdater = null;\n    crossOriginRect = null;\n  };\n\n  /**\n   * Starts observing a target element for intersection changes based on\n   * the thresholds values.\n   * @param {Element} target The DOM element to observe.\n   */\n  IntersectionObserver.prototype.observe = function (target) {\n    var isTargetAlreadyObserved = this._observationTargets.some(function (item) {\n      return item.element == target;\n    });\n\n    if (isTargetAlreadyObserved) {\n      return;\n    }\n\n    if (!(target && target.nodeType == 1)) {\n      throw new Error('target must be an Element');\n    }\n\n    this._registerInstance();\n    this._observationTargets.push({ element: target, entry: null });\n    this._monitorIntersections(target.ownerDocument);\n    this._checkForIntersections();\n  };\n\n  /**\n   * Stops observing a target element for intersection changes.\n   * @param {Element} target The DOM element to observe.\n   */\n  IntersectionObserver.prototype.unobserve = function (target) {\n    this._observationTargets = this._observationTargets.filter(function (item) {\n      return item.element != target;\n    });\n    this._unmonitorIntersections(target.ownerDocument);\n    if (this._observationTargets.length == 0) {\n      this._unregisterInstance();\n    }\n  };\n\n  /**\n   * Stops observing all target elements for intersection changes.\n   */\n  IntersectionObserver.prototype.disconnect = function () {\n    this._observationTargets = [];\n    this._unmonitorAllIntersections();\n    this._unregisterInstance();\n  };\n\n  /**\n   * Returns any queue entries that have not yet been reported to the\n   * callback and clears the queue. This can be used in conjunction with the\n   * callback to obtain the absolute most up-to-date intersection information.\n   * @return {Array} The currently queued entries.\n   */\n  IntersectionObserver.prototype.takeRecords = function () {\n    var records = this._queuedEntries.slice();\n    this._queuedEntries = [];\n    return records;\n  };\n\n  /**\n   * Accepts the threshold value from the user configuration object and\n   * returns a sorted array of unique threshold values. If a value is not\n   * between 0 and 1 and error is thrown.\n   * @private\n   * @param {Array|number=} opt_threshold An optional threshold value or\n   *     a list of threshold values, defaulting to [0].\n   * @return {Array} A sorted list of unique and valid threshold values.\n   */\n  IntersectionObserver.prototype._initThresholds = function (opt_threshold) {\n    var threshold = opt_threshold || [0];\n    if (!Array.isArray(threshold)) threshold = [threshold];\n\n    return threshold.sort().filter(function (t, i, a) {\n      if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n        throw new Error('threshold must be a number between 0 and 1 inclusively');\n      }\n      return t !== a[i - 1];\n    });\n  };\n\n  /**\n   * Accepts the rootMargin value from the user configuration object\n   * and returns an array of the four margin values as an object containing\n   * the value and unit properties. If any of the values are not properly\n   * formatted or use a unit other than px or %, and error is thrown.\n   * @private\n   * @param {string=} opt_rootMargin An optional rootMargin value,\n   *     defaulting to '0px'.\n   * @return {Array<Object>} An array of margin objects with the keys\n   *     value and unit.\n   */\n  IntersectionObserver.prototype._parseRootMargin = function (opt_rootMargin) {\n    var marginString = opt_rootMargin || '0px';\n    var margins = marginString.split(/\\s+/).map(function (margin) {\n      var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n      if (!parts) {\n        throw new Error('rootMargin must be specified in pixels or percent');\n      }\n      return { value: parseFloat(parts[1]), unit: parts[2] };\n    });\n\n    // Handles shorthand.\n    margins[1] = margins[1] || margins[0];\n    margins[2] = margins[2] || margins[0];\n    margins[3] = margins[3] || margins[1];\n\n    return margins;\n  };\n\n  /**\n   * Starts polling for intersection changes if the polling is not already\n   * happening, and if the page's visibility state is visible.\n   * @param {!Document} doc\n   * @private\n   */\n  IntersectionObserver.prototype._monitorIntersections = function (doc) {\n    var win = doc.defaultView;\n    if (!win) {\n      // Already destroyed.\n      return;\n    }\n    if (this._monitoringDocuments.indexOf(doc) != -1) {\n      // Already monitoring.\n      return;\n    }\n\n    // Private state for monitoring.\n    var callback = this._checkForIntersections;\n    var monitoringInterval = null;\n    var domObserver = null;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\n    } else {\n      addEvent(win, 'resize', callback, true);\n      addEvent(doc, 'scroll', callback, true);\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\n        domObserver = new win.MutationObserver(callback);\n        domObserver.observe(doc, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n\n    this._monitoringDocuments.push(doc);\n    this._monitoringUnsubscribes.push(function () {\n      // Get the window object again. When a friendly iframe is destroyed, it\n      // will be null.\n      var win = doc.defaultView;\n\n      if (win) {\n        if (monitoringInterval) {\n          win.clearInterval(monitoringInterval);\n        }\n        removeEvent(win, 'resize', callback, true);\n      }\n\n      removeEvent(doc, 'scroll', callback, true);\n      if (domObserver) {\n        domObserver.disconnect();\n      }\n    });\n\n    // Also monitor the parent.\n    if (doc != (this.root && this.root.ownerDocument || document)) {\n      var frame = getFrameElement(doc);\n      if (frame) {\n        this._monitorIntersections(frame.ownerDocument);\n      }\n    }\n  };\n\n  /**\n   * Stops polling for intersection changes.\n   * @param {!Document} doc\n   * @private\n   */\n  IntersectionObserver.prototype._unmonitorIntersections = function (doc) {\n    var index = this._monitoringDocuments.indexOf(doc);\n    if (index == -1) {\n      return;\n    }\n\n    var rootDoc = this.root && this.root.ownerDocument || document;\n\n    // Check if any dependent targets are still remaining.\n    var hasDependentTargets = this._observationTargets.some(function (item) {\n      var itemDoc = item.element.ownerDocument;\n      // Target is in this context.\n      if (itemDoc == doc) {\n        return true;\n      }\n      // Target is nested in this context.\n      while (itemDoc && itemDoc != rootDoc) {\n        var frame = getFrameElement(itemDoc);\n        itemDoc = frame && frame.ownerDocument;\n        if (itemDoc == doc) {\n          return true;\n        }\n      }\n      return false;\n    });\n    if (hasDependentTargets) {\n      return;\n    }\n\n    // Unsubscribe.\n    var unsubscribe = this._monitoringUnsubscribes[index];\n    this._monitoringDocuments.splice(index, 1);\n    this._monitoringUnsubscribes.splice(index, 1);\n    unsubscribe();\n\n    // Also unmonitor the parent.\n    if (doc != rootDoc) {\n      var frame = getFrameElement(doc);\n      if (frame) {\n        this._unmonitorIntersections(frame.ownerDocument);\n      }\n    }\n  };\n\n  /**\n   * Stops polling for intersection changes.\n   * @param {!Document} doc\n   * @private\n   */\n  IntersectionObserver.prototype._unmonitorAllIntersections = function () {\n    var unsubscribes = this._monitoringUnsubscribes.slice(0);\n    this._monitoringDocuments.length = 0;\n    this._monitoringUnsubscribes.length = 0;\n    for (var i = 0; i < unsubscribes.length; i++) {\n      unsubscribes[i]();\n    }\n  };\n\n  /**\n   * Scans each observation target for intersection changes and adds them\n   * to the internal entries queue. If new entries are found, it\n   * schedules the callback to be invoked.\n   * @private\n   */\n  IntersectionObserver.prototype._checkForIntersections = function () {\n    if (!this.root && crossOriginUpdater && !crossOriginRect) {\n      // Cross origin monitoring, but no initial data available yet.\n      return;\n    }\n\n    var rootIsInDom = this._rootIsInDom();\n    var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n    this._observationTargets.forEach(function (item) {\n      var target = item.element;\n      var targetRect = getBoundingClientRect(target);\n      var rootContainsTarget = this._rootContainsTarget(target);\n      var oldEntry = item.entry;\n      var intersectionRect = rootIsInDom && rootContainsTarget && this._computeTargetAndRootIntersection(target, targetRect, rootRect);\n\n      var newEntry = item.entry = new IntersectionObserverEntry({\n        time: now(),\n        target: target,\n        boundingClientRect: targetRect,\n        rootBounds: crossOriginUpdater && !this.root ? null : rootRect,\n        intersectionRect: intersectionRect\n      });\n\n      if (!oldEntry) {\n        this._queuedEntries.push(newEntry);\n      } else if (rootIsInDom && rootContainsTarget) {\n        // If the new entry intersection ratio has crossed any of the\n        // thresholds, add a new entry.\n        if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n          this._queuedEntries.push(newEntry);\n        }\n      } else {\n        // If the root is not in the DOM or target is not contained within\n        // root but the previous entry for this target had an intersection,\n        // add a new record indicating removal.\n        if (oldEntry && oldEntry.isIntersecting) {\n          this._queuedEntries.push(newEntry);\n        }\n      }\n    }, this);\n\n    if (this._queuedEntries.length) {\n      this._callback(this.takeRecords(), this);\n    }\n  };\n\n  /**\n   * Accepts a target and root rect computes the intersection between then\n   * following the algorithm in the spec.\n   * TODO(philipwalton): at this time clip-path is not considered.\n   * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n   * @param {Element} target The target DOM element\n   * @param {Object} targetRect The bounding rect of the target.\n   * @param {Object} rootRect The bounding rect of the root after being\n   *     expanded by the rootMargin value.\n   * @return {?Object} The final intersection rect object or undefined if no\n   *     intersection is found.\n   * @private\n   */\n  IntersectionObserver.prototype._computeTargetAndRootIntersection = function (target, targetRect, rootRect) {\n    // If the element isn't displayed, an intersection can't happen.\n    if (window.getComputedStyle(target).display == 'none') return;\n\n    var intersectionRect = targetRect;\n    var parent = getParentNode(target);\n    var atRoot = false;\n\n    while (!atRoot && parent) {\n      var parentRect = null;\n      var parentComputedStyle = parent.nodeType == 1 ? window.getComputedStyle(parent) : {};\n\n      // If the parent isn't displayed, an intersection can't happen.\n      if (parentComputedStyle.display == 'none') return null;\n\n      if (parent == this.root || parent.nodeType == /* DOCUMENT */9) {\n        atRoot = true;\n        if (parent == this.root || parent == document) {\n          if (crossOriginUpdater && !this.root) {\n            if (!crossOriginRect || crossOriginRect.width == 0 && crossOriginRect.height == 0) {\n              // A 0-size cross-origin intersection means no-intersection.\n              parent = null;\n              parentRect = null;\n              intersectionRect = null;\n            } else {\n              parentRect = crossOriginRect;\n            }\n          } else {\n            parentRect = rootRect;\n          }\n        } else {\n          // Check if there's a frame that can be navigated to.\n          var frame = getParentNode(parent);\n          var frameRect = frame && getBoundingClientRect(frame);\n          var frameIntersect = frame && this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\n          if (frameRect && frameIntersect) {\n            parent = frame;\n            parentRect = convertFromParentRect(frameRect, frameIntersect);\n          } else {\n            parent = null;\n            intersectionRect = null;\n          }\n        }\n      } else {\n        // If the element has a non-visible overflow, and it's not the <body>\n        // or <html> element, update the intersection rect.\n        // Note: <body> and <html> cannot be clipped to a rect that's not also\n        // the document rect, so no need to compute a new intersection.\n        var doc = parent.ownerDocument;\n        if (parent != doc.body && parent != doc.documentElement && parentComputedStyle.overflow != 'visible') {\n          parentRect = getBoundingClientRect(parent);\n        }\n      }\n\n      // If either of the above conditionals set a new parentRect,\n      // calculate new intersection data.\n      if (parentRect) {\n        intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n      }\n      if (!intersectionRect) break;\n      parent = parent && getParentNode(parent);\n    }\n    return intersectionRect;\n  };\n\n  /**\n   * Returns the root rect after being expanded by the rootMargin value.\n   * @return {ClientRect} The expanded root rect.\n   * @private\n   */\n  IntersectionObserver.prototype._getRootRect = function () {\n    var rootRect;\n    if (this.root) {\n      rootRect = getBoundingClientRect(this.root);\n    } else {\n      // Use <html>/<body> instead of window since scroll bars affect size.\n      var html = document.documentElement;\n      var body = document.body;\n      rootRect = {\n        top: 0,\n        left: 0,\n        right: html.clientWidth || body.clientWidth,\n        width: html.clientWidth || body.clientWidth,\n        bottom: html.clientHeight || body.clientHeight,\n        height: html.clientHeight || body.clientHeight\n      };\n    }\n    return this._expandRectByRootMargin(rootRect);\n  };\n\n  /**\n   * Accepts a rect and expands it by the rootMargin value.\n   * @param {DOMRect|ClientRect} rect The rect object to expand.\n   * @return {ClientRect} The expanded rect.\n   * @private\n   */\n  IntersectionObserver.prototype._expandRectByRootMargin = function (rect) {\n    var margins = this._rootMarginValues.map(function (margin, i) {\n      return margin.unit == 'px' ? margin.value : margin.value * (i % 2 ? rect.width : rect.height) / 100;\n    });\n    var newRect = {\n      top: rect.top - margins[0],\n      right: rect.right + margins[1],\n      bottom: rect.bottom + margins[2],\n      left: rect.left - margins[3]\n    };\n    newRect.width = newRect.right - newRect.left;\n    newRect.height = newRect.bottom - newRect.top;\n\n    return newRect;\n  };\n\n  /**\n   * Accepts an old and new entry and returns true if at least one of the\n   * threshold values has been crossed.\n   * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n   *    particular target element or null if no previous entry exists.\n   * @param {IntersectionObserverEntry} newEntry The current entry for a\n   *    particular target element.\n   * @return {boolean} Returns true if a any threshold has been crossed.\n   * @private\n   */\n  IntersectionObserver.prototype._hasCrossedThreshold = function (oldEntry, newEntry) {\n\n    // To make comparing easier, an entry that has a ratio of 0\n    // but does not actually intersect is given a value of -1\n    var oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;\n    var newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;\n\n    // Ignore unchanged ratios\n    if (oldRatio === newRatio) return;\n\n    for (var i = 0; i < this.thresholds.length; i++) {\n      var threshold = this.thresholds[i];\n\n      // Return true if an entry matches a threshold or if the new ratio\n      // and the old ratio are on the opposite sides of a threshold.\n      if (threshold == oldRatio || threshold == newRatio || threshold < oldRatio !== threshold < newRatio) {\n        return true;\n      }\n    }\n  };\n\n  /**\n   * Returns whether or not the root element is an element and is in the DOM.\n   * @return {boolean} True if the root element is an element and is in the DOM.\n   * @private\n   */\n  IntersectionObserver.prototype._rootIsInDom = function () {\n    return !this.root || containsDeep(document, this.root);\n  };\n\n  /**\n   * Returns whether or not the target element is a child of root.\n   * @param {Element} target The target element to check.\n   * @return {boolean} True if the target element is a child of root.\n   * @private\n   */\n  IntersectionObserver.prototype._rootContainsTarget = function (target) {\n    return containsDeep(this.root || document, target) && (!this.root || this.root.ownerDocument == target.ownerDocument);\n  };\n\n  /**\n   * Adds the instance to the global IntersectionObserver registry if it isn't\n   * already present.\n   * @private\n   */\n  IntersectionObserver.prototype._registerInstance = function () {\n    if (registry.indexOf(this) < 0) {\n      registry.push(this);\n    }\n  };\n\n  /**\n   * Removes the instance from the global IntersectionObserver registry.\n   * @private\n   */\n  IntersectionObserver.prototype._unregisterInstance = function () {\n    var index = registry.indexOf(this);\n    if (index != -1) registry.splice(index, 1);\n  };\n\n  /**\n   * Returns the result of the performance.now() method or null in browsers\n   * that don't support the API.\n   * @return {number} The elapsed time since the page was requested.\n   */\n  function now() {\n    return window.performance && performance.now && performance.now();\n  }\n\n  /**\n   * Throttles a function and delays its execution, so it's only called at most\n   * once within a given time period.\n   * @param {Function} fn The function to throttle.\n   * @param {number} timeout The amount of time that must pass before the\n   *     function can be called again.\n   * @return {Function} The throttled function.\n   */\n  function throttle(fn, timeout) {\n    var timer = null;\n    return function () {\n      if (!timer) {\n        timer = setTimeout(function () {\n          fn();\n          timer = null;\n        }, timeout);\n      }\n    };\n  }\n\n  /**\n   * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n   * @param {Node} node The DOM node to add the event handler to.\n   * @param {string} event The event name.\n   * @param {Function} fn The event handler to add.\n   * @param {boolean} opt_useCapture Optionally adds the even to the capture\n   *     phase. Note: this only works in modern browsers.\n   */\n  function addEvent(node, event, fn, opt_useCapture) {\n    if (typeof node.addEventListener == 'function') {\n      node.addEventListener(event, fn, opt_useCapture || false);\n    } else if (typeof node.attachEvent == 'function') {\n      node.attachEvent('on' + event, fn);\n    }\n  }\n\n  /**\n   * Removes a previously added event handler from a DOM node.\n   * @param {Node} node The DOM node to remove the event handler from.\n   * @param {string} event The event name.\n   * @param {Function} fn The event handler to remove.\n   * @param {boolean} opt_useCapture If the event handler was added with this\n   *     flag set to true, it should be set to true here in order to remove it.\n   */\n  function removeEvent(node, event, fn, opt_useCapture) {\n    if (typeof node.removeEventListener == 'function') {\n      node.removeEventListener(event, fn, opt_useCapture || false);\n    } else if (typeof node.detatchEvent == 'function') {\n      node.detatchEvent('on' + event, fn);\n    }\n  }\n\n  /**\n   * Returns the intersection between two rect objects.\n   * @param {Object} rect1 The first rect.\n   * @param {Object} rect2 The second rect.\n   * @return {?Object|?ClientRect} The intersection rect or undefined if no\n   *     intersection is found.\n   */\n  function computeRectIntersection(rect1, rect2) {\n    var top = Math.max(rect1.top, rect2.top);\n    var bottom = Math.min(rect1.bottom, rect2.bottom);\n    var left = Math.max(rect1.left, rect2.left);\n    var right = Math.min(rect1.right, rect2.right);\n    var width = right - left;\n    var height = bottom - top;\n\n    return width >= 0 && height >= 0 && {\n      top: top,\n      bottom: bottom,\n      left: left,\n      right: right,\n      width: width,\n      height: height\n    } || null;\n  }\n\n  /**\n   * Shims the native getBoundingClientRect for compatibility with older IE.\n   * @param {Element} el The element whose bounding rect to get.\n   * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\n   */\n  function getBoundingClientRect(el) {\n    var rect;\n\n    try {\n      rect = el.getBoundingClientRect();\n    } catch (err) {\n      // Ignore Windows 7 IE11 \"Unspecified error\"\n      // https://github.com/w3c/IntersectionObserver/pull/205\n    }\n\n    if (!rect) return getEmptyRect();\n\n    // Older IE\n    if (!(rect.width && rect.height)) {\n      rect = {\n        top: rect.top,\n        right: rect.right,\n        bottom: rect.bottom,\n        left: rect.left,\n        width: rect.right - rect.left,\n        height: rect.bottom - rect.top\n      };\n    }\n    return rect;\n  }\n\n  /**\n   * Returns an empty rect object. An empty rect is returned when an element\n   * is not in the DOM.\n   * @return {ClientRect} The empty rect.\n   */\n  function getEmptyRect() {\n    return {\n      top: 0,\n      bottom: 0,\n      left: 0,\n      right: 0,\n      width: 0,\n      height: 0\n    };\n  }\n\n  /**\n   * Ensure that the result has all of the necessary fields of the DOMRect.\n   * Specifically this ensures that `x` and `y` fields are set.\n   *\n   * @param {?DOMRect|?ClientRect} rect\n   * @return {?DOMRect}\n   */\n  function ensureDOMRect(rect) {\n    // A `DOMRect` object has `x` and `y` fields.\n    if (!rect || 'x' in rect) {\n      return rect;\n    }\n    // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\n    // for internally calculated Rect objects. For the purposes of\n    // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\n    // for these fields.\n    return {\n      top: rect.top,\n      y: rect.top,\n      bottom: rect.bottom,\n      left: rect.left,\n      x: rect.left,\n      right: rect.right,\n      width: rect.width,\n      height: rect.height\n    };\n  }\n\n  /**\n   * Inverts the intersection and bounding rect from the parent (frame) BCR to\n   * the local BCR space.\n   * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\n   * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\n   * @return {ClientRect} The local root bounding rect for the parent's children.\n   */\n  function convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\n    var top = parentIntersectionRect.top - parentBoundingRect.top;\n    var left = parentIntersectionRect.left - parentBoundingRect.left;\n    return {\n      top: top,\n      left: left,\n      height: parentIntersectionRect.height,\n      width: parentIntersectionRect.width,\n      bottom: top + parentIntersectionRect.height,\n      right: left + parentIntersectionRect.width\n    };\n  }\n\n  /**\n   * Checks to see if a parent element contains a child element (including inside\n   * shadow DOM).\n   * @param {Node} parent The parent element.\n   * @param {Node} child The child element.\n   * @return {boolean} True if the parent node contains the child node.\n   */\n  function containsDeep(parent, child) {\n    var node = child;\n    while (node) {\n      if (node == parent) return true;\n\n      node = getParentNode(node);\n    }\n    return false;\n  }\n\n  /**\n   * Gets the parent node of an element or its host element if the parent node\n   * is a shadow root.\n   * @param {Node} node The node whose parent to get.\n   * @return {Node|null} The parent node or null if no parent exists.\n   */\n  function getParentNode(node) {\n    var parent = node.parentNode;\n\n    if (node.nodeType == /* DOCUMENT */9 && node != document) {\n      // If this node is a document node, look for the embedding frame.\n      return getFrameElement(node);\n    }\n\n    if (parent && parent.nodeType == 11 && parent.host) {\n      // If the parent is a shadow root, return the host element.\n      return parent.host;\n    }\n\n    if (parent && parent.assignedSlot) {\n      // If the parent is distributed in a <slot>, return the parent of a slot.\n      return parent.assignedSlot.parentNode;\n    }\n\n    return parent;\n  }\n\n  // Exposes the constructors globally.\n  window.IntersectionObserver = IntersectionObserver;\n  window.IntersectionObserverEntry = IntersectionObserverEntry;\n})();\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// article-video-loop-bundle-v2-b6f6769c83bf51fb0f0a.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/static/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 41);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap ef783f40e3a096e0ced5","export * from './async';\nexport * from './error';\nexport * from './is';\nexport * from './logger';\nexport * from './memo';\nexport * from './misc';\nexport * from './object';\nexport * from './path';\nexport * from './promisebuffer';\nexport * from './string';\nexport * from './supports';\nexport * from './syncpromise';\nexport * from './instrument';\nexport * from './dsn';\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/index.js","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/tslib/tslib.es6.js","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n  return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n  return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n  return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n  return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  var result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n  return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n  return typeof val === 'number';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n  return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n  return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n  return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n  return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n  return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n  return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n  return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n */\nfunction isStandardBrowserEnv() {\n  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||\n                                           navigator.product === 'NativeScript' ||\n                                           navigator.product === 'NS')) {\n    return false;\n  }\n  return (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined'\n  );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (var i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        fn.call(null, obj[key], key, obj);\n      }\n    }\n  }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (typeof result[key] === 'object' && typeof val === 'object') {\n      result[key] = merge(result[key], val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Function equal to merge with the difference being that no reference\n * to original objects is kept.\n *\n * @see merge\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction deepMerge(/* obj1, obj2, obj3, ... */) {\n  var result = {};\n  function assignValue(val, key) {\n    if (typeof result[key] === 'object' && typeof val === 'object') {\n      result[key] = deepMerge(result[key], val);\n    } else if (typeof val === 'object') {\n      result[key] = deepMerge({}, val);\n    } else {\n      result[key] = val;\n    }\n  }\n\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n  forEach(b, function assignValue(val, key) {\n    if (thisArg && typeof val === 'function') {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  });\n  return a;\n}\n\nmodule.exports = {\n  isArray: isArray,\n  isArrayBuffer: isArrayBuffer,\n  isBuffer: isBuffer,\n  isFormData: isFormData,\n  isArrayBufferView: isArrayBufferView,\n  isString: isString,\n  isNumber: isNumber,\n  isObject: isObject,\n  isUndefined: isUndefined,\n  isDate: isDate,\n  isFile: isFile,\n  isBlob: isBlob,\n  isFunction: isFunction,\n  isStream: isStream,\n  isURLSearchParams: isURLSearchParams,\n  isStandardBrowserEnv: isStandardBrowserEnv,\n  forEach: forEach,\n  merge: merge,\n  deepMerge: deepMerge,\n  extend: extend,\n  trim: trim\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/utils.js","export { addBreadcrumb, captureException, captureEvent, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, withScope, } from '@sentry/minimal';\nexport { addGlobalEventProcessor, getCurrentHub, getHubFromCarrier, Hub, Scope } from '@sentry/hub';\nexport { API } from './api';\nexport { BaseClient } from './baseclient';\nexport { BaseBackend } from './basebackend';\nexport { initAndBind } from './sdk';\nexport { NoopTransport } from './transports/noop';\nimport * as Integrations from './integrations';\nexport { Integrations };\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/index.js","export { LogLevel } from './loglevel';\nexport { Severity } from './severity';\nexport { SpanStatus } from './span';\nexport { Status } from './status';\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/types/esm/index.js","/**\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)\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    // tslint:disable-next-line:strict-type-predicates\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    // tslint:disable-next-line:strict-type-predicates\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    // tslint:disable:no-unsafe-any\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n    // tslint:enable:no-unsafe-any\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    // tslint:disable-next-line:no-unsafe-any\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        // tslint:disable-next-line:no-unsafe-any\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/is.js","export { addGlobalEventProcessor, Scope } from './scope';\nexport { getCurrentHub, getHubFromCarrier, getMainCarrier, Hub, makeMain, setHubOnCarrier } from './hub';\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/hub/esm/index.js","import { isString } from './is';\nimport { snipLine } from './string';\n/**\n * Requires a module which is protected _against bundler minification.\n *\n * @param request The module path to resolve\n */\nexport function dynamicRequire(mod, request) {\n    // tslint:disable-next-line: no-unsafe-any\n    return mod.require(request);\n}\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    // tslint:disable:strict-type-predicates\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\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        // tslint:disable-next-line:no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // tslint: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        // tslint:disable-next-line:no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // tslint: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    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\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\n        // tslint:disable: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\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/**\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        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    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 attrWhitelist = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < attrWhitelist.length; i++) {\n        key = attrWhitelist[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n/**\n * Returns a timestamp in seconds with milliseconds precision.\n */\nexport function timestampWithMs() {\n    return new Date().getTime() / 1000;\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}\nvar 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/**\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//# sourceMappingURL=misc.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/misc.js","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/process/browser.js","/*!\n  * domready (c) Dustin Diaz 2014 - License MIT\n  */\n!function (name, definition) {\n\n  if (typeof module != 'undefined') module.exports = definition()\n  else if (typeof define == 'function' && typeof define.amd == 'object') define(definition)\n  else this[name] = definition()\n\n}('domready', function () {\n\n  var fns = [], listener\n    , doc = document\n    , hack = doc.documentElement.doScroll\n    , domContentLoaded = 'DOMContentLoaded'\n    , loaded = (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState)\n\n\n  if (!loaded)\n  doc.addEventListener(domContentLoaded, listener = function () {\n    doc.removeEventListener(domContentLoaded, listener)\n    loaded = 1\n    while (listener = fns.shift()) listener()\n  })\n\n  return function (fn) {\n    loaded ? setTimeout(fn, 0) : fns.push(fn)\n  }\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/domready/ready.js","export function nodelistToArray (nodeList) {\n  return [].slice.call(nodeList)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/nodelistToArray.js","export function uuid () {\n  return `_${Math.random().toString(36).substr(2, 9)}`\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/uuid.js","import * as tslib_1 from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    tslib_1.__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        // tslint:disable:no-unsafe-any\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/error.js","import { 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(' ')); // tslint:disable-line:no-console\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(' ')); // tslint:disable-line:no-console\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(' ')); // tslint:disable-line:no-console\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/logger.js","import { isRegExp } 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\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    // tslint:disable-next-line:strict-type-predicates\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        colno = ll; // tslint:disable-line:no-parameter-reassignment\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 */\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // tslint:disable-next-line: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 (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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/string.js","// tslint:disable:object-literal-sort-keys\nimport * as tslib_1 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).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js))(?::(\\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/** JSDoc */\nexport function computeStackTrace(ex) {\n    // tslint:disable:no-unsafe-any\n    var stack = null;\n    var popSize = ex && ex.framesToPop;\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// tslint:disable-next-line:cyclomatic-complexity\nfunction computeStackTraceFromStackProp(ex) {\n    // tslint:disable:no-conditional-assignment\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 */\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        // tslint:disable:no-conditional-assignment\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 tslib_1.__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 */\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/tracekit.js","import { API } from '@sentry/core';\nimport { 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        this.url = new API(this.options.dsn).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    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/transports/base.js","import * as tslib_1 from \"tslib\";\nimport { captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue } 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    // tslint:disable-next-line:strict-type-predicates\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    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        // tslint:disable:no-unsafe-any\n        try {\n            // tslint:disable-next-line:strict-type-predicates\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\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                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            // tslint:enable:no-unsafe-any\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = tslib_1.__assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = tslib_1.__assign({}, processedEvent.extra, { arguments: args });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // tslint: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    }\n    catch (_oO) {\n        /*no-empty*/\n    }\n    return sentryWrapped;\n}\n//# sourceMappingURL=helpers.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/helpers.js","module.exports = require('./lib/axios');\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/index.js","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n  return function wrap() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    return fn.apply(thisArg, args);\n  };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/bind.js","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%40/gi, '@').\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n\n  var serializedParams;\n  if (paramsSerializer) {\n    serializedParams = paramsSerializer(params);\n  } else if (utils.isURLSearchParams(params)) {\n    serializedParams = params.toString();\n  } else {\n    var parts = [];\n\n    utils.forEach(params, function serialize(val, key) {\n      if (val === null || typeof val === 'undefined') {\n        return;\n      }\n\n      if (utils.isArray(val)) {\n        key = key + '[]';\n      } else {\n        val = [val];\n      }\n\n      utils.forEach(val, function parseValue(v) {\n        if (utils.isDate(v)) {\n          v = v.toISOString();\n        } else if (utils.isObject(v)) {\n          v = JSON.stringify(v);\n        }\n        parts.push(encode(key) + '=' + encode(v));\n      });\n    });\n\n    serializedParams = parts.join('&');\n  }\n\n  if (serializedParams) {\n    var hashmarkIndex = url.indexOf('#');\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/buildURL.js","'use strict';\n\nmodule.exports = function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/cancel/isCancel.js","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar DEFAULT_CONTENT_TYPE = {\n  'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n    headers['Content-Type'] = value;\n  }\n}\n\nfunction getDefaultAdapter() {\n  var adapter;\n  if (typeof XMLHttpRequest !== 'undefined') {\n    // For browsers use XHR adapter\n    adapter = require('./adapters/xhr');\n  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {\n    // For node use HTTP adapter\n    adapter = require('./adapters/http');\n  }\n  return adapter;\n}\n\nvar defaults = {\n  adapter: getDefaultAdapter(),\n\n  transformRequest: [function transformRequest(data, headers) {\n    normalizeHeaderName(headers, 'Accept');\n    normalizeHeaderName(headers, 'Content-Type');\n    if (utils.isFormData(data) ||\n      utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n      return data.toString();\n    }\n    if (utils.isObject(data)) {\n      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n      return JSON.stringify(data);\n    }\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    /*eslint no-param-reassign:0*/\n    if (typeof data === 'string') {\n      try {\n        data = JSON.parse(data);\n      } catch (e) { /* Ignore */ }\n    }\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  }\n};\n\ndefaults.headers = {\n  common: {\n    'Accept': 'application/json, text/plain, */*'\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/defaults.js","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar buildFullPath = require('../core/buildFullPath');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\n\nmodule.exports = function xhrAdapter(config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    var requestData = config.data;\n    var requestHeaders = config.headers;\n\n    if (utils.isFormData(requestData)) {\n      delete requestHeaders['Content-Type']; // Let the browser set it\n    }\n\n    var request = new XMLHttpRequest();\n\n    // HTTP basic authentication\n    if (config.auth) {\n      var username = config.auth.username || '';\n      var password = config.auth.password || '';\n      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n    }\n\n    var fullPath = buildFullPath(config.baseURL, config.url);\n    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    // Listen for ready state\n    request.onreadystatechange = function handleLoad() {\n      if (!request || request.readyState !== 4) {\n        return;\n      }\n\n      // The request errored out and we didn't get a response, this will be\n      // handled by onerror instead\n      // With one exception: request that using file: protocol, most browsers\n      // will return status as 0 even though it's a successful request\n      if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n        return;\n      }\n\n      // Prepare the response\n      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n      var response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config: config,\n        request: request\n      };\n\n      settle(resolve, reject, response);\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(createError('Request aborted', config, 'ECONNABORTED', request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(createError('Network Error', config, null, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';\n      if (config.timeoutErrorMessage) {\n        timeoutErrorMessage = config.timeoutErrorMessage;\n      }\n      reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (utils.isStandardBrowserEnv()) {\n      var cookies = require('./../helpers/cookies');\n\n      // Add xsrf header\n      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?\n        cookies.read(config.xsrfCookieName) :\n        undefined;\n\n      if (xsrfValue) {\n        requestHeaders[config.xsrfHeaderName] = xsrfValue;\n      }\n    }\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n          // Remove Content-Type if data is undefined\n          delete requestHeaders[key];\n        } else {\n          // Otherwise add header to the request\n          request.setRequestHeader(key, val);\n        }\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(config.withCredentials)) {\n      request.withCredentials = !!config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (config.responseType) {\n      try {\n        request.responseType = config.responseType;\n      } catch (e) {\n        // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.\n        // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.\n        if (config.responseType !== 'json') {\n          throw e;\n        }\n      }\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', config.onDownloadProgress);\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', config.onUploadProgress);\n    }\n\n    if (config.cancelToken) {\n      // Handle cancellation\n      config.cancelToken.promise.then(function onCanceled(cancel) {\n        if (!request) {\n          return;\n        }\n\n        request.abort();\n        reject(cancel);\n        // Clean up request\n        request = null;\n      });\n    }\n\n    if (requestData === undefined) {\n      requestData = null;\n    }\n\n    // Send the request\n    request.send(requestData);\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/adapters/xhr.js","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, request, response) {\n  var error = new Error(message);\n  return enhanceError(error, config, code, request, response);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/createError.js","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n * @returns {Object} New object resulting from merging config2 to config1\n */\nmodule.exports = function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  var config = {};\n\n  var valueFromConfig2Keys = ['url', 'method', 'params', 'data'];\n  var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy'];\n  var defaultToConfig2Keys = [\n    'baseURL', 'url', 'transformRequest', 'transformResponse', 'paramsSerializer',\n    'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',\n    'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress',\n    'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent',\n    'httpsAgent', 'cancelToken', 'socketPath'\n  ];\n\n  utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {\n    if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    }\n  });\n\n  utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {\n    if (utils.isObject(config2[prop])) {\n      config[prop] = utils.deepMerge(config1[prop], config2[prop]);\n    } else if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    } else if (utils.isObject(config1[prop])) {\n      config[prop] = utils.deepMerge(config1[prop]);\n    } else if (typeof config1[prop] !== 'undefined') {\n      config[prop] = config1[prop];\n    }\n  });\n\n  utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {\n    if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    } else if (typeof config1[prop] !== 'undefined') {\n      config[prop] = config1[prop];\n    }\n  });\n\n  var axiosKeys = valueFromConfig2Keys\n    .concat(mergeDeepPropertiesKeys)\n    .concat(defaultToConfig2Keys);\n\n  var otherKeys = Object\n    .keys(config2)\n    .filter(function filterAxiosKeys(key) {\n      return axiosKeys.indexOf(key) === -1;\n    });\n\n  utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {\n    if (typeof config2[prop] !== 'undefined') {\n      config[prop] = config2[prop];\n    } else if (typeof config1[prop] !== 'undefined') {\n      config[prop] = config1[prop];\n    }\n  });\n\n  return config;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/mergeConfig.js","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n  this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n  return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/cancel/Cancel.js","import * as tslib_1 from \"tslib\";\nimport { getGlobalObject, isThenable, SyncPromise, timestampWithMs } 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._context = {};\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     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            setTimeout(function () {\n                _this._scopeListeners.forEach(function (callback) {\n                    callback(_this);\n                });\n                _this._notifyingListeners = false;\n            });\n        }\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            // tslint:disable-next-line:strict-type-predicates\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(tslib_1.__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     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = tslib_1.__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 = tslib_1.__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 = tslib_1.__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 = tslib_1.__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.setTransaction = function (transaction) {\n        this._transaction = transaction;\n        if (this._span) {\n            this._span.transaction = transaction;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        this._context = tslib_1.__assign({}, this._context, (_a = {}, _a[key] = context, _a));\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     * Internal getter for Span, used in Hub.\n     * @hidden\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\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 = tslib_1.__spread(scope._breadcrumbs);\n            newScope._tags = tslib_1.__assign({}, scope._tags);\n            newScope._extra = tslib_1.__assign({}, scope._extra);\n            newScope._context = tslib_1.__assign({}, scope._context);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._transaction = scope._transaction;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = tslib_1.__spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._context = {};\n        this._level = undefined;\n        this._transaction = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestampWithMs() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? tslib_1.__spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : tslib_1.__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 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    /**\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        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = tslib_1.__assign({}, this._extra, event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = tslib_1.__assign({}, this._tags, event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = tslib_1.__assign({}, this._user, event.user);\n        }\n        if (this._context && Object.keys(this._context).length) {\n            event.contexts = tslib_1.__assign({}, this._context, event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transaction) {\n            event.transaction = this._transaction;\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = tslib_1.__spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(tslib_1.__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/hub/esm/scope.js","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/global.js","// tslint:disable:no-unsafe-any\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        // tslint:disable-next-line\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        // tslint:disable-next-line: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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/memo.js","import { isElement, isError, isEvent, isInstanceOf, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName, htmlTreeAsString } from './misc';\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 replacement A function that should be used to wrap a given method.\n * @returns void\n */\nexport function fill(source, name, replacement) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacement(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    // tslint:disable-next-line:strict-type-predicates\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(\n    // tslint:disable-next-line:no-unsafe-any\n    function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all it's attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order 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        // tslint:disable-next-line:strict-type-predicates\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    // tslint: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/** Transforms any input value into a string form, either primitive value or a type of the input */\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 */\n// tslint:disable-next-line:cyclomatic-complexity\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    // tslint:disable-next-line:no-tautology-expression\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    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 */\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    // If value implements `toJSON` method, call it and return early\n    // tslint:disable:no-unsafe-any\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    // tslint:enable:no-unsafe-any\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 */\nexport function normalize(input, depth) {\n    try {\n        // tslint:disable-next-line:no-unsafe-any\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 */\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    // tslint:disable:strict-type-predicates\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//# sourceMappingURL=object.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/object.js","import { 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            if (_this._state === States.REJECTED) {\n                _this._handlers.forEach(function (handler) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                });\n            }\n            else {\n                _this._handlers.forEach(function (handler) {\n                    if (handler.onfulfilled) {\n                        // tslint:disable-next-line:no-unsafe-any\n                        handler.onfulfilled(_this._value);\n                    }\n                });\n            }\n            _this._handlers = [];\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\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                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                // tslint:disable-next-line:no-unsafe-any\n                resolve(val);\n            });\n        });\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/syncpromise.js","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        // tslint:disable:no-unused-expression\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        // It really needs 1 argument, not 0.\n        // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n        // 1 argument required, but only 0 present.\n        // @ts-ignore\n        // tslint:disable:no-unused-expression\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        // tslint:disable:no-unused-expression\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        // tslint:disable-next-line:no-unused-expression\n        new Headers();\n        // tslint:disable-next-line:no-unused-expression\n        new Request('');\n        // tslint:disable-next-line:no-unused-expression\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 */\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    // tslint:disable-next-line:no-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    if (doc) {\n        var sandbox = doc.createElement('iframe');\n        sandbox.hidden = true;\n        try {\n            doc.head.appendChild(sandbox);\n            if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                // tslint:disable-next-line:no-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    // tslint:disable-next-line: no-unsafe-any\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        // tslint:disable:no-unused-expression\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    var chrome = global.chrome;\n    // tslint:disable-next-line:no-unsafe-any\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/supports.js","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// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/transports/noop.js","import * as tslib_1 from \"tslib\";\nimport { API, BaseClient } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\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    tslib_1.__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     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = tslib_1.__assign({}, event.sdk, { name: SDK_NAME, packages: tslib_1.__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     * 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 is disabled');\n            return;\n        }\n        var dsn = options.dsn || this.getDsn();\n        if (!options.eventId) {\n            logger.error('Missing `eventId` option in showReportDialog call');\n            return;\n        }\n        if (!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(dsn).getReportDialogEndpoint(options);\n        if (options.onLoad) {\n            script.onload = options.onLoad;\n        }\n        (document.head || document.body).appendChild(script);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/client.js","import { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/** JSDoc */\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        exception = errorEvent.error; // tslint:disable-line:no-parameter-reassignment\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 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        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// this._options.attachStacktrace\n/** JSDoc */\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/eventbuilder.js","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    // tslint:disable-next-line:strict-type-predicates\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        .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        .slice(0, STACKTRACE_LIMIT)\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/parsers.js","export { BaseTransport } from './base';\nexport { FetchTransport } from './fetch';\nexport { XHRTransport } from './xhr';\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/transports/index.js","export var SDK_NAME = 'sentry.javascript.browser';\nexport var SDK_VERSION = '5.12.1';\n//# sourceMappingURL=version.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/version.js","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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/integrations/index.js","import domready from 'domready'\nimport { nodelistToArray } from '../lib/nodelistToArray'\nimport { uuid } from '../lib/uuid'\nimport levendeStillbilde from '@nrk/dh-basis-levende-stillbilde'\nimport { ElementIntersectionObserver } from '@nrk/dh-basis-common'\nimport styles from './components/VideoLoop.css'\nimport * as Sentry from '@sentry/browser'\n\nconst rootElementClassName = 'article-levende-stillbilde-root'\n\nwindow[rootElementClassName] = window[rootElementClassName] || {}\nwindow.isDhSentryInitiated = false\n\nconst VIEWPORT_POSITION_ATTR = 'data-viewport-position'\n\nfunction init () {\n  if (!window.isDhSentryInitiated) {\n    initSentry()\n  }\n  initCustomElements()\n\n  const elementsArray = nodelistToArray(document.getElementsByClassName(rootElementClassName))\n  elementsArray\n    .filter(el => !isInitialized(el))\n    .forEach(el => {\n      el.id = uuid()\n      window[rootElementClassName][el.id] = true\n\n      // Extract preloaded state sent from server\n      const preloadedState = JSON.parse(el.getAttribute('data-preloaded-state'))\n      mount(el, preloadedState)\n    })\n}\n\nfunction mount (el, preloadedState) {\n  try {\n    // Checks to see whether or not the video element is inside the a feature article cover\n    const insideCover = Boolean(document.querySelector(`.article-feature__cover #${el.id}`))\n    const captionEl = document.querySelector(`#${el.id} [data-caption]`)\n    if (insideCover && captionEl) {\n      captionEl.parentNode.replaceChild(\n        headingCaption(preloadedState.altText, preloadedState.byline),\n        captionEl\n      )\n    }\n\n    const videoWrapperElement = el.querySelector('.dh-video-wrapper')\n\n    // eslint-disable-next-line no-unused-vars\n    const elementObserver = new ElementIntersectionObserver([videoWrapperElement], (intersections) => {\n      const element = intersections[0]\n      const elementViewportPosition = videoWrapperElement.getAttribute(VIEWPORT_POSITION_ATTR)\n      if (element.isIntersecting && elementViewportPosition === 'OUT-OF-VIEWPORT') {\n        videoWrapperElement.setAttribute(VIEWPORT_POSITION_ATTR, 'IN-VIEWPORT')\n      }\n      if (!element.isIntersecting && elementViewportPosition === 'IN-VIEWPORT') {\n        videoWrapperElement.setAttribute(VIEWPORT_POSITION_ATTR, 'OUT-OF-VIEWPORT')\n      }\n    })\n  } catch (err) {\n    // fail silently\n  }\n}\n\nfunction headingCaption (altText, byline) {\n  const captionContainer = document.createElement('div')\n  captionContainer.innerHTML = `<span class='nrk-sr'>${altText}</span><span>${byline}</span>`\n  captionContainer.setAttribute('class', styles['byline'])\n  captionContainer.setAttribute('data-caption', true)\n  return captionContainer\n}\n\nfunction initSentry () {\n  Sentry.init({\n    dsn: 'https://61a06075b4944857a732bd9ae155c639@sentry.io/2432586',\n    sampleRate: 0.3\n  })\n  window.isDhSentryInitiated = true\n}\n\nfunction initCustomElements () {\n  if (typeof customElements.get('dh-lvs-basis-levende-stillbilde') === 'undefined') {\n    customElements.define('dh-lvs-basis-levende-stillbilde', levendeStillbilde)\n  }\n}\n\nfunction isInitialized (el) {\n  return el.id && window[rootElementClassName][el.id]\n}\n\ndomready(() => {\n  if (!('customElements' in window)) {\n    require('@webcomponents/custom-elements')\n  }\n  if (!('IntersectionObserver' in window)) {\n    require('intersection-observer')\n  }\n  init()\n})\n\n\n\n// WEBPACK FOOTER //\n// ./src/article/client.videoLoop.js","import { testReducedMotion, toArray, toggleAttribute } from '@nrk/dh-basis-common';\n\nvar STATE_ATTR = 'data-state';\nvar VIEWPORT_POSITION_ATTR = 'data-viewport-position';\nvar DISABLE_FORCED_ATTRIBUTES_ATTR = 'disable-forced-attributes';\nvar IS_PAUSED = 'is-paused';\nvar AUTOPLAY_BLOCKED = 'autoplay-blocked';\n\nvar isVisible = child => child.offsetWidth > 0 || child.offsetHeight > 0;\n\nclass LevendeStillbilde extends HTMLElement {\n  constructor() {\n    super(...arguments);\n    this._disconnecting = false;\n\n    this._handlePlayChange = () => {\n      this.isPaused = this.visibleVideoElement.paused;\n    };\n\n    this._updatePlayState = () => {\n      if (!this.visibleVideoElement) {\n        return;\n      }\n\n      if (this._shouldPlay()) {\n        this._playVideo();\n      } else {\n        this._pauseVideo();\n      }\n    };\n\n    this._handleResize = () => {\n      this._updatePlayState();\n\n      this._preload();\n    };\n  }\n\n  static get observedAttributes() {\n    return [STATE_ATTR, DISABLE_FORCED_ATTRIBUTES_ATTR, VIEWPORT_POSITION_ATTR];\n  }\n\n  connectedCallback() {\n    this._setVideoAttributes();\n\n    this._setEventListeners();\n\n    this._updatePlayState();\n  }\n\n  disconnectedCallback() {\n    this._disconnecting = true;\n\n    this._removeEventListeners();\n  }\n\n  attributeChangedCallback(name, prevValue, newValue) {\n    var reducedMotion = testReducedMotion();\n    var valueChanged = prevValue !== newValue;\n\n    if ((name === STATE_ATTR || name === VIEWPORT_POSITION_ATTR) && !reducedMotion) {\n      if (valueChanged) {\n        this._updatePlayState();\n\n        if (name === VIEWPORT_POSITION_ATTR && newValue === 'IN-VIEWPORT') {\n          this._preload();\n        }\n      }\n    }\n  }\n\n  _setEventListeners() {\n    window.addEventListener('resize', this._handleResize);\n    this.videoElements.forEach(el => {\n      el.addEventListener('pause', this._handlePlayChange);\n      el.addEventListener('play', this._handlePlayChange);\n      el.addEventListener('loadedmetadata', this._updatePlayState);\n    });\n  }\n\n  _removeEventListeners() {\n    window.removeEventListener('resize', this._handleResize);\n    this.videoElements.forEach(el => {\n      el.removeEventListener('pause', this._handlePlayChange);\n      el.removeEventListener('play', this._handlePlayChange);\n      el.removeEventListener('loadedmetadata', this._updatePlayState);\n    });\n  }\n\n  _setVideoAttributes() {\n    if (!this.disableForcedAttributes) {\n      this.videoElements.forEach(el => {\n        el.setAttribute('playsInline', '');\n        el.setAttribute('loop', '');\n        el.setAttribute('disableRemotePlayback', '');\n        el.setAttribute('x-webkit-airplay', 'deny');\n      });\n    }\n  }\n\n  _shouldPlay() {\n    return this.visibleVideoElement.readyState >= 1 && this.state === 'ACTIVE' && this.viewportPosition === 'IN-VIEWPORT';\n  }\n\n  _preload() {\n    if (this.visibleVideoElement.getAttribute('preload') !== 'auto') {\n      this.visibleVideoElement.setAttribute('preload', 'auto');\n    }\n  }\n\n  _playVideo() {\n    var videoElement = this.visibleVideoElement;\n\n    if (videoElement.paused && !this.autoplayBlocked) {\n      var playPromise = videoElement.play() || Promise.resolve();\n      playPromise.catch(e => {\n        console.error(e);\n        this.autoplayBlocked = true;\n      });\n    }\n  }\n\n  _pauseVideo() {\n    var videoElement = this.visibleVideoElement;\n\n    if (!videoElement.paused) {\n      videoElement.pause();\n    }\n  }\n\n  get visibleVideoElement() {\n    return this.videoElements.find(isVisible);\n  }\n\n  get videoElements() {\n    return toArray(this.querySelectorAll('video'));\n  }\n\n  get disableForcedAttributes() {\n    return this.hasAttribute(DISABLE_FORCED_ATTRIBUTES_ATTR);\n  }\n\n  get state() {\n    return this.getAttribute(STATE_ATTR);\n  }\n\n  set state(val) {\n    this.setAttribute(STATE_ATTR, val);\n  }\n\n  get isPaused() {\n    return this.getAttribute(IS_PAUSED);\n  }\n\n  set isPaused(val) {\n    if (val) {\n      this.setAttribute(IS_PAUSED, '');\n    } else {\n      this.removeAttribute(IS_PAUSED);\n    }\n  }\n\n  get autoplayBlocked() {\n    return this.hasAttribute(AUTOPLAY_BLOCKED) || false;\n  }\n\n  set autoplayBlocked(val) {\n    toggleAttribute(this, AUTOPLAY_BLOCKED, val);\n  }\n\n  get viewportPosition() {\n    return this.getAttribute(VIEWPORT_POSITION_ATTR);\n  }\n\n  set viewportPosition(val) {\n    this.setAttribute(VIEWPORT_POSITION_ATTR, val);\n  }\n\n}\n\nexport default LevendeStillbilde;\n//# sourceMappingURL=dh-basis-levende-stillbilde.esm.js.map\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@nrk/dh-basis-levende-stillbilde/dh-basis-levende-stillbilde.esm.js","import axios from 'axios';\n\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n/* eslint-disable compat/compat */\nvar defaultConfig = {\n  rootMargin: '0px 0px 0px 0px',\n  threshold: [0, 0.5, 1]\n};\nclass ElementIntersectionObserver {\n  constructor(elements, onChange, config) {\n    this.intersections = void 0;\n    this.elements = void 0;\n    this.elements = elements.slice(0);\n    this.intersections = elements.map(target => ({\n      target,\n      isIntersecting: false,\n      ratio: null\n    }));\n    this.intersectionObserver = new IntersectionObserver(entries => {\n      var intersections = this.intersections.slice(0);\n      entries.forEach(entry => {\n        var idx = elements.indexOf(entry.target);\n        intersections.splice(idx, 1, {\n          target: entry.target,\n          isIntersecting: entry.isIntersecting,\n          ratio: entry.intersectionRatio\n        });\n      });\n      this.intersections = intersections;\n      onChange(this.intersections);\n    }, _objectSpread2({}, defaultConfig, {}, config));\n    elements.forEach(elm => this.intersectionObserver.observe(elm));\n  }\n\n  disconnect() {\n    // Unregister trigger elements\n    this.elements.forEach(elm => this.intersectionObserver.unobserve(elm)); // Disconnect intersection observer\n\n    this.intersectionObserver.disconnect();\n  }\n\n}\n\nfunction toggleAttribute(el, name, boolValue) {\n  if (!el) {\n    return;\n  }\n\n  var nextValue;\n\n  if (typeof boolValue !== 'undefined') {\n    nextValue = !!boolValue;\n  } else {\n    nextValue = el.hasAttribute(name);\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, '');\n  } else {\n    el.removeAttribute(name);\n  }\n}\nfunction setAttribute(el, name, nextValue) {\n  if (!el) {\n    return;\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, nextValue);\n  } else {\n    el.removeAttribute(name);\n  }\n}\nvar closest = (() => {\n  var proto = typeof window === 'undefined' ? {} : window.Element.prototype;\n  var match = proto.matches || proto.msMatchesSelector || proto.webkitMatchesSelector;\n\n  if (proto.closest) {\n    return (el, css) => el.closest(css);\n  } else {\n    return (el, css) => {\n      for (; el; el = el.parentElement) {\n        if (match.call(el, css)) return el;\n      }\n\n      return null;\n    };\n  }\n})();\nfunction addStyle(nodeName, css) {\n  var key = \"style-\".concat(nodeName.toLowerCase());\n  var min = css.replace(/\\/\\*[^!][^*]*\\*\\//g, '').replace(/\\s*(^|[:;,{}]|$)\\s*/g, '$1');\n  document.getElementById(key) || document.head.insertAdjacentHTML('afterbegin', \"<style id=\\\"\".concat(key, \"\\\">\").concat(min, \"</style>\"));\n}\nfunction toArray(nodeList) {\n  return [].slice.call(nodeList);\n}\nfunction dispatchEvent(element, name) {\n  var detail = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var ignore = \"prevent_recursive_dispatch_maximum_callstack\".concat(name);\n  var event;\n  if (element[ignore]) return true; // We are already processing this event, so skip sending a new one\n  else element[ignore] = true; // Add name to dispatching ignore\n\n  if (typeof window.CustomEvent === 'function') {\n    event = new window.CustomEvent(name, {\n      bubbles: true,\n      cancelable: true,\n      detail\n    });\n  } else {\n    event = document.createEvent('CustomEvent');\n    event.initCustomEvent(name, true, true, detail);\n  } // IE reports incorrect event.defaultPrevented\n  // but correct return value on element.dispatchEvent\n\n\n  var result = element.dispatchEvent(event);\n  element[ignore] = null; // Remove name from dispatching ignore\n\n  return result; // Follow W3C standard for return value\n}\n\nfunction easeOutQuint(t) {\n  return 1 + --t * t * t * t * t;\n}\n\nclass VerticalScroll {\n  constructor(container) {\n    this.container = void 0;\n    this.container = container;\n  }\n\n  to(top) {\n    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    var from = this.container.scrollTop;\n    var distance = top - from;\n    var startTime = null;\n\n    var loop = currentTime => {\n      if (!startTime) {\n        startTime = currentTime - 1;\n      }\n\n      var timeElapsed = currentTime - startTime;\n      this.container.scrollTop = from + distance * easeOutQuint(timeElapsed / duration);\n\n      if (timeElapsed < duration) {\n        window.requestAnimationFrame(loop);\n      } else {\n        this.container.scrollTop = top;\n      }\n    };\n\n    window.requestAnimationFrame(loop);\n  }\n\n}\nclass HorizontalScroll {\n  constructor(container) {\n    this.container = void 0;\n    this.container = container;\n  }\n\n  to(left) {\n    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    var callback = arguments.length > 2 ? arguments[2] : undefined;\n    var from = this.container.scrollLeft;\n    var distance = left - from;\n    var startTime = null;\n\n    var loop = currentTime => {\n      if (!startTime) {\n        startTime = currentTime - 1;\n      }\n\n      var timeElapsed = currentTime - startTime;\n      this.container.scrollLeft = from + distance * easeOutQuint(timeElapsed / duration);\n\n      if (timeElapsed < duration) {\n        window.requestAnimationFrame(loop);\n      } else {\n        this.container.scrollLeft = left;\n        callback && callback();\n      }\n    };\n\n    window.requestAnimationFrame(loop);\n  }\n\n}\n\nfunction testReducedMotion() {\n  if (typeof window !== 'undefined') {\n    return !!window.matchMedia && window.matchMedia('(prefers-reduced-motion)').matches;\n  }\n\n  return false;\n}\n\nvar name = process.env.npm_package_name;\nvar version = process.env.npm_package_version;\n\nfunction createGqlApi() {\n  return {\n    get(query, url) {\n      return _asyncToGenerator(function* () {\n        var {\n          data,\n          errors\n        } = yield axios({\n          method: 'POST',\n          url,\n          data: {\n            query,\n            variables: null\n          },\n          timeout: 7500,\n          headers: {\n            'User-Agent': \"\".concat(name, \"/\").concat(version, \" (node/isomorphic-fetch)\"),\n            'Content-Type': 'application/json',\n            Accept: 'application/json'\n          }\n        }).then(res => res.data);\n\n        if (errors && errors.length) {\n          throw Error(errors);\n        }\n\n        return transformResponse(data);\n      })();\n    }\n\n  };\n}\n\nvar gqlApi = createGqlApi();\n\nfunction pngFragment(options) {\n  var aspects = options.aspectRatios.map(ratio => {\n    var sizes = ratio.sizes.map(s => \"w\".concat(s, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(s, \", format: png)\")).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsPng on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n\nfunction jpgFragment(options) {\n  var aspects = options.aspectRatios.map(ratio => {\n    var sizes = ratio.sizes.map(size => \"w\".concat(size, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(size, \")\")).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsJpg on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n/**\n * Transforms a series of image sections to a Polopoly GraphQL API query\n */\n\n\nfunction createQuery(imageObjects, options) {\n  var images = getImageIds(imageObjects);\n  return \"\\n    \".concat(createBase(images, options), \"\\n    query {\\n      \").concat(images.map(getImage).join('\\n'), \"\\n    }\");\n}\nvar IMAGE_PROPS = ['vertical', 'horizontal'];\n\nfunction getImageIds(imageObjects) {\n  if (imageObjects.some(image => !image)) {\n    throw new Error('Undefined image object');\n  }\n\n  return imageObjects.reduce((result, image) => {\n    var format = image.format || image.advanced && image.advanced.format || 'jpg';\n    /* Image can be stored directly on image object */\n\n    if (image.id && !result.find(el => el.id === image.id)) {\n      result.push({\n        id: image.id,\n        format\n      });\n    }\n    /* or on a predefined set of image properties */\n\n\n    IMAGE_PROPS.forEach(prop => {\n      var value = image[prop];\n\n      if (value && value.id && !result.find(el => el.id === value.id)) {\n        result.push({\n          id: value.id,\n          format\n        });\n      }\n    });\n    return result;\n  }, []);\n}\n\nfunction getImage(_ref) {\n  var {\n    id,\n    format = 'jpg'\n  } = _ref;\n\n  if (format === 'png') {\n    return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n      ...imageCropsPng\\n    }\");\n  }\n\n  return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n    ...imageCropsJpg\\n  }\");\n}\n\nfunction createBase(imageObjects, options) {\n  var containsJpg = imageObjects.filter(el => el.format === 'jpg').length > 0;\n  var containsPng = imageObjects.filter(el => el.format === 'png').length > 0;\n  return \"\\n    \".concat(containsJpg ? jpgFragment(options) : '', \"\\n    \").concat(containsPng ? pngFragment(options) : '', \"\\n  \");\n}\n/**\n * Transforns a polopoly id to something that can be used as a key in a GraphQL query\n * Example: '1.14252981' -> 'id_1_14252981'\n */\n\n\nfunction transformId(id) {\n  return \"id\".concat(id.replace(/\\./g, '__'));\n}\n/**\n * Transforns an already transformed polopoly id back to a regular polopoly id\n * Example: ''id_1_14252981' -> 1.14252981'\n */\n\n\nfunction transformBackId(id) {\n  return id.replace('id', '').replace(/__/g, '.');\n}\n\nfunction transformResponse(response) {\n  return Object.keys(response).reduce((res, key) => {\n    var transformedKey = transformBackId(key);\n    res[transformedKey] = response[key];\n    return res;\n  }, {});\n}\n\nfunction fromEntries(items) {\n  return [...items].reduce((obj, _ref) => {\n    var [key, val] = _ref;\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nfunction traverse(obj, filter) {\n  var matches = [];\n\n  if (filter(obj)) {\n    /* Object is a match, returning */\n    matches.push(obj);\n  }\n\n  return [...matches, ...Object.entries(obj).filter((_ref2) => {\n    var [_, value] = _ref2;\n    return !!value;\n  }).map((_ref3) => {\n    var [_, value] = _ref3;\n\n    if (Array.isArray(value)) {\n      return value.map(item => traverse(item, filter)).reduce((acc, val) => acc.concat(val), []);\n    } else if (typeof value === 'object') {\n      return traverse(value, filter);\n    } else {\n      return null;\n    }\n  }).reduce((acc, val) => acc.concat(val), []).filter(Boolean)];\n}\n/*\n * Traverses the props tree and fetches data for all image objects\n * */\n\n\nfunction prefetchImageData(_x, _x2) {\n  return _prefetchImageData.apply(this, arguments);\n}\n\nfunction _prefetchImageData() {\n  _prefetchImageData = _asyncToGenerator(function* (props, options) {\n    var imageObjects = traverse(props, value => value.type && value.type.startsWith('image'));\n\n    if (imageObjects.length > 0) {\n      if (!options.gqlApiUrl) {\n        throw new Error(\"Missing option 'gqlApiUrl'\");\n      }\n\n      var query = createQuery(imageObjects, options);\n      return gqlApi.get(query, options.gqlApiUrl);\n    }\n  });\n  return _prefetchImageData.apply(this, arguments);\n}\n\nvar imageProps = ['vertical', 'horizontal'];\nfunction mergeImageProps(props, imageUrls) {\n  if ('id' in props) {\n    return _objectSpread2({}, props, {}, imageUrls[props.id]);\n  } else {\n    return fromEntries(Object.entries(props).map((_ref4) => {\n      var [key, value] = _ref4;\n\n      if (imageProps.indexOf(key) !== -1) {\n        return [key, mergeImageProps(value, imageUrls)];\n      } else {\n        return [key, value];\n      }\n    }));\n  }\n}\n\nfunction mergeVideoloopProps(_x) {\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction _mergeVideoloopProps() {\n  _mergeVideoloopProps = _asyncToGenerator(function* (props) {\n    var objects = yield Promise.all(Object.keys(props).map(\n    /*#__PURE__*/\n    function () {\n      var _ref2 = _asyncToGenerator(function* (key) {\n        if (key === 'horizontal' || key === 'vertical') {\n          return _objectSpread2({\n            id: key\n          }, props[key], {\n            videos: yield getVideoSrc(props[key])\n          });\n        }\n      });\n\n      return function (_x4) {\n        return _ref2.apply(this, arguments);\n      };\n    }()));\n    return _objectSpread2({}, props, {}, objects.filter(Boolean).reduce((accumulator, current) => {\n      accumulator[current.id] = current;\n      delete accumulator[current.id].id;\n      return accumulator;\n    }, {}));\n  });\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction getVideoSrc(_x2) {\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction _getVideoSrc() {\n  _getVideoSrc = _asyncToGenerator(function* (videoObj) {\n    var hasVideoUrl = videoObj && videoObj !== 'null';\n\n    if (hasVideoUrl) {\n      var videos = yield getVideos(videoObj.url);\n      var basePath = extractBasePathFromUrl(videoObj.url);\n      return videos.map(video => ({\n        type: getTypeFromHeight(video.height),\n        poster: \"\".concat(basePath, \"/\").concat(video.stillFileName),\n        aspectRatio: video.displayAspectRatio,\n        height: video.height,\n        sources: {\n          mp4: \"\".concat(basePath, \"/\").concat(video.videoFileName)\n        }\n      }));\n    } else {\n      return null;\n    }\n  });\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction extractBasePathFromUrl(url) {\n  var decodedUrl = url.replace(/%2F/g, '/');\n  return decodedUrl.substr(0, decodedUrl.lastIndexOf('/'));\n}\n\nfunction getVideos(_x3) {\n  return _getVideos.apply(this, arguments);\n}\n\nfunction _getVideos() {\n  _getVideos = _asyncToGenerator(function* (url) {\n    var videoPayload = yield getVideoPayload(url);\n    return videoPayload.movingStills;\n  });\n  return _getVideos.apply(this, arguments);\n}\n\nfunction getVideoPayload(url) {\n  return axios.get(url, {\n    timeout: 2000\n  }).then((_ref) => {\n    var {\n      data\n    } = _ref;\n    return data;\n  });\n}\n\nfunction getTypeFromHeight(height) {\n  switch (height) {\n    case 360:\n      return 'small';\n\n    case 720:\n      return 'medium';\n\n    case 1080:\n      return 'large';\n\n    default:\n      return 'large';\n  }\n}\n\nfunction mergeMapProps(_x) {\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction _mergeMapProps() {\n  _mergeMapProps = _asyncToGenerator(function* (props) {\n    var {\n      id\n    } = props,\n        rest = _objectWithoutProperties(props, [\"id\"]);\n\n    return _objectSpread2({\n      id\n    }, rest, {\n      definition: yield getMapDefinition(id)\n    });\n  });\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction getMapDefinition(_x2) {\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction _getMapDefinition() {\n  _getMapDefinition = _asyncToGenerator(function* (id) {\n    if (!id) {\n      return;\n    }\n\n    return axios.get(\"https://dh.nrk.no/atlas/v1/definition?id=\".concat(id), {\n      timeout: 2000\n    }).then((_ref) => {\n      var {\n        data\n      } = _ref;\n      return data;\n    });\n  });\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction fromEntries$1(items) {\n  return [...items].reduce((obj, _ref) => {\n    var [key, val] = _ref;\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nvar defaultOptions = {\n  image: {\n    gqlApiUrl: 'https://www.nrk.no/api/graphql',\n    aspectRatios: [{\n      id: 'F11',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F34',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F169',\n      sizes: ['900', '1280', '2400']\n    }, {\n      id: 'original',\n      sizes: ['450', '768', '1280', '2400']\n    }]\n  }\n};\nfunction mergeMediaProps(_x, _x2, _x3) {\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nfunction _mergeMediaProps() {\n  _mergeMediaProps = _asyncToGenerator(function* (props, options, imageData) {\n    var mergedOptions = {\n      image: _objectSpread2({}, defaultOptions.image, {}, options === null || options === void 0 ? void 0 : options.image)\n    };\n    var type = props.type;\n    var imageDataStored = imageData || (yield prefetchImageData(props, mergedOptions.image));\n    var mergedProps = props;\n\n    if (type && type.startsWith('videoloop')) {\n      mergedProps = yield mergeVideoloopProps(props);\n    } else if (type && type.startsWith('image')) {\n      mergedProps = yield mergeImageProps(props, imageDataStored);\n    } else if (type && type.startsWith('map')) {\n      mergedProps = yield mergeMapProps(props, imageDataStored);\n    }\n\n    var mappedEntries = yield Promise.all(Object.entries(mergedProps).map(\n    /*#__PURE__*/\n    function () {\n      var _ref2 = _asyncToGenerator(function* (_ref3) {\n        var [key, value] = _ref3;\n\n        if (Array.isArray(value)) {\n          var mergedArray = yield Promise.all(value.map(item => mergeMediaProps(item, options, imageDataStored)));\n          return [key, mergedArray];\n        } else if (typeof value === 'object' && value !== null) {\n          return [key, yield mergeMediaProps(value, options, imageDataStored)];\n        } else {\n          return [key, value];\n        }\n      });\n\n      return function (_x4) {\n        return _ref2.apply(this, arguments);\n      };\n    }()));\n    return fromEntries$1(mappedEntries);\n  });\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nvar MAX_SAFE_INTEGER = 9007199254740991;\nfunction withinRange(current) {\n  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MAX_SAFE_INTEGER;\n  return current >= start && current <= stop;\n}\nfunction withinStops(currentTime, stops, targetStop) {\n  var nrOfStops = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;\n  var uniqueStops = stops.filter(unique);\n  var targetTime = stops[targetStop];\n  var prevTime = uniqueStops[uniqueStops.indexOf(targetTime) - nrOfStops];\n  var nextTime = uniqueStops[uniqueStops.indexOf(targetTime) + nrOfStops];\n  return withinRange(currentTime, prevTime, nextTime);\n}\n\nfunction unique(value, index, self) {\n  return self.indexOf(value) === index;\n}\n\nexport { ElementIntersectionObserver, HorizontalScroll, VerticalScroll, addStyle, closest, dispatchEvent, mergeImageProps, mergeMapProps, mergeMediaProps, mergeVideoloopProps, setAttribute, testReducedMotion, toArray, toggleAttribute, withinRange, withinStops };\n//# sourceMappingURL=dh-basis-common.esm.js.map\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@nrk/dh-basis-levende-stillbilde/node_modules/@nrk/dh-basis-common/dh-basis-common.esm.js","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar mergeConfig = require('./core/mergeConfig');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  var context = new Axios(defaultConfig);\n  var instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context);\n\n  // Copy context to instance\n  utils.extend(instance, context);\n\n  return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n  return createInstance(mergeConfig(axios.defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/axios.js","'use strict';\n\nvar utils = require('./../utils');\nvar buildURL = require('../helpers/buildURL');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar mergeConfig = require('./mergeConfig');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n  this.defaults = instanceConfig;\n  this.interceptors = {\n    request: new InterceptorManager(),\n    response: new InterceptorManager()\n  };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n  /*eslint no-param-reassign:0*/\n  // Allow for axios('example/url'[, config]) a la fetch API\n  if (typeof config === 'string') {\n    config = arguments[1] || {};\n    config.url = arguments[0];\n  } else {\n    config = config || {};\n  }\n\n  config = mergeConfig(this.defaults, config);\n\n  // Set config.method\n  if (config.method) {\n    config.method = config.method.toLowerCase();\n  } else if (this.defaults.method) {\n    config.method = this.defaults.method.toLowerCase();\n  } else {\n    config.method = 'get';\n  }\n\n  // Hook up interceptors middleware\n  var chain = [dispatchRequest, undefined];\n  var promise = Promise.resolve(config);\n\n  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n    chain.unshift(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n    chain.push(interceptor.fulfilled, interceptor.rejected);\n  });\n\n  while (chain.length) {\n    promise = promise.then(chain.shift(), chain.shift());\n  }\n\n  return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n  config = mergeConfig(this.defaults, config);\n  return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\\?/, '');\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, data, config) {\n    return this.request(utils.merge(config || {}, {\n      method: method,\n      url: url,\n      data: data\n    }));\n  };\n});\n\nmodule.exports = Axios;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/Axios.js","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n  this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n  this.handlers.push({\n    fulfilled: fulfilled,\n    rejected: rejected\n  });\n  return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n  if (this.handlers[id]) {\n    this.handlers[id] = null;\n  }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n  utils.forEach(this.handlers, function forEachHandler(h) {\n    if (h !== null) {\n      fn(h);\n    }\n  });\n};\n\nmodule.exports = InterceptorManager;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/InterceptorManager.js","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  // Ensure headers exist\n  config.headers = config.headers || {};\n\n  // Transform request data\n  config.data = transformData(\n    config.data,\n    config.headers,\n    config.transformRequest\n  );\n\n  // Flatten headers\n  config.headers = utils.merge(\n    config.headers.common || {},\n    config.headers[config.method] || {},\n    config.headers\n  );\n\n  utils.forEach(\n    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n    function cleanHeaderConfig(method) {\n      delete config.headers[method];\n    }\n  );\n\n  var adapter = config.adapter || defaults.adapter;\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData(\n      response.data,\n      response.headers,\n      config.transformResponse\n    );\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData(\n          reason.response.data,\n          reason.response.headers,\n          config.transformResponse\n        );\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/dispatchRequest.js","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n  /*eslint no-param-reassign:0*/\n  utils.forEach(fns, function transform(fn) {\n    data = fn(data, headers);\n  });\n\n  return data;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/transformData.js","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n  utils.forEach(headers, function processHeader(value, name) {\n    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n      headers[normalizedName] = value;\n      delete headers[name];\n    }\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/normalizeHeaderName.js","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n  var validateStatus = response.config.validateStatus;\n  if (!validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(createError(\n      'Request failed with status code ' + response.status,\n      response.config,\n      null,\n      response.request,\n      response\n    ));\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/settle.js","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, request, response) {\n  error.config = config;\n  if (code) {\n    error.code = code;\n  }\n\n  error.request = request;\n  error.response = response;\n  error.isAxiosError = true;\n\n  error.toJSON = function() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: this.config,\n      code: this.code\n    };\n  };\n  return error;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/enhanceError.js","'use strict';\n\nvar isAbsoluteURL = require('../helpers/isAbsoluteURL');\nvar combineURLs = require('../helpers/combineURLs');\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n * @returns {string} The combined full path\n */\nmodule.exports = function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/core/buildFullPath.js","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/isAbsoluteURL.js","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/combineURLs.js","'use strict';\n\nvar utils = require('./../utils');\n\n// Headers whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nvar ignoreDuplicateOf = [\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n];\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n  var parsed = {};\n  var key;\n  var val;\n  var i;\n\n  if (!headers) { return parsed; }\n\n  utils.forEach(headers.split('\\n'), function parser(line) {\n    i = line.indexOf(':');\n    key = utils.trim(line.substr(0, i)).toLowerCase();\n    val = utils.trim(line.substr(i + 1));\n\n    if (key) {\n      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {\n        return;\n      }\n      if (key === 'set-cookie') {\n        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);\n      } else {\n        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n      }\n    }\n  });\n\n  return parsed;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/parseHeaders.js","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs have full support of the APIs needed to test\n  // whether the request URL is of the same origin as current location.\n    (function standardBrowserEnv() {\n      var msie = /(msie|trident)/i.test(navigator.userAgent);\n      var urlParsingNode = document.createElement('a');\n      var originURL;\n\n      /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n      function resolveURL(url) {\n        var href = url;\n\n        if (msie) {\n        // IE needs attribute set twice to normalize properties\n          urlParsingNode.setAttribute('href', href);\n          href = urlParsingNode.href;\n        }\n\n        urlParsingNode.setAttribute('href', href);\n\n        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n        return {\n          href: urlParsingNode.href,\n          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n          host: urlParsingNode.host,\n          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n          hostname: urlParsingNode.hostname,\n          port: urlParsingNode.port,\n          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n            urlParsingNode.pathname :\n            '/' + urlParsingNode.pathname\n        };\n      }\n\n      originURL = resolveURL(window.location.href);\n\n      /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n      return function isURLSameOrigin(requestURL) {\n        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n        return (parsed.protocol === originURL.protocol &&\n            parsed.host === originURL.host);\n      };\n    })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return function isURLSameOrigin() {\n        return true;\n      };\n    })()\n);\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/isURLSameOrigin.js","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n  utils.isStandardBrowserEnv() ?\n\n  // Standard browser envs support document.cookie\n    (function standardBrowserEnv() {\n      return {\n        write: function write(name, value, expires, path, domain, secure) {\n          var cookie = [];\n          cookie.push(name + '=' + encodeURIComponent(value));\n\n          if (utils.isNumber(expires)) {\n            cookie.push('expires=' + new Date(expires).toGMTString());\n          }\n\n          if (utils.isString(path)) {\n            cookie.push('path=' + path);\n          }\n\n          if (utils.isString(domain)) {\n            cookie.push('domain=' + domain);\n          }\n\n          if (secure === true) {\n            cookie.push('secure');\n          }\n\n          document.cookie = cookie.join('; ');\n        },\n\n        read: function read(name) {\n          var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n          return (match ? decodeURIComponent(match[3]) : null);\n        },\n\n        remove: function remove(name) {\n          this.write(name, '', Date.now() - 86400000);\n        }\n      };\n    })() :\n\n  // Non standard browser env (web workers, react-native) lack needed support.\n    (function nonStandardBrowserEnv() {\n      return {\n        write: function write() {},\n        read: function read() { return null; },\n        remove: function remove() {}\n      };\n    })()\n);\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/cookies.js","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n  if (typeof executor !== 'function') {\n    throw new TypeError('executor must be a function.');\n  }\n\n  var resolvePromise;\n  this.promise = new Promise(function promiseExecutor(resolve) {\n    resolvePromise = resolve;\n  });\n\n  var token = this;\n  executor(function cancel(message) {\n    if (token.reason) {\n      // Cancellation has already been requested\n      return;\n    }\n\n    token.reason = new Cancel(message);\n    resolvePromise(token.reason);\n  });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n  if (this.reason) {\n    throw this.reason;\n  }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n  var cancel;\n  var token = new CancelToken(function executor(c) {\n    cancel = c;\n  });\n  return {\n    token: token,\n    cancel: cancel\n  };\n};\n\nmodule.exports = CancelToken;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/cancel/CancelToken.js","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/axios/lib/helpers/spread.js","import axios from 'axios';\n\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(source, true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(source).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n/* eslint-disable compat/compat */\nvar defaultConfig = {\n  rootMargin: '0px 0px 0px 0px',\n  threshold: [0, 0.5, 1]\n};\nclass ElementIntersectionObserver {\n  constructor(elements, onChange, config) {\n    this.intersections = void 0;\n    this.elements = void 0;\n    this.elements = elements.slice(0);\n    this.intersections = elements.map(target => ({\n      target,\n      isIntersecting: false,\n      ratio: null\n    }));\n    this.intersectionObserver = new IntersectionObserver(entries => {\n      var intersections = this.intersections.slice(0);\n      entries.forEach(entry => {\n        var idx = elements.indexOf(entry.target);\n        intersections.splice(idx, 1, {\n          target: entry.target,\n          isIntersecting: entry.isIntersecting,\n          ratio: entry.intersectionRatio\n        });\n      });\n      this.intersections = intersections;\n      onChange(this.intersections);\n    }, _objectSpread2({}, defaultConfig, {}, config));\n    elements.forEach(elm => this.intersectionObserver.observe(elm));\n  }\n\n  disconnect() {\n    // Unregister trigger elements\n    this.elements.forEach(elm => this.intersectionObserver.unobserve(elm)); // Disconnect intersection observer\n\n    this.intersectionObserver.disconnect();\n  }\n\n}\n\nfunction toggleAttribute(el, name, boolValue) {\n  if (!el) {\n    return;\n  }\n\n  var nextValue;\n\n  if (typeof boolValue !== 'undefined') {\n    nextValue = !!boolValue;\n  } else {\n    nextValue = el.hasAttribute(name);\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, '');\n  } else {\n    el.removeAttribute(name);\n  }\n}\nfunction setAttribute(el, name, nextValue) {\n  if (!el) {\n    return;\n  }\n\n  if (nextValue) {\n    el.setAttribute(name, nextValue);\n  } else {\n    el.removeAttribute(name);\n  }\n}\nvar closest = (() => {\n  var proto = typeof window === 'undefined' ? {} : window.Element.prototype;\n  var match = proto.matches || proto.msMatchesSelector || proto.webkitMatchesSelector;\n\n  if (proto.closest) {\n    return (el, css) => el.closest(css);\n  } else {\n    return (el, css) => {\n      for (; el; el = el.parentElement) {\n        if (match.call(el, css)) return el;\n      }\n\n      return null;\n    };\n  }\n})();\nfunction addStyle(nodeName, css) {\n  var key = \"style-\".concat(nodeName.toLowerCase());\n  var min = css.replace(/\\/\\*[^!][^*]*\\*\\//g, '').replace(/\\s*(^|[:;,{}]|$)\\s*/g, '$1');\n  document.getElementById(key) || document.head.insertAdjacentHTML('afterbegin', \"<style id=\\\"\".concat(key, \"\\\">\").concat(min, \"</style>\"));\n}\nfunction toArray(nodeList) {\n  return [].slice.call(nodeList);\n}\nfunction dispatchEvent(element, name) {\n  var detail = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var ignore = \"prevent_recursive_dispatch_maximum_callstack\".concat(name);\n  var event;\n  if (element[ignore]) return true; // We are already processing this event, so skip sending a new one\n  else element[ignore] = true; // Add name to dispatching ignore\n\n  if (typeof window.CustomEvent === 'function') {\n    event = new window.CustomEvent(name, {\n      bubbles: true,\n      cancelable: true,\n      detail\n    });\n  } else {\n    event = document.createEvent('CustomEvent');\n    event.initCustomEvent(name, true, true, detail);\n  } // IE reports incorrect event.defaultPrevented\n  // but correct return value on element.dispatchEvent\n\n\n  var result = element.dispatchEvent(event);\n  element[ignore] = null; // Remove name from dispatching ignore\n\n  return result; // Follow W3C standard for return value\n}\n\nfunction easeOutQuint(t) {\n  return 1 + --t * t * t * t * t;\n}\n\nclass VerticalScroll {\n  constructor(container) {\n    this.container = void 0;\n    this.container = container;\n  }\n\n  to(top) {\n    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    var from = this.container.scrollTop;\n    var distance = top - from;\n    var startTime = null;\n\n    var loop = currentTime => {\n      if (!startTime) {\n        startTime = currentTime - 1;\n      }\n\n      var timeElapsed = currentTime - startTime;\n      this.container.scrollTop = from + distance * easeOutQuint(timeElapsed / duration);\n\n      if (timeElapsed < duration) {\n        window.requestAnimationFrame(loop);\n      } else {\n        this.container.scrollTop = top;\n      }\n    };\n\n    window.requestAnimationFrame(loop);\n  }\n\n}\nclass HorizontalScroll {\n  constructor(container) {\n    this.container = void 0;\n    this.container = container;\n  }\n\n  to(left) {\n    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    var callback = arguments.length > 2 ? arguments[2] : undefined;\n    var from = this.container.scrollLeft;\n    var distance = left - from;\n    var startTime = null;\n\n    var loop = currentTime => {\n      if (!startTime) {\n        startTime = currentTime - 1;\n      }\n\n      var timeElapsed = currentTime - startTime;\n      this.container.scrollLeft = from + distance * easeOutQuint(timeElapsed / duration);\n\n      if (timeElapsed < duration) {\n        window.requestAnimationFrame(loop);\n      } else {\n        this.container.scrollLeft = left;\n        callback && callback();\n      }\n    };\n\n    window.requestAnimationFrame(loop);\n  }\n\n}\n\nfunction testReducedMotion() {\n  if (typeof window !== 'undefined') {\n    return !!window.matchMedia && window.matchMedia('(prefers-reduced-motion)').matches;\n  }\n\n  return false;\n}\n\nvar name = process.env.npm_package_name;\nvar version = process.env.npm_package_version;\n\nfunction createGqlApi() {\n  return {\n    get(query, url) {\n      return _asyncToGenerator(function* () {\n        var {\n          data,\n          errors\n        } = yield axios({\n          method: 'POST',\n          url,\n          data: {\n            query,\n            variables: null\n          },\n          timeout: 7500,\n          headers: {\n            'User-Agent': \"\".concat(name, \"/\").concat(version, \" (node/isomorphic-fetch)\"),\n            'Content-Type': 'application/json',\n            Accept: 'application/json'\n          }\n        }).then(res => res.data);\n\n        if (errors && errors.length) {\n          throw Error(errors);\n        }\n\n        return transformResponse(data);\n      })();\n    }\n\n  };\n}\n\nvar gqlApi = createGqlApi();\n\nfunction pngFragment(options) {\n  var aspects = options.aspectRatios.map(ratio => {\n    var sizes = ratio.sizes.map(s => \"w\".concat(s, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(s, \", format: png)\")).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsPng on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n\nfunction jpgFragment(options) {\n  var aspects = options.aspectRatios.map(ratio => {\n    var sizes = ratio.sizes.map(size => \"w\".concat(size, \": url(quality: \").concat(ratio.quality || '0.7', \", width: \").concat(size, \")\")).join('\\n');\n    return \"\".concat(ratio.id, \": crop(aspect: \").concat(ratio.id, \") {\\n        \").concat(ratio.id === 'original' ? 'aspect' : '', \"\\n        \").concat(sizes, \"\\n      }\");\n  }).join('\\n');\n  return \"\\nfragment imageCropsJpg on Image {\\n  title,\\n  creators,\\n  credit,\\n  category,\\n  \".concat(aspects, \"\\n}\\n\");\n}\n/**\n * Transforms a series of image sections to a Polopoly GraphQL API query\n */\n\n\nfunction createQuery(imageObjects, options) {\n  var images = getImageIds(imageObjects);\n  return \"\\n    \".concat(createBase(images, options), \"\\n    query {\\n      \").concat(images.map(getImage).join('\\n'), \"\\n    }\");\n}\nvar IMAGE_PROPS = ['vertical', 'horizontal'];\n\nfunction getImageIds(imageObjects) {\n  if (imageObjects.some(image => !image)) {\n    throw new Error('Undefined image object');\n  }\n\n  return imageObjects.reduce((result, image) => {\n    var format = image.advanced && image.advanced.format || 'jpg';\n    /* Image can be stored directly on image object */\n\n    if (image.id && !result.find(el => el.id === image.id)) {\n      result.push({\n        id: image.id,\n        format\n      });\n    }\n    /* or on a predefined set of image properties */\n\n\n    IMAGE_PROPS.forEach(prop => {\n      var value = image[prop];\n\n      if (value && value.id && !result.find(el => el.id === value.id)) {\n        result.push({\n          id: value.id,\n          format\n        });\n      }\n    });\n    return result;\n  }, []);\n}\n\nfunction getImage(_ref) {\n  var {\n    id,\n    format = 'jpg'\n  } = _ref;\n\n  if (format === 'png') {\n    return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n      ...imageCropsPng\\n    }\");\n  }\n\n  return \"\".concat(transformId(id), \": model(id: \\\"\").concat(id, \"\\\") {\\n    ...imageCropsJpg\\n  }\");\n}\n\nfunction createBase(imageObjects, options) {\n  var containsJpg = imageObjects.filter(el => el.format === 'jpg').length > 0;\n  var containsPng = imageObjects.filter(el => el.format === 'png').length > 0;\n  return \"\\n    \".concat(containsJpg ? jpgFragment(options) : '', \"\\n    \").concat(containsPng ? pngFragment(options) : '', \"\\n  \");\n}\n/**\n * Transforns a polopoly id to something that can be used as a key in a GraphQL query\n * Example: '1.14252981' -> 'id_1_14252981'\n */\n\n\nfunction transformId(id) {\n  return \"id\".concat(id.replace(/\\./g, '__'));\n}\n/**\n * Transforns an already transformed polopoly id back to a regular polopoly id\n * Example: ''id_1_14252981' -> 1.14252981'\n */\n\n\nfunction transformBackId(id) {\n  return id.replace('id', '').replace(/__/g, '.');\n}\n\nfunction transformResponse(response) {\n  return Object.keys(response).reduce((res, key) => {\n    var transformedKey = transformBackId(key);\n    res[transformedKey] = response[key];\n    return res;\n  }, {});\n}\n\nfunction fromEntries(items) {\n  return [...items].reduce((obj, _ref) => {\n    var [key, val] = _ref;\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nfunction traverse(obj, filter) {\n  if (filter(obj)) {\n    /* Object is a match, returning */\n    return [obj];\n  } else {\n    return Object.entries(obj).filter((_ref2) => {\n      var [_, value] = _ref2;\n      return !!value;\n    }).map((_ref3) => {\n      var [_, value] = _ref3;\n\n      if (Array.isArray(value)) {\n        return value.map(item => traverse(item, filter)).reduce((acc, val) => acc.concat(val), []);\n      } else if (typeof value === 'object') {\n        return traverse(value, filter);\n      } else {\n        return null;\n      }\n    }).reduce((acc, val) => acc.concat(val), []).filter(Boolean);\n  }\n}\n/*\n * Traverses the props tree and fetches data for all image objects\n * */\n\n\nfunction prefetchImageData(_x, _x2) {\n  return _prefetchImageData.apply(this, arguments);\n}\n\nfunction _prefetchImageData() {\n  _prefetchImageData = _asyncToGenerator(function* (props, options) {\n    var imageObjects = traverse(props, value => value.type === 'image');\n\n    if (imageObjects.length > 0) {\n      if (!options.gqlApiUrl) {\n        throw new Error(\"Missing option 'gqlApiUrl'\");\n      }\n\n      var query = createQuery(imageObjects, options);\n      return gqlApi.get(query, options.gqlApiUrl);\n    }\n  });\n  return _prefetchImageData.apply(this, arguments);\n}\n\nvar imageProps = ['vertical', 'horizontal'];\nfunction mergeImageProps(props, imageUrls) {\n  if ('id' in props) {\n    return _objectSpread2({}, props, {}, imageUrls[props.id]);\n  } else {\n    return fromEntries(Object.entries(props).map((_ref4) => {\n      var [key, value] = _ref4;\n\n      if (imageProps.indexOf(key) !== -1) {\n        return [key, mergeImageProps(value, imageUrls)];\n      } else {\n        return [key, value];\n      }\n    }));\n  }\n}\n\nfunction mergeVideoloopProps(_x) {\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction _mergeVideoloopProps() {\n  _mergeVideoloopProps = _asyncToGenerator(function* (props) {\n    var objects = yield Promise.all(Object.keys(props).map(\n    /*#__PURE__*/\n    function () {\n      var _ref2 = _asyncToGenerator(function* (key) {\n        if (key === 'horizontal' || key === 'vertical') {\n          return _objectSpread2({\n            id: key\n          }, props[key], {\n            videos: yield getVideoSrc(props[key])\n          });\n        }\n      });\n\n      return function (_x4) {\n        return _ref2.apply(this, arguments);\n      };\n    }()));\n    return _objectSpread2({}, props, {}, objects.filter(Boolean).reduce((accumulator, current) => {\n      accumulator[current.id] = current;\n      delete accumulator[current.id].id;\n      return accumulator;\n    }, {}));\n  });\n  return _mergeVideoloopProps.apply(this, arguments);\n}\n\nfunction getVideoSrc(_x2) {\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction _getVideoSrc() {\n  _getVideoSrc = _asyncToGenerator(function* (videoObj) {\n    var hasVideoUrl = videoObj && videoObj !== 'null';\n\n    if (hasVideoUrl) {\n      var videos = yield getVideos(videoObj.url);\n      var basePath = extractBasePathFromUrl(videoObj.url);\n      return videos.map(video => ({\n        type: getTypeFromHeight(video.height),\n        poster: \"\".concat(basePath, \"/\").concat(video.stillFileName),\n        aspectRatio: video.displayAspectRatio,\n        height: video.height,\n        sources: {\n          mp4: \"\".concat(basePath, \"/\").concat(video.videoFileName)\n        }\n      }));\n    } else {\n      return null;\n    }\n  });\n  return _getVideoSrc.apply(this, arguments);\n}\n\nfunction extractBasePathFromUrl(url) {\n  var decodedUrl = url.replace(/%2F/g, '/');\n  return decodedUrl.substr(0, decodedUrl.lastIndexOf('/'));\n}\n\nfunction getVideos(_x3) {\n  return _getVideos.apply(this, arguments);\n}\n\nfunction _getVideos() {\n  _getVideos = _asyncToGenerator(function* (url) {\n    var videoPayload = yield getVideoPayload(url);\n    return videoPayload.movingStills;\n  });\n  return _getVideos.apply(this, arguments);\n}\n\nfunction getVideoPayload(url) {\n  return axios.get(url, {\n    timeout: 2000\n  }).then((_ref) => {\n    var {\n      data\n    } = _ref;\n    return data;\n  });\n}\n\nfunction getTypeFromHeight(height) {\n  switch (height) {\n    case 360:\n      return 'small';\n\n    case 720:\n      return 'medium';\n\n    case 1080:\n      return 'large';\n\n    default:\n      return 'large';\n  }\n}\n\nfunction mergeMapProps(_x) {\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction _mergeMapProps() {\n  _mergeMapProps = _asyncToGenerator(function* (props) {\n    var {\n      id\n    } = props,\n        rest = _objectWithoutProperties(props, [\"id\"]);\n\n    return _objectSpread2({\n      id\n    }, rest, {\n      definition: yield getMapDefinition(id)\n    });\n  });\n  return _mergeMapProps.apply(this, arguments);\n}\n\nfunction getMapDefinition(_x2) {\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction _getMapDefinition() {\n  _getMapDefinition = _asyncToGenerator(function* (id) {\n    if (!id) {\n      return;\n    }\n\n    return axios.get(\"https://dh.nrk.no/atlas/v1/definition?id=\".concat(id), {\n      timeout: 2000\n    }).then((_ref) => {\n      var {\n        data\n      } = _ref;\n      return data;\n    });\n  });\n  return _getMapDefinition.apply(this, arguments);\n}\n\nfunction fromEntries$1(items) {\n  return [...items].reduce((obj, _ref) => {\n    var [key, val] = _ref;\n    obj[key] = val;\n    return obj;\n  }, {});\n}\n\nvar defaultOptions = {\n  image: {\n    gqlApiUrl: 'https://www.nrk.no/api/graphql',\n    aspectRatios: [{\n      id: 'F11',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F34',\n      sizes: ['450', '768', '1280']\n    }, {\n      id: 'F169',\n      sizes: ['900', '1280', '2400']\n    }, {\n      id: 'original',\n      sizes: ['450', '768', '1280', '2400']\n    }]\n  }\n};\nfunction mergeMediaProps(_x, _x2, _x3) {\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nfunction _mergeMediaProps() {\n  _mergeMediaProps = _asyncToGenerator(function* (props, options, imageData) {\n    var mergedOptions = {\n      image: _objectSpread2({}, defaultOptions.image, {}, options === null || options === void 0 ? void 0 : options.image)\n    };\n    var imageDataStored = imageData || (yield prefetchImageData(props, mergedOptions.image));\n\n    if (props.type === 'videoloop') {\n      return mergeVideoloopProps(props);\n    } else if (props.type === 'image') {\n      return mergeImageProps(props, imageDataStored);\n    } else if (props.type === 'map') {\n      return mergeMapProps(props, imageDataStored);\n    } else {\n      var mappedEntries = yield Promise.all(Object.entries(props).map(\n      /*#__PURE__*/\n      function () {\n        var _ref3 = _asyncToGenerator(function* (_ref2) {\n          var [key, value] = _ref2;\n\n          if (Array.isArray(value)) {\n            var mergedArray = yield Promise.all(value.map(item => mergeMediaProps(item, options, imageDataStored)));\n            return [key, mergedArray];\n          } else if (typeof value === 'object' && value !== null) {\n            return [key, yield mergeMediaProps(value, options, imageDataStored)];\n          } else {\n            return [key, value];\n          }\n        });\n\n        return function (_x4) {\n          return _ref3.apply(this, arguments);\n        };\n      }()));\n      return fromEntries$1(mappedEntries);\n    }\n  });\n  return _mergeMediaProps.apply(this, arguments);\n}\n\nvar MAX_SAFE_INTEGER = 9007199254740991;\nfunction withinRange(current) {\n  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MAX_SAFE_INTEGER;\n  return current >= start && current <= stop;\n}\n\nexport { ElementIntersectionObserver, HorizontalScroll, VerticalScroll, addStyle, closest, dispatchEvent, mergeImageProps, mergeMapProps, mergeMediaProps, mergeVideoloopProps, setAttribute, testReducedMotion, toArray, toggleAttribute, withinRange };\n//# sourceMappingURL=dh-basis-common.esm.js.map\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@nrk/dh-basis-common/dh-basis-common.esm.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"standaloneVideo\":\"dh-video-standaloneVideo\",\"small\":\"dh-video-small\",\"medium\":\"dh-video-medium\",\"large\":\"dh-video-large\",\"horizontalVideo\":\"dh-video-horizontalVideo\",\"verticalVideo\":\"dh-video-verticalVideo\",\"videoLoop\":\"dh-video-videoLoop\",\"videoLoop__fallbackImage\":\"dh-video-videoLoop__fallbackImage\",\"wrapper\":\"dh-video-wrapper\",\"byline\":\"dh-video-byline\",\"videoLoop--played\":\"dh-video-videoLoop--played\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/article/components/VideoLoop.css\n// module id = 62\n// module chunks = 0","import * as tslib_1 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\n// tslint:disable: no-unsafe-any\nvar _window = getGlobalObject();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\n// tslint:enable: no-unsafe-any\nvar INTEGRATIONS = tslib_1.__assign({}, windowIntegrations, CoreIntegrations, BrowserIntegrations);\nexport { INTEGRATIONS as Integrations, Transports };\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/index.js","export { Severity, Status, } from '@sentry/types';\nexport { addGlobalEventProcessor, addBreadcrumb, captureException, captureEvent, captureMessage, configureScope, getHubFromCarrier, getCurrentHub, Hub, Scope, setContext, setExtra, setExtras, setTag, setTags, setUser, withScope, } from '@sentry/core';\nexport { BrowserClient } from './client';\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/exports.js","/** 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// WEBPACK FOOTER //\n// ./node_modules/@sentry/types/esm/loglevel.js","/** JSDoc */\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// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/types/esm/severity.js","/** The status of an Span. */\nexport var SpanStatus;\n(function (SpanStatus) {\n    /** The operation completed successfully. */\n    SpanStatus[\"Ok\"] = \"ok\";\n    /** Deadline expired before operation could complete. */\n    SpanStatus[\"DealineExceeded\"] = \"deadline_exceeded\";\n    /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n    SpanStatus[\"Unauthenticated\"] = \"unauthenticated\";\n    /** 403 Forbidden */\n    SpanStatus[\"PermissionDenied\"] = \"permission_denied\";\n    /** 404 Not Found. Some requested entity (file or directory) was not found. */\n    SpanStatus[\"NotFound\"] = \"not_found\";\n    /** 429 Too Many Requests */\n    SpanStatus[\"ResourceExhausted\"] = \"resource_exhausted\";\n    /** Client specified an invalid argument. 4xx. */\n    SpanStatus[\"InvalidArgument\"] = \"invalid_argument\";\n    /** 501 Not Implemented */\n    SpanStatus[\"Unimplemented\"] = \"unimplemented\";\n    /** 503 Service Unavailable */\n    SpanStatus[\"Unavailable\"] = \"unavailable\";\n    /** Other/generic 5xx. */\n    SpanStatus[\"InternalError\"] = \"internal_error\";\n    /** Unknown. Any non-standard HTTP status code. */\n    SpanStatus[\"UnknownError\"] = \"unknown_error\";\n    /** The operation was cancelled (typically by the user). */\n    SpanStatus[\"Cancelled\"] = \"cancelled\";\n    /** Already exists (409) */\n    SpanStatus[\"AlreadyExists\"] = \"already_exists\";\n    /** Operation was rejected because the system is not in a state required for the operation's */\n    SpanStatus[\"FailedPrecondition\"] = \"failed_precondition\";\n    /** The operation was aborted, typically due to a concurrency issue. */\n    SpanStatus[\"Aborted\"] = \"aborted\";\n    /** Operation was attempted past the valid range. */\n    SpanStatus[\"OutOfRange\"] = \"out_of_range\";\n    /** Unrecoverable data loss or corruption */\n    SpanStatus[\"DataLoss\"] = \"data_loss\";\n})(SpanStatus || (SpanStatus = {}));\n// tslint:disable:no-unnecessary-qualifier no-namespace\n(function (SpanStatus) {\n    /**\n     * Converts a HTTP status code into a {@link SpanStatus}.\n     *\n     * @param httpStatus The HTTP response status code.\n     * @returns The span status or {@link SpanStatus.UnknownError}.\n     */\n    // tslint:disable-next-line:completed-docs\n    function fromHttpCode(httpStatus) {\n        if (httpStatus < 400) {\n            return SpanStatus.Ok;\n        }\n        if (httpStatus >= 400 && httpStatus < 500) {\n            switch (httpStatus) {\n                case 401:\n                    return SpanStatus.Unauthenticated;\n                case 403:\n                    return SpanStatus.PermissionDenied;\n                case 404:\n                    return SpanStatus.NotFound;\n                case 409:\n                    return SpanStatus.AlreadyExists;\n                case 413:\n                    return SpanStatus.FailedPrecondition;\n                case 429:\n                    return SpanStatus.ResourceExhausted;\n                default:\n                    return SpanStatus.InvalidArgument;\n            }\n        }\n        if (httpStatus >= 500 && httpStatus < 600) {\n            switch (httpStatus) {\n                case 501:\n                    return SpanStatus.Unimplemented;\n                case 503:\n                    return SpanStatus.Unavailable;\n                case 504:\n                    return SpanStatus.DealineExceeded;\n                default:\n                    return SpanStatus.InternalError;\n            }\n        }\n        return SpanStatus.UnknownError;\n    }\n    SpanStatus.fromHttpCode = fromHttpCode;\n})(SpanStatus || (SpanStatus = {}));\n//# sourceMappingURL=span.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/types/esm/span.js","/** The status of an event. */\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// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/types/esm/status.js","import * as tslib_1 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 */\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        // tslint:disable-next-line:no-unsafe-any\n        return hub[method].apply(hub, tslib_1.__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 */\nexport function captureException(exception) {\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        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, level) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureMessage', message, level, {\n        originalException: message,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\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 normailzed.\n */\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 normailzed.\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 * @param key String key of tag\n * @param value String 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 */\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, tslib_1.__spread(['_invokeClient', method], args));\n}\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/minimal/esm/index.js","/**\n * Consumes the promise and logs the error when it rejects.\n * @param promise A promise to forget.\n */\nexport function forget(promise) {\n    promise.then(null, function (e) {\n        // TODO: Use a better logging mechanism\n        console.error(e);\n    });\n}\n//# sourceMappingURL=async.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/async.js","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties); // tslint:disable-line:no-unbound-method\n/**\n * setPrototypeOf polyfill using __proto__\n */\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/polyfill.js","// 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            up++;\n        }\n        else if (up) {\n            parts.splice(i, 1);\n            up--;\n        }\n    }\n    // if the path is allowed to go above the root, restore leading ..s\n    if (allowAboveRoot) {\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    // tslint:disable:no-parameter-reassignment\n    from = resolve(from).substr(1);\n    to = resolve(to).substr(1);\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/path.js","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// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/promisebuffer.js","/* tslint:disable:only-arrow-functions no-unsafe-any */\nimport * as tslib_1 from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getFunctionName, getGlobalObject } from './misc';\nimport { fill } from './object';\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 */\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        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    // tslint:disable-next-line:strict-type-predicates\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 = tslib_1.__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 commonHandlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData));\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), error: error }));\n                throw error;\n            });\n        };\n    });\n}\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/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\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            var url = args[1];\n            this.__sentry_xhr__ = {\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            if (isString(url) && this.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                this.__sentry_own_request__ = true;\n            }\n            return originalOpen.apply(this, 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            var xhr = this; // tslint:disable-line:no-this-assignment\n            var commonHandlerData = {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: xhr,\n            };\n            triggerHandlers('xhr', tslib_1.__assign({}, commonHandlerData));\n            /**\n             * @hidden\n             */\n            function onreadystatechangeHandler() {\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                    triggerHandlers('xhr', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now() }));\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                // if onreadystatechange wasn't actually set by the page on this xhr, we\n                // are free to set our own and capture the breadcrumb\n                xhr.onreadystatechange = onreadystatechangeHandler;\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        var proto = global[target] && global[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\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                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, 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}\n//# sourceMappingURL=instrument.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/instrument.js","import * as tslib_1 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        // tslint:disable-next-line:no-this-assignment\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 = tslib_1.__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        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);\n            }\n        });\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n    };\n    return Dsn;\n}());\nexport { Dsn };\n//# sourceMappingURL=dsn.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/utils/esm/dsn.js","import * as tslib_1 from \"tslib\";\nimport { consoleSandbox, dynamicRequire, getGlobalObject, isNodeEnv, logger, timestampWithMs, uuid4, } from '@sentry/utils';\nimport { Scope } from './scope';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be incresed when the global interface\n * changes a 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._stack.push({ client: client, scope: scope });\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    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 top = this.getStackTop();\n        if (top && top.client && top.client[method]) {\n            (_a = top.client)[method].apply(_a, tslib_1.__spread(args, [top.scope]));\n        }\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    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var stack = this.getStack();\n        var parentScope = stack.length > 0 ? stack[stack.length - 1].scope : undefined;\n        var scope = Scope.clone(parentScope);\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        return this.getStack().pop() !== undefined;\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    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, tslib_1.__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, tslib_1.__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, tslib_1.__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 top = this.getStackTop();\n        if (!top.scope || !top.client) {\n            return;\n        }\n        var _a = (top.client.getOptions && top.client.getOptions()) || {}, _b = _a.beforeBreadcrumb, beforeBreadcrumb = _b === void 0 ? null : _b, _c = _a.maxBreadcrumbs, maxBreadcrumbs = _c === void 0 ? DEFAULT_BREADCRUMBS : _c;\n        if (maxBreadcrumbs <= 0) {\n            return;\n        }\n        var timestamp = timestampWithMs();\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null) {\n            return;\n        }\n        top.scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setContext = function (name, context) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var top = this.getStackTop();\n        if (top.scope && top.client) {\n            callback(top.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        }\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 (spanOrSpanContext, forceNoChild) {\n        if (forceNoChild === void 0) { forceNoChild = false; }\n        return this._callExtensionMethod('startSpan', spanOrSpanContext, forceNoChild);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore\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        // tslint:disable-next-line: strict-type-predicates\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 * Try to read the hub from an active domain, fallback to the registry if one doesnt exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        // We need to use `dynamicRequire` because `require` on it's own will be optimized by webpack.\n        // We do not want this to happen, we need to try to `require` the domain node module and fail if we are in browser\n        // for example so we do not have to shim it and use `getCurrentHub` universally.\n        var domain = dynamicRequire(module, 'domain');\n        var activeDomain = domain.active;\n        // If there 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 its 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    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n        return true;\n    }\n    return false;\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    }\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    }\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/hub/esm/hub.js","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/module.js","import { Dsn, timestampWithMs, 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 a string with auth headers in the url to the store endpoint. */\n    API.prototype.getStoreEndpoint = function () {\n        return \"\" + this._getBaseUrl() + this.getStoreEndpointPath();\n    };\n    /** Returns the store endpoint with auth added in url encoded. */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        // Auth is intentionally sent as part of query string (NOT as custom HTTP header)\n        // to avoid preflight CORS requests\n        return this.getStoreEndpoint() + \"?\" + urlEncode(auth);\n    };\n    /** Returns the base path of the url including the port. */\n    API.prototype._getBaseUrl = 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;\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    /** Returns an object that can be used in request headers. */\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_timestamp=\" + timestampWithMs()); // TODO: This can be removed\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._getBaseUrl() + (dsn.path ? \"/\" + dsn.path : '') + \"/api/embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\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    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/api.js","import * as tslib_1 from \"tslib\";\nimport { Dsn, isPrimitive, isThenable, logger, normalize, 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        /** Is the client still processing a call? */\n        this._processing = false;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new Dsn(options.dsn);\n        }\n        if (this._isEnabled()) {\n            this._integrations = setupIntegrations(this._options);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._processEvent(event, hint, scope); })\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\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        this._processing = true;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(\"\" + message, level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        promisedEvent\n            .then(function (event) { return _this._processEvent(event, hint, scope); })\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._processEvent(event, hint, scope)\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\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 (status) {\n            clearInterval(status.interval);\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return status.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     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegrations = function () {\n        return this._integrations || {};\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    /** 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 = 0;\n            clearInterval(interval);\n            interval = setInterval(function () {\n                if (!_this._processing) {\n                    resolve({\n                        interval: interval,\n                        ready: true,\n                    });\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        resolve({\n                            interval: interval,\n                            ready: false,\n                        });\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 informartion 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(), environment = _a.environment, release = _a.release, dist = _a.dist, _b = _a.maxValueLength, maxValueLength = _b === void 0 ? 250 : _b, _c = _a.normalizeDepth, normalizeDepth = _c === void 0 ? 3 : _c;\n        var prepared = tslib_1.__assign({}, event);\n        if (prepared.environment === undefined && environment !== undefined) {\n            prepared.environment = environment;\n        }\n        if (prepared.release === undefined && release !== undefined) {\n            prepared.release = release;\n        }\n        if (prepared.dist === undefined && dist !== undefined) {\n            prepared.dist = dist;\n        }\n        if (prepared.message) {\n            prepared.message = truncate(prepared.message, maxValueLength);\n        }\n        var exception = prepared.exception && prepared.exception.values && prepared.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = truncate(exception.value, maxValueLength);\n        }\n        var request = prepared.request;\n        if (request && request.url) {\n            request.url = truncate(request.url, maxValueLength);\n        }\n        if (prepared.event_id === undefined) {\n            prepared.event_id = hint && hint.event_id ? hint.event_id : uuid4();\n        }\n        this._addIntegrations(prepared.sdk);\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 (scope) {\n            // In case we have a hub we reassign it.\n            result = scope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            // tslint:disable-next-line:strict-type-predicates\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        // tslint:disable:no-unsafe-any\n        return tslib_1.__assign({}, event, (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (tslib_1.__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    };\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._addIntegrations = function (sdkInfo) {\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\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 informartion 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        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject('SDK not enabled, will not send event.');\n        }\n        // 1.0 === 100% events are sent\n        // 0.0 === 0% events are sent\n        if (typeof sampleRate === 'number' && Math.random() > sampleRate) {\n            return SyncPromise.reject('This event has been sampled, will not send event.');\n        }\n        return new SyncPromise(function (resolve, reject) {\n            _this._prepareEvent(event, scope, hint)\n                .then(function (prepared) {\n                if (prepared === null) {\n                    reject('An event processor returned null, will not send event.');\n                    return;\n                }\n                var finalEvent = prepared;\n                try {\n                    var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n                    if (isInternalException || !beforeSend) {\n                        _this._getBackend().sendEvent(finalEvent);\n                        resolve(finalEvent);\n                        return;\n                    }\n                    var beforeSendResult = beforeSend(prepared, hint);\n                    // tslint:disable-next-line:strict-type-predicates\n                    if (typeof beforeSendResult === 'undefined') {\n                        logger.error('`beforeSend` method has to return `null` or a valid event.');\n                    }\n                    else if (isThenable(beforeSendResult)) {\n                        _this._handleAsyncBeforeSend(beforeSendResult, resolve, reject);\n                    }\n                    else {\n                        finalEvent = beforeSendResult;\n                        if (finalEvent === null) {\n                            logger.log('`beforeSend` returned `null`, will not send event.');\n                            resolve(null);\n                            return;\n                        }\n                        // From here on we are really async\n                        _this._getBackend().sendEvent(finalEvent);\n                        resolve(finalEvent);\n                    }\n                }\n                catch (exception) {\n                    _this.captureException(exception, {\n                        data: {\n                            __sentry__: true,\n                        },\n                        originalException: exception,\n                    });\n                    reject('`beforeSend` threw an error, will not send event.');\n                }\n            })\n                .then(null, function () {\n                reject('`beforeSend` threw an error, will not send event.');\n            });\n        });\n    };\n    /**\n     * Resolves before send Promise and calls resolve/reject on parent SyncPromise.\n     */\n    BaseClient.prototype._handleAsyncBeforeSend = function (beforeSend, resolve, reject) {\n        var _this = this;\n        beforeSend\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                reject('`beforeSend` returned `null`, will not send event.');\n                return;\n            }\n            // From here on we are really async\n            _this._getBackend().sendEvent(processedEvent);\n            resolve(processedEvent);\n        })\n            .then(null, function (e) {\n            reject(\"beforeSend rejected with \" + e);\n        });\n    };\n    return BaseClient;\n}());\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/baseclient.js","import * as tslib_1 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 && tslib_1.__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 = tslib_1.__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, tslib_1.__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// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/integration.js","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     * 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    /**\n     * @inheritDoc\n     */\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.getTransport = function () {\n        return this._transport;\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/basebackend.js","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 instanciate.\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    getCurrentHub().bindClient(new clientClass(options));\n}\n//# sourceMappingURL=sdk.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/sdk.js","export { FunctionToString } from './functiontostring';\nexport { InboundFilters } from './inboundfilters';\n//# sourceMappingURL=index.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/integrations/index.js","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        originalFunctionToString = Function.prototype.toString;\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            // tslint:disable-next-line:no-unsafe-any\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/integrations/functiontostring.js","import * as tslib_1 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._isBlacklistedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `blacklistUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isWhitelistedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `whitelistUrls` 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 === void 0) { 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 === void 0) { 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._isBlacklistedUrl = function (event, options) {\n        if (options === void 0) { options = {}; }\n        // TODO: Use Glob instead?\n        if (!options.blacklistUrls || !options.blacklistUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.blacklistUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isWhitelistedUrl = function (event, options) {\n        if (options === void 0) { options = {}; }\n        // TODO: Use Glob instead?\n        if (!options.whitelistUrls || !options.whitelistUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.whitelistUrls.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            blacklistUrls: tslib_1.__spread((this._options.blacklistUrls || []), (clientOptions.blacklistUrls || [])),\n            ignoreErrors: tslib_1.__spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n            whitelistUrls: tslib_1.__spread((this._options.whitelistUrls || []), (clientOptions.whitelistUrls || [])),\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/core/esm/integrations/inboundfilters.js","import * as tslib_1 from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, supportsFetch, SyncPromise } from '@sentry/utils';\nimport { eventFromString, eventFromUnknownInput } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    tslib_1.__extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\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 = tslib_1.__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    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        var syntheticException = (hint && hint.syntheticException) || undefined;\n        var event = eventFromUnknownInput(exception, syntheticException, {\n            attachStacktrace: this._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     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (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: this._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    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/backend.js","import * as tslib_1 from \"tslib\";\nimport { Status } from '@sentry/types';\nimport { getGlobalObject, logger, parseRetryAfterHeader, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    tslib_1.__extends(FetchTransport, _super);\n    function FetchTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var defaultOptions = {\n            body: JSON.stringify(event),\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.headers !== undefined) {\n            defaultOptions.headers = this.options.headers;\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            global\n                .fetch(_this.url, defaultOptions)\n                .then(function (response) {\n                var status = Status.fromHttpCode(response.status);\n                if (status === Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + parseRetryAfterHeader(now, response.headers.get('Retry-After')));\n                    logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(response);\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/transports/fetch.js","import * as tslib_1 from \"tslib\";\nimport { Status } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    tslib_1.__extends(XHRTransport, _super);\n    function XHRTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" 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                    return;\n                }\n                var status = Status.fromHttpCode(request.status);\n                if (status === Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + parseRetryAfterHeader(now, request.getResponseHeader('Retry-After')));\n                    logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(request);\n            };\n            request.open('POST', _this.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(JSON.stringify(event));\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/transports/xhr.js","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    initAndBind(BrowserClient, options);\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 */\nexport function wrap(fn) {\n    return internalWrap(fn)(); // tslint:disable-line:no-unsafe-any\n}\n//# sourceMappingURL=sdk.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/sdk.js","import * as tslib_1 from \"tslib\";\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, getGlobalObject, 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._global = getGlobalObject();\n        /** JSDoc */\n        this._oldOnErrorHandler = null;\n        /** JSDoc */\n        this._oldOnUnhandledRejectionHandler = null;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = tslib_1.__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        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        var self = this; // tslint:disable-line:no-this-assignment\n        this._oldOnErrorHandler = this._global.onerror;\n        this._global.onerror = function (msg, url, line, column, 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                if (self._oldOnErrorHandler) {\n                    return self._oldOnErrorHandler.apply(this, arguments);\n                }\n                return false;\n            }\n            var client = currentHub.getClient();\n            var event = isPrimitive(error)\n                ? self._eventFromIncompleteOnError(msg, url, line, column)\n                : self._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {\n                    attachStacktrace: client && client.getOptions().attachStacktrace,\n                    rejection: false,\n                }), url, line, column);\n            addExceptionMechanism(event, {\n                handled: false,\n                type: 'onerror',\n            });\n            currentHub.captureEvent(event, {\n                originalException: error,\n            });\n            if (self._oldOnErrorHandler) {\n                return self._oldOnErrorHandler.apply(this, arguments);\n            }\n            return false;\n        };\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        var self = this; // tslint:disable-line:no-this-assignment\n        this._oldOnUnhandledRejectionHandler = this._global.onunhandledrejection;\n        this._global.onunhandledrejection = function (e) {\n            var error = e;\n            try {\n                error = e && 'reason' in e ? e.reason : e;\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                if (self._oldOnUnhandledRejectionHandler) {\n                    return self._oldOnUnhandledRejectionHandler.apply(this, arguments);\n                }\n                return true;\n            }\n            var client = currentHub.getClient();\n            var event = isPrimitive(error)\n                ? self._eventFromIncompleteRejection(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            if (self._oldOnUnhandledRejectionHandler) {\n                return self._oldOnUnhandledRejectionHandler.apply(this, arguments);\n            }\n            return true;\n        };\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\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     * This function creates an Event from an TraceKitStackTrace that has part of it missing.\n     */\n    GlobalHandlers.prototype._eventFromIncompleteRejection = function (error) {\n        return {\n            exception: {\n                values: [\n                    {\n                        type: 'UnhandledRejection',\n                        value: \"Non-Error promise rejection captured with value: \" + error,\n                    },\n                ],\n            },\n        };\n    };\n    /** JSDoc */\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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","import { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    function TryCatch() {\n        /** JSDoc */\n        this._ignoreOnError = 0;\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n    }\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\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    TryCatch.prototype._wrapRAF = function (original) {\n        return function (callback) {\n            return original(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        var global = getGlobalObject();\n        var proto = global[target] && global[target].prototype;\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                    // tslint:disable-next-line:no-unbound-method strict-type-predicates\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, 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 (original) {\n            return function (eventName, fn, options) {\n                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        return function () {\n            var _this = this;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var xhr = this; // tslint:disable-line:no-this-assignment\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in _this && typeof _this[prop] === 'function') {\n                    fill(_this, prop, function (original) {\n                        return wrap(original, {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: getFunctionName(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    });\n                }\n            });\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    var wrapOptions = {\n                        mechanism: {\n                            data: {\n                                function: 'onreadystatechange',\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            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        this._ignoreOnError = this._ignoreOnError;\n        var global = getGlobalObject();\n        fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        if ('XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        [\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        ].forEach(this._wrapEventTarget.bind(this));\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/integrations/trycatch.js","import * as tslib_1 from \"tslib\";\nimport { API, getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, logger, 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 = tslib_1.__assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Creates breadcrumbs from console API calls\n     */\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    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: event,\n            name: handlerData.name,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\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            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: handlerData.xhr.__sentry_xhr__,\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n            });\n            return;\n        }\n        // We only capture issued sentry requests\n        if (handlerData.xhr.__sentry_own_request__) {\n            addSentryBreadcrumb(handlerData.args[0]);\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\n        }\n        var client = getCurrentHub().getClient();\n        var dsn = client && client.getDsn();\n        if (dsn) {\n            var filterUrl = new API(dsn).getStoreEndpoint();\n            // if Sentry key appears in URL, don't capture it as a request\n            // but rather as our own 'sentry' type breadcrumb\n            if (filterUrl &&\n                handlerData.fetchData.url.indexOf(filterUrl) !== -1 &&\n                handlerData.fetchData.method === 'POST' &&\n                handlerData.args[1] &&\n                handlerData.args[1].body) {\n                addSentryBreadcrumb(handlerData.args[1].body);\n                return;\n            }\n        }\n        if (handlerData.error) {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: tslib_1.__assign({}, handlerData.fetchData, { status_code: handlerData.response.status }),\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: tslib_1.__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    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            // tslint:disable-next-line:no-parameter-reassignment\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            // tslint:disable-next-line:no-parameter-reassignment\n            from = parsedFrom.relative;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    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, tslib_1.__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, tslib_1.__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, tslib_1.__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, tslib_1.__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, tslib_1.__spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n/**\n * Create a breadcrumb of `sentry` from the events themselves\n */\nfunction addSentryBreadcrumb(serializedData) {\n    // There's always something that can go wrong with deserialization...\n    try {\n        var event_1 = JSON.parse(serializedData);\n        getCurrentHub().addBreadcrumb({\n            category: 'sentry',\n            event_id: event_1.event_id,\n            level: event_1.level || Severity.fromString('error'),\n            message: getEventDescription(event_1),\n        }, {\n            event: event_1,\n        });\n    }\n    catch (_oO) {\n        logger.error('Error while adding sentry type breadcrumb');\n    }\n}\n//# sourceMappingURL=breadcrumbs.js.map\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","import * as tslib_1 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 = tslib_1.__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, tslib_1.__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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/integrations/linkederrors.js","import * as tslib_1 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            if (getCurrentHub().getIntegration(UserAgent)) {\n                if (!global.navigator || !global.location) {\n                    return event;\n                }\n                // Request Interface: https://docs.sentry.io/development/sdk-dev/event-payloads/request/\n                var request = event.request || {};\n                request.url = request.url || global.location.href;\n                request.headers = request.headers || {};\n                request.headers['User-Agent'] = global.navigator.userAgent;\n                return tslib_1.__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// WEBPACK FOOTER //\n// ./node_modules/@sentry/browser/esm/integrations/useragent.js","(function(){\n/*\n\n Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n Code distributed by Google as part of the polymer project is also\n subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n'use strict';var n=window.Document.prototype.createElement,p=window.Document.prototype.createElementNS,aa=window.Document.prototype.importNode,ba=window.Document.prototype.prepend,ca=window.Document.prototype.append,da=window.DocumentFragment.prototype.prepend,ea=window.DocumentFragment.prototype.append,q=window.Node.prototype.cloneNode,r=window.Node.prototype.appendChild,t=window.Node.prototype.insertBefore,u=window.Node.prototype.removeChild,v=window.Node.prototype.replaceChild,x=Object.getOwnPropertyDescriptor(window.Node.prototype,\n\"textContent\"),y=window.Element.prototype.attachShadow,z=Object.getOwnPropertyDescriptor(window.Element.prototype,\"innerHTML\"),A=window.Element.prototype.getAttribute,B=window.Element.prototype.setAttribute,C=window.Element.prototype.removeAttribute,D=window.Element.prototype.getAttributeNS,E=window.Element.prototype.setAttributeNS,F=window.Element.prototype.removeAttributeNS,G=window.Element.prototype.insertAdjacentElement,fa=window.Element.prototype.insertAdjacentHTML,ha=window.Element.prototype.prepend,\nia=window.Element.prototype.append,ja=window.Element.prototype.before,ka=window.Element.prototype.after,la=window.Element.prototype.replaceWith,ma=window.Element.prototype.remove,na=window.HTMLElement,H=Object.getOwnPropertyDescriptor(window.HTMLElement.prototype,\"innerHTML\"),oa=window.HTMLElement.prototype.insertAdjacentElement,pa=window.HTMLElement.prototype.insertAdjacentHTML;var qa=new Set;\"annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph\".split(\" \").forEach(function(a){return qa.add(a)});function ra(a){var b=qa.has(a);a=/^[a-z][.0-9_a-z]*-[\\-.0-9_a-z]*$/.test(a);return!b&&a}var sa=document.contains?document.contains.bind(document):document.documentElement.contains.bind(document.documentElement);\nfunction I(a){var b=a.isConnected;if(void 0!==b)return b;if(sa(a))return!0;for(;a&&!(a.__CE_isImportDocument||a instanceof Document);)a=a.parentNode||(window.ShadowRoot&&a instanceof ShadowRoot?a.host:void 0);return!(!a||!(a.__CE_isImportDocument||a instanceof Document))}function J(a){var b=a.children;if(b)return Array.prototype.slice.call(b);b=[];for(a=a.firstChild;a;a=a.nextSibling)a.nodeType===Node.ELEMENT_NODE&&b.push(a);return b}\nfunction K(a,b){for(;b&&b!==a&&!b.nextSibling;)b=b.parentNode;return b&&b!==a?b.nextSibling:null}\nfunction L(a,b,c){for(var f=a;f;){if(f.nodeType===Node.ELEMENT_NODE){var d=f;b(d);var e=d.localName;if(\"link\"===e&&\"import\"===d.getAttribute(\"rel\")){f=d.import;void 0===c&&(c=new Set);if(f instanceof Node&&!c.has(f))for(c.add(f),f=f.firstChild;f;f=f.nextSibling)L(f,b,c);f=K(a,d);continue}else if(\"template\"===e){f=K(a,d);continue}if(d=d.__CE_shadowRoot)for(d=d.firstChild;d;d=d.nextSibling)L(d,b,c)}f=f.firstChild?f.firstChild:K(a,f)}}function M(a,b,c){a[b]=c};function ta(a){var b=document;this.c=a;this.a=b;this.b=void 0;N(this.c,this.a);\"loading\"===this.a.readyState&&(this.b=new MutationObserver(this.f.bind(this)),this.b.observe(this.a,{childList:!0,subtree:!0}))}function ua(a){a.b&&a.b.disconnect()}ta.prototype.f=function(a){var b=this.a.readyState;\"interactive\"!==b&&\"complete\"!==b||ua(this);for(b=0;b<a.length;b++)for(var c=a[b].addedNodes,f=0;f<c.length;f++)N(this.c,c[f])};function va(){var a=this;this.b=this.a=void 0;this.c=new Promise(function(b){a.b=b;a.a&&b(a.a)})}function wa(a){if(a.a)throw Error(\"Already resolved.\");a.a=void 0;a.b&&a.b(void 0)};function O(a){this.f=new Map;this.g=new Map;this.l=new Map;this.i=!1;this.b=a;this.j=new Map;this.c=function(b){return b()};this.a=!1;this.h=[];this.m=a.f?new ta(a):void 0}O.prototype.o=function(a,b){var c=this;if(!(b instanceof Function))throw new TypeError(\"Custom element constructor getters must be functions.\");xa(this,a);this.f.set(a,b);this.h.push(a);this.a||(this.a=!0,this.c(function(){return ya(c)}))};\nO.prototype.define=function(a,b){var c=this;if(!(b instanceof Function))throw new TypeError(\"Custom element constructors must be functions.\");xa(this,a);za(this,a,b);this.h.push(a);this.a||(this.a=!0,this.c(function(){return ya(c)}))};function xa(a,b){if(!ra(b))throw new SyntaxError(\"The element name '\"+b+\"' is not valid.\");if(P(a,b))throw Error(\"A custom element with name '\"+b+\"' has already been defined.\");if(a.i)throw Error(\"A custom element is already being defined.\");}\nfunction za(a,b,c){a.i=!0;var f;try{var d=function(m){var w=e[m];if(void 0!==w&&!(w instanceof Function))throw Error(\"The '\"+m+\"' callback must be a function.\");return w},e=c.prototype;if(!(e instanceof Object))throw new TypeError(\"The custom element constructor's prototype is not an object.\");var g=d(\"connectedCallback\");var h=d(\"disconnectedCallback\");var k=d(\"adoptedCallback\");var l=(f=d(\"attributeChangedCallback\"))&&c.observedAttributes||[]}catch(m){throw m;}finally{a.i=!1}c={localName:b,constructorFunction:c,\nconnectedCallback:g,disconnectedCallback:h,adoptedCallback:k,attributeChangedCallback:f,observedAttributes:l,constructionStack:[]};a.g.set(b,c);a.l.set(c.constructorFunction,c);return c}O.prototype.upgrade=function(a){N(this.b,a)};\nfunction ya(a){if(!1!==a.a){a.a=!1;for(var b=[],c=a.h,f=new Map,d=0;d<c.length;d++)f.set(c[d],[]);N(a.b,document,{upgrade:function(k){if(void 0===k.__CE_state){var l=k.localName,m=f.get(l);m?m.push(k):a.g.has(l)&&b.push(k)}}});for(d=0;d<b.length;d++)Q(a.b,b[d]);for(d=0;d<c.length;d++){for(var e=c[d],g=f.get(e),h=0;h<g.length;h++)Q(a.b,g[h]);(e=a.j.get(e))&&wa(e)}c.length=0}}O.prototype.get=function(a){if(a=P(this,a))return a.constructorFunction};\nO.prototype.whenDefined=function(a){if(!ra(a))return Promise.reject(new SyntaxError(\"'\"+a+\"' is not a valid custom element name.\"));var b=this.j.get(a);if(b)return b.c;b=new va;this.j.set(a,b);var c=this.g.has(a)||this.f.has(a);a=-1===this.h.indexOf(a);c&&a&&wa(b);return b.c};O.prototype.polyfillWrapFlushCallback=function(a){this.m&&ua(this.m);var b=this.c;this.c=function(c){return a(function(){return b(c)})}};\nfunction P(a,b){var c=a.g.get(b);if(c)return c;if(c=a.f.get(b)){a.f.delete(b);try{return za(a,b,c())}catch(f){R(f)}}}window.CustomElementRegistry=O;O.prototype.define=O.prototype.define;O.prototype.upgrade=O.prototype.upgrade;O.prototype.get=O.prototype.get;O.prototype.whenDefined=O.prototype.whenDefined;O.prototype.polyfillDefineLazy=O.prototype.o;O.prototype.polyfillWrapFlushCallback=O.prototype.polyfillWrapFlushCallback;function S(){var a=T&&T.noDocumentConstructionObserver,b=T&&T.shadyDomFastWalk;this.b=[];this.c=[];this.a=!1;this.shadyDomFastWalk=b;this.f=!a}function U(a,b,c,f){var d=window.ShadyDOM;if(a.shadyDomFastWalk&&d&&d.inUse){if(b.nodeType===Node.ELEMENT_NODE&&c(b),b.querySelectorAll)for(a=d.nativeMethods.querySelectorAll.call(b,\"*\"),b=0;b<a.length;b++)c(a[b])}else L(b,c,f)}function Aa(a,b){a.a=!0;a.b.push(b)}function Ba(a,b){a.a=!0;a.c.push(b)}function V(a,b){a.a&&U(a,b,function(c){return W(a,c)})}\nfunction W(a,b){if(a.a&&!b.__CE_patched){b.__CE_patched=!0;for(var c=0;c<a.b.length;c++)a.b[c](b);for(c=0;c<a.c.length;c++)a.c[c](b)}}function X(a,b){var c=[];U(a,b,function(d){return c.push(d)});for(b=0;b<c.length;b++){var f=c[b];1===f.__CE_state?a.connectedCallback(f):Q(a,f)}}function Y(a,b){var c=[];U(a,b,function(d){return c.push(d)});for(b=0;b<c.length;b++){var f=c[b];1===f.__CE_state&&a.disconnectedCallback(f)}}\nfunction N(a,b,c){c=void 0===c?{}:c;var f=c.s,d=c.upgrade||function(g){return Q(a,g)},e=[];U(a,b,function(g){a.a&&W(a,g);if(\"link\"===g.localName&&\"import\"===g.getAttribute(\"rel\")){var h=g.import;h instanceof Node&&(h.__CE_isImportDocument=!0,h.__CE_registry=document.__CE_registry);h&&\"complete\"===h.readyState?h.__CE_documentLoadHandled=!0:g.addEventListener(\"load\",function(){var k=g.import;if(!k.__CE_documentLoadHandled){k.__CE_documentLoadHandled=!0;var l=new Set;f&&(f.forEach(function(m){return l.add(m)}),\nl.delete(k));N(a,k,{s:l,upgrade:d})}})}else e.push(g)},f);for(b=0;b<e.length;b++)d(e[b])}\nfunction Q(a,b){try{var c=b.ownerDocument,f=c.__CE_registry;var d=f&&(c.defaultView||c.__CE_isImportDocument)?P(f,b.localName):void 0;if(d&&void 0===b.__CE_state){d.constructionStack.push(b);try{try{if(new d.constructorFunction!==b)throw Error(\"The custom element constructor did not produce the element being upgraded.\");}finally{d.constructionStack.pop()}}catch(k){throw b.__CE_state=2,k;}b.__CE_state=1;b.__CE_definition=d;if(d.attributeChangedCallback&&b.hasAttributes()){var e=d.observedAttributes;\nfor(d=0;d<e.length;d++){var g=e[d],h=b.getAttribute(g);null!==h&&a.attributeChangedCallback(b,g,null,h,null)}}I(b)&&a.connectedCallback(b)}}catch(k){R(k)}}S.prototype.connectedCallback=function(a){var b=a.__CE_definition;if(b.connectedCallback)try{b.connectedCallback.call(a)}catch(c){R(c)}};S.prototype.disconnectedCallback=function(a){var b=a.__CE_definition;if(b.disconnectedCallback)try{b.disconnectedCallback.call(a)}catch(c){R(c)}};\nS.prototype.attributeChangedCallback=function(a,b,c,f,d){var e=a.__CE_definition;if(e.attributeChangedCallback&&-1<e.observedAttributes.indexOf(b))try{e.attributeChangedCallback.call(a,b,c,f,d)}catch(g){R(g)}};\nfunction Ca(a,b,c,f){var d=b.__CE_registry;if(d&&(null===f||\"http://www.w3.org/1999/xhtml\"===f)&&(d=P(d,c)))try{var e=new d.constructorFunction;if(void 0===e.__CE_state||void 0===e.__CE_definition)throw Error(\"Failed to construct '\"+c+\"': The returned value was not constructed with the HTMLElement constructor.\");if(\"http://www.w3.org/1999/xhtml\"!==e.namespaceURI)throw Error(\"Failed to construct '\"+c+\"': The constructed element's namespace must be the HTML namespace.\");if(e.hasAttributes())throw Error(\"Failed to construct '\"+\nc+\"': The constructed element must not have any attributes.\");if(null!==e.firstChild)throw Error(\"Failed to construct '\"+c+\"': The constructed element must not have any children.\");if(null!==e.parentNode)throw Error(\"Failed to construct '\"+c+\"': The constructed element must not have a parent node.\");if(e.ownerDocument!==b)throw Error(\"Failed to construct '\"+c+\"': The constructed element's owner document is incorrect.\");if(e.localName!==c)throw Error(\"Failed to construct '\"+c+\"': The constructed element's local name is incorrect.\");\nreturn e}catch(g){return R(g),b=null===f?n.call(b,c):p.call(b,f,c),Object.setPrototypeOf(b,HTMLUnknownElement.prototype),b.__CE_state=2,b.__CE_definition=void 0,W(a,b),b}b=null===f?n.call(b,c):p.call(b,f,c);W(a,b);return b}\nfunction R(a){var b=a.message,c=a.sourceURL||a.fileName||\"\",f=a.line||a.lineNumber||0,d=a.column||a.columnNumber||0,e=void 0;void 0===ErrorEvent.prototype.initErrorEvent?e=new ErrorEvent(\"error\",{cancelable:!0,message:b,filename:c,lineno:f,colno:d,error:a}):(e=document.createEvent(\"ErrorEvent\"),e.initErrorEvent(\"error\",!1,!0,b,c,f),e.preventDefault=function(){Object.defineProperty(this,\"defaultPrevented\",{configurable:!0,get:function(){return!0}})});void 0===e.error&&Object.defineProperty(e,\"error\",\n{configurable:!0,enumerable:!0,get:function(){return a}});window.dispatchEvent(e);e.defaultPrevented||console.error(a)};var Da=new function(){};function Ea(a){window.HTMLElement=function(){function b(){var c=this.constructor;var f=document.__CE_registry.l.get(c);if(!f)throw Error(\"Failed to construct a custom element: The constructor was not registered with `customElements`.\");var d=f.constructionStack;if(0===d.length)return d=n.call(document,f.localName),Object.setPrototypeOf(d,c.prototype),d.__CE_state=1,d.__CE_definition=f,W(a,d),d;var e=d.length-1,g=d[e];if(g===Da)throw Error(\"Failed to construct '\"+f.localName+\"': This element was already constructed.\");\nd[e]=Da;Object.setPrototypeOf(g,c.prototype);W(a,g);return g}b.prototype=na.prototype;Object.defineProperty(b.prototype,\"constructor\",{writable:!0,configurable:!0,enumerable:!1,value:b});return b}()};function Z(a,b,c){function f(d){return function(e){for(var g=[],h=0;h<arguments.length;++h)g[h]=arguments[h];h=[];for(var k=[],l=0;l<g.length;l++){var m=g[l];m instanceof Element&&I(m)&&k.push(m);if(m instanceof DocumentFragment)for(m=m.firstChild;m;m=m.nextSibling)h.push(m);else h.push(m)}d.apply(this,g);for(g=0;g<k.length;g++)Y(a,k[g]);if(I(this))for(g=0;g<h.length;g++)k=h[g],k instanceof Element&&X(a,k)}}void 0!==c.prepend&&M(b,\"prepend\",f(c.prepend));void 0!==c.append&&M(b,\"append\",f(c.append))}\n;function Fa(a){M(Document.prototype,\"createElement\",function(b){return Ca(a,this,b,null)});M(Document.prototype,\"importNode\",function(b,c){b=aa.call(this,b,!!c);this.__CE_registry?N(a,b):V(a,b);return b});M(Document.prototype,\"createElementNS\",function(b,c){return Ca(a,this,c,b)});Z(a,Document.prototype,{prepend:ba,append:ca})};function Ga(a){function b(c,f){Object.defineProperty(c,\"textContent\",{enumerable:f.enumerable,configurable:!0,get:f.get,set:function(d){if(this.nodeType===Node.TEXT_NODE)f.set.call(this,d);else{var e=void 0;if(this.firstChild){var g=this.childNodes,h=g.length;if(0<h&&I(this)){e=Array(h);for(var k=0;k<h;k++)e[k]=g[k]}}f.set.call(this,d);if(e)for(d=0;d<e.length;d++)Y(a,e[d])}}})}M(Node.prototype,\"insertBefore\",function(c,f){if(c instanceof DocumentFragment){var d=J(c);c=t.call(this,c,f);if(I(this))for(f=\n0;f<d.length;f++)X(a,d[f]);return c}d=c instanceof Element&&I(c);f=t.call(this,c,f);d&&Y(a,c);I(this)&&X(a,c);return f});M(Node.prototype,\"appendChild\",function(c){if(c instanceof DocumentFragment){var f=J(c);c=r.call(this,c);if(I(this))for(var d=0;d<f.length;d++)X(a,f[d]);return c}f=c instanceof Element&&I(c);d=r.call(this,c);f&&Y(a,c);I(this)&&X(a,c);return d});M(Node.prototype,\"cloneNode\",function(c){c=q.call(this,!!c);this.ownerDocument.__CE_registry?N(a,c):V(a,c);return c});M(Node.prototype,\n\"removeChild\",function(c){var f=c instanceof Element&&I(c),d=u.call(this,c);f&&Y(a,c);return d});M(Node.prototype,\"replaceChild\",function(c,f){if(c instanceof DocumentFragment){var d=J(c);c=v.call(this,c,f);if(I(this))for(Y(a,f),f=0;f<d.length;f++)X(a,d[f]);return c}d=c instanceof Element&&I(c);var e=v.call(this,c,f),g=I(this);g&&Y(a,f);d&&Y(a,c);g&&X(a,c);return e});x&&x.get?b(Node.prototype,x):Aa(a,function(c){b(c,{enumerable:!0,configurable:!0,get:function(){for(var f=[],d=this.firstChild;d;d=\nd.nextSibling)d.nodeType!==Node.COMMENT_NODE&&f.push(d.textContent);return f.join(\"\")},set:function(f){for(;this.firstChild;)u.call(this,this.firstChild);null!=f&&\"\"!==f&&r.call(this,document.createTextNode(f))}})})};function Ha(a){function b(f){return function(d){for(var e=[],g=0;g<arguments.length;++g)e[g]=arguments[g];g=[];for(var h=[],k=0;k<e.length;k++){var l=e[k];l instanceof Element&&I(l)&&h.push(l);if(l instanceof DocumentFragment)for(l=l.firstChild;l;l=l.nextSibling)g.push(l);else g.push(l)}f.apply(this,e);for(e=0;e<h.length;e++)Y(a,h[e]);if(I(this))for(e=0;e<g.length;e++)h=g[e],h instanceof Element&&X(a,h)}}var c=Element.prototype;void 0!==ja&&M(c,\"before\",b(ja));void 0!==ka&&M(c,\"after\",b(ka));void 0!==\nla&&M(c,\"replaceWith\",function(f){for(var d=[],e=0;e<arguments.length;++e)d[e]=arguments[e];e=[];for(var g=[],h=0;h<d.length;h++){var k=d[h];k instanceof Element&&I(k)&&g.push(k);if(k instanceof DocumentFragment)for(k=k.firstChild;k;k=k.nextSibling)e.push(k);else e.push(k)}h=I(this);la.apply(this,d);for(d=0;d<g.length;d++)Y(a,g[d]);if(h)for(Y(a,this),d=0;d<e.length;d++)g=e[d],g instanceof Element&&X(a,g)});void 0!==ma&&M(c,\"remove\",function(){var f=I(this);ma.call(this);f&&Y(a,this)})};function Ia(a){function b(d,e){Object.defineProperty(d,\"innerHTML\",{enumerable:e.enumerable,configurable:!0,get:e.get,set:function(g){var h=this,k=void 0;I(this)&&(k=[],U(a,this,function(w){w!==h&&k.push(w)}));e.set.call(this,g);if(k)for(var l=0;l<k.length;l++){var m=k[l];1===m.__CE_state&&a.disconnectedCallback(m)}this.ownerDocument.__CE_registry?N(a,this):V(a,this);return g}})}function c(d,e){M(d,\"insertAdjacentElement\",function(g,h){var k=I(h);g=e.call(this,g,h);k&&Y(a,h);I(g)&&X(a,h);return g})}\nfunction f(d,e){function g(h,k){for(var l=[];h!==k;h=h.nextSibling)l.push(h);for(k=0;k<l.length;k++)N(a,l[k])}M(d,\"insertAdjacentHTML\",function(h,k){h=h.toLowerCase();if(\"beforebegin\"===h){var l=this.previousSibling;e.call(this,h,k);g(l||this.parentNode.firstChild,this)}else if(\"afterbegin\"===h)l=this.firstChild,e.call(this,h,k),g(this.firstChild,l);else if(\"beforeend\"===h)l=this.lastChild,e.call(this,h,k),g(l||this.firstChild,null);else if(\"afterend\"===h)l=this.nextSibling,e.call(this,h,k),g(this.nextSibling,\nl);else throw new SyntaxError(\"The value provided (\"+String(h)+\") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.\");})}y&&M(Element.prototype,\"attachShadow\",function(d){d=y.call(this,d);if(a.a&&!d.__CE_patched){d.__CE_patched=!0;for(var e=0;e<a.b.length;e++)a.b[e](d)}return this.__CE_shadowRoot=d});z&&z.get?b(Element.prototype,z):H&&H.get?b(HTMLElement.prototype,H):Ba(a,function(d){b(d,{enumerable:!0,configurable:!0,get:function(){return q.call(this,!0).innerHTML},set:function(e){var g=\n\"template\"===this.localName,h=g?this.content:this,k=p.call(document,this.namespaceURI,this.localName);for(k.innerHTML=e;0<h.childNodes.length;)u.call(h,h.childNodes[0]);for(e=g?k.content:k;0<e.childNodes.length;)r.call(h,e.childNodes[0])}})});M(Element.prototype,\"setAttribute\",function(d,e){if(1!==this.__CE_state)return B.call(this,d,e);var g=A.call(this,d);B.call(this,d,e);e=A.call(this,d);a.attributeChangedCallback(this,d,g,e,null)});M(Element.prototype,\"setAttributeNS\",function(d,e,g){if(1!==this.__CE_state)return E.call(this,\nd,e,g);var h=D.call(this,d,e);E.call(this,d,e,g);g=D.call(this,d,e);a.attributeChangedCallback(this,e,h,g,d)});M(Element.prototype,\"removeAttribute\",function(d){if(1!==this.__CE_state)return C.call(this,d);var e=A.call(this,d);C.call(this,d);null!==e&&a.attributeChangedCallback(this,d,e,null,null)});M(Element.prototype,\"removeAttributeNS\",function(d,e){if(1!==this.__CE_state)return F.call(this,d,e);var g=D.call(this,d,e);F.call(this,d,e);var h=D.call(this,d,e);g!==h&&a.attributeChangedCallback(this,\ne,g,h,d)});oa?c(HTMLElement.prototype,oa):G&&c(Element.prototype,G);pa?f(HTMLElement.prototype,pa):fa&&f(Element.prototype,fa);Z(a,Element.prototype,{prepend:ha,append:ia});Ha(a)};var T=window.customElements;function Ja(){var a=new S;Ea(a);Fa(a);Z(a,DocumentFragment.prototype,{prepend:da,append:ea});Ga(a);Ia(a);a=new O(a);document.__CE_registry=a;Object.defineProperty(window,\"customElements\",{configurable:!0,enumerable:!0,value:a})}T&&!T.forcePolyfill&&\"function\"==typeof T.define&&\"function\"==typeof T.get||Ja();window.__CE_installPolyfill=Ja;\n}).call(self);\n\n//# sourceMappingURL=custom-elements.min.js.map\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@webcomponents/custom-elements/custom-elements.min.js","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n/**\n * Returns the embedding frame element, if any.\n * @param {!Document} doc\n * @return {!Element}\n */\nfunction getFrameElement(doc) {\n  try {\n    return doc.defaultView && doc.defaultView.frameElement || null;\n  } catch (e) {\n    // Ignore the error.\n    return null;\n  }\n}\n\n/**\n * A local reference to the root document.\n */\nvar document = (function(startDoc) {\n  var doc = startDoc;\n  var frame = getFrameElement(doc);\n  while (frame) {\n    doc = frame.ownerDocument;\n    frame = getFrameElement(doc);\n  }\n  return doc;\n})(window.document);\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n/**\n * The signal updater for cross-origin intersection. When not null, it means\n * that the polyfill is configured to work in a cross-origin mode.\n * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nvar crossOriginUpdater = null;\n\n/**\n * The current cross-origin intersection. Only used in the cross-origin mode.\n * @type {DOMRect|ClientRect}\n */\nvar crossOriginRect = null;\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = ensureDOMRect(entry.rootBounds);\n  this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\n  this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n\n  /** @private @const {!Array<!Document>} */\n  this._monitoringDocuments = [];\n  /** @private @const {!Array<function()>} */\n  this._monitoringUnsubscribes = [];\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Sets up the polyfill in the cross-origin mode. The result is the\n * updater function that accepts two arguments: `boundingClientRect` and\n * `intersectionRect` - just as these fields would be available to the\n * parent via `IntersectionObserverEntry`. This function should be called\n * each time the iframe receives intersection information from the parent\n * window, e.g. via messaging.\n * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nIntersectionObserver._setupCrossOriginUpdater = function() {\n  if (!crossOriginUpdater) {\n    /**\n     * @param {DOMRect|ClientRect} boundingClientRect\n     * @param {DOMRect|ClientRect} intersectionRect\n     */\n    crossOriginUpdater = function(boundingClientRect, intersectionRect) {\n      if (!boundingClientRect || !intersectionRect) {\n        crossOriginRect = getEmptyRect();\n      } else {\n        crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\n      }\n      registry.forEach(function(observer) {\n        observer._checkForIntersections();\n      });\n    };\n  }\n  return crossOriginUpdater;\n};\n\n\n/**\n * Resets the cross-origin mode.\n */\nIntersectionObserver._resetCrossOriginUpdater = function() {\n  crossOriginUpdater = null;\n  crossOriginRect = null;\n};\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections(target.ownerDocument);\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n        return item.element != target;\n      });\n  this._unmonitorIntersections(target.ownerDocument);\n  if (this._observationTargets.length == 0) {\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorAllIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function(doc) {\n  var win = doc.defaultView;\n  if (!win) {\n    // Already destroyed.\n    return;\n  }\n  if (this._monitoringDocuments.indexOf(doc) != -1) {\n    // Already monitoring.\n    return;\n  }\n\n  // Private state for monitoring.\n  var callback = this._checkForIntersections;\n  var monitoringInterval = null;\n  var domObserver = null;\n\n  // If a poll interval is set, use polling instead of listening to\n  // resize and scroll events or DOM mutations.\n  if (this.POLL_INTERVAL) {\n    monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\n  } else {\n    addEvent(win, 'resize', callback, true);\n    addEvent(doc, 'scroll', callback, true);\n    if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\n      domObserver = new win.MutationObserver(callback);\n      domObserver.observe(doc, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    }\n  }\n\n  this._monitoringDocuments.push(doc);\n  this._monitoringUnsubscribes.push(function() {\n    // Get the window object again. When a friendly iframe is destroyed, it\n    // will be null.\n    var win = doc.defaultView;\n\n    if (win) {\n      if (monitoringInterval) {\n        win.clearInterval(monitoringInterval);\n      }\n      removeEvent(win, 'resize', callback, true);\n    }\n\n    removeEvent(doc, 'scroll', callback, true);\n    if (domObserver) {\n      domObserver.disconnect();\n    }\n  });\n\n  // Also monitor the parent.\n  if (doc != (this.root && this.root.ownerDocument || document)) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._monitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function(doc) {\n  var index = this._monitoringDocuments.indexOf(doc);\n  if (index == -1) {\n    return;\n  }\n\n  var rootDoc = (this.root && this.root.ownerDocument || document);\n\n  // Check if any dependent targets are still remaining.\n  var hasDependentTargets =\n      this._observationTargets.some(function(item) {\n        var itemDoc = item.element.ownerDocument;\n        // Target is in this context.\n        if (itemDoc == doc) {\n          return true;\n        }\n        // Target is nested in this context.\n        while (itemDoc && itemDoc != rootDoc) {\n          var frame = getFrameElement(itemDoc);\n          itemDoc = frame && frame.ownerDocument;\n          if (itemDoc == doc) {\n            return true;\n          }\n        }\n        return false;\n      });\n  if (hasDependentTargets) {\n    return;\n  }\n\n  // Unsubscribe.\n  var unsubscribe = this._monitoringUnsubscribes[index];\n  this._monitoringDocuments.splice(index, 1);\n  this._monitoringUnsubscribes.splice(index, 1);\n  unsubscribe();\n\n  // Also unmonitor the parent.\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._unmonitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorAllIntersections = function() {\n  var unsubscribes = this._monitoringUnsubscribes.slice(0);\n  this._monitoringDocuments.length = 0;\n  this._monitoringUnsubscribes.length = 0;\n  for (var i = 0; i < unsubscribes.length; i++) {\n    unsubscribes[i]();\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  if (!this.root && crossOriginUpdater && !crossOriginRect) {\n    // Cross origin monitoring, but no initial data available yet.\n    return;\n  }\n\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, targetRect, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: crossOriginUpdater && !this.root ? null : rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} targetRect The bounding rect of the target.\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, targetRect, rootRect) {\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot && parent) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return null;\n\n    if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {\n      atRoot = true;\n      if (parent == this.root || parent == document) {\n        if (crossOriginUpdater && !this.root) {\n          if (!crossOriginRect ||\n              crossOriginRect.width == 0 && crossOriginRect.height == 0) {\n            // A 0-size cross-origin intersection means no-intersection.\n            parent = null;\n            parentRect = null;\n            intersectionRect = null;\n          } else {\n            parentRect = crossOriginRect;\n          }\n        } else {\n          parentRect = rootRect;\n        }\n      } else {\n        // Check if there's a frame that can be navigated to.\n        var frame = getParentNode(parent);\n        var frameRect = frame && getBoundingClientRect(frame);\n        var frameIntersect =\n            frame &&\n            this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\n        if (frameRect && frameIntersect) {\n          parent = frame;\n          parentRect = convertFromParentRect(frameRect, frameIntersect);\n        } else {\n          parent = null;\n          intersectionRect = null;\n        }\n      }\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      var doc = parent.ownerDocument;\n      if (parent != doc.body &&\n          parent != doc.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n    }\n    if (!intersectionRect) break;\n    parent = parent && getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {ClientRect} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {DOMRect|ClientRect} rect The rect object to expand.\n * @return {ClientRect} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target) &&\n    (!this.root || this.root.ownerDocument == target.ownerDocument);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object|?ClientRect} The intersection rect or undefined if no\n *     intersection is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  } || null;\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {ClientRect} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n\n/**\n * Ensure that the result has all of the necessary fields of the DOMRect.\n * Specifically this ensures that `x` and `y` fields are set.\n *\n * @param {?DOMRect|?ClientRect} rect\n * @return {?DOMRect}\n */\nfunction ensureDOMRect(rect) {\n  // A `DOMRect` object has `x` and `y` fields.\n  if (!rect || 'x' in rect) {\n    return rect;\n  }\n  // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\n  // for internally calculated Rect objects. For the purposes of\n  // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\n  // for these fields.\n  return {\n    top: rect.top,\n    y: rect.top,\n    bottom: rect.bottom,\n    left: rect.left,\n    x: rect.left,\n    right: rect.right,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\n\n/**\n * Inverts the intersection and bounding rect from the parent (frame) BCR to\n * the local BCR space.\n * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\n * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\n * @return {ClientRect} The local root bounding rect for the parent's children.\n */\nfunction convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\n  var top = parentIntersectionRect.top - parentBoundingRect.top;\n  var left = parentIntersectionRect.left - parentBoundingRect.left;\n  return {\n    top: top,\n    left: left,\n    height: parentIntersectionRect.height,\n    width: parentIntersectionRect.width,\n    bottom: top + parentIntersectionRect.height,\n    right: left + parentIntersectionRect.width\n  };\n}\n\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (node.nodeType == /* DOCUMENT */ 9 && node != document) {\n    // If this node is a document node, look for the embedding frame.\n    return getFrameElement(node);\n  }\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  if (parent && parent.assignedSlot) {\n    // If the parent is distributed in a <slot>, return the parent of a slot.\n    return parent.assignedSlot.parentNode;\n  }\n\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/intersection-observer/intersection-observer.js"],"sourceRoot":""}