{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./app/javascript/controllers/quick_bookmark_controller.js","webpack:///./app/javascript/packs/integrations.js","webpack:///./app/javascript/packs/notifications.js","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/mousetrap/mousetrap.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/hub/esm/span.js","webpack:///./node_modules/micromodal/dist/micromodal.es.js","webpack:///./node_modules/cookieconsent/build/cookieconsent.min.js","webpack:///(webpack)/buildin/harmony-module.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/utils/esm/polyfill.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/core/esm/dsn.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/types/esm/status.js","webpack:///./node_modules/@sentry/core/esm/transports/noop.js","webpack:///./node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/core/esm/basebackend.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/browser/esm/tracekit.js","webpack:///./node_modules/@sentry/browser/esm/parsers.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/browser/esm/transports/base.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/backend.js","webpack:///./node_modules/@sentry/browser/esm/version.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/browser/esm/helpers.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/globalhandlers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/browser/esm/integrations/useragent.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js","webpack:///./app/javascript/packs/outside_critical_path.js","webpack:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@stimulus/core/dist/src/event_listener.js","webpack:///./node_modules/@stimulus/core/dist/src/dispatcher.js","webpack:///./node_modules/@stimulus/core/dist/src/action_descriptor.js","webpack:///./node_modules/@stimulus/core/dist/src/action.js","webpack:///./node_modules/@stimulus/core/dist/src/binding.js","webpack:///./node_modules/@stimulus/mutation-observers/dist/src/element_observer.js","webpack:///./node_modules/@stimulus/mutation-observers/dist/src/attribute_observer.js","webpack:///./node_modules/@stimulus/multimap/dist/src/set_operations.js","webpack:///./node_modules/@stimulus/multimap/dist/src/multimap.js","webpack:///./node_modules/@stimulus/multimap/dist/src/indexed_multimap.js","webpack:///./node_modules/@stimulus/mutation-observers/dist/src/token_list_observer.js","webpack:///./node_modules/@stimulus/mutation-observers/dist/src/value_list_observer.js","webpack:///./node_modules/@stimulus/core/dist/src/binding_observer.js","webpack:///./node_modules/@stimulus/core/dist/src/context.js","webpack:///./node_modules/@stimulus/core/dist/src/definition.js","webpack:///./node_modules/@stimulus/core/dist/src/module.js","webpack:///./node_modules/@stimulus/core/dist/src/data_map.js","webpack:///./node_modules/@stimulus/core/dist/src/selectors.js","webpack:///./node_modules/@stimulus/core/dist/src/target_set.js","webpack:///./node_modules/@stimulus/core/dist/src/scope.js","webpack:///./node_modules/@stimulus/core/dist/src/scope_observer.js","webpack:///./node_modules/@stimulus/core/dist/src/router.js","webpack:///./node_modules/@stimulus/core/dist/src/schema.js","webpack:///./node_modules/@stimulus/core/dist/src/application.js","webpack:///./node_modules/@stimulus/core/dist/src/target_properties.js","webpack:///./node_modules/@stimulus/core/dist/src/controller.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/utils/esm/object.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","$modal","$","title","window","Tefter","orgName","text","find","show","val","setTimeout","focus","event","detail","data","message","status","responseText","match","JSON","parse","errors","this","messageTarget","innerHTML","response","resource","existing","buttonTarget","hide","url","id","organizationSlug","length","ctrl","fetchMetadata","inputTarget","then","metadata","modalId","element","replace","refreshUrl","MicroModal","close","Turbo","visit","action","post","timeout","Controller","targets","Integrations","embedPlayers","each","_i","el","embedPlayer","$element","type","html","width","height","addClass","source","encodedId","encodeURIComponent","Notifications","notifications_enabled","CHECK_INTERVAL","user_signed_in","checkUnread","timer","setInterval","params","organization_id","organizationId","getJSON","unread","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_context","addScopeListener","callback","push","addEventProcessor","_notifyScopeListeners","_this","forEach","_notifyEventProcessors","processors","hint","index","resolve","reject","processor","result","final","catch","setUser","user","setTags","tags","setTag","_a","setExtras","extra","setExtra","setFingerprint","fingerprint","_fingerprint","setLevel","level","_level","setTransaction","transaction","_transaction","setContext","context","undefined","setSpan","span","_span","startSpan","parentSpan","setParent","getSpan","clone","scope","newScope","assign","clear","addBreadcrumb","breadcrumb","maxBreadcrumbs","timestamp","Date","getTime","mergedBreadcrumb","slice","clearBreadcrumbs","_applyFingerprint","Array","isArray","concat","applyToEvent","keys","contexts","trace","breadcrumbs","getGlobalEventProcessors","global","__SENTRY__","globalEventProcessors","addGlobalEventProcessor","_typeof","obj","iterator","constructor","g","Function","e","document","_REVERSE_MAP","_MAP","8","9","13","16","17","18","20","27","32","33","34","35","36","37","38","39","40","45","46","91","93","224","_KEYCODE_MAP","106","107","109","110","111","186","187","188","189","190","191","192","219","220","221","222","_SHIFT_MAP","_SPECIAL_ALIASES","test","navigator","platform","toString","Mousetrap","self","_bindMultiple","unbind","trigger","_directMap","reset","_callbacks","stopCallback","className","indexOf","_belongsTo","target","composedPath","initialEventTarget","tagName","isContentEditable","handleKey","_handleKey","apply","arguments","addKeycodes","init","documentMousetrap","method","charAt","_addEvent","addEventListener","attachEvent","_characterFromEvent","character","String","fromCharCode","which","shiftKey","toLowerCase","_isModifier","_pickBestAction","modifiers","_getReverseMap","_getKeyInfo","combination","split","_keysFromString","ancestor","parentNode","targetElement","_resetTimer","_sequenceLevels","_ignoreNextKeyup","_ignoreNextKeypress","_nextExpectedAction","_resetSequences","doNotReset","activeSequences","_getMatches","sequenceName","modifiers1","modifiers2","matches","seq","metaKey","ctrlKey","sort","join","deleteCombo","combo","deleteSequence","splice","_fireCallback","sequence","srcElement","preventDefault","returnValue","_preventDefault","stopPropagation","cancelBubble","_stopPropagation","_handleKeyEvent","keyCode","altKey","_eventModifiers","_bindSequence","_increaseSequence","nextAction","clearTimeout","_callbackAndReset","wrappedCallback","_bindSingle","info","callbacks","maxLevel","processedSequenceCallback","Math","max","ignoreThisKeypress","combinations","PREFIX","Logger","_enabled","disable","enable","log","args","console","warn","error","logger","Memo","_hasWeakSet","WeakSet","_inner","memoize","has","add","unmemoize","delete","TRACEPARENT_REGEXP","Span","_traceId","_spanId","_sampled","_parent","substring","parent","setSampled","sampled","fromTraceparent","traceparent","parent_1","toTraceparent","toJSON","span_id","trace_id","_toConsumableArray","arr","_arrayLikeToArray","_arrayWithoutHoles","iter","from","_iterableToArray","minLen","_unsupportedIterableToArray","TypeError","_nonIterableSpread","len","arr2","_defineProperties","props","descriptor","configurable","writable","FOCUSABLE_ELEMENTS","Modal","activeModal","validateModalPresence","validateArgs","_ref","targetModal","_ref$triggers","triggers","_ref$onShow","onShow","_ref$onClose","onClose","_ref$openTrigger","openTrigger","_ref$closeTrigger","closeTrigger","_ref$disableScroll","disableScroll","_ref$disableFocus","disableFocus","_ref$awaitCloseAnimat","awaitCloseAnimation","_ref$awaitOpenAnimati","awaitOpenAnimation","_ref$debugMode","debugMode","instance","Constructor","_classCallCheck","modal","getElementById","config","registerTriggers","onClick","onKeydown","protoProps","staticProps","_len","_key","filter","Boolean","showModal","_this2","activeElement","setAttribute","classList","scrollBehaviour","addEventListeners","handler","removeEventListener","setFocusToFirstNode","removeEventListeners","remove","closeModal","toggle","body","querySelector","style","overflow","hasAttribute","maintainFocus","nodes","querySelectorAll","focusableNodes","getFocusableNodes","contains","focusedItemIndex","triggerMap","validateTriggerPresence","options","triggerAttr","attributes","generateTriggerMap","closeModalById","hasInitialised","escapeRegExp","hasClass","nodeType","removeClass","RegExp","interpolateString","getCookie","cookie","pop","shift","setCookie","setHours","getHours","a","toUTCString","deepExtend","isPlainObject","throttle","hash","charCodeAt","normaliseHex","substr","getContrast","parseInt","getLuminance","isMobile","userAgent","traverseDOMPath","deny","allow","dismiss","transitionEnd","createElement","OT","msT","MozT","WebkitT","hasTransition","map","customStyles","Popup","enabled","container","path","domain","expiryDays","secure","onPopupOpen","onPopupClose","onInitialise","onStatusChange","onRevokeChoice","onNoCookieLaw","content","header","link","href","policy","elements","messagelink","revokeBtn","compliance","layouts","basic","layout","position","theme","static","palette","revokable","animateRevokable","showLink","dismissOnScroll","dismissOnTimeout","dismissOnWindowClick","ignoreClicksFrom","autoOpen","autoAttach","whitelistPage","blacklistPage","overrideHTML","initialise","openingTimeout","display","afterTransition","children","onButtonClick","setStatus","revokeChoice","firstChild","insertBefore","appendChild","u","destroy","cookieEnabled","CookiesOK","getStatus","location","pathname","stringify","customStyleSelector","references","popup","button","highlight","background","border","padding","hover","head","sheet","h","insertRule","dismissTimeout","floor","pageYOffset","onWindowScroll","onWindowClick","innerHeight","clientY","onMouseMove","removeChild","ownerNode","open","isOpen","fadeIn","toggleRevokeButton","fadeOut","clientHeight","maxHeight","clearStatus","hasAnswered","hasConsented","Location","services","serviceDefinitions","ipinfo","headers","code","country","ipinfodb","isScript","statusCode","statusMessage","countryCode","maxmind","geoip2","iso_code","Error","currentServiceIndex","src","async","onreadystatechange","onload","readyState","done","XMLHttpRequest","ActiveXObject","setRequestHeader","send","getNextService","getServiceByIdx","locate","callbackComplete","callbackError","runService","runNextServiceOnError","setupUrl","getCurrentServiceOpts","now","__JSONP_DATA","interpolateUrl","runServiceCallback","onServiceResult","logError","completeService","Law","regionalLaw","hasLaw","explicitAction","applyLaw","law","getCountryCode","utils","cookieconsent","originalModule","webpackPolyfill","originalFunctionToString","FunctionToString","setupOnce","__sentry__","__sentry_original__","truncate","str","safeJoin","input","delimiter","output","keysToEventMessage","maxLength","includedKeys","serialized","isMatchingPattern","pattern","is","includes","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","hub","getIntegration","client","getClient","clientOptions","getOptions","_mergeOptions","_shouldDropEvent","_isSentryError","_isIgnoredError","_isBlacklistedUrl","_getEventFilterUrl","_isWhitelistedUrl","ignoreInternal","exception","values","_oO","ignoreErrors","_getPossibleEventMessages","some","blacklistUrls","whitelistUrls","oO","stacktrace","frames_1","frames","filename","frames_2","setPrototypeOf","__proto__","proto","prop","_super","SentryError","_newTarget","DSN_REGEX","ERROR_MESSAGE","Dsn","_fromString","_fromComponents","_validate","withPassword","host","pass","port","projectId","protocol","exec","_b","_c","components","component","Number","isNaN","API","dsn","_dsnObject","getDsn","getStoreEndpoint","_getBaseUrl","getStoreEndpointPath","getStoreEndpointWithUrlEncodedAuth","auth","sentry_key","sentry_version","getRequestHeaders","clientName","clientVersion","getReportDialogEndpoint","dialogOptions","endpoint","encodedOptions","email","installedIntegrations","setupIntegrations","integrations","defaultIntegrations","userIntegrations","userIntegrationsNames_1","pickedIntegrationsNames_1","defaultIntegration","userIntegration","getIntegrationsToSetup","integration","setupIntegration","Status","BaseClient","backendClass","_integrations","_processing","_backend","_dsn","_isEnabled","captureException","eventId","event_id","_getBackend","eventFromException","_processEvent","finalEvent","reason","captureMessage","eventFromMessage","captureEvent","flush","_isClientProcessing","clearInterval","interval","getTransport","transportFlushed","ready","getIntegrations","Promise","ticked","_prepareEvent","environment","release","dist","maxValueLength","prepared","request","_addIntegrations","sdk","sdkInfo","integrationsArray","beforeSend","sampleRate","random","sendEvent","beforeSendResult","_handleAsyncBeforeSend","originalException","processedEvent","fromHttpCode","Success","RateLimit","Invalid","Failed","Unknown","Severity","NoopTransport","_","Skipped","BaseBackend","_transport","_setupTransport","_exception","_hint","_message","supportsFetch","Headers","Request","Response","supportsReferrerPolicy","referrerPolicy","fromString","Debug","Info","Warning","Fatal","Critical","Log","TraceKit","_report","_collectWindowErrors","_computeStackTrace","_linesOfContext","UNKNOWN_FUNCTION","ERROR_TYPES_RE","_has","getLocationHref","_oldOnerrorHandler","_onErrorHandlerInstalled","handlers","lastException","lastExceptionStack","_notifyHandlers","stack","isWindowError","inner","_traceKitWindowOnError","lineNo","columnNo","errorObj","_augmentStackTraceWithInitialElement","processLastException","mechanism","line","column","msg","groups","func","_traceKitWindowOnUnhandledRejection","err","_lastExceptionStack","_lastException","ex","incomplete","_subscribe","_installGlobalHandler","onerror","_installGlobalUnhandledRejectionHandler","onunhandledrejection","_computeStackTraceFromStackProp","submatch","parts","chrome","gecko","winjs","geckoEval","chromeEval","lines","reference","j","isNative","columnNumber","stackInfo","initial","unshift","partial","_computeStackTraceByWalkingCallerChain","depth","item","functionName","funcs","recursion","curr","caller","sourceURL","fileName","lineNumber","description","computeStackTrace","popSize","framesToPop","opera10Regex","opera11Regex","_computeStackTraceFromStacktraceProp","popFrames","lineRE1","lineRE2","lineRE3","scripts","getElementsByTagName","inlineScriptBlocks","_computeStackTraceFromOperaMultiLineMessage","original","exceptionFromStacktrace","prepareFramesForEvent","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","frame","colno","function","in_app","lineno","reverse","PromiseBuffer","_limit","_buffer","isReady","task","drain","capturedSetTimeout","all","BaseTransport","FetchTransport","defaultOptions","fetch","XHRTransport","BrowserBackend","transportOptions","transport","_buildEvent","domException","name_1","message_1","messageEvent","syntheticException","exceptionKeys","__serialized__","eventFromPlainObject","handled","synthetic","stringException","attachStacktrace","SDK_VERSION","BrowserClient","packages","version","showReportDialog","script","onLoad","callOnHub","withScope","keypressTimeout","lastCapturedEvent","ignoreOnError","ignoreNextOnError","wrap","fn","before","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","handleEvent","defineProperties","getOwnPropertyDescriptor","debounceTimer","breadcrumbEventHandler","eventName","debounce","captureBreadcrumb","_htmlTreeAsString","category","keypressEventHandler","elem","nextStr","currentElem","out","sepLength","_htmlElementAsString","classes","attr","attrWhitelist","getAttribute","TryCatch","_ignoreOnError","_wrapTimeFunction","originalCallback","getFunctionName","_wrapRAF","_wrapEventTarget","lastHref","Breadcrumbs","dom","history","sentry","xhr","_instrumentConsole","originalConsoleLevel","breadcrumbData","_instrumentDOM","innerOriginal","_instrumentFetch","isNativeFunc","doc","sandbox","hidden","contentWindow","supportsNativeFetch","originalFetch","fetchInput","filterUrl","addSentryBreadcrumb","fetchData","toUpperCase","status_code","_instrumentHistory","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","captureUrlChange","to","parsedLoc","parsedTo","parsedFrom","relative","oldOnPopState","onpopstate","currentHref","historyReplacementFunction","originalHistoryFunction","_instrumentXHR","xhrproto","originalOpen","__sentry_xhr__","__sentry_own_request__","originalSend","onreadystatechangeHandler","wrapProp","serializedData","event_1","GlobalHandlers","stackTraceLimit","_eventFromGlobalHandler","_eventFromIncompleteRejection","fallbackValue","fallbackType","LinkedErrors","limit","_handler","linkedErrors","_walkErrorTree","UserAgent","QuickBookmark","click","bodyClass","on","css","loadMicroModal","attach","Headway","headwayConfig","initHeadway","localStorage","getItem","chosenBefore","setItem","window_1","SENTRY_RELEASE","clientClass","debug","bindClient","initAndBind","Sentry","States","SyncPromise","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","REJECTED","state","_value","_executeHandlers","onFail","onSuccess","_attachHandler","onfulfilled","onrejected","Hub","_version","_stack","_invokeClient","top","getStackTop","isOlderThan","pushScope","getStack","parentScope","popScope","getScope","_lastEventId","finalHint","lastEventId","beforeBreadcrumb","finalBreadcrumb","min","extras","configureScope","run","oldHub","makeMain","traceHeaders","getMainCarrier","carrier","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","active","registryHubTopStack","_Oo","dynamicRequire","mod","require","fallbackGlobalObject","getGlobalObject","process","uuid4","crypto","msCrypto","getRandomValues","Uint16Array","pad","num","v","parseUrl","query","fragment","getEventDescription","consoleSandbox","originalConsole","wrappedLevels","addExceptionTypeValue","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","Item","array","noop","nextTick","browser","env","argv","versions","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","_extendStatics","b","__extends","__","_assign","__read","ar","next","__spread","EventListener","eventTarget","unorderedBindings","Set","connect","disconnect","bindingConnected","bindingDisconnected","extendedEvent","stopImmediatePropagation_1","stopImmediatePropagation","immediatePropagationStopped","extendEvent","bindings","left","right","leftIndex","rightIndex","Dispatcher","application","eventListenerMaps","Map","started","start","eventListeners","eventListener","stop","reduce","fetchEventListenerForBinding","handleError","fetchEventListener","eventListenerMap","fetchEventListenerMapForEventTarget","createEventListener","set","descriptorPattern","parseEventTarget","eventTargetName","Action","defaultEventNames","getDefaultEventNameForElement","identifier","methodName","forToken","token","descriptorString","trim","eventNameSuffix","Binding","willBeInvokedByEvent","invokeWithEvent","controller","Element","containsElement","ElementObserver","delegate","mutationObserver","MutationObserver","mutations","processMutations","observe","childList","subtree","refresh","takeRecords","matchElementsInTree","removeElement","addElement","mutations_1","mutation","processMutation","processAttributeChange","attributeName","processRemovedNodes","removedNodes","processAddedNodes","addedNodes","node","elementAttributeChanged","matchElement","elementFromNode","processTree","elementIsActive","tree","Node","ELEMENT_NODE","isConnected","elementMatched","elementUnmatched","AttributeObserver","elementObserver","selector","elementMatchedAttribute","elementUnmatchedAttribute","elementAttributeValueChanged","del","size","prune","extendStatics","Multimap","valuesByKey","hasKey","hasValue","getValuesForKey","getKeysForValue","IndexedMultimap","keysByValue","TokenListObserver","attributeObserver","tokensByElement","tokensMatched","readTokensForElement","refreshTokensForElement","unmatchedTokens","matchedTokens","tokensUnmatched","tokens","tokenMatched","tokenUnmatched","previousTokens","currentTokens","firstDifferingIndex","findIndex","tokensAreEqual","tokenString","parseTokenString","ValueListObserver","tokenListObserver","parseResultsByToken","WeakMap","valuesByTokenByElement","fetchParseResultForToken","fetchValuesByTokenForElement","elementMatchedValue","elementUnmatchedValue","parseResult","parseToken","valuesByToken","parseValueForToken","BindingObserver","bindingsByAction","valueListObserver","actionAttribute","disconnectAllActions","schema","connectAction","disconnectAction","Context","controllerConstructor","bindingObserver","dispatcher","initialize","parentElement","blessControllerConstructor","extend","bless","extendWithReflect","Reflect","construct","Module","definition","blessDefinition","contextsByScope","connectedContexts","connectContextForScope","fetchContextForScope","disconnectContextForScope","DataMap","getFormattedKey","removeAttribute","char","attributeValueContainsToken","TargetSet","targetName","targetNames","getSelectorForTargetNames","findElement","findAll","findAllElements","getSelectorForTargetName","targetDescriptor","targetAttribute","tail","filterElements","closest","controllerSelector","controllerAttribute","ScopeObserver","scopesByIdentifierByElement","scopeReferenceCounts","scopesByIdentifier","fetchScopesByIdentifierForElement","referenceCount","scopeConnected","scopeDisconnected","Router","scopeObserver","modulesByIdentifier","loadDefinition","unloadIdentifier","connectModule","disconnectModule","getContextForElementAndIdentifier","defaultSchema","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","__generator","f","y","label","sent","trys","ops","verb","op","Application","documentElement","router","register","load","rest","definitions","unload","identifiers","getControllerForElementAndIdentifier","defineTargetProperties","ancestors","getPrototypeOf","getAncestorsForConstructor","getOwnTargetNamesForConstructor","getTargetNamesForConstructor","properties","capitalize","isError","wat","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isRegExp","isThenable","isSyntheticEvent","fill","replacement","wrapped","urlEncode","jsonSize","encodeURI","utf8Length","normalizeToSize","maxSize","normalize","normalizeValue","_events","Event","walk","memo","Infinity","normalized","serializeValue","objectifyError","acc","innerKey"],"mappings":"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","file":"js/outside_critical_path-0e426d4066aada812cf2.js","sourcesContent":[" \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, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\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 = \"//d1eub78dsdxite.cloudfront.net/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 165);\n","import { Controller } from \"stimulus\";\n\nexport default class extends Controller {\n  static targets = ['input', 'message', 'button'];\n\n  reset() {\n    let $modal = $(\"#modal-quick-bookmark\");\n\n    let title = 'Add bookmark';\n\n    if (window.Tefter.orgName) {\n      title = `${title} to ${window.Tefter.orgName}`;\n    }\n\n    $(\"#modal-quick-bookmark-title\").text(title);\n\n    $modal.find('input[type=text]').show().val('');\n    $modal.find('input[type=text]').val('');\n\n    setTimeout(function() { $modal.find('input[type=text]').focus(); }, 100);\n\n    $modal.find('.message').text('');\n    $modal.find('.create').show().val('Save')\n  }\n\n  handleResponse(event) {\n    let [data, status, xhr] = event.detail;\n    let message = '';\n\n    if (data.status === 422) {\n      if (data.responseText.match('Your plan supports')) {\n        message = JSON.parse(data.responseText).errors.title;\n      }\n      else {\n        message = `Address is invalid. Please provide a well\nformatted address like https://www.example.com`\n      }\n\n      this.messageTarget.innerHTML = message;\n    }\n\n    if (data.status === 200) {\n      let response = JSON.parse(data.response);\n\n      if (response.resource.existing == true) {\n        $(this.buttonTarget).hide();\n\n        let url = '/bookmarks/' + response.resource.id + '/edit';\n\n        if (window.Tefter.organizationSlug && window.Tefter.organizationSlug.length > 0) {\n          url = `/orgs/${window.Tefter.organizationSlug}${url}`;\n        }\n\n        message = `Bookmark already exists. Click <a href=\"${url}\">here</a> to edit.`;\n\n        this.messageTarget.innerHTML = message;\n      }\n    }\n\n    if (data.status === 201) {\n      let response = JSON.parse(data.response);\n      let ctrl = this;\n\n      this.fetchMetadata(this.inputTarget.value).then(function(metadata) {\n        let modalId = ctrl.element.id.replace('-content', '');\n\n        $(ctrl.inputTarget).hide();\n        $(ctrl.buttonTarget).hide();\n        $(\"#modal-quick-bookmark-title\").text('Bookmark added!');\n\n        let url = '/bookmarks/' + response.resource.id + '/edit';\n        let refreshUrl = '/bookmarks';\n\n        if (window.Tefter.organizationSlug && window.Tefter.organizationSlug.length > 0) {\n          url = `/orgs/${window.Tefter.organizationSlug}${url}`;\n          refreshUrl = `/orgs/${window.Tefter.organizationSlug}${refreshUrl}`;\n        }\n\n        if (metadata.title) {\n          message = `\n            “${metadata.title}”\n            <br/>\n            <a class=\"btn\" href=${url}>Edit</a>\n            `;\n        } else {\n          message = `<a class=\"btn\" href=${url}>Edit</a>`;\n        }\n\n        window.setTimeout(window.Tefter.MicroModal.close, 2 * 1000, modalId);\n        window.setTimeout(Turbo.visit, 1000, refreshUrl, { action: 'replace' });\n\n        ctrl.messageTarget.innerHTML = message;\n      });\n    }\n\n    this.buttonTarget.value = 'Save';\n  }\n\n  fetchMetadata(url) {\n    return $.post('/bookmarks/infer_metadata', { url: url, timeout: 1000 });\n  }\n\n  submit(event) {\n    this.buttonTarget.value = 'Saving..';\n  }\n}\n","export default class Integrations {\n  attach() {\n    this.embedPlayers();\n  }\n\n  embedPlayers() {\n    $('.card .screenshot[data-integration=youtube]').each(function(_i, el) {\n      this.embedPlayer($(el), 'youtube');\n    }.bind(this));\n\n    $('.card .screenshot[data-integration=soundcloud]').each(function(_i, el) {\n      this.embedPlayer($(el), 'soundcloud');\n    }.bind(this));\n\n    $('.card .screenshot[data-integration=mixcloud]').each(function(_i, el) {\n      this.embedPlayer($(el), 'mixcloud');\n    }.bind(this));\n  }\n\n  embedPlayer($element, type) {\n    $element.html(this[`${type}Embed`]($element.data(`${type}Id`),\n                                        $element.width(),\n                                        $element.height()));\n    $element.addClass('embedded-player');\n  }\n\n  youtubeEmbed(id, width, height) {\n    return `<iframe width=\"${width}\" height=\"${height}\" ` +\n      `src=\"//www.youtube.com/embed/${id}\" frameborder=\"0\" `  +\n      `allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>`;\n  }\n\n  soundcloudEmbed(id, width, height) {\n    const base_url = `https://w.soundcloud.com/player/?` +\n          `url=https%3A//api.soundcloud.com/tracks/`;\n    const opts = `&color=%23ffffff&auto_play=false&hide_related=true` +\n          `&show_comments=false&show_user=true&show_reposts=false` +\n          `&show_teaser=true&visual=true`;\n    const source = `${base_url}${id}${opts}`;\n\n    return `<iframe width=\"${width}\" height=\"${height}\" ` +\n      `scrolling=\"no\" frameborder=\"no\" allow=\"autoplay\" ` +\n      `src=\"${source}\"></iframe>`;\n  }\n\n  mixcloudEmbed(id, width, height) {\n    const base_url = `https://www.mixcloud.com/widget/iframe/?`;\n    const encodedId = encodeURIComponent(`/${id}/`);\n    const source = `${base_url}feed=${encodedId}`;\n\n    return `<iframe width=\"${width}\" height=\"${height}\" ` +\n      `scrolling=\"no\" frameborder=\"no\" allow=\"autoplay\" ` +\n      `src=\"${source}\"></iframe>`;\n  }\n}\n","export default class Notifications {\n  attach() {\n    if (Tefter.notifications_enabled) {\n      this.CHECK_INTERVAL = 5 * 60000; // 5 minutes\n\n      if (Tefter.user_signed_in) {\n        this.checkUnread();\n        this.timer = window.setInterval(this.checkUnread.bind(this), this.CHECK_INTERVAL);\n      }\n    }\n  }\n\n  checkUnread() {\n    const params = { organization_id: window.Tefter.organizationId };\n\n    $.getJSON('/notifications/check_unread', params, function(response) {\n      const { unread: unread } = response;\n\n      if (unread) {\n        $('.header-settings .notifications').addClass('unread-notifications');\n        $('.sidebar-user .notifications').addClass('unread-notifications');\n      }\n    })\n  }\n}\n","import * as tslib_1 from \"tslib\";\nimport { getGlobalObject, isThenable, normalize, SyncPromise } from '@sentry/utils';\nimport { Span } from './span';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\n\nvar Scope =\n/** @class */\nfunction () {\n  function Scope() {\n    /** Flag if notifiying is happening. */\n    this._notifyingListeners = false;\n    /** Callback for client to receive scope changes. */\n\n    this._scopeListeners = [];\n    /** Callback list that will be called after {@link applyToEvent}. */\n\n    this._eventProcessors = [];\n    /** Array of breadcrumbs. */\n\n    this._breadcrumbs = [];\n    /** User */\n\n    this._user = {};\n    /** Tags */\n\n    this._tags = {};\n    /** Extra */\n\n    this._extra = {};\n    /** Contexts */\n\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\n\n  Scope.prototype.addScopeListener = function (callback) {\n    this._scopeListeners.push(callback);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.addEventProcessor = function (callback) {\n    this._eventProcessors.push(callback);\n\n    return this;\n  };\n  /**\n   * This will be called on every set call.\n   */\n\n\n  Scope.prototype._notifyScopeListeners = function () {\n    var _this = this;\n\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      setTimeout(function () {\n        _this._scopeListeners.forEach(function (callback) {\n          callback(_this);\n        });\n\n        _this._notifyingListeners = false;\n      });\n    }\n  };\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n\n\n  Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n    var _this = this;\n\n    if (index === void 0) {\n      index = 0;\n    }\n\n    return new SyncPromise(function (resolve, reject) {\n      var processor = processors[index]; // tslint:disable-next-line:strict-type-predicates\n\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        var result = processor(tslib_1.__assign({}, event), hint);\n\n        if (isThenable(result)) {\n          result.then(function (final) {\n            return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve);\n          }).catch(reject);\n        } else {\n          _this._notifyEventProcessors(processors, result, hint, index + 1).then(resolve).catch(reject);\n        }\n      }\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setUser = function (user) {\n    this._user = normalize(user);\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setTags = function (tags) {\n    this._tags = tslib_1.__assign({}, this._tags, normalize(tags));\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setTag = function (key, value) {\n    var _a;\n\n    this._tags = tslib_1.__assign({}, this._tags, (_a = {}, _a[key] = normalize(value), _a));\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setExtras = function (extra) {\n    this._extra = tslib_1.__assign({}, this._extra, normalize(extra));\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setExtra = function (key, extra) {\n    var _a;\n\n    this._extra = tslib_1.__assign({}, this._extra, (_a = {}, _a[key] = normalize(extra), _a));\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setFingerprint = function (fingerprint) {\n    this._fingerprint = normalize(fingerprint);\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setLevel = function (level) {\n    this._level = normalize(level);\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setTransaction = function (transaction) {\n    this._transaction = transaction;\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setContext = function (name, context) {\n    this._context[name] = context ? normalize(context) : undefined;\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.setSpan = function (span) {\n    this._span = span;\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.startSpan = function (parentSpan) {\n    var span = new Span();\n    span.setParent(parentSpan);\n    this.setSpan(span);\n    return span;\n  };\n  /**\n   * Internal getter for Span, used in Hub.\n   * @hidden\n   */\n\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\n\n  Scope.clone = function (scope) {\n    var newScope = new Scope();\n    Object.assign(newScope, scope, {\n      _scopeListeners: []\n    });\n\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\n    return newScope;\n  };\n  /**\n   * @inheritDoc\n   */\n\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\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n    var timestamp = new Date().getTime() / 1000;\n\n    var mergedBreadcrumb = tslib_1.__assign({\n      timestamp: timestamp\n    }, breadcrumb);\n\n    this._breadcrumbs = maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0 ? tslib_1.__spread(this._breadcrumbs, [normalize(mergedBreadcrumb)]).slice(-maxBreadcrumbs) : tslib_1.__spread(this._breadcrumbs, [normalize(mergedBreadcrumb)]);\n\n    this._notifyScopeListeners();\n\n    return this;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Scope.prototype.clearBreadcrumbs = function () {\n    this._breadcrumbs = [];\n\n    this._notifyScopeListeners();\n\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\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] : []; // If we have something on the scope, then merge it with event\n\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    } // If we have no data at all, remove empty array default\n\n\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\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\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = tslib_1.__assign({}, this._tags, event.tags);\n    }\n\n    if (this._user && Object.keys(this._user).length) {\n      event.user = tslib_1.__assign({}, this._user, event.user);\n    }\n\n    if (this._context && Object.keys(this._context).length) {\n      event.contexts = tslib_1.__assign({}, this._context, event.contexts);\n    }\n\n    if (this._level) {\n      event.level = this._level;\n    }\n\n    if (this._transaction) {\n      event.transaction = this._transaction;\n    }\n\n    if (this._span) {\n      event.contexts = event.contexts || {};\n      event.contexts.trace = this._span;\n    }\n\n    this._applyFingerprint(event);\n\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\n  return Scope;\n}();\n\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\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 */\n\n\nexport function addGlobalEventProcessor(callback) {\n  getGlobalEventProcessors().push(callback);\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar g; // This works in non-strict mode\n\ng = function () {\n  return this;\n}();\n\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\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\n\nmodule.exports = g;","/*global define:false */\n\n/**\n * Copyright 2012-2017 Craig Campbell\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * Mousetrap is a simple keyboard shortcut library for Javascript with\n * no external dependencies\n *\n * @version 1.6.5\n * @url craig.is/killing/mice\n */\n(function (window, document, undefined) {\n  // Check if mousetrap is used inside browser, if not, return\n  if (!window) {\n    return;\n  }\n  /**\n   * mapping of special keycodes to their corresponding keys\n   *\n   * everything in this dictionary cannot use keypress events\n   * so it has to be here to map to the correct keycodes for\n   * keyup/keydown events\n   *\n   * @type {Object}\n   */\n\n\n  var _MAP = {\n    8: 'backspace',\n    9: 'tab',\n    13: 'enter',\n    16: 'shift',\n    17: 'ctrl',\n    18: 'alt',\n    20: 'capslock',\n    27: 'esc',\n    32: 'space',\n    33: 'pageup',\n    34: 'pagedown',\n    35: 'end',\n    36: 'home',\n    37: 'left',\n    38: 'up',\n    39: 'right',\n    40: 'down',\n    45: 'ins',\n    46: 'del',\n    91: 'meta',\n    93: 'meta',\n    224: 'meta'\n  };\n  /**\n   * mapping for special characters so they can support\n   *\n   * this dictionary is only used incase you want to bind a\n   * keyup or keydown event to one of these keys\n   *\n   * @type {Object}\n   */\n\n  var _KEYCODE_MAP = {\n    106: '*',\n    107: '+',\n    109: '-',\n    110: '.',\n    111: '/',\n    186: ';',\n    187: '=',\n    188: ',',\n    189: '-',\n    190: '.',\n    191: '/',\n    192: '`',\n    219: '[',\n    220: '\\\\',\n    221: ']',\n    222: '\\''\n  };\n  /**\n   * this is a mapping of keys that require shift on a US keypad\n   * back to the non shift equivelents\n   *\n   * this is so you can use keyup events with these keys\n   *\n   * note that this will only work reliably on US keyboards\n   *\n   * @type {Object}\n   */\n\n  var _SHIFT_MAP = {\n    '~': '`',\n    '!': '1',\n    '@': '2',\n    '#': '3',\n    '$': '4',\n    '%': '5',\n    '^': '6',\n    '&': '7',\n    '*': '8',\n    '(': '9',\n    ')': '0',\n    '_': '-',\n    '+': '=',\n    ':': ';',\n    '\\\"': '\\'',\n    '<': ',',\n    '>': '.',\n    '?': '/',\n    '|': '\\\\'\n  };\n  /**\n   * this is a list of special strings you can use to map\n   * to modifier keys when you specify your keyboard shortcuts\n   *\n   * @type {Object}\n   */\n\n  var _SPECIAL_ALIASES = {\n    'option': 'alt',\n    'command': 'meta',\n    'return': 'enter',\n    'escape': 'esc',\n    'plus': '+',\n    'mod': /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? 'meta' : 'ctrl'\n  };\n  /**\n   * variable to store the flipped version of _MAP from above\n   * needed to check if we should use keypress or not when no action\n   * is specified\n   *\n   * @type {Object|undefined}\n   */\n\n  var _REVERSE_MAP;\n  /**\n   * loop through the f keys, f1 to f19 and add them to the map\n   * programatically\n   */\n\n\n  for (var i = 1; i < 20; ++i) {\n    _MAP[111 + i] = 'f' + i;\n  }\n  /**\n   * loop through to map numbers on the numeric keypad\n   */\n\n\n  for (i = 0; i <= 9; ++i) {\n    // This needs to use a string cause otherwise since 0 is falsey\n    // mousetrap will never fire for numpad 0 pressed as part of a keydown\n    // event.\n    //\n    // @see https://github.com/ccampbell/mousetrap/pull/258\n    _MAP[i + 96] = i.toString();\n  }\n  /**\n   * cross browser add event method\n   *\n   * @param {Element|HTMLDocument} object\n   * @param {string} type\n   * @param {Function} callback\n   * @returns void\n   */\n\n\n  function _addEvent(object, type, callback) {\n    if (object.addEventListener) {\n      object.addEventListener(type, callback, false);\n      return;\n    }\n\n    object.attachEvent('on' + type, callback);\n  }\n  /**\n   * takes the event and returns the key character\n   *\n   * @param {Event} e\n   * @return {string}\n   */\n\n\n  function _characterFromEvent(e) {\n    // for keypress events we should return the character as is\n    if (e.type == 'keypress') {\n      var character = String.fromCharCode(e.which); // if the shift key is not pressed then it is safe to assume\n      // that we want the character to be lowercase.  this means if\n      // you accidentally have caps lock on then your key bindings\n      // will continue to work\n      //\n      // the only side effect that might not be desired is if you\n      // bind something like 'A' cause you want to trigger an\n      // event when capital A is pressed caps lock will no longer\n      // trigger the event.  shift+a will though.\n\n      if (!e.shiftKey) {\n        character = character.toLowerCase();\n      }\n\n      return character;\n    } // for non keypress events the special maps are needed\n\n\n    if (_MAP[e.which]) {\n      return _MAP[e.which];\n    }\n\n    if (_KEYCODE_MAP[e.which]) {\n      return _KEYCODE_MAP[e.which];\n    } // if it is not in the special map\n    // with keydown and keyup events the character seems to always\n    // come in as an uppercase character whether you are pressing shift\n    // or not.  we should make sure it is always lowercase for comparisons\n\n\n    return String.fromCharCode(e.which).toLowerCase();\n  }\n  /**\n   * checks if two arrays are equal\n   *\n   * @param {Array} modifiers1\n   * @param {Array} modifiers2\n   * @returns {boolean}\n   */\n\n\n  function _modifiersMatch(modifiers1, modifiers2) {\n    return modifiers1.sort().join(',') === modifiers2.sort().join(',');\n  }\n  /**\n   * takes a key event and figures out what the modifiers are\n   *\n   * @param {Event} e\n   * @returns {Array}\n   */\n\n\n  function _eventModifiers(e) {\n    var modifiers = [];\n\n    if (e.shiftKey) {\n      modifiers.push('shift');\n    }\n\n    if (e.altKey) {\n      modifiers.push('alt');\n    }\n\n    if (e.ctrlKey) {\n      modifiers.push('ctrl');\n    }\n\n    if (e.metaKey) {\n      modifiers.push('meta');\n    }\n\n    return modifiers;\n  }\n  /**\n   * prevents default for this event\n   *\n   * @param {Event} e\n   * @returns void\n   */\n\n\n  function _preventDefault(e) {\n    if (e.preventDefault) {\n      e.preventDefault();\n      return;\n    }\n\n    e.returnValue = false;\n  }\n  /**\n   * stops propogation for this event\n   *\n   * @param {Event} e\n   * @returns void\n   */\n\n\n  function _stopPropagation(e) {\n    if (e.stopPropagation) {\n      e.stopPropagation();\n      return;\n    }\n\n    e.cancelBubble = true;\n  }\n  /**\n   * determines if the keycode specified is a modifier key or not\n   *\n   * @param {string} key\n   * @returns {boolean}\n   */\n\n\n  function _isModifier(key) {\n    return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta';\n  }\n  /**\n   * reverses the map lookup so that we can look for specific keys\n   * to see what can and can't use keypress\n   *\n   * @return {Object}\n   */\n\n\n  function _getReverseMap() {\n    if (!_REVERSE_MAP) {\n      _REVERSE_MAP = {};\n\n      for (var key in _MAP) {\n        // pull out the numeric keypad from here cause keypress should\n        // be able to detect the keys from the character\n        if (key > 95 && key < 112) {\n          continue;\n        }\n\n        if (_MAP.hasOwnProperty(key)) {\n          _REVERSE_MAP[_MAP[key]] = key;\n        }\n      }\n    }\n\n    return _REVERSE_MAP;\n  }\n  /**\n   * picks the best action based on the key combination\n   *\n   * @param {string} key - character for key\n   * @param {Array} modifiers\n   * @param {string=} action passed in\n   */\n\n\n  function _pickBestAction(key, modifiers, action) {\n    // if no action was picked in we should try to pick the one\n    // that we think would work best for this key\n    if (!action) {\n      action = _getReverseMap()[key] ? 'keydown' : 'keypress';\n    } // modifier keys don't work as expected with keypress,\n    // switch to keydown\n\n\n    if (action == 'keypress' && modifiers.length) {\n      action = 'keydown';\n    }\n\n    return action;\n  }\n  /**\n   * Converts from a string key combination to an array\n   *\n   * @param  {string} combination like \"command+shift+l\"\n   * @return {Array}\n   */\n\n\n  function _keysFromString(combination) {\n    if (combination === '+') {\n      return ['+'];\n    }\n\n    combination = combination.replace(/\\+{2}/g, '+plus');\n    return combination.split('+');\n  }\n  /**\n   * Gets info for a specific key combination\n   *\n   * @param  {string} combination key combination (\"command+s\" or \"a\" or \"*\")\n   * @param  {string=} action\n   * @returns {Object}\n   */\n\n\n  function _getKeyInfo(combination, action) {\n    var keys;\n    var key;\n    var i;\n    var modifiers = []; // take the keys from this pattern and figure out what the actual\n    // pattern is all about\n\n    keys = _keysFromString(combination);\n\n    for (i = 0; i < keys.length; ++i) {\n      key = keys[i]; // normalize key names\n\n      if (_SPECIAL_ALIASES[key]) {\n        key = _SPECIAL_ALIASES[key];\n      } // if this is not a keypress event then we should\n      // be smart about using shift keys\n      // this will only work for US keyboards however\n\n\n      if (action && action != 'keypress' && _SHIFT_MAP[key]) {\n        key = _SHIFT_MAP[key];\n        modifiers.push('shift');\n      } // if this key is a modifier then add it to the list of modifiers\n\n\n      if (_isModifier(key)) {\n        modifiers.push(key);\n      }\n    } // depending on what the key combination is\n    // we will try to pick the best event for it\n\n\n    action = _pickBestAction(key, modifiers, action);\n    return {\n      key: key,\n      modifiers: modifiers,\n      action: action\n    };\n  }\n\n  function _belongsTo(element, ancestor) {\n    if (element === null || element === document) {\n      return false;\n    }\n\n    if (element === ancestor) {\n      return true;\n    }\n\n    return _belongsTo(element.parentNode, ancestor);\n  }\n\n  function Mousetrap(targetElement) {\n    var self = this;\n    targetElement = targetElement || document;\n\n    if (!(self instanceof Mousetrap)) {\n      return new Mousetrap(targetElement);\n    }\n    /**\n     * element to attach key events to\n     *\n     * @type {Element}\n     */\n\n\n    self.target = targetElement;\n    /**\n     * a list of all the callbacks setup via Mousetrap.bind()\n     *\n     * @type {Object}\n     */\n\n    self._callbacks = {};\n    /**\n     * direct map of string combinations to callbacks used for trigger()\n     *\n     * @type {Object}\n     */\n\n    self._directMap = {};\n    /**\n     * keeps track of what level each sequence is at since multiple\n     * sequences can start out with the same sequence\n     *\n     * @type {Object}\n     */\n\n    var _sequenceLevels = {};\n    /**\n     * variable to store the setTimeout call\n     *\n     * @type {null|number}\n     */\n\n    var _resetTimer;\n    /**\n     * temporary state where we will ignore the next keyup\n     *\n     * @type {boolean|string}\n     */\n\n\n    var _ignoreNextKeyup = false;\n    /**\n     * temporary state where we will ignore the next keypress\n     *\n     * @type {boolean}\n     */\n\n    var _ignoreNextKeypress = false;\n    /**\n     * are we currently inside of a sequence?\n     * type of action (\"keyup\" or \"keydown\" or \"keypress\") or false\n     *\n     * @type {boolean|string}\n     */\n\n    var _nextExpectedAction = false;\n    /**\n     * resets all sequence counters except for the ones passed in\n     *\n     * @param {Object} doNotReset\n     * @returns void\n     */\n\n    function _resetSequences(doNotReset) {\n      doNotReset = doNotReset || {};\n      var activeSequences = false,\n          key;\n\n      for (key in _sequenceLevels) {\n        if (doNotReset[key]) {\n          activeSequences = true;\n          continue;\n        }\n\n        _sequenceLevels[key] = 0;\n      }\n\n      if (!activeSequences) {\n        _nextExpectedAction = false;\n      }\n    }\n    /**\n     * finds all callbacks that match based on the keycode, modifiers,\n     * and action\n     *\n     * @param {string} character\n     * @param {Array} modifiers\n     * @param {Event|Object} e\n     * @param {string=} sequenceName - name of the sequence we are looking for\n     * @param {string=} combination\n     * @param {number=} level\n     * @returns {Array}\n     */\n\n\n    function _getMatches(character, modifiers, e, sequenceName, combination, level) {\n      var i;\n      var callback;\n      var matches = [];\n      var action = e.type; // if there are no events related to this keycode\n\n      if (!self._callbacks[character]) {\n        return [];\n      } // if a modifier key is coming up on its own we should allow it\n\n\n      if (action == 'keyup' && _isModifier(character)) {\n        modifiers = [character];\n      } // loop through all callbacks for the key that was pressed\n      // and see if any of them match\n\n\n      for (i = 0; i < self._callbacks[character].length; ++i) {\n        callback = self._callbacks[character][i]; // if a sequence name is not specified, but this is a sequence at\n        // the wrong level then move onto the next match\n\n        if (!sequenceName && callback.seq && _sequenceLevels[callback.seq] != callback.level) {\n          continue;\n        } // if the action we are looking for doesn't match the action we got\n        // then we should keep going\n\n\n        if (action != callback.action) {\n          continue;\n        } // if this is a keypress event and the meta key and control key\n        // are not pressed that means that we need to only look at the\n        // character, otherwise check the modifiers as well\n        //\n        // chrome will not fire a keypress if meta or control is down\n        // safari will fire a keypress if meta or meta+shift is down\n        // firefox will fire a keypress if meta or control is down\n\n\n        if (action == 'keypress' && !e.metaKey && !e.ctrlKey || _modifiersMatch(modifiers, callback.modifiers)) {\n          // when you bind a combination or sequence a second time it\n          // should overwrite the first one.  if a sequenceName or\n          // combination is specified in this call it does just that\n          //\n          // @todo make deleting its own method?\n          var deleteCombo = !sequenceName && callback.combo == combination;\n          var deleteSequence = sequenceName && callback.seq == sequenceName && callback.level == level;\n\n          if (deleteCombo || deleteSequence) {\n            self._callbacks[character].splice(i, 1);\n          }\n\n          matches.push(callback);\n        }\n      }\n\n      return matches;\n    }\n    /**\n     * actually calls the callback function\n     *\n     * if your callback function returns false this will use the jquery\n     * convention - prevent default and stop propogation on the event\n     *\n     * @param {Function} callback\n     * @param {Event} e\n     * @returns void\n     */\n\n\n    function _fireCallback(callback, e, combo, sequence) {\n      // if this event should not happen stop here\n      if (self.stopCallback(e, e.target || e.srcElement, combo, sequence)) {\n        return;\n      }\n\n      if (callback(e, combo) === false) {\n        _preventDefault(e);\n\n        _stopPropagation(e);\n      }\n    }\n    /**\n     * handles a character key event\n     *\n     * @param {string} character\n     * @param {Array} modifiers\n     * @param {Event} e\n     * @returns void\n     */\n\n\n    self._handleKey = function (character, modifiers, e) {\n      var callbacks = _getMatches(character, modifiers, e);\n\n      var i;\n      var doNotReset = {};\n      var maxLevel = 0;\n      var processedSequenceCallback = false; // Calculate the maxLevel for sequences so we can only execute the longest callback sequence\n\n      for (i = 0; i < callbacks.length; ++i) {\n        if (callbacks[i].seq) {\n          maxLevel = Math.max(maxLevel, callbacks[i].level);\n        }\n      } // loop through matching callbacks for this key event\n\n\n      for (i = 0; i < callbacks.length; ++i) {\n        // fire for all sequence callbacks\n        // this is because if for example you have multiple sequences\n        // bound such as \"g i\" and \"g t\" they both need to fire the\n        // callback for matching g cause otherwise you can only ever\n        // match the first one\n        if (callbacks[i].seq) {\n          // only fire callbacks for the maxLevel to prevent\n          // subsequences from also firing\n          //\n          // for example 'a option b' should not cause 'option b' to fire\n          // even though 'option b' is part of the other sequence\n          //\n          // any sequences that do not match here will be discarded\n          // below by the _resetSequences call\n          if (callbacks[i].level != maxLevel) {\n            continue;\n          }\n\n          processedSequenceCallback = true; // keep a list of which sequences were matches for later\n\n          doNotReset[callbacks[i].seq] = 1;\n\n          _fireCallback(callbacks[i].callback, e, callbacks[i].combo, callbacks[i].seq);\n\n          continue;\n        } // if there were no sequence matches but we are still here\n        // that means this is a regular match so we should fire that\n\n\n        if (!processedSequenceCallback) {\n          _fireCallback(callbacks[i].callback, e, callbacks[i].combo);\n        }\n      } // if the key you pressed matches the type of sequence without\n      // being a modifier (ie \"keyup\" or \"keypress\") then we should\n      // reset all sequences that were not matched by this event\n      //\n      // this is so, for example, if you have the sequence \"h a t\" and you\n      // type \"h e a r t\" it does not match.  in this case the \"e\" will\n      // cause the sequence to reset\n      //\n      // modifier keys are ignored because you can have a sequence\n      // that contains modifiers such as \"enter ctrl+space\" and in most\n      // cases the modifier key will be pressed before the next key\n      //\n      // also if you have a sequence such as \"ctrl+b a\" then pressing the\n      // \"b\" key will trigger a \"keypress\" and a \"keydown\"\n      //\n      // the \"keydown\" is expected when there is a modifier, but the\n      // \"keypress\" ends up matching the _nextExpectedAction since it occurs\n      // after and that causes the sequence to reset\n      //\n      // we ignore keypresses in a sequence that directly follow a keydown\n      // for the same character\n\n\n      var ignoreThisKeypress = e.type == 'keypress' && _ignoreNextKeypress;\n\n      if (e.type == _nextExpectedAction && !_isModifier(character) && !ignoreThisKeypress) {\n        _resetSequences(doNotReset);\n      }\n\n      _ignoreNextKeypress = processedSequenceCallback && e.type == 'keydown';\n    };\n    /**\n     * handles a keydown event\n     *\n     * @param {Event} e\n     * @returns void\n     */\n\n\n    function _handleKeyEvent(e) {\n      // normalize e.which for key events\n      // @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion\n      if (typeof e.which !== 'number') {\n        e.which = e.keyCode;\n      }\n\n      var character = _characterFromEvent(e); // no character found then stop\n\n\n      if (!character) {\n        return;\n      } // need to use === for the character check because the character can be 0\n\n\n      if (e.type == 'keyup' && _ignoreNextKeyup === character) {\n        _ignoreNextKeyup = false;\n        return;\n      }\n\n      self.handleKey(character, _eventModifiers(e), e);\n    }\n    /**\n     * called to set a 1 second timeout on the specified sequence\n     *\n     * this is so after each key press in the sequence you have 1 second\n     * to press the next key before you have to start over\n     *\n     * @returns void\n     */\n\n\n    function _resetSequenceTimer() {\n      clearTimeout(_resetTimer);\n      _resetTimer = setTimeout(_resetSequences, 1000);\n    }\n    /**\n     * binds a key sequence to an event\n     *\n     * @param {string} combo - combo specified in bind call\n     * @param {Array} keys\n     * @param {Function} callback\n     * @param {string=} action\n     * @returns void\n     */\n\n\n    function _bindSequence(combo, keys, callback, action) {\n      // start off by adding a sequence level record for this combination\n      // and setting the level to 0\n      _sequenceLevels[combo] = 0;\n      /**\n       * callback to increase the sequence level for this sequence and reset\n       * all other sequences that were active\n       *\n       * @param {string} nextAction\n       * @returns {Function}\n       */\n\n      function _increaseSequence(nextAction) {\n        return function () {\n          _nextExpectedAction = nextAction;\n          ++_sequenceLevels[combo];\n\n          _resetSequenceTimer();\n        };\n      }\n      /**\n       * wraps the specified callback inside of another function in order\n       * to reset all sequence counters as soon as this sequence is done\n       *\n       * @param {Event} e\n       * @returns void\n       */\n\n\n      function _callbackAndReset(e) {\n        _fireCallback(callback, e, combo); // we should ignore the next key up if the action is key down\n        // or keypress.  this is so if you finish a sequence and\n        // release the key the final key will not trigger a keyup\n\n\n        if (action !== 'keyup') {\n          _ignoreNextKeyup = _characterFromEvent(e);\n        } // weird race condition if a sequence ends with the key\n        // another sequence begins with\n\n\n        setTimeout(_resetSequences, 10);\n      } // loop through keys one at a time and bind the appropriate callback\n      // function.  for any key leading up to the final one it should\n      // increase the sequence. after the final, it should reset all sequences\n      //\n      // if an action is specified in the original bind call then that will\n      // be used throughout.  otherwise we will pass the action that the\n      // next key in the sequence should match.  this allows a sequence\n      // to mix and match keypress and keydown events depending on which\n      // ones are better suited to the key provided\n\n\n      for (var i = 0; i < keys.length; ++i) {\n        var isFinal = i + 1 === keys.length;\n        var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence(action || _getKeyInfo(keys[i + 1]).action);\n\n        _bindSingle(keys[i], wrappedCallback, action, combo, i);\n      }\n    }\n    /**\n     * binds a single keyboard combination\n     *\n     * @param {string} combination\n     * @param {Function} callback\n     * @param {string=} action\n     * @param {string=} sequenceName - name of sequence if part of sequence\n     * @param {number=} level - what part of the sequence the command is\n     * @returns void\n     */\n\n\n    function _bindSingle(combination, callback, action, sequenceName, level) {\n      // store a direct mapped reference for use with Mousetrap.trigger\n      self._directMap[combination + ':' + action] = callback; // make sure multiple spaces in a row become a single space\n\n      combination = combination.replace(/\\s+/g, ' ');\n      var sequence = combination.split(' ');\n      var info; // if this pattern is a sequence of keys then run through this method\n      // to reprocess each pattern one key at a time\n\n      if (sequence.length > 1) {\n        _bindSequence(combination, sequence, callback, action);\n\n        return;\n      }\n\n      info = _getKeyInfo(combination, action); // make sure to initialize array if this is the first time\n      // a callback is added for this key\n\n      self._callbacks[info.key] = self._callbacks[info.key] || []; // remove an existing match if there is one\n\n      _getMatches(info.key, info.modifiers, {\n        type: info.action\n      }, sequenceName, combination, level); // add this call back to the array\n      // if it is a sequence put it at the beginning\n      // if not put it at the end\n      //\n      // this is important because the way these are processed expects\n      // the sequence ones to come first\n\n\n      self._callbacks[info.key][sequenceName ? 'unshift' : 'push']({\n        callback: callback,\n        modifiers: info.modifiers,\n        action: info.action,\n        seq: sequenceName,\n        level: level,\n        combo: combination\n      });\n    }\n    /**\n     * binds multiple combinations to the same callback\n     *\n     * @param {Array} combinations\n     * @param {Function} callback\n     * @param {string|undefined} action\n     * @returns void\n     */\n\n\n    self._bindMultiple = function (combinations, callback, action) {\n      for (var i = 0; i < combinations.length; ++i) {\n        _bindSingle(combinations[i], callback, action);\n      }\n    }; // start!\n\n\n    _addEvent(targetElement, 'keypress', _handleKeyEvent);\n\n    _addEvent(targetElement, 'keydown', _handleKeyEvent);\n\n    _addEvent(targetElement, 'keyup', _handleKeyEvent);\n  }\n  /**\n   * binds an event to mousetrap\n   *\n   * can be a single key, a combination of keys separated with +,\n   * an array of keys, or a sequence of keys separated by spaces\n   *\n   * be sure to list the modifier keys first to make sure that the\n   * correct key ends up getting bound (the last key in the pattern)\n   *\n   * @param {string|Array} keys\n   * @param {Function} callback\n   * @param {string=} action - 'keypress', 'keydown', or 'keyup'\n   * @returns void\n   */\n\n\n  Mousetrap.prototype.bind = function (keys, callback, action) {\n    var self = this;\n    keys = keys instanceof Array ? keys : [keys];\n\n    self._bindMultiple.call(self, keys, callback, action);\n\n    return self;\n  };\n  /**\n   * unbinds an event to mousetrap\n   *\n   * the unbinding sets the callback function of the specified key combo\n   * to an empty function and deletes the corresponding key in the\n   * _directMap dict.\n   *\n   * TODO: actually remove this from the _callbacks dictionary instead\n   * of binding an empty function\n   *\n   * the keycombo+action has to be exactly the same as\n   * it was defined in the bind method\n   *\n   * @param {string|Array} keys\n   * @param {string} action\n   * @returns void\n   */\n\n\n  Mousetrap.prototype.unbind = function (keys, action) {\n    var self = this;\n    return self.bind.call(self, keys, function () {}, action);\n  };\n  /**\n   * triggers an event that has already been bound\n   *\n   * @param {string} keys\n   * @param {string=} action\n   * @returns void\n   */\n\n\n  Mousetrap.prototype.trigger = function (keys, action) {\n    var self = this;\n\n    if (self._directMap[keys + ':' + action]) {\n      self._directMap[keys + ':' + action]({}, keys);\n    }\n\n    return self;\n  };\n  /**\n   * resets the library back to its initial state.  this is useful\n   * if you want to clear out the current keyboard shortcuts and bind\n   * new ones - for example if you switch to another page\n   *\n   * @returns void\n   */\n\n\n  Mousetrap.prototype.reset = function () {\n    var self = this;\n    self._callbacks = {};\n    self._directMap = {};\n    return self;\n  };\n  /**\n   * should we stop this event before firing off callbacks\n   *\n   * @param {Event} e\n   * @param {Element} element\n   * @return {boolean}\n   */\n\n\n  Mousetrap.prototype.stopCallback = function (e, element) {\n    var self = this; // if the element has the class \"mousetrap\" then no need to stop\n\n    if ((' ' + element.className + ' ').indexOf(' mousetrap ') > -1) {\n      return false;\n    }\n\n    if (_belongsTo(element, self.target)) {\n      return false;\n    } // Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,\n    // not the initial event target in the shadow tree. Note that not all events cross the\n    // shadow boundary.\n    // For shadow trees with `mode: 'open'`, the initial event target is the first element in\n    // the event’s composed path. For shadow trees with `mode: 'closed'`, the initial event\n    // target cannot be obtained.\n\n\n    if ('composedPath' in e && typeof e.composedPath === 'function') {\n      // For open shadow trees, update `element` so that the following check works.\n      var initialEventTarget = e.composedPath()[0];\n\n      if (initialEventTarget !== e.target) {\n        element = initialEventTarget;\n      }\n    } // stop for input, select, and textarea\n\n\n    return element.tagName == 'INPUT' || element.tagName == 'SELECT' || element.tagName == 'TEXTAREA' || element.isContentEditable;\n  };\n  /**\n   * exposes _handleKey publicly so it can be overwritten by extensions\n   */\n\n\n  Mousetrap.prototype.handleKey = function () {\n    var self = this;\n    return self._handleKey.apply(self, arguments);\n  };\n  /**\n   * allow custom key mappings\n   */\n\n\n  Mousetrap.addKeycodes = function (object) {\n    for (var key in object) {\n      if (object.hasOwnProperty(key)) {\n        _MAP[key] = object[key];\n      }\n    }\n\n    _REVERSE_MAP = null;\n  };\n  /**\n   * Init the global mousetrap functions\n   *\n   * This method is needed to allow the global mousetrap functions to work\n   * now that mousetrap is a constructor function.\n   */\n\n\n  Mousetrap.init = function () {\n    var documentMousetrap = Mousetrap(document);\n\n    for (var method in documentMousetrap) {\n      if (method.charAt(0) !== '_') {\n        Mousetrap[method] = function (method) {\n          return function () {\n            return documentMousetrap[method].apply(documentMousetrap, arguments);\n          };\n        }(method);\n      }\n    }\n  };\n\n  Mousetrap.init(); // expose mousetrap to the global object\n\n  window.Mousetrap = Mousetrap; // expose as a common js module\n\n  if (typeof module !== 'undefined' && module.exports) {\n    module.exports = Mousetrap;\n  } // expose mousetrap as an AMD module\n\n\n  if (typeof define === 'function' && define.amd) {\n    define(function () {\n      return Mousetrap;\n    });\n  }\n})(typeof window !== 'undefined' ? window : null, typeof window !== 'undefined' ? document : null);","import { consoleSandbox, getGlobalObject } from './misc'; // TODO: Implement different loggers for different environments\n\nvar global = getGlobalObject();\n/** Prefix for logging strings */\n\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\n\nvar Logger =\n/** @class */\nfunction () {\n  /** JSDoc */\n  function Logger() {\n    this._enabled = false;\n  }\n  /** JSDoc */\n\n\n  Logger.prototype.disable = function () {\n    this._enabled = false;\n  };\n  /** JSDoc */\n\n\n  Logger.prototype.enable = function () {\n    this._enabled = true;\n  };\n  /** JSDoc */\n\n\n  Logger.prototype.log = function () {\n    var args = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n\n    if (!this._enabled) {\n      return;\n    }\n\n    consoleSandbox(function () {\n      global.console.log(PREFIX + \"[Log]: \" + args.join(' ')); // tslint:disable-line:no-console\n    });\n  };\n  /** JSDoc */\n\n\n  Logger.prototype.warn = function () {\n    var args = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n\n    if (!this._enabled) {\n      return;\n    }\n\n    consoleSandbox(function () {\n      global.console.warn(PREFIX + \"[Warn]: \" + args.join(' ')); // tslint:disable-line:no-console\n    });\n  };\n  /** JSDoc */\n\n\n  Logger.prototype.error = function () {\n    var args = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n\n    if (!this._enabled) {\n      return;\n    }\n\n    consoleSandbox(function () {\n      global.console.error(PREFIX + \"[Error]: \" + args.join(' ')); // tslint:disable-line:no-console\n    });\n  };\n\n  return Logger;\n}(); // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\n\n\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };","// tslint:disable:no-unsafe-any\n\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo =\n/** @class */\nfunction () {\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\n\n  Memo.prototype.memoize = function (obj) {\n    if (this._hasWeakSet) {\n      if (this._inner.has(obj)) {\n        return true;\n      }\n\n      this._inner.add(obj);\n\n      return false;\n    } // tslint:disable-next-line:prefer-for-of\n\n\n    for (var i = 0; i < this._inner.length; i++) {\n      var value = this._inner[i];\n\n      if (value === obj) {\n        return true;\n      }\n    }\n\n    this._inner.push(obj);\n\n    return false;\n  };\n  /**\n   * Removes object from internal storage.\n   * @param obj Object to forget\n   */\n\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\n          break;\n        }\n      }\n    }\n  };\n\n  return Memo;\n}();\n\nexport { Memo };","import { uuid4 } from '@sentry/utils';\nexport var TRACEPARENT_REGEXP = /^[ \\t]*([0-9a-f]{32})?-?([0-9a-f]{16})?-?([01])?[ \\t]*$/;\n/**\n * Span containg all data about a span\n */\n\nvar Span =\n/** @class */\nfunction () {\n  function Span(_traceId, _spanId, _sampled, _parent) {\n    if (_traceId === void 0) {\n      _traceId = uuid4();\n    }\n\n    if (_spanId === void 0) {\n      _spanId = uuid4().substring(16);\n    }\n\n    this._traceId = _traceId;\n    this._spanId = _spanId;\n    this._sampled = _sampled;\n    this._parent = _parent;\n  }\n  /**\n   * Setter for parent\n   */\n\n\n  Span.prototype.setParent = function (parent) {\n    this._parent = parent;\n    return this;\n  };\n  /**\n   * Setter for sampled\n   */\n\n\n  Span.prototype.setSampled = function (sampled) {\n    this._sampled = sampled;\n    return this;\n  };\n  /**\n   * Continues a trace\n   * @param traceparent Traceparent string\n   */\n\n\n  Span.fromTraceparent = function (traceparent) {\n    var matches = traceparent.match(TRACEPARENT_REGEXP);\n\n    if (matches) {\n      var sampled = void 0;\n\n      if (matches[3] === '1') {\n        sampled = true;\n      } else if (matches[3] === '0') {\n        sampled = false;\n      }\n\n      var parent_1 = new Span(matches[1], matches[2], sampled);\n      return new Span(matches[1], undefined, sampled, parent_1);\n    }\n\n    return undefined;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.toTraceparent = function () {\n    var sampled = '';\n\n    if (this._sampled === true) {\n      sampled = '-1';\n    } else if (this._sampled === false) {\n      sampled = '-0';\n    }\n\n    return this._traceId + \"-\" + this._spanId + sampled;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Span.prototype.toJSON = function () {\n    return {\n      parent: this._parent && this._parent.toJSON() || undefined,\n      sampled: this._sampled,\n      span_id: this._spanId,\n      trace_id: this._traceId\n    };\n  };\n\n  return Span;\n}();\n\nexport { Span };","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar MicroModal = function () {\n  var FOCUSABLE_ELEMENTS = ['a[href]', 'area[href]', 'input:not([disabled]):not([type=\"hidden\"]):not([aria-hidden])', 'select:not([disabled]):not([aria-hidden])', 'textarea:not([disabled]):not([aria-hidden])', 'button:not([disabled]):not([aria-hidden])', 'iframe', 'object', 'embed', '[contenteditable]', '[tabindex]:not([tabindex^=\"-\"])'];\n\n  var Modal = /*#__PURE__*/function () {\n    function Modal(_ref) {\n      var targetModal = _ref.targetModal,\n          _ref$triggers = _ref.triggers,\n          triggers = _ref$triggers === void 0 ? [] : _ref$triggers,\n          _ref$onShow = _ref.onShow,\n          onShow = _ref$onShow === void 0 ? function () {} : _ref$onShow,\n          _ref$onClose = _ref.onClose,\n          onClose = _ref$onClose === void 0 ? function () {} : _ref$onClose,\n          _ref$openTrigger = _ref.openTrigger,\n          openTrigger = _ref$openTrigger === void 0 ? 'data-micromodal-trigger' : _ref$openTrigger,\n          _ref$closeTrigger = _ref.closeTrigger,\n          closeTrigger = _ref$closeTrigger === void 0 ? 'data-micromodal-close' : _ref$closeTrigger,\n          _ref$disableScroll = _ref.disableScroll,\n          disableScroll = _ref$disableScroll === void 0 ? false : _ref$disableScroll,\n          _ref$disableFocus = _ref.disableFocus,\n          disableFocus = _ref$disableFocus === void 0 ? false : _ref$disableFocus,\n          _ref$awaitCloseAnimat = _ref.awaitCloseAnimation,\n          awaitCloseAnimation = _ref$awaitCloseAnimat === void 0 ? false : _ref$awaitCloseAnimat,\n          _ref$awaitOpenAnimati = _ref.awaitOpenAnimation,\n          awaitOpenAnimation = _ref$awaitOpenAnimati === void 0 ? false : _ref$awaitOpenAnimati,\n          _ref$debugMode = _ref.debugMode,\n          debugMode = _ref$debugMode === void 0 ? false : _ref$debugMode;\n\n      _classCallCheck(this, Modal);\n\n      // Save a reference of the modal\n      this.modal = document.getElementById(targetModal); // Save a reference to the passed config\n\n      this.config = {\n        debugMode: debugMode,\n        disableScroll: disableScroll,\n        openTrigger: openTrigger,\n        closeTrigger: closeTrigger,\n        onShow: onShow,\n        onClose: onClose,\n        awaitCloseAnimation: awaitCloseAnimation,\n        awaitOpenAnimation: awaitOpenAnimation,\n        disableFocus: disableFocus // Register click events only if pre binding eventListeners\n\n      };\n      if (triggers.length > 0) this.registerTriggers.apply(this, _toConsumableArray(triggers)); // pre bind functions for event listeners\n\n      this.onClick = this.onClick.bind(this);\n      this.onKeydown = this.onKeydown.bind(this);\n    }\n    /**\n     * Loops through all openTriggers and binds click event\n     * @param  {array} triggers [Array of node elements]\n     * @return {void}\n     */\n\n\n    _createClass(Modal, [{\n      key: \"registerTriggers\",\n      value: function registerTriggers() {\n        var _this = this;\n\n        for (var _len = arguments.length, triggers = new Array(_len), _key = 0; _key < _len; _key++) {\n          triggers[_key] = arguments[_key];\n        }\n\n        triggers.filter(Boolean).forEach(function (trigger) {\n          trigger.addEventListener('click', function (event) {\n            return _this.showModal(event);\n          });\n        });\n      }\n    }, {\n      key: \"showModal\",\n      value: function showModal() {\n        var _this2 = this;\n\n        this.activeElement = document.activeElement;\n        this.modal.setAttribute('aria-hidden', 'false');\n        this.modal.classList.add('is-open');\n        this.scrollBehaviour('disable');\n        this.addEventListeners();\n\n        if (this.config.awaitOpenAnimation) {\n          var handler = function handler() {\n            _this2.modal.removeEventListener('animationend', handler, false);\n\n            _this2.setFocusToFirstNode();\n          };\n\n          this.modal.addEventListener('animationend', handler, false);\n        } else {\n          this.setFocusToFirstNode();\n        }\n\n        this.config.onShow(this.modal, this.activeElement);\n      }\n    }, {\n      key: \"closeModal\",\n      value: function closeModal() {\n        var modal = this.modal;\n        this.modal.setAttribute('aria-hidden', 'true');\n        this.removeEventListeners();\n        this.scrollBehaviour('enable');\n\n        if (this.activeElement) {\n          this.activeElement.focus();\n        }\n\n        this.config.onClose(this.modal);\n\n        if (this.config.awaitCloseAnimation) {\n          this.modal.addEventListener('animationend', function handler() {\n            modal.classList.remove('is-open');\n            modal.removeEventListener('animationend', handler, false);\n          }, false);\n        } else {\n          modal.classList.remove('is-open');\n        }\n      }\n    }, {\n      key: \"closeModalById\",\n      value: function closeModalById(targetModal) {\n        this.modal = document.getElementById(targetModal);\n        if (this.modal) this.closeModal();\n      }\n    }, {\n      key: \"scrollBehaviour\",\n      value: function scrollBehaviour(toggle) {\n        if (!this.config.disableScroll) return;\n        var body = document.querySelector('body');\n\n        switch (toggle) {\n          case 'enable':\n            Object.assign(body.style, {\n              overflow: '',\n              height: ''\n            });\n            break;\n\n          case 'disable':\n            Object.assign(body.style, {\n              overflow: 'hidden',\n              height: '100vh'\n            });\n            break;\n\n          default:\n        }\n      }\n    }, {\n      key: \"addEventListeners\",\n      value: function addEventListeners() {\n        this.modal.addEventListener('touchstart', this.onClick);\n        this.modal.addEventListener('click', this.onClick);\n        document.addEventListener('keydown', this.onKeydown);\n      }\n    }, {\n      key: \"removeEventListeners\",\n      value: function removeEventListeners() {\n        this.modal.removeEventListener('touchstart', this.onClick);\n        this.modal.removeEventListener('click', this.onClick);\n        document.removeEventListener('keydown', this.onKeydown);\n      }\n    }, {\n      key: \"onClick\",\n      value: function onClick(event) {\n        if (event.target.hasAttribute(this.config.closeTrigger)) {\n          this.closeModal();\n          event.preventDefault();\n        }\n      }\n    }, {\n      key: \"onKeydown\",\n      value: function onKeydown(event) {\n        if (event.keyCode === 27) this.closeModal(event);\n        if (event.keyCode === 9) this.maintainFocus(event);\n      }\n    }, {\n      key: \"getFocusableNodes\",\n      value: function getFocusableNodes() {\n        var nodes = this.modal.querySelectorAll(FOCUSABLE_ELEMENTS);\n        return Array.apply(void 0, _toConsumableArray(nodes));\n      }\n    }, {\n      key: \"setFocusToFirstNode\",\n      value: function setFocusToFirstNode() {\n        if (this.config.disableFocus) return;\n        var focusableNodes = this.getFocusableNodes();\n        if (focusableNodes.length) focusableNodes[0].focus();\n      }\n    }, {\n      key: \"maintainFocus\",\n      value: function maintainFocus(event) {\n        var focusableNodes = this.getFocusableNodes(); // if disableFocus is true\n\n        if (!this.modal.contains(document.activeElement)) {\n          focusableNodes[0].focus();\n        } else {\n          var focusedItemIndex = focusableNodes.indexOf(document.activeElement);\n\n          if (event.shiftKey && focusedItemIndex === 0) {\n            focusableNodes[focusableNodes.length - 1].focus();\n            event.preventDefault();\n          }\n\n          if (!event.shiftKey && focusedItemIndex === focusableNodes.length - 1) {\n            focusableNodes[0].focus();\n            event.preventDefault();\n          }\n        }\n      }\n    }]);\n\n    return Modal;\n  }();\n  /**\n   * Modal prototype ends.\n   * Here on code is responsible for detecting and\n   * auto binding event handlers on modal triggers\n   */\n  // Keep a reference to the opened modal\n\n\n  var activeModal = null;\n  /**\n   * Generates an associative array of modals and it's\n   * respective triggers\n   * @param  {array} triggers     An array of all triggers\n   * @param  {string} triggerAttr The data-attribute which triggers the module\n   * @return {array}\n   */\n\n  var generateTriggerMap = function generateTriggerMap(triggers, triggerAttr) {\n    var triggerMap = [];\n    triggers.forEach(function (trigger) {\n      var targetModal = trigger.attributes[triggerAttr].value;\n      if (triggerMap[targetModal] === undefined) triggerMap[targetModal] = [];\n      triggerMap[targetModal].push(trigger);\n    });\n    return triggerMap;\n  };\n  /**\n   * Validates whether a modal of the given id exists\n   * in the DOM\n   * @param  {number} id  The id of the modal\n   * @return {boolean}\n   */\n\n\n  var validateModalPresence = function validateModalPresence(id) {\n    if (!document.getElementById(id)) {\n      console.warn(\"MicroModal: \\u2757Seems like you have missed %c'\".concat(id, \"'\"), 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', 'ID somewhere in your code. Refer example below to resolve it.');\n      console.warn(\"%cExample:\", 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', \"<div class=\\\"modal\\\" id=\\\"\".concat(id, \"\\\"></div>\"));\n      return false;\n    }\n  };\n  /**\n   * Validates if there are modal triggers present\n   * in the DOM\n   * @param  {array} triggers An array of data-triggers\n   * @return {boolean}\n   */\n\n\n  var validateTriggerPresence = function validateTriggerPresence(triggers) {\n    if (triggers.length <= 0) {\n      console.warn(\"MicroModal: \\u2757Please specify at least one %c'micromodal-trigger'\", 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', 'data attribute.');\n      console.warn(\"%cExample:\", 'background-color: #f8f9fa;color: #50596c;font-weight: bold;', \"<a href=\\\"#\\\" data-micromodal-trigger=\\\"my-modal\\\"></a>\");\n      return false;\n    }\n  };\n  /**\n   * Checks if triggers and their corresponding modals\n   * are present in the DOM\n   * @param  {array} triggers   Array of DOM nodes which have data-triggers\n   * @param  {array} triggerMap Associative array of modals and their triggers\n   * @return {boolean}\n   */\n\n\n  var validateArgs = function validateArgs(triggers, triggerMap) {\n    validateTriggerPresence(triggers);\n    if (!triggerMap) return true;\n\n    for (var id in triggerMap) {\n      validateModalPresence(id);\n    }\n\n    return true;\n  };\n  /**\n   * Binds click handlers to all modal triggers\n   * @param  {object} config [description]\n   * @return void\n   */\n\n\n  var init = function init(config) {\n    // Create an config object with default openTrigger\n    var options = Object.assign({}, {\n      openTrigger: 'data-micromodal-trigger'\n    }, config); // Collects all the nodes with the trigger\n\n    var triggers = _toConsumableArray(document.querySelectorAll(\"[\".concat(options.openTrigger, \"]\"))); // Makes a mappings of modals with their trigger nodes\n\n\n    var triggerMap = generateTriggerMap(triggers, options.openTrigger); // Checks if modals and triggers exist in dom\n\n    if (options.debugMode === true && validateArgs(triggers, triggerMap) === false) return; // For every target modal creates a new instance\n\n    for (var key in triggerMap) {\n      var value = triggerMap[key];\n      options.targetModal = key;\n      options.triggers = _toConsumableArray(value);\n      activeModal = new Modal(options); // eslint-disable-line no-new\n    }\n  };\n  /**\n   * Shows a particular modal\n   * @param  {string} targetModal [The id of the modal to display]\n   * @param  {object} config [The configuration object to pass]\n   * @return {void}\n   */\n\n\n  var show = function show(targetModal, config) {\n    var options = config || {};\n    options.targetModal = targetModal; // Checks if modals and triggers exist in dom\n\n    if (options.debugMode === true && validateModalPresence(targetModal) === false) return; // stores reference to active modal\n\n    activeModal = new Modal(options); // eslint-disable-line no-new\n\n    activeModal.showModal();\n  };\n  /**\n   * Closes the active modal\n   * @param  {string} targetModal [The id of the modal to close]\n   * @return {void}\n   */\n\n\n  var close = function close(targetModal) {\n    targetModal ? activeModal.closeModalById(targetModal) : activeModal.closeModal();\n  };\n\n  return {\n    init: init,\n    show: show,\n    close: close\n  };\n}();\n\nexport default MicroModal;","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n!function (e) {\n  if (!e.hasInitialised) {\n    var t = {\n      escapeRegExp: function escapeRegExp(e) {\n        return e.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n      },\n      hasClass: function hasClass(e, t) {\n        var i = \" \";\n        return 1 === e.nodeType && (i + e.className + i).replace(/[\\n\\t]/g, i).indexOf(i + t + i) >= 0;\n      },\n      addClass: function addClass(e, t) {\n        e.className += \" \" + t;\n      },\n      removeClass: function removeClass(e, t) {\n        var i = new RegExp(\"\\\\b\" + this.escapeRegExp(t) + \"\\\\b\");\n        e.className = e.className.replace(i, \"\");\n      },\n      interpolateString: function interpolateString(e, t) {\n        return e.replace(/{{([a-z][a-z0-9\\-_]*)}}/gi, function (e) {\n          return t(arguments[1]) || \"\";\n        });\n      },\n      getCookie: function getCookie(e) {\n        var t = (\"; \" + document.cookie).split(\"; \" + e + \"=\");\n        return t.length < 2 ? void 0 : t.pop().split(\";\").shift();\n      },\n      setCookie: function setCookie(e, t, i, n, o, s) {\n        var r = new Date();\n        r.setHours(r.getHours() + 24 * (i || 365));\n        var a = [e + \"=\" + t, \"expires=\" + r.toUTCString(), \"path=\" + (o || \"/\")];\n        n && a.push(\"domain=\" + n), s && a.push(\"secure\"), document.cookie = a.join(\";\");\n      },\n      deepExtend: function deepExtend(e, t) {\n        for (var i in t) {\n          t.hasOwnProperty(i) && (i in e && this.isPlainObject(e[i]) && this.isPlainObject(t[i]) ? this.deepExtend(e[i], t[i]) : e[i] = t[i]);\n        }\n\n        return e;\n      },\n      throttle: function throttle(e, t) {\n        var i = !1;\n        return function () {\n          i || (e.apply(this, arguments), i = !0, setTimeout(function () {\n            i = !1;\n          }, t));\n        };\n      },\n      hash: function hash(e) {\n        var t,\n            i,\n            n = 0;\n        if (0 === e.length) return n;\n\n        for (t = 0, i = e.length; t < i; ++t) {\n          n = (n << 5) - n + e.charCodeAt(t), n |= 0;\n        }\n\n        return n;\n      },\n      normaliseHex: function normaliseHex(e) {\n        return \"#\" == e[0] && (e = e.substr(1)), 3 == e.length && (e = e[0] + e[0] + e[1] + e[1] + e[2] + e[2]), e;\n      },\n      getContrast: function getContrast(e) {\n        return e = this.normaliseHex(e), (299 * parseInt(e.substr(0, 2), 16) + 587 * parseInt(e.substr(2, 2), 16) + 114 * parseInt(e.substr(4, 2), 16)) / 1e3 >= 128 ? \"#000\" : \"#fff\";\n      },\n      getLuminance: function getLuminance(e) {\n        var t = parseInt(this.normaliseHex(e), 16),\n            i = 38 + (t >> 16),\n            n = 38 + (t >> 8 & 255),\n            o = 38 + (255 & t);\n        return \"#\" + (16777216 + 65536 * (i < 255 ? i < 1 ? 0 : i : 255) + 256 * (n < 255 ? n < 1 ? 0 : n : 255) + (o < 255 ? o < 1 ? 0 : o : 255)).toString(16).slice(1);\n      },\n      isMobile: function isMobile() {\n        return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);\n      },\n      isPlainObject: function isPlainObject(e) {\n        return \"object\" == _typeof(e) && null !== e && e.constructor == Object;\n      },\n      traverseDOMPath: function traverseDOMPath(e, i) {\n        return e && e.parentNode ? t.hasClass(e, i) ? e : this.traverseDOMPath(e.parentNode, i) : null;\n      }\n    };\n    e.status = {\n      deny: \"deny\",\n      allow: \"allow\",\n      dismiss: \"dismiss\"\n    }, e.transitionEnd = function () {\n      var e = document.createElement(\"div\"),\n          t = {\n        t: \"transitionend\",\n        OT: \"oTransitionEnd\",\n        msT: \"MSTransitionEnd\",\n        MozT: \"transitionend\",\n        WebkitT: \"webkitTransitionEnd\"\n      };\n\n      for (var i in t) {\n        if (t.hasOwnProperty(i) && void 0 !== e.style[i + \"ransition\"]) return t[i];\n      }\n\n      return \"\";\n    }(), e.hasTransition = !!e.transitionEnd;\n    var i = Object.keys(e.status).map(t.escapeRegExp);\n    e.customStyles = {}, e.Popup = function () {\n      var n = {\n        enabled: !0,\n        container: null,\n        cookie: {\n          name: \"cookieconsent_status\",\n          path: \"/\",\n          domain: \"\",\n          expiryDays: 365,\n          secure: !1\n        },\n        onPopupOpen: function onPopupOpen() {},\n        onPopupClose: function onPopupClose() {},\n        onInitialise: function onInitialise(e) {},\n        onStatusChange: function onStatusChange(e, t) {},\n        onRevokeChoice: function onRevokeChoice() {},\n        onNoCookieLaw: function onNoCookieLaw(e, t) {},\n        content: {\n          header: \"Cookies used on the website!\",\n          message: \"This website uses cookies to ensure you get the best experience on our website.\",\n          dismiss: \"Got it!\",\n          allow: \"Allow cookies\",\n          deny: \"Decline\",\n          link: \"Learn more\",\n          href: \"https://www.cookiesandyou.com\",\n          close: \"&#x274c;\",\n          target: \"_blank\",\n          policy: \"Cookie Policy\"\n        },\n        elements: {\n          header: '<span class=\"cc-header\">{{header}}</span>&nbsp;',\n          message: '<span id=\"cookieconsent:desc\" class=\"cc-message\">{{message}}</span>',\n          messagelink: '<span id=\"cookieconsent:desc\" class=\"cc-message\">{{message}} <a aria-label=\"learn more about cookies\" role=button tabindex=\"0\" class=\"cc-link\" href=\"{{href}}\" rel=\"noopener noreferrer nofollow\" target=\"{{target}}\">{{link}}</a></span>',\n          dismiss: '<a aria-label=\"dismiss cookie message\" role=button tabindex=\"0\" class=\"cc-btn cc-dismiss\">{{dismiss}}</a>',\n          allow: '<a aria-label=\"allow cookies\" role=button tabindex=\"0\"  class=\"cc-btn cc-allow\">{{allow}}</a>',\n          deny: '<a aria-label=\"deny cookies\" role=button tabindex=\"0\" class=\"cc-btn cc-deny\">{{deny}}</a>',\n          link: '<a aria-label=\"learn more about cookies\" role=button tabindex=\"0\" class=\"cc-link\" href=\"{{href}}\" rel=\"noopener noreferrer nofollow\" target=\"{{target}}\">{{link}}</a>',\n          close: '<span aria-label=\"dismiss cookie message\" role=button tabindex=\"0\" class=\"cc-close\">{{close}}</span>'\n        },\n        window: '<div role=\"dialog\" aria-live=\"polite\" aria-label=\"cookieconsent\" aria-describedby=\"cookieconsent:desc\" class=\"cc-window {{classes}}\">\\x3c!--googleoff: all--\\x3e{{children}}\\x3c!--googleon: all--\\x3e</div>',\n        revokeBtn: '<div class=\"cc-revoke {{classes}}\">{{policy}}</div>',\n        compliance: {\n          info: '<div class=\"cc-compliance\">{{dismiss}}</div>',\n          \"opt-in\": '<div class=\"cc-compliance cc-highlight\">{{deny}}{{allow}}</div>',\n          \"opt-out\": '<div class=\"cc-compliance cc-highlight\">{{deny}}{{allow}}</div>'\n        },\n        type: \"info\",\n        layouts: {\n          basic: \"{{messagelink}}{{compliance}}\",\n          \"basic-close\": \"{{messagelink}}{{compliance}}{{close}}\",\n          \"basic-header\": \"{{header}}{{message}}{{link}}{{compliance}}\"\n        },\n        layout: \"basic\",\n        position: \"bottom\",\n        theme: \"block\",\n        static: !1,\n        palette: null,\n        revokable: !1,\n        animateRevokable: !0,\n        showLink: !0,\n        dismissOnScroll: !1,\n        dismissOnTimeout: !1,\n        dismissOnWindowClick: !1,\n        ignoreClicksFrom: [\"cc-revoke\", \"cc-btn\"],\n        autoOpen: !0,\n        autoAttach: !0,\n        whitelistPage: [],\n        blacklistPage: [],\n        overrideHTML: null\n      };\n\n      function o() {\n        this.initialise.apply(this, arguments);\n      }\n\n      function s(e) {\n        this.openingTimeout = null, t.removeClass(e, \"cc-invisible\");\n      }\n\n      function r(t) {\n        t.style.display = \"none\", t.removeEventListener(e.transitionEnd, this.afterTransition), this.afterTransition = null;\n      }\n\n      function a() {\n        var e = this.options.position.split(\"-\"),\n            t = [];\n        return e.forEach(function (e) {\n          t.push(\"cc-\" + e);\n        }), t;\n      }\n\n      function c(n) {\n        var o = this.options,\n            s = document.createElement(\"div\"),\n            r = o.container && 1 === o.container.nodeType ? o.container : document.body;\n        s.innerHTML = n;\n        var a = s.children[0];\n        return a.style.display = \"none\", t.hasClass(a, \"cc-window\") && e.hasTransition && t.addClass(a, \"cc-invisible\"), this.onButtonClick = function (n) {\n          var o = t.traverseDOMPath(n.target, \"cc-btn\") || n.target;\n\n          if (t.hasClass(o, \"cc-btn\")) {\n            var s = o.className.match(new RegExp(\"\\\\bcc-(\" + i.join(\"|\") + \")\\\\b\")),\n                r = s && s[1] || !1;\n            r && (this.setStatus(r), this.close(!0));\n          }\n\n          t.hasClass(o, \"cc-close\") && (this.setStatus(e.status.dismiss), this.close(!0));\n          t.hasClass(o, \"cc-revoke\") && this.revokeChoice();\n        }.bind(this), a.addEventListener(\"click\", this.onButtonClick), o.autoAttach && (r.firstChild ? r.insertBefore(a, r.firstChild) : r.appendChild(a)), a;\n      }\n\n      function l(e) {\n        return \"000000\" == (e = t.normaliseHex(e)) ? \"#222\" : t.getLuminance(e);\n      }\n\n      function u(e, t) {\n        for (var i = 0, n = e.length; i < n; ++i) {\n          var o = e[i];\n          if (o instanceof RegExp && o.test(t) || \"string\" == typeof o && o.length && o === t) return !0;\n        }\n\n        return !1;\n      }\n\n      return o.prototype.initialise = function (i) {\n        this.options && this.destroy(), t.deepExtend(this.options = {}, n), t.isPlainObject(i) && t.deepExtend(this.options, i), function () {\n          var t = this.options.onInitialise.bind(this);\n          if (!window.navigator.cookieEnabled) return t(e.status.deny), !0;\n          if (window.CookiesOK || window.navigator.CookiesOK) return t(e.status.allow), !0;\n          var i = Object.keys(e.status),\n              n = this.getStatus(),\n              o = i.indexOf(n) >= 0;\n          o && t(n);\n          return o;\n        }.call(this) && (this.options.enabled = !1), u(this.options.blacklistPage, location.pathname) && (this.options.enabled = !1), u(this.options.whitelistPage, location.pathname) && (this.options.enabled = !0);\n        var o = this.options.window.replace(\"{{classes}}\", function () {\n          var i = this.options,\n              n = \"top\" == i.position || \"bottom\" == i.position ? \"banner\" : \"floating\";\n          t.isMobile() && (n = \"floating\");\n          var o = [\"cc-\" + n, \"cc-type-\" + i.type, \"cc-theme-\" + i.theme];\n          i.static && o.push(\"cc-static\");\n          o.push.apply(o, a.call(this));\n          (function (i) {\n            var n = t.hash(JSON.stringify(i)),\n                o = \"cc-color-override-\" + n,\n                s = t.isPlainObject(i);\n            this.customStyleSelector = s ? o : null, s && function (i, n, o) {\n              if (e.customStyles[i]) return void ++e.customStyles[i].references;\n              var s = {},\n                  r = n.popup,\n                  a = n.button,\n                  c = n.highlight;\n              r && (r.text = r.text ? r.text : t.getContrast(r.background), r.link = r.link ? r.link : r.text, s[o + \".cc-window\"] = [\"color: \" + r.text, \"background-color: \" + r.background], s[o + \".cc-revoke\"] = [\"color: \" + r.text, \"background-color: \" + r.background], s[o + \" .cc-link,\" + o + \" .cc-link:active,\" + o + \" .cc-link:visited\"] = [\"color: \" + r.link], a && (a.text = a.text ? a.text : t.getContrast(a.background), a.border = a.border ? a.border : \"transparent\", s[o + \" .cc-btn\"] = [\"color: \" + a.text, \"border-color: \" + a.border, \"background-color: \" + a.background], a.padding && s[o + \" .cc-btn\"].push(\"padding: \" + a.padding), \"transparent\" != a.background && (s[o + \" .cc-btn:hover, \" + o + \" .cc-btn:focus\"] = [\"background-color: \" + (a.hover || l(a.background))]), c ? (c.text = c.text ? c.text : t.getContrast(c.background), c.border = c.border ? c.border : \"transparent\", s[o + \" .cc-highlight .cc-btn:first-child\"] = [\"color: \" + c.text, \"border-color: \" + c.border, \"background-color: \" + c.background]) : s[o + \" .cc-highlight .cc-btn:first-child\"] = [\"color: \" + r.text]));\n              var u = document.createElement(\"style\");\n              document.head.appendChild(u), e.customStyles[i] = {\n                references: 1,\n                element: u.sheet\n              };\n              var h = -1;\n\n              for (var p in s) {\n                s.hasOwnProperty(p) && u.sheet.insertRule(p + \"{\" + s[p].join(\";\") + \"}\", ++h);\n              }\n            }(n, i, \".\" + o);\n            return s;\n          }).call(this, this.options.palette);\n          this.customStyleSelector && o.push(this.customStyleSelector);\n          return o;\n        }.call(this).join(\" \")).replace(\"{{children}}\", function () {\n          var e = {},\n              i = this.options;\n          i.showLink || (i.elements.link = \"\", i.elements.messagelink = i.elements.message);\n          Object.keys(i.elements).forEach(function (n) {\n            e[n] = t.interpolateString(i.elements[n], function (e) {\n              var t = i.content[e];\n              return e && \"string\" == typeof t && t.length ? t : \"\";\n            });\n          });\n          var n = i.compliance[i.type];\n          n || (n = i.compliance.info);\n          e.compliance = t.interpolateString(n, function (t) {\n            return e[t];\n          });\n          var o = i.layouts[i.layout];\n          o || (o = i.layouts.basic);\n          return t.interpolateString(o, function (t) {\n            return e[t];\n          });\n        }.call(this)),\n            s = this.options.overrideHTML;\n\n        if (\"string\" == typeof s && s.length && (o = s), this.options.static) {\n          var r = c.call(this, '<div class=\"cc-grower\">' + o + \"</div>\");\n          r.style.display = \"\", this.element = r.firstChild, this.element.style.display = \"none\", t.addClass(this.element, \"cc-invisible\");\n        } else this.element = c.call(this, o);\n\n        (function () {\n          var i = this.setStatus.bind(this),\n              n = this.close.bind(this),\n              o = this.options.dismissOnTimeout;\n          \"number\" == typeof o && o >= 0 && (this.dismissTimeout = window.setTimeout(function () {\n            i(e.status.dismiss), n(!0);\n          }, Math.floor(o)));\n          var s = this.options.dismissOnScroll;\n\n          if (\"number\" == typeof s && s >= 0) {\n            var r = function r(t) {\n              window.pageYOffset > Math.floor(s) && (i(e.status.dismiss), n(!0), window.removeEventListener(\"scroll\", r), this.onWindowScroll = null);\n            };\n\n            this.options.enabled && (this.onWindowScroll = r, window.addEventListener(\"scroll\", r));\n          }\n\n          var a = this.options.dismissOnWindowClick,\n              c = this.options.ignoreClicksFrom;\n\n          if (a) {\n            var l = function (o) {\n              for (var s = !1, r = o.path.length, a = c.length, u = 0; u < r; u++) {\n                if (!s) for (var h = 0; h < a; h++) {\n                  s || (s = t.hasClass(o.path[u], c[h]));\n                }\n              }\n\n              s || (i(e.status.dismiss), n(!0), window.removeEventListener(\"click\", l), window.removeEventListener(\"touchend\", l), this.onWindowClick = null);\n            }.bind(this);\n\n            this.options.enabled && (this.onWindowClick = l, window.addEventListener(\"click\", l), window.addEventListener(\"touchend\", l));\n          }\n        }).call(this), function () {\n          \"info\" != this.options.type && (this.options.revokable = !0);\n          t.isMobile() && (this.options.animateRevokable = !1);\n\n          if (this.options.revokable) {\n            var e = a.call(this);\n            this.options.animateRevokable && e.push(\"cc-animate\"), this.customStyleSelector && e.push(this.customStyleSelector);\n            var i = this.options.revokeBtn.replace(\"{{classes}}\", e.join(\" \")).replace(\"{{policy}}\", this.options.content.policy);\n            this.revokeBtn = c.call(this, i);\n            var n = this.revokeBtn;\n\n            if (this.options.animateRevokable) {\n              var o = t.throttle(function (e) {\n                var i = !1,\n                    o = window.innerHeight - 20;\n                t.hasClass(n, \"cc-top\") && e.clientY < 20 && (i = !0), t.hasClass(n, \"cc-bottom\") && e.clientY > o && (i = !0), i ? t.hasClass(n, \"cc-active\") || t.addClass(n, \"cc-active\") : t.hasClass(n, \"cc-active\") && t.removeClass(n, \"cc-active\");\n              }, 200);\n              this.onMouseMove = o, window.addEventListener(\"mousemove\", o);\n            }\n          }\n        }.call(this), this.options.autoOpen && this.autoOpen();\n      }, o.prototype.destroy = function () {\n        this.onButtonClick && this.element && (this.element.removeEventListener(\"click\", this.onButtonClick), this.onButtonClick = null), this.dismissTimeout && (clearTimeout(this.dismissTimeout), this.dismissTimeout = null), this.onWindowScroll && (window.removeEventListener(\"scroll\", this.onWindowScroll), this.onWindowScroll = null), this.onWindowClick && (window.removeEventListener(\"click\", this.onWindowClick), this.onWindowClick = null), this.onMouseMove && (window.removeEventListener(\"mousemove\", this.onMouseMove), this.onMouseMove = null), this.element && this.element.parentNode && this.element.parentNode.removeChild(this.element), this.element = null, this.revokeBtn && this.revokeBtn.parentNode && this.revokeBtn.parentNode.removeChild(this.revokeBtn), this.revokeBtn = null, function (i) {\n          if (t.isPlainObject(i)) {\n            var n = t.hash(JSON.stringify(i)),\n                o = e.customStyles[n];\n\n            if (o && ! --o.references) {\n              var s = o.element.ownerNode;\n              s && s.parentNode && s.parentNode.removeChild(s), e.customStyles[n] = null;\n            }\n          }\n        }(this.options.palette), this.options = null;\n      }, o.prototype.open = function (t) {\n        if (this.element) return this.isOpen() || (e.hasTransition ? this.fadeIn() : this.element.style.display = \"\", this.options.revokable && this.toggleRevokeButton(), this.options.onPopupOpen.call(this)), this;\n      }, o.prototype.close = function (t) {\n        if (this.element) return this.isOpen() && (e.hasTransition ? this.fadeOut() : this.element.style.display = \"none\", t && this.options.revokable && this.toggleRevokeButton(!0), this.options.onPopupClose.call(this)), this;\n      }, o.prototype.fadeIn = function () {\n        var i = this.element;\n\n        if (e.hasTransition && i && (this.afterTransition && r.call(this, i), t.hasClass(i, \"cc-invisible\"))) {\n          if (i.style.display = \"\", this.options.static) {\n            var n = this.element.clientHeight;\n            this.element.parentNode.style.maxHeight = n + \"px\";\n          }\n\n          this.openingTimeout = setTimeout(s.bind(this, i), 20);\n        }\n      }, o.prototype.fadeOut = function () {\n        var i = this.element;\n        e.hasTransition && i && (this.openingTimeout && (clearTimeout(this.openingTimeout), s.bind(this, i)), t.hasClass(i, \"cc-invisible\") || (this.options.static && (this.element.parentNode.style.maxHeight = \"\"), this.afterTransition = r.bind(this, i), i.addEventListener(e.transitionEnd, this.afterTransition), t.addClass(i, \"cc-invisible\")));\n      }, o.prototype.isOpen = function () {\n        return this.element && \"\" == this.element.style.display && (!e.hasTransition || !t.hasClass(this.element, \"cc-invisible\"));\n      }, o.prototype.toggleRevokeButton = function (e) {\n        this.revokeBtn && (this.revokeBtn.style.display = e ? \"\" : \"none\");\n      }, o.prototype.revokeChoice = function (e) {\n        this.options.enabled = !0, this.clearStatus(), this.options.onRevokeChoice.call(this), e || this.autoOpen();\n      }, o.prototype.hasAnswered = function (t) {\n        return Object.keys(e.status).indexOf(this.getStatus()) >= 0;\n      }, o.prototype.hasConsented = function (t) {\n        var i = this.getStatus();\n        return i == e.status.allow || i == e.status.dismiss;\n      }, o.prototype.autoOpen = function (e) {\n        !this.hasAnswered() && this.options.enabled ? this.open() : this.hasAnswered() && this.options.revokable && this.toggleRevokeButton(!0);\n      }, o.prototype.setStatus = function (i) {\n        var n = this.options.cookie,\n            o = t.getCookie(n.name),\n            s = Object.keys(e.status).indexOf(o) >= 0;\n        Object.keys(e.status).indexOf(i) >= 0 ? (t.setCookie(n.name, i, n.expiryDays, n.domain, n.path, n.secure), this.options.onStatusChange.call(this, i, s)) : this.clearStatus();\n      }, o.prototype.getStatus = function () {\n        return t.getCookie(this.options.cookie.name);\n      }, o.prototype.clearStatus = function () {\n        var e = this.options.cookie;\n        t.setCookie(e.name, \"\", -1, e.domain, e.path);\n      }, o;\n    }(), e.Location = function () {\n      var e = {\n        timeout: 5e3,\n        services: [\"ipinfo\"],\n        serviceDefinitions: {\n          ipinfo: function ipinfo() {\n            return {\n              url: \"//ipinfo.io\",\n              headers: [\"Accept: application/json\"],\n              callback: function callback(e, t) {\n                try {\n                  var i = JSON.parse(t);\n                  return i.error ? s(i) : {\n                    code: i.country\n                  };\n                } catch (e) {\n                  return s({\n                    error: \"Invalid response (\" + e + \")\"\n                  });\n                }\n              }\n            };\n          },\n          ipinfodb: function ipinfodb(e) {\n            return {\n              url: \"//api.ipinfodb.com/v3/ip-country/?key={api_key}&format=json&callback={callback}\",\n              isScript: !0,\n              callback: function callback(e, t) {\n                try {\n                  var i = JSON.parse(t);\n                  return \"ERROR\" == i.statusCode ? s({\n                    error: i.statusMessage\n                  }) : {\n                    code: i.countryCode\n                  };\n                } catch (e) {\n                  return s({\n                    error: \"Invalid response (\" + e + \")\"\n                  });\n                }\n              }\n            };\n          },\n          maxmind: function maxmind() {\n            return {\n              url: \"//js.maxmind.com/js/apis/geoip2/v2.1/geoip2.js\",\n              isScript: !0,\n              callback: function callback(e) {\n                window.geoip2 ? geoip2.country(function (t) {\n                  try {\n                    e({\n                      code: t.country.iso_code\n                    });\n                  } catch (t) {\n                    e(s(t));\n                  }\n                }, function (t) {\n                  e(s(t));\n                }) : e(new Error(\"Unexpected response format. The downloaded script should have exported `geoip2` to the global scope\"));\n              }\n            };\n          }\n        }\n      };\n\n      function i(i) {\n        t.deepExtend(this.options = {}, e), t.isPlainObject(i) && t.deepExtend(this.options, i), this.currentServiceIndex = -1;\n      }\n\n      function n(e, t, i) {\n        var n,\n            o = document.createElement(\"script\");\n        o.type = \"text/\" + (e.type || \"javascript\"), o.src = e.src || e, o.async = !1, o.onreadystatechange = o.onload = function () {\n          var e = o.readyState;\n          clearTimeout(n), t.done || e && !/loaded|complete/.test(e) || (t.done = !0, t(), o.onreadystatechange = o.onload = null);\n        }, document.body.appendChild(o), n = setTimeout(function () {\n          t.done = !0, t(), o.onreadystatechange = o.onload = null;\n        }, i);\n      }\n\n      function o(e, t, i, n, o) {\n        var s = new (window.XMLHttpRequest || window.ActiveXObject)(\"MSXML2.XMLHTTP.3.0\");\n        if (s.open(n ? \"POST\" : \"GET\", e, 1), s.setRequestHeader(\"Content-type\", \"application/x-www-form-urlencoded\"), Array.isArray(o)) for (var r = 0, a = o.length; r < a; ++r) {\n          var c = o[r].split(\":\", 2);\n          s.setRequestHeader(c[0].replace(/^\\s+|\\s+$/g, \"\"), c[1].replace(/^\\s+|\\s+$/g, \"\"));\n        }\n        \"function\" == typeof t && (s.onreadystatechange = function () {\n          s.readyState > 3 && t(s);\n        }), s.send(n);\n      }\n\n      function s(e) {\n        return new Error(\"Error [\" + (e.code || \"UNKNOWN\") + \"]: \" + e.error);\n      }\n\n      return i.prototype.getNextService = function () {\n        var e;\n\n        do {\n          e = this.getServiceByIdx(++this.currentServiceIndex);\n        } while (this.currentServiceIndex < this.options.services.length && !e);\n\n        return e;\n      }, i.prototype.getServiceByIdx = function (e) {\n        var i = this.options.services[e];\n\n        if (\"function\" == typeof i) {\n          var n = i();\n          return n.name && t.deepExtend(n, this.options.serviceDefinitions[n.name](n)), n;\n        }\n\n        return \"string\" == typeof i ? this.options.serviceDefinitions[i]() : t.isPlainObject(i) ? this.options.serviceDefinitions[i.name](i) : null;\n      }, i.prototype.locate = function (e, t) {\n        var i = this.getNextService();\n        i ? (this.callbackComplete = e, this.callbackError = t, this.runService(i, this.runNextServiceOnError.bind(this))) : t(new Error(\"No services to run\"));\n      }, i.prototype.setupUrl = function (e) {\n        var t = this.getCurrentServiceOpts();\n        return e.url.replace(/\\{(.*?)\\}/g, function (i, n) {\n          if (\"callback\" === n) {\n            var o = \"callback\" + Date.now();\n            return window[o] = function (t) {\n              e.__JSONP_DATA = JSON.stringify(t);\n            }, o;\n          }\n\n          if (n in t.interpolateUrl) return t.interpolateUrl[n];\n        });\n      }, i.prototype.runService = function (e, t) {\n        var i = this;\n        e && e.url && e.callback && (e.isScript ? n : o)(this.setupUrl(e), function (n) {\n          var o = n ? n.responseText : \"\";\n          e.__JSONP_DATA && (o = e.__JSONP_DATA, delete e.__JSONP_DATA), i.runServiceCallback.call(i, t, e, o);\n        }, this.options.timeout, e.data, e.headers);\n      }, i.prototype.runServiceCallback = function (e, t, i) {\n        var n = this,\n            o = t.callback(function (t) {\n          o || n.onServiceResult.call(n, e, t);\n        }, i);\n        o && this.onServiceResult.call(this, e, o);\n      }, i.prototype.onServiceResult = function (e, t) {\n        t instanceof Error || t && t.error ? e.call(this, t, null) : e.call(this, null, t);\n      }, i.prototype.runNextServiceOnError = function (e, t) {\n        if (e) {\n          this.logError(e);\n          var i = this.getNextService();\n          i ? this.runService(i, this.runNextServiceOnError.bind(this)) : this.completeService.call(this, this.callbackError, new Error(\"All services failed\"));\n        } else this.completeService.call(this, this.callbackComplete, t);\n      }, i.prototype.getCurrentServiceOpts = function () {\n        var e = this.options.services[this.currentServiceIndex];\n        return \"string\" == typeof e ? {\n          name: e\n        } : \"function\" == typeof e ? e() : t.isPlainObject(e) ? e : {};\n      }, i.prototype.completeService = function (e, t) {\n        this.currentServiceIndex = -1, e && e(t);\n      }, i.prototype.logError = function (e) {\n        var t = this.currentServiceIndex,\n            i = this.getServiceByIdx(t);\n        console.warn(\"The service[\" + t + \"] (\" + i.url + \") responded with the following error\", e);\n      }, i;\n    }(), e.Law = function () {\n      var e = {\n        regionalLaw: !0,\n        hasLaw: [\"AT\", \"BE\", \"BG\", \"HR\", \"CZ\", \"CY\", \"DK\", \"EE\", \"FI\", \"FR\", \"DE\", \"EL\", \"HU\", \"IE\", \"IT\", \"LV\", \"LT\", \"LU\", \"MT\", \"NL\", \"PL\", \"PT\", \"SK\", \"ES\", \"SE\", \"GB\", \"UK\", \"GR\", \"EU\"],\n        revokable: [\"HR\", \"CY\", \"DK\", \"EE\", \"FR\", \"DE\", \"LV\", \"LT\", \"NL\", \"PT\", \"ES\"],\n        explicitAction: [\"HR\", \"IT\", \"ES\"]\n      };\n\n      function i(e) {\n        this.initialise.apply(this, arguments);\n      }\n\n      return i.prototype.initialise = function (i) {\n        t.deepExtend(this.options = {}, e), t.isPlainObject(i) && t.deepExtend(this.options, i);\n      }, i.prototype.get = function (e) {\n        var t = this.options;\n        return {\n          hasLaw: t.hasLaw.indexOf(e) >= 0,\n          revokable: t.revokable.indexOf(e) >= 0,\n          explicitAction: t.explicitAction.indexOf(e) >= 0\n        };\n      }, i.prototype.applyLaw = function (e, t) {\n        var i = this.get(t);\n        return i.hasLaw || (e.enabled = !1, \"function\" == typeof e.onNoCookieLaw && e.onNoCookieLaw(t, i)), this.options.regionalLaw && (i.revokable && (e.revokable = !0), i.explicitAction && (e.dismissOnScroll = !1, e.dismissOnTimeout = !1)), e;\n      }, i;\n    }(), e.initialise = function (i, n, o) {\n      var s = new e.Law(i.law);\n      n || (n = function n() {}), o || (o = function o() {});\n      var r = Object.keys(e.status),\n          a = t.getCookie(\"cookieconsent_status\");\n      r.indexOf(a) >= 0 ? n(new e.Popup(i)) : e.getCountryCode(i, function (t) {\n        delete i.law, delete i.location, t.code && (i = s.applyLaw(i, t.code)), n(new e.Popup(i));\n      }, function (t) {\n        delete i.law, delete i.location, o(t, new e.Popup(i));\n      });\n    }, e.getCountryCode = function (t, i, n) {\n      t.law && t.law.countryCode ? i({\n        code: t.law.countryCode\n      }) : t.location ? new e.Location(t.location).locate(function (e) {\n        i(e || {});\n      }, n) : i({});\n    }, e.utils = t, e.hasInitialised = !0, window.cookieconsent = e;\n  }\n}(window.cookieconsent || {});","module.exports = function (originalModule) {\n  if (!originalModule.webpackPolyfill) {\n    var module = Object.create(originalModule); // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    Object.defineProperty(module, \"exports\", {\n      enumerable: true\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","var originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\n\nvar FunctionToString =\n/** @class */\nfunction () {\n  function FunctionToString() {\n    /**\n     * @inheritDoc\n     */\n    this.name = FunctionToString.id;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  FunctionToString.prototype.setupOnce = function () {\n    originalFunctionToString = Function.prototype.toString;\n\n    Function.prototype.toString = function () {\n      var args = [];\n\n      for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n      }\n\n      var context = this.__sentry__ ? this.__sentry_original__ : this; // tslint:disable-next-line:no-unsafe-any\n\n      return originalFunctionToString.apply(context, args);\n    };\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  FunctionToString.id = 'FunctionToString';\n  return FunctionToString;\n}();\n\nexport { FunctionToString };","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 */\n\nexport function truncate(str, max) {\n  if (max === void 0) {\n    max = 0;\n  } // tslint:disable-next-line:strict-type-predicates\n\n\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\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 */\n\nexport function snipLine(line, colno) {\n  var newLine = line;\n  var ll = newLine.length;\n\n  if (ll <= 150) {\n    return newLine;\n  }\n\n  if (colno > ll) {\n    colno = ll; // tslint:disable-line:no-parameter-reassignment\n  }\n\n  var start = Math.max(colno - 60, 0);\n\n  if (start < 5) {\n    start = 0;\n  }\n\n  var end = Math.min(start + 140, ll);\n\n  if (end > ll - 5) {\n    end = ll;\n  }\n\n  if (end === ll) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n\n  if (start > 0) {\n    newLine = \"'{snip} \" + newLine;\n  }\n\n  if (end < ll) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n\nexport function safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  var output = []; // tslint:disable-next-line:prefer-for-of\n\n  for (var i = 0; i < input.length; i++) {\n    var value = input[i];\n\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n/** Merges provided array of keys into */\n\nexport function keysToEventMessage(keys, maxLength) {\n  if (maxLength === void 0) {\n    maxLength = 40;\n  }\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    var serialized = keys.slice(0, includedKeys).join(', ');\n\n    if (serialized.length > maxLength) {\n      continue;\n    }\n\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n/**\n * 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 */\n\nexport function isMatchingPattern(value, pattern) {\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n\n  if (typeof pattern === 'string') {\n    return value.includes(pattern);\n  }\n\n  return false;\n}","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils'; // \"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.\n\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n/** Inbound filters configurable by the user */\n\nvar InboundFilters =\n/** @class */\nfunction () {\n  function InboundFilters(_options) {\n    if (_options === void 0) {\n      _options = {};\n    }\n\n    this._options = _options;\n    /**\n     * @inheritDoc\n     */\n\n    this.name = InboundFilters.id;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  InboundFilters.prototype.setupOnce = function () {\n    addGlobalEventProcessor(function (event) {\n      var hub = getCurrentHub();\n\n      if (!hub) {\n        return event;\n      }\n\n      var self = hub.getIntegration(InboundFilters);\n\n      if (self) {\n        var client = hub.getClient();\n        var clientOptions = client ? client.getOptions() : {};\n\n        var options = self._mergeOptions(clientOptions);\n\n        if (self._shouldDropEvent(event, options)) {\n          return null;\n        }\n      }\n\n      return event;\n    });\n  };\n  /** JSDoc */\n\n\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\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\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\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\n    return false;\n  };\n  /** JSDoc */\n\n\n  InboundFilters.prototype._isSentryError = function (event, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    if (!options.ignoreInternal) {\n      return false;\n    }\n\n    try {\n      // tslint:disable-next-line:no-unsafe-any\n      return event.exception.values[0].type === 'SentryError';\n    } catch (_oO) {\n      return false;\n    }\n  };\n  /** JSDoc */\n\n\n  InboundFilters.prototype._isIgnoredError = function (event, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    if (!options.ignoreErrors || !options.ignoreErrors.length) {\n      return false;\n    }\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 isMatchingPattern(message, pattern);\n      });\n    });\n  };\n  /** JSDoc */\n\n\n  InboundFilters.prototype._isBlacklistedUrl = function (event, options) {\n    if (options === void 0) {\n      options = {};\n    } // TODO: Use Glob instead?\n\n\n    if (!options.blacklistUrls || !options.blacklistUrls.length) {\n      return false;\n    }\n\n    var url = this._getEventFilterUrl(event);\n\n    return !url ? false : options.blacklistUrls.some(function (pattern) {\n      return isMatchingPattern(url, pattern);\n    });\n  };\n  /** JSDoc */\n\n\n  InboundFilters.prototype._isWhitelistedUrl = function (event, options) {\n    if (options === void 0) {\n      options = {};\n    } // TODO: Use Glob instead?\n\n\n    if (!options.whitelistUrls || !options.whitelistUrls.length) {\n      return true;\n    }\n\n    var url = this._getEventFilterUrl(event);\n\n    return !url ? true : options.whitelistUrls.some(function (pattern) {\n      return isMatchingPattern(url, pattern);\n    });\n  };\n  /** JSDoc */\n\n\n  InboundFilters.prototype._mergeOptions = function (clientOptions) {\n    if (clientOptions === void 0) {\n      clientOptions = {};\n    }\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\n\n  InboundFilters.prototype._getPossibleEventMessages = function (event) {\n    if (event.message) {\n      return [event.message];\n    }\n\n    if (event.exception) {\n      try {\n        // tslint:disable-next-line:no-unsafe-any\n        var _a = event.exception.values[0],\n            type = _a.type,\n            value = _a.value;\n        return [\"\" + value, type + \": \" + value];\n      } catch (oO) {\n        logger.error(\"Cannot extract message for event \" + getEventDescription(event));\n        return [];\n      }\n    }\n\n    return [];\n  };\n  /** JSDoc */\n\n\n  InboundFilters.prototype._getEventFilterUrl = function (event) {\n    try {\n      if (event.stacktrace) {\n        // tslint:disable:no-unsafe-any\n        var frames_1 = event.stacktrace.frames;\n        return frames_1[frames_1.length - 1].filename;\n      }\n\n      if (event.exception) {\n        // tslint:disable:no-unsafe-any\n        var frames_2 = event.exception.values[0].stacktrace.frames;\n        return frames_2[frames_2.length - 1].filename;\n      }\n\n      return null;\n    } catch (oO) {\n      logger.error(\"Cannot extract url for event \" + getEventDescription(event));\n      return null;\n    }\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  InboundFilters.id = 'InboundFilters';\n  return InboundFilters;\n}();\n\nexport { InboundFilters };","export var setPrototypeOf = Object.setPrototypeOf || ({\n  __proto__: []\n} instanceof Array ? setProtoOf : mixinProperties); // tslint:disable-line:no-unbound-method\n\n/**\n * setPrototypeOf polyfill using __proto__\n */\n\nfunction setProtoOf(obj, proto) {\n  // @ts-ignore\n  obj.__proto__ = proto;\n  return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\n\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\n  return obj;\n}","import * as tslib_1 from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\n\nvar SentryError =\n/** @class */\nfunction (_super) {\n  tslib_1.__extends(SentryError, _super);\n\n  function SentryError(message) {\n    var _newTarget = this.constructor;\n\n    var _this = _super.call(this, message) || this;\n\n    _this.message = message; // tslint:disable:no-unsafe-any\n\n    _this.name = _newTarget.prototype.constructor.name;\n    setPrototypeOf(_this, _newTarget.prototype);\n    return _this;\n  }\n\n  return SentryError;\n}(Error);\n\nexport { SentryError };","import * as tslib_1 from \"tslib\";\nimport { SentryError } from '@sentry/utils';\n/** Regular expression used to parse a Dsn. */\n\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w\\.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\n\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\n\nvar Dsn =\n/** @class */\nfunction () {\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\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\n\n  Dsn.prototype.toString = function (withPassword) {\n    if (withPassword === void 0) {\n      withPassword = false;\n    } // tslint:disable-next-line:no-this-assignment\n\n\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\n    return protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') + (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId);\n  };\n  /** Parses a string into this Dsn. */\n\n\n  Dsn.prototype._fromString = function (str) {\n    var match = DSN_REGEX.exec(str);\n\n    if (!match) {\n      throw new SentryError(ERROR_MESSAGE);\n    }\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\n    var path = '';\n    var projectId = lastPath;\n    var split = projectId.split('/');\n\n    if (split.length > 1) {\n      path = split.slice(0, -1).join('/');\n      projectId = split.pop();\n    }\n\n    Object.assign(this, {\n      host: host,\n      pass: pass,\n      path: path,\n      projectId: projectId,\n      port: port,\n      protocol: protocol,\n      user: user\n    });\n  };\n  /** Maps Dsn components into this instance. */\n\n\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\n\n  Dsn.prototype._validate = function () {\n    var _this = this;\n\n    ['protocol', 'user', 'host', 'projectId'].forEach(function (component) {\n      if (!_this[component]) {\n        throw new SentryError(ERROR_MESSAGE);\n      }\n    });\n\n    if (this.protocol !== 'http' && this.protocol !== 'https') {\n      throw new SentryError(ERROR_MESSAGE);\n    }\n\n    if (this.port && Number.isNaN(parseInt(this.port, 10))) {\n      throw new SentryError(ERROR_MESSAGE);\n    }\n  };\n\n  return Dsn;\n}();\n\nexport { Dsn };","import { urlEncode } from '@sentry/utils';\nimport { Dsn } from './dsn';\nvar SENTRY_API_VERSION = '7';\n/** Helper class to provide urls to different Sentry endpoints. */\n\nvar API =\n/** @class */\nfunction () {\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\n\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\n\n  API.prototype.getStoreEndpoint = function () {\n    return \"\" + this._getBaseUrl() + this.getStoreEndpointPath();\n  };\n  /** Returns the store endpoint with auth added in url encoded. */\n\n\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    }; // Auth is intentionally sent as part of query string (NOT as custom HTTP header)\n    // to avoid preflight CORS requests\n\n    return this.getStoreEndpoint() + \"?\" + urlEncode(auth);\n  };\n  /** Returns the base path of the url including the port. */\n\n\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\n\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\n\n  API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n    var dsn = this._dsnObject;\n    var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n    header.push(\"sentry_timestamp=\" + new Date().getTime());\n    header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n    header.push(\"sentry_key=\" + dsn.user);\n\n    if (dsn.pass) {\n      header.push(\"sentry_secret=\" + dsn.pass);\n    }\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\n\n  API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n    if (dialogOptions === void 0) {\n      dialogOptions = {};\n    }\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\n    for (var key in dialogOptions) {\n      if (key === 'user') {\n        if (!dialogOptions.user) {\n          continue;\n        }\n\n        if (dialogOptions.user.name) {\n          encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n        }\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\n    if (encodedOptions.length) {\n      return endpoint + \"?\" + encodedOptions.join('&');\n    }\n\n    return endpoint;\n  };\n\n  return API;\n}();\n\nexport { API };","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 */\n\nexport function getIntegrationsToSetup(options) {\n  var defaultIntegrations = options.defaultIntegrations && tslib_1.__spread(options.defaultIntegrations) || [];\n  var userIntegrations = options.integrations;\n  var integrations = [];\n\n  if (Array.isArray(userIntegrations)) {\n    var userIntegrationsNames_1 = userIntegrations.map(function (i) {\n      return i.name;\n    });\n    var pickedIntegrationsNames_1 = []; // Leave only unique default integrations, that were not overridden with provided user integrations\n\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    }); // Don't add same user integration twice\n\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    return tslib_1.__spread(defaultIntegrations);\n  }\n\n  return integrations;\n}\n/** Setup given integration */\n\nexport function setupIntegration(integration) {\n  if (installedIntegrations.indexOf(integration.name) !== -1) {\n    return;\n  }\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 */\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}","import * as tslib_1 from \"tslib\";\nimport { isPrimitive, isThenable, logger, SyncPromise, truncate, uuid4 } from '@sentry/utils';\nimport { Dsn } from './dsn';\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 */\n\nvar BaseClient =\n/** @class */\nfunction () {\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\n    this._processing = false;\n    this._backend = new backendClass(options);\n    this._options = options;\n\n    if (options.dsn) {\n      this._dsn = new Dsn(options.dsn);\n    }\n\n    if (this._isEnabled()) {\n      this._integrations = setupIntegrations(this._options);\n    }\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.captureException = function (exception, hint, scope) {\n    var _this = this;\n\n    var eventId = hint && hint.event_id;\n    this._processing = true;\n\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    }).catch(function (reason) {\n      logger.error(reason);\n      _this._processing = false;\n    });\n\n    return eventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n    var _this = this;\n\n    var eventId = hint && hint.event_id;\n    this._processing = true;\n    var promisedEvent = 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    }).catch(function (reason) {\n      logger.error(reason);\n      _this._processing = false;\n    });\n    return eventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.captureEvent = function (event, hint, scope) {\n    var _this = this;\n\n    var eventId = hint && hint.event_id;\n    this._processing = true;\n\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    }).catch(function (reason) {\n      logger.error(reason);\n      _this._processing = false;\n    });\n\n    return eventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.getDsn = function () {\n    return this._dsn;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.getOptions = function () {\n    return this._options;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.flush = function (timeout) {\n    var _this = this;\n\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\n\n  BaseClient.prototype.close = function (timeout) {\n    var _this = this;\n\n    return this.flush(timeout).then(function (result) {\n      _this.getOptions().enabled = false;\n      return result;\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.getIntegrations = function () {\n    return this._integrations || {};\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseClient.prototype.getIntegration = function (integration) {\n    try {\n      return this._integrations[integration.id] || null;\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\n\n  BaseClient.prototype._isClientProcessing = function (timeout) {\n    var _this = this;\n\n    return new Promise(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\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\n\n  BaseClient.prototype._getBackend = function () {\n    return this._backend;\n  };\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n\n\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\n\n  BaseClient.prototype._prepareEvent = function (event, scope, hint) {\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\n    var prepared = tslib_1.__assign({}, event);\n\n    if (prepared.environment === undefined && environment !== undefined) {\n      prepared.environment = environment;\n    }\n\n    if (prepared.release === undefined && release !== undefined) {\n      prepared.release = release;\n    }\n\n    if (prepared.dist === undefined && dist !== undefined) {\n      prepared.dist = dist;\n    }\n\n    if (prepared.message) {\n      prepared.message = truncate(prepared.message, maxValueLength);\n    }\n\n    var exception = prepared.exception && prepared.exception.values && prepared.exception.values[0];\n\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    var request = prepared.request;\n\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\n    }\n\n    if (prepared.event_id === undefined) {\n      prepared.event_id = uuid4();\n    }\n\n    this._addIntegrations(prepared.sdk); // We prepare the result here with a resolved Event.\n\n\n    var result = SyncPromise.resolve(prepared); // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n\n    if (scope) {\n      // In case we have a hub we reassign it.\n      result = scope.applyToEvent(prepared, hint);\n    }\n\n    return result;\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\n\n  BaseClient.prototype._addIntegrations = function (sdkInfo) {\n    var integrationsArray = Object.keys(this._integrations);\n\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\n\n  BaseClient.prototype._processEvent = function (event, hint, scope) {\n    var _this = this;\n\n    var _a = this.getOptions(),\n        beforeSend = _a.beforeSend,\n        sampleRate = _a.sampleRate;\n\n    if (!this._isEnabled()) {\n      return SyncPromise.reject('SDK not enabled, will not send event.');\n    } // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n\n\n    if (typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      return SyncPromise.reject('This event has been sampled, will not send event.');\n    }\n\n    return new 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\n        var finalEvent = prepared;\n\n        try {\n          var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n\n          if (isInternalException || !beforeSend) {\n            _this._getBackend().sendEvent(finalEvent);\n\n            resolve(finalEvent);\n            return;\n          }\n\n          var beforeSendResult = beforeSend(prepared, hint);\n\n          if (typeof beforeSendResult === 'undefined') {\n            logger.error('`beforeSend` method has to return `null` or a valid event.');\n          } else if (isThenable(beforeSendResult)) {\n            _this._handleAsyncBeforeSend(beforeSendResult, resolve, reject);\n          } else {\n            finalEvent = beforeSendResult;\n\n            if (finalEvent === null) {\n              logger.log('`beforeSend` returned `null`, will not send event.');\n              resolve(null);\n              return;\n            } // From here on we are really async\n\n\n            _this._getBackend().sendEvent(finalEvent);\n\n            resolve(finalEvent);\n          }\n        } catch (exception) {\n          _this.captureException(exception, {\n            data: {\n              __sentry__: true\n            },\n            originalException: exception\n          });\n\n          reject('`beforeSend` throw an error, will not send event.');\n        }\n      });\n    });\n  };\n  /**\n   * Resolves before send Promise and calls resolve/reject on parent SyncPromise.\n   */\n\n\n  BaseClient.prototype._handleAsyncBeforeSend = function (beforeSend, resolve, reject) {\n    var _this = this;\n\n    beforeSend.then(function (processedEvent) {\n      if (processedEvent === null) {\n        reject('`beforeSend` returned `null`, will not send event.');\n        return;\n      } // From here on we are really async\n\n\n      _this._getBackend().sendEvent(processedEvent);\n\n      resolve(processedEvent);\n    }).catch(function (e) {\n      reject(\"beforeSend rejected with \" + e);\n    });\n  };\n\n  return BaseClient;\n}();\n\nexport { BaseClient };","/** The status of an event. */\nexport var Status;\n\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\n  Status[\"Skipped\"] = \"skipped\";\n  /** The event was sent to Sentry successfully. */\n\n  Status[\"Success\"] = \"success\";\n  /** The client is currently rate limited and will try again later. */\n\n  Status[\"RateLimit\"] = \"rate_limit\";\n  /** The event could not be processed. */\n\n  Status[\"Invalid\"] = \"invalid\";\n  /** A server-side error ocurred during submission. */\n\n  Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {})); // tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\n\n\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\n    if (code === 429) {\n      return Status.RateLimit;\n    }\n\n    if (code >= 400 && code < 500) {\n      return Status.Invalid;\n    }\n\n    if (code >= 500) {\n      return Status.Failed;\n    }\n\n    return Status.Unknown;\n  }\n\n  Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));","import { Status } from '@sentry/types';\n/** Noop transport */\n\nvar NoopTransport =\n/** @class */\nfunction () {\n  function NoopTransport() {}\n  /**\n   * @inheritDoc\n   */\n\n\n  NoopTransport.prototype.sendEvent = function (_) {\n    return Promise.resolve({\n      reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n      status: Status.Skipped\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  NoopTransport.prototype.close = function (_) {\n    return Promise.resolve(true);\n  };\n\n  return NoopTransport;\n}();\n\nexport { NoopTransport };","/** JSDoc */\nexport var Severity;\n\n(function (Severity) {\n  /** JSDoc */\n  Severity[\"Fatal\"] = \"fatal\";\n  /** JSDoc */\n\n  Severity[\"Error\"] = \"error\";\n  /** JSDoc */\n\n  Severity[\"Warning\"] = \"warning\";\n  /** JSDoc */\n\n  Severity[\"Log\"] = \"log\";\n  /** JSDoc */\n\n  Severity[\"Info\"] = \"info\";\n  /** JSDoc */\n\n  Severity[\"Debug\"] = \"debug\";\n  /** JSDoc */\n\n  Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {})); // tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\n\n\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\n      case 'info':\n        return Severity.Info;\n\n      case 'warn':\n      case 'warning':\n        return Severity.Warning;\n\n      case 'error':\n        return Severity.Error;\n\n      case 'fatal':\n        return Severity.Fatal;\n\n      case 'critical':\n        return Severity.Critical;\n\n      case 'log':\n      default:\n        return Severity.Log;\n    }\n  }\n\n  Severity.fromString = fromString;\n})(Severity || (Severity = {}));","import { logger, SentryError } from '@sentry/utils';\nimport { NoopTransport } from './transports/noop';\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\n\nvar BaseBackend =\n/** @class */\nfunction () {\n  /** Creates a new backend instance. */\n  function BaseBackend(options) {\n    this._options = options;\n\n    if (!this._options.dsn) {\n      logger.warn('No DSN provided, backend will not do anything.');\n    }\n\n    this._transport = this._setupTransport();\n  }\n  /**\n   * Sets up the transport so it can be used later to send requests.\n   */\n\n\n  BaseBackend.prototype._setupTransport = function () {\n    return new NoopTransport();\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n    throw new SentryError('Backend has to implement `eventFromException` method');\n  };\n  /**\n   * @inheritDoc\n   */\n\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\n\n  BaseBackend.prototype.sendEvent = function (event) {\n    this._transport.sendEvent(event).catch(function (reason) {\n      logger.error(\"Error while sending event: \" + reason);\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseBackend.prototype.getTransport = function () {\n    return this._transport;\n  };\n\n  return BaseBackend;\n}();\n\nexport { BaseBackend };","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 */\n\nexport function 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 */\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  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\n\nexport function 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 */\n\nexport function supportsFetch() {\n  if (!('fetch' in getGlobalObject())) {\n    return false;\n  }\n\n  try {\n    // tslint:disable-next-line:no-unused-expression\n    new Headers(); // tslint:disable-next-line:no-unused-expression\n\n    new Request(''); // tslint:disable-next-line:no-unused-expression\n\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\n\nexport function supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  var isNativeFunc = function isNativeFunc(func) {\n    return func.toString().indexOf('native') !== -1;\n  };\n\n  var global = getGlobalObject();\n  var result = null;\n  var doc = global.document;\n\n  if (doc) {\n    var sandbox = doc.createElement('iframe');\n    sandbox.hidden = true;\n\n    try {\n      doc.head.appendChild(sandbox);\n\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // tslint:disable-next-line no-unbound-method\n        result = isNativeFunc(sandbox.contentWindow.fetch);\n      }\n\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  if (result === null) {\n    // tslint:disable-next-line no-unbound-method\n    result = isNativeFunc(global.fetch);\n  }\n\n  return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\n\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 */\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\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 */\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; // tslint:disable-next-line:no-unsafe-any\n\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}","// tslint:disable\nimport * as tslib_1 from \"tslib\";\nimport { getGlobalObject, isError, isErrorEvent } from '@sentry/utils';\n/**\n * TraceKit - Cross brower stack traces\n *\n * This was originally forked from github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n *\n * NOTE: Last merge with upstream repository\n * Jul 11,2018 - #f03357c\n *\n * https://github.com/csnover/TraceKit\n * @license MIT\n * @namespace TraceKit\n */\n\nvar window = getGlobalObject();\nvar TraceKit = {\n  _report: false,\n  _collectWindowErrors: false,\n  _computeStackTrace: false,\n  _linesOfContext: false\n}; // var TraceKit: TraceKitInterface = {};\n// var TraceKit = {};\n// global reference to slice\n\nvar UNKNOWN_FUNCTION = '?'; // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\n\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;\n/**\n * A better form of hasOwnProperty<br/>\n * Example: `_has(MainHostObject, property) === true/false`\n *\n * @param {Object} object to check property\n * @param {string} key to check\n * @return {Boolean} true if the object has the key and it is not inherited\n */\n\nfunction _has(object, key) {\n  return Object.prototype.hasOwnProperty.call(object, key);\n}\n/**\n * A safe form of location.href<br/>\n *\n * @return {string} location.href\n */\n\n\nfunction getLocationHref() {\n  if (typeof document === 'undefined' || document.location == null) return '';\n  return document.location.href;\n}\n/**\n * Cross-browser processing of unhandled exceptions\n *\n * Syntax:\n * ```js\n *   TraceKit.report.subscribe(function(stackInfo) { ... })\n *   TraceKit.report(exception)\n *   try { ...code... } catch(ex) { TraceKit.report(ex); }\n * ```\n *\n * Supports:\n *   - Firefox: full stack trace with line numbers, plus column number\n *     on top frame; column number is not guaranteed\n *   - Opera: full stack trace with line and column numbers\n *   - Chrome: full stack trace with line and column numbers\n *   - Safari: line and column number for the top frame only; some frames\n *     may be missing, and column number is not guaranteed\n *   - IE: line and column number for the top frame only; some frames\n *     may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n *   - IE5.5+ (only 8.0 tested)\n *   - Firefox 0.9+ (only 3.5+ tested)\n *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n *     Exceptions Have Stacktrace to be enabled in opera:config)\n *   - Safari 3+ (only 4+ tested)\n *   - Chrome 1+ (only 5+ tested)\n *   - Konqueror 3.5+ (untested)\n *\n * Requires TraceKit._computeStackTrace.\n *\n * Tries to catch all unhandled exceptions and report them to the\n * subscribed handlers. Please note that TraceKit.report will rethrow the\n * exception. This is REQUIRED in order to get a useful stack trace in IE.\n * If the exception does not reach the top of the browser, you will only\n * get a stack trace from the point where TraceKit.report was called.\n *\n * Handlers receive a TraceKit.StackTrace object as described in the\n * TraceKit._computeStackTrace docs.\n *\n * @memberof TraceKit\n * @namespace\n */\n\n\nTraceKit._report = function reportModuleWrapper() {\n  var handlers = [],\n      lastException = null,\n      lastExceptionStack = null;\n  /**\n   * Add a crash handler.\n   * @param {Function} handler\n   * @memberof TraceKit.report\n   */\n\n  function _subscribe(handler) {\n    // NOTE: We call both handlers manually in browser/integrations/globalhandler.ts\n    // So user can choose which one he wants to attach\n    // installGlobalHandler();\n    // installGlobalUnhandledRejectionHandler();\n    handlers.push(handler);\n  }\n  /**\n   * Dispatch stack information to all handlers.\n   * @param {TraceKit.StackTrace} stack\n   * @param {boolean} isWindowError Is this a top-level window error?\n   * @param {Error=} error The error that's being handled (if available, null otherwise)\n   * @memberof TraceKit.report\n   * @throws An exception if an error occurs while calling an handler.\n   */\n\n\n  function _notifyHandlers(stack, isWindowError, error) {\n    var exception = null;\n\n    if (isWindowError && !TraceKit._collectWindowErrors) {\n      return;\n    }\n\n    for (var i in handlers) {\n      if (_has(handlers, i)) {\n        try {\n          handlers[i](stack, isWindowError, error);\n        } catch (inner) {\n          exception = inner;\n        }\n      }\n    }\n\n    if (exception) {\n      throw exception;\n    }\n  }\n\n  var _oldOnerrorHandler, _onErrorHandlerInstalled;\n  /**\n   * Ensures all global unhandled exceptions are recorded.\n   * Supported by Gecko and IE.\n   * @param {string} message Error message.\n   * @param {string} url URL of script that generated the exception.\n   * @param {(number|string)} lineNo The line number at which the error occurred.\n   * @param {(number|string)=} columnNo The column number at which the error occurred.\n   * @param {Error=} errorObj The actual Error object.\n   * @memberof TraceKit.report\n   */\n\n\n  function _traceKitWindowOnError(message, url, lineNo, columnNo, errorObj) {\n    var stack = null; // If 'errorObj' is ErrorEvent, get real Error from inside\n\n    errorObj = isErrorEvent(errorObj) ? errorObj.error : errorObj; // If 'message' is ErrorEvent, get real message from inside\n\n    message = isErrorEvent(message) ? message.message : message;\n\n    if (lastExceptionStack) {\n      TraceKit._computeStackTrace._augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);\n\n      processLastException();\n    } else if (errorObj && isError(errorObj)) {\n      stack = TraceKit._computeStackTrace(errorObj);\n      stack.mechanism = 'onerror';\n\n      _notifyHandlers(stack, true, errorObj);\n    } else {\n      var location = {\n        url: url,\n        line: lineNo,\n        column: columnNo\n      };\n      var name;\n      var msg = message; // must be new var or will modify original `arguments`\n\n      if ({}.toString.call(message) === '[object String]') {\n        var groups = message.match(ERROR_TYPES_RE);\n\n        if (groups) {\n          name = groups[1];\n          msg = groups[2];\n        }\n      }\n\n      location.func = UNKNOWN_FUNCTION;\n      location.context = null;\n      stack = {\n        name: name,\n        message: msg,\n        mode: 'onerror',\n        mechanism: 'onerror',\n        stack: [tslib_1.__assign({}, location, {\n          // Firefox sometimes doesn't return url correctly and this is an old behavior\n          // that I prefer to port here as well.\n          // It can be altered only here, as previously it's using `location.url` for other things — Kamil\n          url: location.url || getLocationHref()\n        })]\n      };\n\n      _notifyHandlers(stack, true, null);\n    }\n\n    if (_oldOnerrorHandler) {\n      // @ts-ignore\n      return _oldOnerrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  }\n  /**\n   * Ensures all unhandled rejections are recorded.\n   * @param {PromiseRejectionEvent} e event.\n   * @memberof TraceKit.report\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onunhandledrejection\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n   */\n\n\n  function _traceKitWindowOnUnhandledRejection(e) {\n    var err = e; // You cannot itterate over non-objects, but we want to check\n    // for the existence in any value, not for the value itself\n\n    try {\n      err = e && 'reason' in e ? e.reason : e;\n    } catch (_oO) {}\n\n    var stack = TraceKit._computeStackTrace(err);\n\n    stack.mechanism = 'onunhandledrejection';\n\n    _notifyHandlers(stack, true, err);\n  }\n  /**\n   * Install a global onerror handler\n   * @memberof TraceKit.report\n   */\n\n\n  function _installGlobalHandler() {\n    if (_onErrorHandlerInstalled === true) {\n      return;\n    }\n\n    _oldOnerrorHandler = window.onerror;\n    window.onerror = _traceKitWindowOnError;\n    _onErrorHandlerInstalled = true;\n  }\n  /**\n   * Install a global onunhandledrejection handler\n   * @memberof TraceKit.report\n   */\n\n\n  function _installGlobalUnhandledRejectionHandler() {\n    window.onunhandledrejection = _traceKitWindowOnUnhandledRejection;\n  }\n  /**\n   * Process the most recent exception\n   * @memberof TraceKit.report\n   */\n\n\n  function processLastException() {\n    var _lastExceptionStack = lastExceptionStack,\n        _lastException = lastException;\n    lastExceptionStack = null;\n    lastException = null;\n\n    _notifyHandlers(_lastExceptionStack, false, _lastException);\n  }\n  /**\n   * Reports an unhandled Error to TraceKit.\n   * @param {Error} ex\n   * @memberof TraceKit.report\n   * @throws An exception if an incomplete stack trace is detected (old IE browsers).\n   */\n\n\n  function _report(ex) {\n    if (lastExceptionStack) {\n      if (lastException === ex) {\n        return; // already caught by an inner catch block, ignore\n      } else {\n        processLastException();\n      }\n    }\n\n    var stack = TraceKit._computeStackTrace(ex);\n\n    lastExceptionStack = stack;\n    lastException = ex; // If the stack trace is incomplete, wait for 2 seconds for\n    // slow slow IE to see if onerror occurs or not before reporting\n    // this exception; otherwise, we will end up with an incomplete\n    // stack trace\n\n    setTimeout(function () {\n      if (lastException === ex) {\n        processLastException();\n      }\n    }, stack.incomplete ? 2000 : 0);\n    throw ex; // re-throw to propagate to the top level (and cause window.onerror)\n  }\n\n  _report._subscribe = _subscribe;\n  _report._installGlobalHandler = _installGlobalHandler;\n  _report._installGlobalUnhandledRejectionHandler = _installGlobalUnhandledRejectionHandler;\n  return _report;\n}();\n/**\n * An object representing a single stack frame.\n * @typedef {Object} StackFrame\n * @property {string} url The JavaScript or HTML file URL.\n * @property {string} func The function name, or empty for anonymous functions (if guessing did not work).\n * @property {string[]?} args The arguments passed to the function, if known.\n * @property {number=} line The line number, if known.\n * @property {number=} column The column number, if known.\n * @property {string[]} context An array of source code lines; the middle element corresponds to the correct line#.\n * @memberof TraceKit\n */\n\n/**\n * An object representing a JavaScript stack trace.\n * @typedef {Object} StackTrace\n * @property {string} name The name of the thrown exception.\n * @property {string} message The exception error message.\n * @property {TraceKit.StackFrame[]} stack An array of stack frames.\n * @property {string} mode 'stack', 'stacktrace', 'multiline', 'callers', 'onerror', or 'failed' -- method used to collect the stack trace.\n * @memberof TraceKit\n */\n\n/**\n * TraceKit._computeStackTrace: cross-browser stack traces in JavaScript\n *\n * Syntax:\n *   ```js\n *   s = TraceKit._computeStackTrace(exception) // consider using TraceKit.report instead (see below)\n *   ```\n *\n * Supports:\n *   - Firefox:  full stack trace with line numbers and unreliable column\n *               number on top frame\n *   - Opera 10: full stack trace with line and column numbers\n *   - Opera 9-: full stack trace with line numbers\n *   - Chrome:   full stack trace with line and column numbers\n *   - Safari:   line and column number for the topmost stacktrace element\n *               only\n *   - IE:       no line numbers whatsoever\n *\n * Tries to guess names of anonymous functions by looking for assignments\n * in the source code. In IE and Safari, we have to guess source file names\n * by searching for function bodies inside all page scripts. This will not\n * work for scripts that are loaded cross-domain.\n * Here be dragons: some function names may be guessed incorrectly, and\n * duplicate functions may be mismatched.\n *\n * TraceKit._computeStackTrace should only be used for tracing purposes.\n * Logging of unhandled exceptions should be done with TraceKit.report,\n * which builds on top of TraceKit._computeStackTrace and provides better\n * IE support by utilizing the window.onerror event to retrieve information\n * about the top of the stack.\n *\n * Note: In IE and Safari, no stack trace is recorded on the Error object,\n * so computeStackTrace instead walks its *own* chain of callers.\n * This means that:\n *  * in Safari, some methods may be missing from the stack trace;\n *  * in IE, the topmost function in the stack trace will always be the\n *    caller of computeStackTrace.\n *\n * This is okay for tracing (because you are likely to be calling\n * computeStackTrace from the function you want to be the topmost element\n * of the stack trace anyway), but not okay for logging unhandled\n * exceptions (because your catch block will likely be far away from the\n * inner function that actually caused the exception).\n *\n * @memberof TraceKit\n * @namespace\n */\n\n\nTraceKit._computeStackTrace = function _computeStackTraceWrapper() {\n  // Contents of Exception in various browsers.\n  //\n  // SAFARI:\n  // ex.message = Can't find variable: qq\n  // ex.line = 59\n  // ex.sourceId = 580238192\n  // ex.sourceURL = http://...\n  // ex.expressionBeginOffset = 96\n  // ex.expressionCaretOffset = 98\n  // ex.expressionEndOffset = 98\n  // ex.name = ReferenceError\n  //\n  // FIREFOX:\n  // ex.message = qq is not defined\n  // ex.fileName = http://...\n  // ex.lineNumber = 59\n  // ex.columnNumber = 69\n  // ex.stack = ...stack trace... (see the example below)\n  // ex.name = ReferenceError\n  //\n  // CHROME:\n  // ex.message = qq is not defined\n  // ex.name = ReferenceError\n  // ex.type = not_defined\n  // ex.arguments = ['aa']\n  // ex.stack = ...stack trace...\n  //\n  // INTERNET EXPLORER:\n  // ex.message = ...\n  // ex.name = ReferenceError\n  //\n  // OPERA:\n  // ex.message = ...message... (see the example below)\n  // ex.name = ReferenceError\n  // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)\n  // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'\n\n  /**\n   * Computes stack trace information from the stack property.\n   * Chrome and Gecko use this property.\n   * @param {Error} ex\n   * @return {?TraceKit.StackTrace} Stack trace information.\n   * @memberof TraceKit._computeStackTrace\n   */\n  function _computeStackTraceFromStackProp(ex) {\n    if (!ex || !ex.stack) {\n      return null;\n    } // Chromium based browsers: Chrome, Brave, new Opera, new Edge\n\n\n    var chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|[-a-z]+:|\\/).*?)(?::(\\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.\n    gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js))(?::(\\d+))?(?::(\\d+))?\\s*$/i,\n        winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i,\n        // Used to additionally parse URL/line/column from eval frames\n    isEval,\n        geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i,\n        chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/,\n        lines = ex.stack.split('\\n'),\n        stack = [],\n        submatch,\n        parts,\n        element,\n        reference = /^(.*) is undefined$/.exec(ex.message);\n\n    for (var i = 0, j = lines.length; i < j; ++i) {\n      if (parts = chrome.exec(lines[i])) {\n        var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n\n        isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\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\n          parts[3] = submatch[2]; // line\n\n          parts[4] = submatch[3]; // column\n        }\n\n        element = {\n          url: 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\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\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\n      if (!element.func && element.line) {\n        element.func = UNKNOWN_FUNCTION;\n      }\n\n      element.context = null;\n      stack.push(element);\n    }\n\n    if (!stack.length) {\n      return null;\n    }\n\n    if (stack[0] && stack[0].line && !stack[0].column && reference) {\n      stack[0].column = null;\n    }\n\n    return {\n      mode: 'stack',\n      name: ex.name,\n      message: ex.message,\n      stack: stack\n    };\n  }\n  /**\n   * Computes stack trace information from the stacktrace property.\n   * Opera 10+ uses this property.\n   * @param {Error} ex\n   * @return {?TraceKit.StackTrace} Stack trace information.\n   * @memberof TraceKit._computeStackTrace\n   */\n\n\n  function _computeStackTraceFromStacktraceProp(ex) {\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\n    if (!stacktrace) {\n      return;\n    }\n\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i,\n        opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^\\)]+))\\((.*)\\))? in (.*):\\s*$/i,\n        lines = stacktrace.split('\\n'),\n        stack = [],\n        parts;\n\n    for (var line = 0; line < lines.length; line += 2) {\n      var element = null;\n\n      if (parts = opera10Regex.exec(lines[line])) {\n        element = {\n          url: parts[2],\n          line: +parts[1],\n          column: null,\n          func: parts[3],\n          args: []\n        };\n      } else if (parts = opera11Regex.exec(lines[line])) {\n        element = {\n          url: parts[6],\n          line: +parts[1],\n          column: +parts[2],\n          func: parts[3] || parts[4],\n          args: parts[5] ? parts[5].split(',') : []\n        };\n      }\n\n      if (element) {\n        if (!element.func && element.line) {\n          element.func = UNKNOWN_FUNCTION;\n        }\n\n        if (element.line) {\n          element.context = null;\n        }\n\n        if (!element.context) {\n          element.context = [lines[line + 1]];\n        }\n\n        stack.push(element);\n      }\n    }\n\n    if (!stack.length) {\n      return null;\n    }\n\n    return {\n      mode: 'stacktrace',\n      name: ex.name,\n      message: ex.message,\n      stack: stack\n    };\n  }\n  /**\n   * NOT TESTED.\n   * Computes stack trace information from an error message that includes\n   * the stack trace.\n   * Opera 9 and earlier use this method if the option to show stack\n   * traces is turned on in opera:config.\n   * @param {Error} ex\n   * @return {?TraceKit.StackTrace} Stack information.\n   * @memberof TraceKit._computeStackTrace\n   */\n\n\n  function _computeStackTraceFromOperaMultiLineMessage(ex) {\n    // TODO: Clean this function up\n    // Opera includes a stack trace into the exception message. An example is:\n    //\n    // Statement on line 3: Undefined variable: undefinedFunc\n    // Backtrace:\n    //   Line 3 of linked script file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.js: In function zzz\n    //         undefinedFunc(a);\n    //   Line 7 of inline#1 script in file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.html: In function yyy\n    //           zzz(x, y, z);\n    //   Line 3 of inline#1 script in file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.html: In function xxx\n    //           yyy(a, a, a);\n    //   Line 1 of function script\n    //     try { xxx('hi'); return false; } catch(ex) { TraceKit.report(ex); }\n    //   ...\n    var lines = ex.message.split('\\n');\n\n    if (lines.length < 4) {\n      return null;\n    }\n\n    var lineRE1 = /^\\s*Line (\\d+) of linked script ((?:file|https?|blob)\\S+)(?:: in function (\\S+))?\\s*$/i,\n        lineRE2 = /^\\s*Line (\\d+) of inline#(\\d+) script in ((?:file|https?|blob)\\S+)(?:: in function (\\S+))?\\s*$/i,\n        lineRE3 = /^\\s*Line (\\d+) of function script\\s*$/i,\n        stack = [],\n        scripts = window && window.document && window.document.getElementsByTagName('script'),\n        inlineScriptBlocks = [],\n        parts;\n\n    for (var s in scripts) {\n      if (_has(scripts, s) && !scripts[s].src) {\n        inlineScriptBlocks.push(scripts[s]);\n      }\n    }\n\n    for (var line = 2; line < lines.length; line += 2) {\n      var item = null;\n\n      if (parts = lineRE1.exec(lines[line])) {\n        item = {\n          url: parts[2],\n          func: parts[3],\n          args: [],\n          line: +parts[1],\n          column: null\n        };\n      } else if (parts = lineRE2.exec(lines[line])) {\n        item = {\n          url: parts[3],\n          func: parts[4],\n          args: [],\n          line: +parts[1],\n          column: null\n        };\n      } else if (parts = lineRE3.exec(lines[line])) {\n        var url = getLocationHref().replace(/#.*$/, '');\n        item = {\n          url: url,\n          func: '',\n          args: [],\n          line: parts[1],\n          column: null\n        };\n      }\n\n      if (item) {\n        if (!item.func) {\n          item.func = UNKNOWN_FUNCTION;\n        } // if (context) alert(\"Context mismatch. Correct midline:\\n\" + lines[i+1] + \"\\n\\nMidline:\\n\" + midline + \"\\n\\nContext:\\n\" + context.join(\"\\n\") + \"\\n\\nURL:\\n\" + item.url);\n\n\n        item.context = [lines[line + 1]];\n        stack.push(item);\n      }\n    }\n\n    if (!stack.length) {\n      return null; // could not parse multiline exception message as Opera stack trace\n    }\n\n    return {\n      mode: 'multiline',\n      name: ex.name,\n      message: lines[0],\n      stack: stack\n    };\n  }\n  /**\n   * Adds information about the first frame to incomplete stack traces.\n   * Safari and IE require this to get complete data on the first frame.\n   * @param {TraceKit.StackTrace} stackInfo Stack trace information from\n   * one of the compute* methods.\n   * @param {string} url The URL of the script that caused an error.\n   * @param {(number|string)} lineNo The line number of the script that\n   * caused an error.\n   * @param {string=} message The error generated by the browser, which\n   * hopefully contains the name of the object that caused the error.\n   * @return {boolean} Whether or not the stack information was\n   * augmented.\n   * @memberof TraceKit._computeStackTrace\n   */\n\n\n  function _augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {\n    var initial = {\n      url: url,\n      line: lineNo\n    };\n\n    if (initial.url && initial.line) {\n      stackInfo.incomplete = false;\n\n      if (!initial.func) {\n        initial.func = UNKNOWN_FUNCTION;\n      }\n\n      if (!initial.context) {\n        initial.context = null;\n      }\n\n      var reference = / '([^']+)' /.exec(message);\n\n      if (reference) {\n        initial.column = null;\n      }\n\n      if (stackInfo.stack.length > 0) {\n        if (stackInfo.stack[0].url === initial.url) {\n          if (stackInfo.stack[0].line === initial.line) {\n            return false; // already in stack trace\n          } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {\n            stackInfo.stack[0].line = initial.line;\n            stackInfo.stack[0].context = initial.context;\n            return false;\n          }\n        }\n      }\n\n      stackInfo.stack.unshift(initial);\n      stackInfo.partial = true;\n      return true;\n    } else {\n      stackInfo.incomplete = true;\n    }\n\n    return false;\n  }\n  /**\n   * Computes stack trace information by walking the arguments.caller\n   * chain at the time the exception occurred. This will cause earlier\n   * frames to be missed but is the only way to get any stack trace in\n   * Safari and IE. The top frame is restored by\n   * {@link augmentStackTraceWithInitialElement}.\n   * @param {Error} ex\n   * @return {TraceKit.StackTrace=} Stack trace information.\n   * @memberof TraceKit._computeStackTrace\n   */\n\n\n  function _computeStackTraceByWalkingCallerChain(ex, depth) {\n    var functionName = /function\\s+([_$a-zA-Z\\xA0-\\uFFFF][_$a-zA-Z0-9\\xA0-\\uFFFF]*)?\\s*\\(/i,\n        stack = [],\n        funcs = {},\n        recursion = false,\n        parts,\n        item;\n\n    for (var curr = _computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {\n      if (curr === _computeStackTrace || curr === TraceKit._report) {\n        continue;\n      }\n\n      item = {\n        url: null,\n        func: UNKNOWN_FUNCTION,\n        args: [],\n        line: null,\n        column: null\n      };\n\n      if (curr.name) {\n        item.func = curr.name;\n      } else if (parts = functionName.exec(curr.toString())) {\n        item.func = parts[1];\n      }\n\n      if (typeof item.func === 'undefined') {\n        try {\n          item.func = parts.input.substring(0, parts.input.indexOf('{'));\n        } catch (e) {}\n      }\n\n      if (funcs['' + curr]) {\n        recursion = true;\n      } else {\n        funcs['' + curr] = true;\n      }\n\n      stack.push(item);\n    }\n\n    if (depth) {\n      stack.splice(0, depth);\n    }\n\n    var result = {\n      mode: 'callers',\n      name: ex.name,\n      message: ex.message,\n      stack: stack\n    };\n\n    _augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);\n\n    return result;\n  }\n  /**\n   * Computes a stack trace for an exception.\n   * @param {Error} ex\n   * @param {(string|number)=} depth\n   * @memberof TraceKit._computeStackTrace\n   */\n\n\n  function computeStackTrace(ex, depth) {\n    var stack = null;\n    var popSize = ex && ex.framesToPop;\n    depth = depth == null ? 0 : +depth;\n\n    try {\n      // This must be tried first because Opera 10 *destroys*\n      // its stacktrace property if you try to access the stack\n      // property first!!\n      stack = _computeStackTraceFromStacktraceProp(ex);\n\n      if (stack) {\n        return popFrames(stack, popSize);\n      }\n    } catch (e) {}\n\n    try {\n      stack = _computeStackTraceFromStackProp(ex);\n\n      if (stack) {\n        return popFrames(stack, popSize);\n      }\n    } catch (e) {}\n\n    try {\n      stack = _computeStackTraceFromOperaMultiLineMessage(ex);\n\n      if (stack) {\n        return popFrames(stack, popSize);\n      }\n    } catch (e) {}\n\n    try {\n      stack = _computeStackTraceByWalkingCallerChain(ex, depth + 1);\n\n      if (stack) {\n        return popFrames(stack, popSize);\n      }\n    } catch (e) {}\n\n    return {\n      original: ex,\n      name: ex && ex.name,\n      message: ex && ex.message,\n      mode: 'failed'\n    };\n  }\n\n  function popFrames(stacktrace, popSize) {\n    if (Number.isNaN(popSize)) {\n      return stacktrace;\n    }\n\n    try {\n      return tslib_1.__assign({}, stacktrace, {\n        stack: stacktrace.stack.slice(popSize)\n      });\n    } catch (e) {\n      return stacktrace;\n    }\n  }\n\n  computeStackTrace._augmentStackTraceWithInitialElement = _augmentStackTraceWithInitialElement;\n  computeStackTrace._computeStackTraceFromStackProp = _computeStackTraceFromStackProp;\n  return computeStackTrace;\n}();\n\nTraceKit._collectWindowErrors = true;\nTraceKit._linesOfContext = 11;\nvar _subscribe = TraceKit._report._subscribe;\nvar _installGlobalHandler = TraceKit._report._installGlobalHandler;\nvar _installGlobalUnhandledRejectionHandler = TraceKit._report._installGlobalUnhandledRejectionHandler;\nvar _computeStackTrace = TraceKit._computeStackTrace;\nexport { _subscribe, _installGlobalHandler, _installGlobalUnhandledRejectionHandler, _computeStackTrace };","import { keysToEventMessage, 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 */\n\nexport function exceptionFromStacktrace(stacktrace) {\n  var frames = prepareFramesForEvent(stacktrace.stack);\n  var exception = {\n    type: stacktrace.name,\n    value: stacktrace.message\n  };\n\n  if (frames && frames.length) {\n    exception.stacktrace = {\n      frames: frames\n    };\n  } // tslint:disable-next-line:strict-type-predicates\n\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n/**\n * @hidden\n */\n\nexport function eventFromPlainObject(exception, syntheticException) {\n  var exceptionKeys = Object.keys(exception).sort();\n  var event = {\n    extra: {\n      __serialized__: normalizeToSize(exception)\n    },\n    message: \"Non-Error exception captured with keys: \" + keysToEventMessage(exceptionKeys)\n  };\n\n  if (syntheticException) {\n    var stacktrace = _computeStackTrace(syntheticException);\n\n    var frames_1 = prepareFramesForEvent(stacktrace.stack);\n    event.stacktrace = {\n      frames: frames_1\n    };\n  }\n\n  return event;\n}\n/**\n * @hidden\n */\n\nexport function eventFromStacktrace(stacktrace) {\n  var exception = exceptionFromStacktrace(stacktrace);\n  return {\n    exception: {\n      values: [exception]\n    }\n  };\n}\n/**\n * @hidden\n */\n\nexport function prepareFramesForEvent(stack) {\n  if (!stack || !stack.length) {\n    return [];\n  }\n\n  var localStack = stack;\n  var firstFrameFunction = localStack[0].func || '';\n  var lastFrameFunction = localStack[localStack.length - 1].func || ''; // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n\n  if (firstFrameFunction.includes('captureMessage') || firstFrameFunction.includes('captureException')) {\n    localStack = localStack.slice(1);\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\n\n  if (lastFrameFunction.includes('sentryWrapped')) {\n    localStack = localStack.slice(0, -1);\n  } // The frame where the crash happened, should be the last entry in the array\n\n\n  return localStack.map(function (frame) {\n    return {\n      colno: frame.column,\n      filename: frame.url || localStack[0].url,\n      function: frame.func || '?',\n      in_app: true,\n      lineno: frame.line\n    };\n  }).slice(0, STACKTRACE_LIMIT).reverse();\n}","import { SentryError } from './error';\n/** A simple queue that holds promises. */\n\nvar PromiseBuffer =\n/** @class */\nfunction () {\n  function PromiseBuffer(_limit) {\n    this._limit = _limit;\n    /** Internal set of queued Promises */\n\n    this._buffer = [];\n  }\n  /**\n   * Says if the buffer is ready to take more requests\n   */\n\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 Promise<T>\n   * @returns The original promise.\n   */\n\n\n  PromiseBuffer.prototype.add = function (task) {\n    var _this = this;\n\n    if (!this.isReady()) {\n      return Promise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n    }\n\n    if (this._buffer.indexOf(task) === -1) {\n      this._buffer.push(task);\n    }\n\n    task.then(function () {\n      return _this.remove(task);\n    }).catch(function () {\n      return _this.remove(task).catch(function () {// 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 Promise<T>\n   * @returns Removed promise.\n   */\n\n\n  PromiseBuffer.prototype.remove = function (task) {\n    var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n\n    return removedTask;\n  };\n  /**\n   * This function returns the number of unresolved promises in the queue.\n   */\n\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\n\n  PromiseBuffer.prototype.drain = function (timeout) {\n    var _this = this;\n\n    return new Promise(function (resolve) {\n      var capturedSetTimeout = setTimeout(function () {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n      Promise.all(_this._buffer).then(function () {\n        clearTimeout(capturedSetTimeout);\n        resolve(true);\n      }).catch(function () {\n        resolve(true);\n      });\n    });\n  };\n\n  return PromiseBuffer;\n}();\n\nexport { PromiseBuffer };","import { API } from '@sentry/core';\nimport { PromiseBuffer, SentryError } from '@sentry/utils';\n/** Base Transport class implementation */\n\nvar BaseTransport =\n/** @class */\nfunction () {\n  function BaseTransport(options) {\n    this.options = options;\n    /** A simple buffer holding all requests. */\n\n    this._buffer = new PromiseBuffer(30);\n    this.url = new API(this.options.dsn).getStoreEndpointWithUrlEncodedAuth();\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseTransport.prototype.sendEvent = function (_) {\n    throw new SentryError('Transport Class has to implement `sendEvent` method');\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BaseTransport.prototype.close = function (timeout) {\n    return this._buffer.drain(timeout);\n  };\n\n  return BaseTransport;\n}();\n\nexport { BaseTransport };","import * as tslib_1 from \"tslib\";\nimport { Status } from '@sentry/types';\nimport { getGlobalObject, supportsReferrerPolicy } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\n\nvar FetchTransport =\n/** @class */\nfunction (_super) {\n  tslib_1.__extends(FetchTransport, _super);\n\n  function FetchTransport() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  FetchTransport.prototype.sendEvent = function (event) {\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    return this._buffer.add(global.fetch(this.url, defaultOptions).then(function (response) {\n      return {\n        status: Status.fromHttpCode(response.status)\n      };\n    }));\n  };\n\n  return FetchTransport;\n}(BaseTransport);\n\nexport { FetchTransport };","import * as tslib_1 from \"tslib\";\nimport { Status } from '@sentry/types';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\n\nvar XHRTransport =\n/** @class */\nfunction (_super) {\n  tslib_1.__extends(XHRTransport, _super);\n\n  function XHRTransport() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  XHRTransport.prototype.sendEvent = function (event) {\n    var _this = this;\n\n    return this._buffer.add(new Promise(function (resolve, reject) {\n      var request = new XMLHttpRequest();\n\n      request.onreadystatechange = function () {\n        if (request.readyState !== 4) {\n          return;\n        }\n\n        if (request.status === 200) {\n          resolve({\n            status: Status.fromHttpCode(request.status)\n          });\n        }\n\n        reject(request);\n      };\n\n      request.open('POST', _this.url);\n      request.send(JSON.stringify(event));\n    }));\n  };\n\n  return XHRTransport;\n}(BaseTransport);\n\nexport { XHRTransport };","import * as tslib_1 from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isPlainObject, supportsFetch, SyncPromise } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { _computeStackTrace } from './tracekit';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\n\nvar BrowserBackend =\n/** @class */\nfunction (_super) {\n  tslib_1.__extends(BrowserBackend, _super);\n\n  function BrowserBackend() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n  /**\n   * @inheritDoc\n   */\n\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\n    var transportOptions = tslib_1.__assign({}, this._options.transportOptions, {\n      dsn: this._options.dsn\n    });\n\n    if (this._options.transport) {\n      return new this._options.transport(transportOptions);\n    }\n\n    if (supportsFetch()) {\n      return new FetchTransport(transportOptions);\n    }\n\n    return new XHRTransport(transportOptions);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BrowserBackend.prototype.eventFromException = function (exception, hint) {\n    var _this = this;\n\n    var event;\n\n    if (isErrorEvent(exception) && exception.error) {\n      // If it is an ErrorEvent with `error` property, extract it to get actual Error\n      var errorEvent = exception;\n      exception = errorEvent.error; // tslint:disable-line:no-parameter-reassignment\n\n      event = eventFromStacktrace(_computeStackTrace(exception));\n      return SyncPromise.resolve(this._buildEvent(event, hint));\n    }\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_1 = domException.message ? name_1 + \": \" + domException.message : name_1;\n      return this.eventFromMessage(message_1, Severity.Error, hint).then(function (messageEvent) {\n        addExceptionTypeValue(messageEvent, message_1);\n        return SyncPromise.resolve(_this._buildEvent(messageEvent, hint));\n      });\n    }\n\n    if (isError(exception)) {\n      // we have a real Error object, do nothing\n      event = eventFromStacktrace(_computeStackTrace(exception));\n      return SyncPromise.resolve(this._buildEvent(event, hint));\n    }\n\n    if (isPlainObject(exception) && hint && hint.syntheticException) {\n      // If it is plain Object, 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, hint.syntheticException);\n      addExceptionTypeValue(event, 'Custom Object', undefined, {\n        handled: true,\n        synthetic: true,\n        type: 'generic'\n      });\n      event.level = Severity.Error;\n      return SyncPromise.resolve(this._buildEvent(event, hint));\n    } // If none of previous checks were valid, then it means that\n    // it's not a DOMError/DOMException\n    // it's not a plain Object\n    // it's not a valid ErrorEvent (one with an error property)\n    // it's not an Error\n    // So bail out and capture it as a simple message:\n\n\n    var stringException = exception;\n    return this.eventFromMessage(stringException, undefined, hint).then(function (messageEvent) {\n      addExceptionTypeValue(messageEvent, \"\" + stringException, undefined, {\n        handled: true,\n        synthetic: true,\n        type: 'generic'\n      });\n      messageEvent.level = Severity.Error;\n      return SyncPromise.resolve(_this._buildEvent(messageEvent, hint));\n    });\n  };\n  /**\n   * This is an internal helper function that creates an event.\n   */\n\n\n  BrowserBackend.prototype._buildEvent = function (event, hint) {\n    return tslib_1.__assign({}, event, {\n      event_id: hint && hint.event_id\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n    if (level === void 0) {\n      level = Severity.Info;\n    }\n\n    var event = {\n      event_id: hint && hint.event_id,\n      level: level,\n      message: message\n    };\n\n    if (this._options.attachStacktrace && hint && hint.syntheticException) {\n      var stacktrace = _computeStackTrace(hint.syntheticException);\n\n      var frames_1 = prepareFramesForEvent(stacktrace.stack);\n      event.stacktrace = {\n        frames: frames_1\n      };\n    }\n\n    return SyncPromise.resolve(event);\n  };\n\n  return BrowserBackend;\n}(BaseBackend);\n\nexport { BrowserBackend };","export var SDK_NAME = 'sentry.javascript.browser';\nexport var SDK_VERSION = '5.6.2';","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 */\n\nvar BrowserClient =\n/** @class */\nfunction (_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\n\n  function BrowserClient(options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    return _super.call(this, BrowserBackend, options) || this;\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n    event.platform = event.platform || 'javascript';\n    event.sdk = tslib_1.__assign({}, event.sdk, {\n      name: SDK_NAME,\n      packages: tslib_1.__spread(event.sdk && event.sdk.packages || [], [{\n        name: 'npm:@sentry/browser',\n        version: SDK_VERSION\n      }]),\n      version: SDK_VERSION\n    });\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\n\n  BrowserClient.prototype.showReportDialog = function (options) {\n    if (options === void 0) {\n      options = {};\n    } // doesn't work without a document (React Native)\n\n\n    var document = getGlobalObject().document;\n\n    if (!document) {\n      return;\n    }\n\n    if (!this._isEnabled()) {\n      logger.error('Trying to call showReportDialog with Sentry Client is disabled');\n      return;\n    }\n\n    var dsn = options.dsn || this.getDsn();\n\n    if (!options.eventId) {\n      logger.error('Missing `eventId` option in showReportDialog call');\n      return;\n    }\n\n    if (!dsn) {\n      logger.error('Missing `Dsn` option in showReportDialog call');\n      return;\n    }\n\n    var script = document.createElement('script');\n    script.async = true;\n    script.src = new API(dsn).getReportDialogEndpoint(options);\n\n    if (options.onLoad) {\n      script.onload = options.onLoad;\n    }\n\n    (document.head || document.body).appendChild(script);\n  };\n\n  return BrowserClient;\n}(BaseClient);\n\nexport { BrowserClient };","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 */\n\nfunction callOnHub(method) {\n  var args = [];\n\n  for (var _i = 1; _i < arguments.length; _i++) {\n    args[_i - 1] = arguments[_i];\n  }\n\n  var hub = getCurrentHub();\n\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\n  throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n\n\nexport function captureException(exception) {\n  var syntheticException;\n\n  try {\n    throw new Error('Sentry syntheticException');\n  } catch (exception) {\n    syntheticException = exception;\n  }\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 */\n\nexport function captureMessage(message, level) {\n  var syntheticException;\n\n  try {\n    throw new Error(message);\n  } catch (exception) {\n    syntheticException = exception;\n  }\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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\n\nexport function _callOnClient(method) {\n  var args = [];\n\n  for (var _i = 1; _i < arguments.length; _i++) {\n    args[_i - 1] = arguments[_i];\n  }\n\n  callOnHub.apply(void 0, tslib_1.__spread(['_invokeClient', method], args));\n}","import * as tslib_1 from \"tslib\";\nimport { captureException, getCurrentHub, withScope } from '@sentry/core';\nimport { addExceptionTypeValue, isString, normalize } from '@sentry/utils';\nvar debounceDuration = 1000;\nvar keypressTimeout;\nvar lastCapturedEvent;\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\n\nexport function shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\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 */\n\nexport function wrap(fn, options, before) {\n  if (options === void 0) {\n    options = {};\n  } // tslint:disable-next-line:strict-type-predicates\n\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // We don't wanna wrap it twice\n    if (fn.__sentry__) {\n      return fn;\n    } // If this has already been wrapped in the past, return that wrapped function\n\n\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\n  var sentryWrapped = function sentryWrapped() {\n    // tslint:disable-next-line:strict-type-predicates\n    if (before && typeof before === 'function') {\n      before.apply(this, arguments);\n    }\n\n    var args = Array.prototype.slice.call(arguments); // tslint:disable:no-unsafe-any\n\n    try {\n      var wrappedArguments = args.map(function (arg) {\n        return wrap(arg, options);\n      });\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      } // 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\n\n      return fn.apply(this, wrappedArguments); // tslint:enable:no-unsafe-any\n    } catch (ex) {\n      ignoreNextOnError();\n      withScope(function (scope) {\n        scope.addEventProcessor(function (event) {\n          var processedEvent = tslib_1.__assign({}, event);\n\n          if (options.mechanism) {\n            addExceptionTypeValue(processedEvent, undefined, undefined, options.mechanism);\n          }\n\n          processedEvent.extra = tslib_1.__assign({}, processedEvent.extra, {\n            arguments: normalize(args, 3)\n          });\n          return processedEvent;\n        });\n        captureException(ex);\n      });\n      throw ex;\n    }\n  }; // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n\n\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\n\n  fn.prototype = fn.prototype || {};\n  sentryWrapped.prototype = fn.prototype;\n  Object.defineProperty(fn, '__sentry_wrapped__', {\n    enumerable: false,\n    value: sentryWrapped\n  }); // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n\n  Object.defineProperties(sentryWrapped, {\n    __sentry__: {\n      enumerable: false,\n      value: true\n    },\n    __sentry_original__: {\n      enumerable: false,\n      value: fn\n    }\n  }); // Restore original function name (not all browsers allow that)\n\n  try {\n    var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n\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\n  return sentryWrapped;\n}\nvar debounceTimer = 0;\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param eventName the event name (e.g. \"click\")\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\n\nexport function breadcrumbEventHandler(eventName, debounce) {\n  if (debounce === void 0) {\n    debounce = false;\n  }\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; // 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\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    lastCapturedEvent = event;\n\n    var captureBreadcrumb = function captureBreadcrumb() {\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      var target;\n\n      try {\n        target = event.target ? _htmlTreeAsString(event.target) : _htmlTreeAsString(event);\n      } catch (e) {\n        target = '<unknown>';\n      }\n\n      if (target.length === 0) {\n        return;\n      }\n\n      getCurrentHub().addBreadcrumb({\n        category: \"ui.\" + eventName,\n        message: target\n      }, {\n        event: event,\n        name: eventName\n      });\n    };\n\n    if (debounceTimer) {\n      clearTimeout(debounceTimer);\n    }\n\n    if (debounce) {\n      debounceTimer = setTimeout(captureBreadcrumb);\n    } else {\n      captureBreadcrumb();\n    }\n  };\n}\n/**\n * Wraps addEventListener to capture keypress UI events\n * @returns wrapped keypress events handler\n * @hidden\n */\n\nexport function keypressEventHandler() {\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\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\n    var tagName = target && target.tagName; // only consider keypress events on actual input elements\n    // this will disregard keypresses targeting body (e.g. tabbing\n    // through elements, hotkeys, etc)\n\n    if (!tagName || tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable) {\n      return;\n    } // record first keypress in a series, but ignore subsequent\n    // keypresses until debounce clears\n\n\n    if (!keypressTimeout) {\n      breadcrumbEventHandler('input')(event);\n    }\n\n    clearTimeout(keypressTimeout);\n    keypressTimeout = setTimeout(function () {\n      keypressTimeout = undefined;\n    }, debounceDuration);\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 */\n\nfunction _htmlTreeAsString(elem) {\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;\n\n  while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n    nextStr = _htmlElementAsString(currentElem); // 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\n    if (nextStr === 'html' || height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN) {\n      break;\n    }\n\n    out.push(nextStr);\n    len += nextStr.length;\n    currentElem = currentElem.parentNode;\n  }\n\n  return out.reverse().join(separator);\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\n\n\nfunction _htmlElementAsString(elem) {\n  var out = [];\n  var className;\n  var classes;\n  var key;\n  var attr;\n  var i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  if (elem.id) {\n    out.push(\"#\" + elem.id);\n  }\n\n  className = elem.className;\n\n  if (className && isString(className)) {\n    classes = className.split(/\\s+/);\n\n    for (i = 0; i < classes.length; i++) {\n      out.push(\".\" + classes[i]);\n    }\n  }\n\n  var attrWhitelist = ['type', 'name', 'title', 'alt'];\n\n  for (i = 0; i < attrWhitelist.length; i++) {\n    key = attrWhitelist[i];\n    attr = elem.getAttribute(key);\n\n    if (attr) {\n      out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n    }\n  }\n\n  return out.join('');\n}","import { fill, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\n\nvar TryCatch =\n/** @class */\nfunction () {\n  function TryCatch() {\n    /** JSDoc */\n    this._ignoreOnError = 0;\n    /**\n     * @inheritDoc\n     */\n\n    this.name = TryCatch.id;\n  }\n  /** JSDoc */\n\n\n  TryCatch.prototype._wrapTimeFunction = function (original) {\n    return function () {\n      var args = [];\n\n      for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n      }\n\n      var originalCallback = args[0];\n      args[0] = wrap(originalCallback, {\n        mechanism: {\n          data: {\n            function: getFunctionName(original)\n          },\n          handled: true,\n          type: 'instrument'\n        }\n      });\n      return original.apply(this, args);\n    };\n  };\n  /** JSDoc */\n\n\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\n\n  TryCatch.prototype._wrapEventTarget = function (target) {\n    var global = getGlobalObject();\n    var proto = global[target] && global[target].prototype;\n\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (original) {\n      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        } catch (err) {// can sometimes get 'Permission denied to access property \"handle Event'\n        }\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\n        try {\n          callback = callback && (callback.__sentry_wrapped__ || callback);\n        } catch (e) {// ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n\n        return original.call(this, eventName, callback, options);\n      };\n    });\n  };\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n\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    ['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\n\n  TryCatch.id = 'TryCatch';\n  return TryCatch;\n}();\n\nexport { TryCatch };\n/**\n * Safely extract function name from itself\n */\n\nfunction getFunctionName(fn) {\n  try {\n    return fn && fn.name || '<anonymous>';\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 '<anonymous>';\n  }\n}","import * as tslib_1 from \"tslib\";\nimport { API, getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { fill, getEventDescription, getGlobalObject, isString, logger, normalize, parseUrl, safeJoin, supportsHistory, supportsNativeFetch } from '@sentry/utils';\nimport { breadcrumbEventHandler, keypressEventHandler, wrap } from '../helpers';\nvar global = getGlobalObject();\nvar lastHref;\n/** Default Breadcrumbs instrumentations */\n\nvar Breadcrumbs =\n/** @class */\nfunction () {\n  /**\n   * @inheritDoc\n   */\n  function Breadcrumbs(options) {\n    /**\n     * @inheritDoc\n     */\n    this.name = Breadcrumbs.id;\n    this._options = tslib_1.__assign({\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true\n    }, options);\n  }\n  /** JSDoc */\n\n\n  Breadcrumbs.prototype._instrumentConsole = function () {\n    if (!('console' in global)) {\n      return;\n    }\n\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n      if (!(level in global.console)) {\n        return;\n      }\n\n      fill(global.console, level, function (originalConsoleLevel) {\n        return function () {\n          var args = [];\n\n          for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n          }\n\n          var breadcrumbData = {\n            category: 'console',\n            data: {\n              extra: {\n                arguments: normalize(args, 3)\n              },\n              logger: 'console'\n            },\n            level: Severity.fromString(level),\n            message: safeJoin(args, ' ')\n          };\n\n          if (level === 'assert') {\n            if (args[0] === false) {\n              breadcrumbData.message = \"Assertion failed: \" + (safeJoin(args.slice(1), ' ') || 'console.assert');\n              breadcrumbData.data.extra.arguments = normalize(args.slice(1), 3);\n            }\n          }\n\n          Breadcrumbs.addBreadcrumb(breadcrumbData, {\n            input: args,\n            level: level\n          }); // this fails for some browsers. :(\n\n          if (originalConsoleLevel) {\n            Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n          }\n        };\n      });\n    });\n  };\n  /** JSDoc */\n\n\n  Breadcrumbs.prototype._instrumentDOM = function () {\n    if (!('document' in global)) {\n      return;\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\n\n    global.document.addEventListener('click', breadcrumbEventHandler('click'), false);\n    global.document.addEventListener('keypress', keypressEventHandler(), false); // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n\n    ['EventTarget', 'Node'].forEach(function (target) {\n      var proto = global[target] && global[target].prototype;\n\n      if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n        return;\n      }\n\n      fill(proto, 'addEventListener', function (original) {\n        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                  breadcrumbEventHandler('click')(event);\n                  return innerOriginal.call(this, event);\n                };\n              });\n            }\n\n            if (eventName === 'keypress') {\n              fill(fn, 'handleEvent', function (innerOriginal) {\n                return function (event) {\n                  keypressEventHandler()(event);\n                  return innerOriginal.call(this, event);\n                };\n              });\n            }\n          } else {\n            if (eventName === 'click') {\n              breadcrumbEventHandler('click', true)(this);\n            }\n\n            if (eventName === 'keypress') {\n              keypressEventHandler()(this);\n            }\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\n          try {\n            callback = callback && (callback.__sentry_wrapped__ || callback);\n          } catch (e) {// ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n          }\n\n          return original.call(this, eventName, callback, options);\n        };\n      });\n    });\n  };\n  /** JSDoc */\n\n\n  Breadcrumbs.prototype._instrumentFetch = function () {\n    if (!supportsNativeFetch()) {\n      return;\n    }\n\n    fill(global, 'fetch', function (originalFetch) {\n      return function () {\n        var args = [];\n\n        for (var _i = 0; _i < arguments.length; _i++) {\n          args[_i] = arguments[_i];\n        }\n\n        var fetchInput = args[0];\n        var method = 'GET';\n        var url;\n\n        if (typeof fetchInput === 'string') {\n          url = fetchInput;\n        } else if ('Request' in global && fetchInput instanceof Request) {\n          url = fetchInput.url;\n\n          if (fetchInput.method) {\n            method = fetchInput.method;\n          }\n        } else {\n          url = String(fetchInput);\n        }\n\n        if (args[1] && args[1].method) {\n          method = args[1].method;\n        }\n\n        var client = getCurrentHub().getClient();\n        var dsn = client && client.getDsn();\n\n        if (dsn) {\n          var filterUrl = new API(dsn).getStoreEndpoint(); // if Sentry key appears in URL, don't capture it as a request\n          // but rather as our own 'sentry' type breadcrumb\n\n          if (filterUrl && url.includes(filterUrl)) {\n            if (method === 'POST' && args[1] && args[1].body) {\n              addSentryBreadcrumb(args[1].body);\n            }\n\n            return originalFetch.apply(global, args);\n          }\n        }\n\n        var fetchData = {\n          method: isString(method) ? method.toUpperCase() : method,\n          url: url\n        };\n        return originalFetch.apply(global, args).then(function (response) {\n          fetchData.status_code = response.status;\n          Breadcrumbs.addBreadcrumb({\n            category: 'fetch',\n            data: fetchData,\n            type: 'http'\n          }, {\n            input: args,\n            response: response\n          });\n          return response;\n        }).catch(function (error) {\n          Breadcrumbs.addBreadcrumb({\n            category: 'fetch',\n            data: fetchData,\n            level: Severity.Error,\n            type: 'http'\n          }, {\n            error: error,\n            input: args\n          });\n          throw error;\n        });\n      };\n    });\n  };\n  /** JSDoc */\n\n\n  Breadcrumbs.prototype._instrumentHistory = function () {\n    var _this = this;\n\n    if (!supportsHistory()) {\n      return;\n    }\n\n    var captureUrlChange = function captureUrlChange(from, to) {\n      var parsedLoc = parseUrl(global.location.href);\n      var parsedTo = parseUrl(to);\n      var parsedFrom = parseUrl(from); // Initial pushState doesn't provide `from` information\n\n      if (!parsedFrom.path) {\n        parsedFrom = parsedLoc;\n      } // because onpopstate only tells you the \"new\" (to) value of location.href, and\n      // not the previous (from) value, we need to track the value of the current URL\n      // state ourselves\n\n\n      lastHref = to; // Use only the path component of the URL if the URL matches the current\n      // document (almost all the time when using pushState)\n\n      if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n        // tslint:disable-next-line:no-parameter-reassignment\n        to = parsedTo.relative;\n      }\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\n      Breadcrumbs.addBreadcrumb({\n        category: 'navigation',\n        data: {\n          from: from,\n          to: to\n        }\n      });\n    }; // record navigation (URL) changes\n\n\n    var oldOnPopState = global.onpopstate;\n\n    global.onpopstate = function () {\n      var args = [];\n\n      for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n      }\n\n      var currentHref = global.location.href;\n      captureUrlChange(lastHref, currentHref);\n\n      if (oldOnPopState) {\n        return oldOnPopState.apply(_this, args);\n      }\n    };\n    /**\n     * @hidden\n     */\n\n\n    function historyReplacementFunction(originalHistoryFunction) {\n      // note history.pushState.length is 0; intentionally not declaring\n      // params to preserve 0 arity\n      return function () {\n        var args = [];\n\n        for (var _i = 0; _i < arguments.length; _i++) {\n          args[_i] = arguments[_i];\n        }\n\n        var url = args.length > 2 ? args[2] : undefined; // url argument is optional\n\n        if (url) {\n          // coerce to string (this is what pushState does)\n          captureUrlChange(lastHref, String(url));\n        }\n\n        return originalHistoryFunction.apply(this, args);\n      };\n    }\n\n    fill(global.history, 'pushState', historyReplacementFunction);\n    fill(global.history, 'replaceState', historyReplacementFunction);\n  };\n  /** JSDoc */\n\n\n  Breadcrumbs.prototype._instrumentXHR = function () {\n    if (!('XMLHttpRequest' in global)) {\n      return;\n    }\n    /**\n     * @hidden\n     */\n\n\n    function wrapProp(prop, xhr) {\n      // TODO: Fix XHR types\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        fill(xhr, prop, function (original) {\n          return wrap(original, {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: original && original.name || '<anonymous>'\n              },\n              handled: true,\n              type: 'instrument'\n            }\n          });\n        });\n      }\n    }\n\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n      return function () {\n        var args = [];\n\n        for (var _i = 0; _i < arguments.length; _i++) {\n          args[_i] = arguments[_i];\n        }\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        var client = getCurrentHub().getClient();\n        var dsn = client && client.getDsn();\n\n        if (dsn) {\n          var filterUrl = new API(dsn).getStoreEndpoint(); // if Sentry key appears in URL, don't capture it as a request\n          // but rather as our own 'sentry' type breadcrumb\n\n          if (isString(url) && filterUrl && url.includes(filterUrl)) {\n            this.__sentry_own_request__ = true;\n          }\n        }\n\n        return originalOpen.apply(this, args);\n      };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n      return function () {\n        var args = [];\n\n        for (var _i = 0; _i < arguments.length; _i++) {\n          args[_i] = arguments[_i];\n        }\n\n        var xhr = this; // tslint:disable-line:no-this-assignment\n\n        if (xhr.__sentry_own_request__) {\n          addSentryBreadcrumb(args[0]);\n        }\n        /**\n         * @hidden\n         */\n\n\n        function onreadystatechangeHandler() {\n          if (xhr.readyState === 4) {\n            if (xhr.__sentry_own_request__) {\n              return;\n            }\n\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\n            Breadcrumbs.addBreadcrumb({\n              category: 'xhr',\n              data: xhr.__sentry_xhr__,\n              type: 'http'\n            }, {\n              xhr: xhr\n            });\n          }\n        }\n\n        ['onload', 'onerror', 'onprogress'].forEach(function (prop) {\n          wrapProp(prop, xhr);\n        });\n\n        if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n          fill(xhr, 'onreadystatechange', function (original) {\n            return wrap(original, {\n              mechanism: {\n                data: {\n                  function: 'onreadystatechange',\n                  handler: original && original.name || '<anonymous>'\n                },\n                handled: true,\n                type: 'instrument'\n              }\n            }, onreadystatechangeHandler);\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\n        return originalSend.apply(this, args);\n      };\n    });\n  };\n  /**\n   * Helper that checks if integration is enabled on the client.\n   * @param breadcrumb Breadcrumb\n   * @param hint BreadcrumbHint\n   */\n\n\n  Breadcrumbs.addBreadcrumb = function (breadcrumb, hint) {\n    if (getCurrentHub().getIntegration(Breadcrumbs)) {\n      getCurrentHub().addBreadcrumb(breadcrumb, hint);\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\n\n  Breadcrumbs.prototype.setupOnce = function () {\n    if (this._options.console) {\n      this._instrumentConsole();\n    }\n\n    if (this._options.dom) {\n      this._instrumentDOM();\n    }\n\n    if (this._options.xhr) {\n      this._instrumentXHR();\n    }\n\n    if (this._options.fetch) {\n      this._instrumentFetch();\n    }\n\n    if (this._options.history) {\n      this._instrumentHistory();\n    }\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Breadcrumbs.id = 'Breadcrumbs';\n  return Breadcrumbs;\n}();\n\nexport { Breadcrumbs };\n/** JSDoc */\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    Breadcrumbs.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  } catch (_oO) {\n    logger.error('Error while adding sentry type breadcrumb');\n  }\n}","import * as tslib_1 from \"tslib\";\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionTypeValue, isPrimitive, isString, keysToEventMessage, logger, normalize, normalizeToSize, truncate } from '@sentry/utils';\nimport { shouldIgnoreOnError } from '../helpers';\nimport { eventFromStacktrace } from '../parsers';\nimport { _installGlobalHandler, _installGlobalUnhandledRejectionHandler, _subscribe } from '../tracekit';\n/** Global handlers */\n\nvar GlobalHandlers =\n/** @class */\nfunction () {\n  /** JSDoc */\n  function GlobalHandlers(options) {\n    /**\n     * @inheritDoc\n     */\n    this.name = GlobalHandlers.id;\n    this._options = tslib_1.__assign({\n      onerror: true,\n      onunhandledrejection: true\n    }, options);\n  }\n  /**\n   * @inheritDoc\n   */\n\n\n  GlobalHandlers.prototype.setupOnce = function () {\n    Error.stackTraceLimit = 50;\n\n    _subscribe(function (stack, _, error) {\n      if (shouldIgnoreOnError()) {\n        return;\n      }\n\n      var self = getCurrentHub().getIntegration(GlobalHandlers);\n\n      if (self) {\n        getCurrentHub().captureEvent(self._eventFromGlobalHandler(stack, error), {\n          data: {\n            stack: stack\n          },\n          originalException: error\n        });\n      }\n    });\n\n    if (this._options.onerror) {\n      logger.log('Global Handler attached: onerror');\n\n      _installGlobalHandler();\n    }\n\n    if (this._options.onunhandledrejection) {\n      logger.log('Global Handler attached: onunhandledrejection');\n\n      _installGlobalUnhandledRejectionHandler();\n    }\n  };\n  /**\n   * This function creates an Event from an TraceKitStackTrace.\n   *\n   * @param stacktrace TraceKitStackTrace to be converted to an Event.\n   */\n\n\n  GlobalHandlers.prototype._eventFromGlobalHandler = function (stacktrace, error) {\n    if (!isString(stacktrace.message) && stacktrace.mechanism !== 'onunhandledrejection') {\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      var message = stacktrace.message;\n      stacktrace.message = message.error && isString(message.error.message) ? message.error.message : 'No error message';\n    }\n\n    if (stacktrace.mechanism === 'onunhandledrejection' && (stacktrace.incomplete || stacktrace.mode === 'failed')) {\n      return this._eventFromIncompleteRejection(stacktrace, error);\n    }\n\n    var event = eventFromStacktrace(stacktrace);\n    var data = {\n      mode: stacktrace.mode\n    };\n\n    if (stacktrace.message) {\n      data.message = stacktrace.message;\n    }\n\n    if (stacktrace.name) {\n      data.name = stacktrace.name;\n    }\n\n    var client = getCurrentHub().getClient();\n    var maxValueLength = client && client.getOptions().maxValueLength || 250;\n    var fallbackValue = stacktrace.original ? truncate(JSON.stringify(normalize(stacktrace.original)), maxValueLength) : '';\n    var fallbackType = stacktrace.mechanism === 'onunhandledrejection' ? 'UnhandledRejection' : 'Error'; // This makes sure we have type/value in every exception\n\n    addExceptionTypeValue(event, fallbackValue, fallbackType, {\n      data: data,\n      handled: false,\n      type: stacktrace.mechanism\n    });\n    return event;\n  };\n  /**\n   * This function creates an Event from an TraceKitStackTrace that has part of it missing.\n   *\n   * @param stacktrace TraceKitStackTrace to be converted to an Event.\n   */\n\n\n  GlobalHandlers.prototype._eventFromIncompleteRejection = function (stacktrace, error) {\n    var event = {\n      level: Severity.Error\n    };\n\n    if (isPrimitive(error)) {\n      event.exception = {\n        values: [{\n          type: 'UnhandledRejection',\n          value: \"Non-Error promise rejection captured with value: \" + error\n        }]\n      };\n    } else {\n      event.exception = {\n        values: [{\n          type: 'UnhandledRejection',\n          value: \"Non-Error promise rejection captured with keys: \" + keysToEventMessage(Object.keys(error).sort())\n        }]\n      };\n      event.extra = {\n        __serialized__: normalizeToSize(error)\n      };\n    }\n\n    if (event.exception.values && event.exception.values[0]) {\n      event.exception.values[0].mechanism = {\n        data: tslib_1.__assign({\n          mode: stacktrace.mode\n        }, stacktrace.incomplete && {\n          incomplete: stacktrace.incomplete\n        }, stacktrace.message && {\n          message: stacktrace.message\n        }, stacktrace.name && {\n          name: stacktrace.name\n        }),\n        handled: false,\n        type: stacktrace.mechanism\n      };\n    }\n\n    return event;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  GlobalHandlers.id = 'GlobalHandlers';\n  return GlobalHandlers;\n}();\n\nexport { GlobalHandlers };","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { _computeStackTrace } from '../tracekit';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\n\nvar LinkedErrors =\n/** @class */\nfunction () {\n  /**\n   * @inheritDoc\n   */\n  function LinkedErrors(options) {\n    if (options === void 0) {\n      options = {};\n    }\n    /**\n     * @inheritDoc\n     */\n\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\n\n  LinkedErrors.prototype.setupOnce = function () {\n    addGlobalEventProcessor(function (event, hint) {\n      var self = getCurrentHub().getIntegration(LinkedErrors);\n\n      if (self) {\n        return self._handler(event, hint);\n      }\n\n      return event;\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  LinkedErrors.prototype._handler = function (event, hint) {\n    if (!event.exception || !event.exception.values || !hint || !(hint.originalException instanceof Error)) {\n      return event;\n    }\n\n    var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n\n    event.exception.values = tslib_1.__spread(linkedErrors, event.exception.values);\n    return event;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n    if (stack === void 0) {\n      stack = [];\n    }\n\n    if (!(error[key] instanceof Error) || stack.length + 1 >= this._limit) {\n      return stack;\n    }\n\n    var stacktrace = _computeStackTrace(error[key]);\n\n    var exception = exceptionFromStacktrace(stacktrace);\n    return this._walkErrorTree(error[key], key, tslib_1.__spread([exception], stack));\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  LinkedErrors.id = 'LinkedErrors';\n  return LinkedErrors;\n}();\n\nexport { LinkedErrors };","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\n\nvar UserAgent =\n/** @class */\nfunction () {\n  function UserAgent() {\n    /**\n     * @inheritDoc\n     */\n    this.name = UserAgent.id;\n  }\n  /**\n   * @inheritDoc\n   */\n\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        } // HTTP Interface: https://docs.sentry.io/clientdev/interfaces/http/?platform=javascript\n\n\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, {\n          request: request\n        });\n      }\n\n      return event;\n    });\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  UserAgent.id = 'UserAgent';\n  return UserAgent;\n}();\n\nexport { UserAgent };","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [new CoreIntegrations.InboundFilters(), new CoreIntegrations.FunctionToString(), new TryCatch(), new Breadcrumbs(), new GlobalHandlers(), new LinkedErrors(), new 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 */\n\nexport function init(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n\n  if (options.release === undefined) {\n    var window_1 = getGlobalObject(); // This supports the variable that sentry-webpack-plugin injects\n\n    if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n      options.release = window_1.SENTRY_RELEASE.id;\n    }\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 */\n\nexport function showReportDialog(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  if (!options.eventId) {\n    options.eventId = getCurrentHub().lastEventId();\n  }\n\n  var client = getCurrentHub().getClient();\n\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 */\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 */\n\nexport function forceLoad() {// Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\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 */\n\nexport function flush(timeout) {\n  var client = getCurrentHub().getClient();\n\n  if (client) {\n    return client.flush(timeout);\n  }\n\n  return Promise.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 */\n\nexport function close(timeout) {\n  var client = getCurrentHub().getClient();\n\n  if (client) {\n    return client.close(timeout);\n  }\n\n  return Promise.reject(false);\n}\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n\nexport function wrap(fn) {\n  // tslint:disable-next-line: no-unsafe-any\n  return internalWrap(fn)();\n}","import MicroModal from 'micromodal';\nimport Notifications from './notifications.js';\nimport Integrations from './integrations.js';\nimport QuickBookmark from 'controllers/quick_bookmark_controller.js';\nimport Mousetrap from 'mousetrap';\nimport CookieConsent from 'cookieconsent';\nimport * as Sentry from '@sentry/browser';\n\nMicroModal.init({\n  openTrigger: 'data-custom-open',\n  disableScroll: true,\n  awaitCloseAnimation: true\n});\n\nfunction setMousetrap() {\n  Mousetrap.bind('/', function(e) {\n    $('.autocomplete input').focus();\n\n    return false;\n  });\n\n  Mousetrap.bind(['command+b', 'ctrl+b'], function(e) {\n    (new QuickBookmark).reset();\n    $('.new-bookmark').click();\n    $('.quick-bookmark-form').find('input[name=url]').focus();\n\n    return false;\n  });\n}\n\nfunction closeAllModals() {\n  $('.modal__overlay').on('click', function(event) {\n    $('.micromodal-slide').each(function(element) {\n      window.Tefter.MicroModal.close(element['id']);\n    })\n\n    // Reset sidebar css opacity\n    $('.sidebar').css('opacity', 1);\n  });\n}\n\nfunction loadMicroModal() {\n  window.Tefter.MicroModal = MicroModal;\n  let bodyClass = '.dashboard';\n\n  $(document).on('click', '.js-modal-trigger', function() {\n    let modalId = this.getAttribute('data-modal-id');\n\n    MicroModal.show(modalId, {\n      debugMode: false,\n      disableScroll: false,\n      onShow: function (modal) { document.querySelector(bodyClass).classList.add(modal.id) },\n      onClose: function (modal) { document.querySelector(bodyClass).classList.remove(modal.id);\n                                  $('.sidebar').css('opacity', 1.0)},\n      closeTrigger: 'data-custom-close',\n      awaitCloseAnimation: true\n    })\n\n    if (modalId != 'modal-quick-bookmark') {\n      $('.sidebar').css('opacity', 0.35);\n    }\n  });\n\n  $(document).on('click', '.js-modal-close-trigger', function() {\n    let modalId = this.getAttribute('data-modal-id');\n\n    event.preventDefault();\n\n    MicroModal.close(modalId);\n\n    // Reset sidebar opacity\n    $('.sidebar').css('opacity', 1);\n  });\n}\n\nfunction initHeadway() {\n  if (typeof Headway === 'undefined') {\n    return;\n  }\n\n  try {\n    Headway.init(headwayConfig);\n  } catch(error) { }\n}\n\nfunction displayCookieConsent() {\n  window.cookieconsent.initialise({\n    enabled: !localStorage.getItem('tefter-cookie-got-it'),\n    cookie: {\n      expiryDays: 365,\n      domain: \".tefter.io\",\n      secure: true,\n      name: \"cookieconsent\"\n    },\n\n    palette: {\n      popup: {\n        background: \"#eaf7f7\",\n        text: \"#5c7291\"\n      },\n\n      button: {\n        background: \"#56cbdb\",\n        text: \"#ffffff\"\n      }\n    },\n\n    position: 'bottom-left',\n\n    content: {\n      header: 'Cookies used on the website',\n      message: 'Tefter uses cookies to ensure you get the best experience.',\n      dismiss: 'Got it!',\n      allow: 'Allow cookies',\n      deny: 'Decline',\n      link: 'Learn more',\n      href: 'https://tefter.io/privacy-policy',\n      close: '&#x274c;',\n      policy: 'Cookie Policy',\n      target: '_blank',\n    },\n\n    onStatusChange: function(status, chosenBefore) {\n      if (status == 'dismiss') {\n        localStorage.setItem('tefter-cookie-got-it', 'true');\n      }\n    },\n  });\n}\n\nsetMousetrap();\n\nloadMicroModal()\n\ncloseAllModals();\n\n(new Notifications).attach();\n\n(new Integrations).attach();\n\ninitHeadway();\n\ndisplayCookieConsent();\n\nif (window.Tefter.environment == 'production') {\n  Sentry.init({ dsn: 'https://d2da3c61c76043df930d66235d008f5b@sentry.io/1208965' });\n}\n","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 */\n\nexport function initAndBind(clientClass, options) {\n  if (options.debug === true) {\n    logger.enable();\n  }\n\n  getCurrentHub().bindClient(new clientClass(options));\n}","import { isThenable } from './is';\n/** SyncPromise internal states */\n\nvar States;\n\n(function (States) {\n  /** Pending */\n  States[\"PENDING\"] = \"PENDING\";\n  /** Resolved / OK */\n\n  States[\"RESOLVED\"] = \"RESOLVED\";\n  /** Rejected / Error */\n\n  States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/** JSDoc */\n\n\nvar SyncPromise =\n/** @class */\nfunction () {\n  function SyncPromise(callback) {\n    var _this = this;\n    /** JSDoc */\n\n\n    this._state = States.PENDING;\n    /** JSDoc */\n\n    this._handlers = [];\n    /** JSDoc */\n\n    this._resolve = function (value) {\n      _this._setResult(value, States.RESOLVED);\n    };\n    /** JSDoc */\n\n\n    this._reject = function (reason) {\n      _this._setResult(reason, States.REJECTED);\n    };\n    /** JSDoc */\n\n\n    this._setResult = function (value, state) {\n      if (_this._state !== States.PENDING) {\n        return;\n      }\n\n      if (isThenable(value)) {\n        value.then(_this._resolve, _this._reject);\n        return;\n      }\n\n      _this._value = value;\n      _this._state = state;\n\n      _this._executeHandlers();\n    };\n    /** JSDoc */\n\n\n    this._executeHandlers = function () {\n      if (_this._state === States.PENDING) {\n        return;\n      }\n\n      if (_this._state === States.REJECTED) {\n        // tslint:disable-next-line:no-unsafe-any\n        _this._handlers.forEach(function (h) {\n          return h.onFail && h.onFail(_this._value);\n        });\n      } else {\n        // tslint:disable-next-line:no-unsafe-any\n        _this._handlers.forEach(function (h) {\n          return h.onSuccess && h.onSuccess(_this._value);\n        });\n      }\n\n      _this._handlers = [];\n      return;\n    };\n    /** JSDoc */\n\n\n    this._attachHandler = function (handler) {\n      _this._handlers = _this._handlers.concat(handler);\n\n      _this._executeHandlers();\n    };\n\n    try {\n      callback(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n  /** JSDoc */\n\n\n  SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n    var _this = this; // public then<U>(onSuccess?: HandlerOnSuccess<T, U>, onFail?: HandlerOnFail<U>): SyncPromise<T | U> {\n\n\n    return new SyncPromise(function (resolve, reject) {\n      _this._attachHandler({\n        onFail: function onFail(reason) {\n          if (!onrejected) {\n            reject(reason);\n            return;\n          }\n\n          try {\n            resolve(onrejected(reason));\n            return;\n          } catch (e) {\n            reject(e);\n            return;\n          }\n        },\n        onSuccess: function onSuccess(result) {\n          if (!onfulfilled) {\n            resolve(result);\n            return;\n          }\n\n          try {\n            resolve(onfulfilled(result));\n            return;\n          } catch (e) {\n            reject(e);\n            return;\n          }\n        }\n      });\n    });\n  };\n  /** JSDoc */\n\n\n  SyncPromise.prototype.catch = function (onFail) {\n    // tslint:disable-next-line:no-unsafe-any\n    return this.then(function (val) {\n      return val;\n    }, onFail);\n  };\n  /** JSDoc */\n\n\n  SyncPromise.prototype.toString = function () {\n    return \"[object SyncPromise]\";\n  };\n  /** JSDoc */\n\n\n  SyncPromise.resolve = function (value) {\n    return new SyncPromise(function (resolve) {\n      resolve(value);\n    });\n  };\n  /** JSDoc */\n\n\n  SyncPromise.reject = function (reason) {\n    return new SyncPromise(function (_, reject) {\n      reject(reason);\n    });\n  };\n\n  return SyncPromise;\n}();\n\nexport { SyncPromise };","import * as tslib_1 from \"tslib\";\nimport { consoleSandbox, dynamicRequire, getGlobalObject, logger, 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 */\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 */\n\nvar DEFAULT_BREADCRUMBS = 30;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\n\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\n\nvar Hub =\n/** @class */\nfunction () {\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();\n    }\n\n    if (_version === void 0) {\n      _version = API_VERSION;\n    }\n\n    this._version = _version;\n    /** Is a {@link Layer}[] containing the client and scope */\n\n    this._stack = [];\n\n    this._stack.push({\n      client: client,\n      scope: scope\n    });\n  }\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n\n\n  Hub.prototype._invokeClient = function (method) {\n    var _a;\n\n    var args = [];\n\n    for (var _i = 1; _i < arguments.length; _i++) {\n      args[_i - 1] = arguments[_i];\n    }\n\n    var top = this.getStackTop();\n\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\n\n  Hub.prototype.isOlderThan = function (version) {\n    return this._version < version;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.bindClient = function (client) {\n    var top = this.getStackTop();\n    top.client = client;\n  };\n  /**\n   * @inheritDoc\n   */\n\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\n\n  Hub.prototype.popScope = function () {\n    return this.getStack().pop() !== undefined;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.withScope = function (callback) {\n    var scope = this.pushScope();\n\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.getClient = function () {\n    return this.getStackTop().client;\n  };\n  /** Returns the scope of the top stack. */\n\n\n  Hub.prototype.getScope = function () {\n    return this.getStackTop().scope;\n  };\n  /** Returns the scope stack for domains or the process. */\n\n\n  Hub.prototype.getStack = function () {\n    return this._stack;\n  };\n  /** Returns the topmost scope layer in the order domain > local > process. */\n\n\n  Hub.prototype.getStackTop = function () {\n    return this._stack[this._stack.length - 1];\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.captureException = function (exception, hint) {\n    var eventId = this._lastEventId = uuid4();\n    var finalHint = hint; // 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\n    if (!hint) {\n      var syntheticException = void 0;\n\n      try {\n        throw new Error('Sentry syntheticException');\n      } catch (exception) {\n        syntheticException = exception;\n      }\n\n      finalHint = {\n        originalException: exception,\n        syntheticException: syntheticException\n      };\n    }\n\n    this._invokeClient('captureException', exception, tslib_1.__assign({}, finalHint, {\n      event_id: eventId\n    }));\n\n    return eventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.captureMessage = function (message, level, hint) {\n    var eventId = this._lastEventId = uuid4();\n    var finalHint = hint; // 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\n    if (!hint) {\n      var syntheticException = void 0;\n\n      try {\n        throw new Error(message);\n      } catch (exception) {\n        syntheticException = exception;\n      }\n\n      finalHint = {\n        originalException: message,\n        syntheticException: syntheticException\n      };\n    }\n\n    this._invokeClient('captureMessage', message, level, tslib_1.__assign({}, finalHint, {\n      event_id: eventId\n    }));\n\n    return eventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.captureEvent = function (event, hint) {\n    var eventId = this._lastEventId = uuid4();\n\n    this._invokeClient('captureEvent', event, tslib_1.__assign({}, hint, {\n      event_id: eventId\n    }));\n\n    return eventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.lastEventId = function () {\n    return this._lastEventId;\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n    var top = this.getStackTop();\n\n    if (!top.scope || !top.client) {\n      return;\n    }\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\n    if (maxBreadcrumbs <= 0) {\n      return;\n    }\n\n    var timestamp = new Date().getTime() / 1000;\n\n    var mergedBreadcrumb = tslib_1.__assign({\n      timestamp: timestamp\n    }, breadcrumb);\n\n    var finalBreadcrumb = beforeBreadcrumb ? consoleSandbox(function () {\n      return beforeBreadcrumb(mergedBreadcrumb, hint);\n    }) : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) {\n      return;\n    }\n\n    top.scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.setUser = function (user) {\n    var top = this.getStackTop();\n\n    if (!top.scope) {\n      return;\n    }\n\n    top.scope.setUser(user);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.setTags = function (tags) {\n    var top = this.getStackTop();\n\n    if (!top.scope) {\n      return;\n    }\n\n    top.scope.setTags(tags);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.setExtras = function (extras) {\n    var top = this.getStackTop();\n\n    if (!top.scope) {\n      return;\n    }\n\n    top.scope.setExtras(extras);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.setTag = function (key, value) {\n    var top = this.getStackTop();\n\n    if (!top.scope) {\n      return;\n    }\n\n    top.scope.setTag(key, value);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.setExtra = function (key, extra) {\n    var top = this.getStackTop();\n\n    if (!top.scope) {\n      return;\n    }\n\n    top.scope.setExtra(key, extra);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.setContext = function (name, context) {\n    var top = this.getStackTop();\n\n    if (!top.scope) {\n      return;\n    }\n\n    top.scope.setContext(name, context);\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.configureScope = function (callback) {\n    var top = this.getStackTop();\n\n    if (top.scope && top.client) {\n      callback(top.scope);\n    }\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.run = function (callback) {\n    var oldHub = makeMain(this);\n\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  };\n  /**\n   * @inheritDoc\n   */\n\n\n  Hub.prototype.getIntegration = function (integration) {\n    var client = this.getClient();\n\n    if (!client) {\n      return null;\n    }\n\n    try {\n      return client.getIntegration(integration);\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\n\n  Hub.prototype.traceHeaders = function () {\n    var top = this.getStackTop();\n\n    if (top.scope && top.client) {\n      var span = top.scope.getSpan();\n\n      if (span) {\n        return {\n          'sentry-trace': span.toTraceparent()\n        };\n      }\n    }\n\n    return {};\n  };\n\n  return Hub;\n}();\n\nexport { Hub };\n/** Returns the global shim registry. */\n\nexport function getMainCarrier() {\n  var carrier = getGlobalObject();\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {\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 */\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 */\n\nexport function getCurrentHub() {\n  // Get main carrier (global for every environment)\n  var registry = getMainCarrier(); // If there's no hub, or its an old API, assign a new one\n\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  } // Prefer domains over global if they are there\n\n\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; // If there no active domain, just return global hub\n\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    } // If there's no hub on current domain, or its an old API, assign a new one\n\n\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    } // Return hub that lives on a domain\n\n\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 */\n\nfunction hasHubOnCarrier(carrier) {\n  if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n    return true;\n  }\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 */\n\n\nexport function getHubFromCarrier(carrier) {\n  if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n    return carrier.__SENTRY__.hub;\n  }\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 */\n\nexport function setHubOnCarrier(carrier, hub) {\n  if (!carrier) {\n    return false;\n  }\n\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n  carrier.__SENTRY__.hub = hub;\n  return true;\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 */\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 */\n\nexport function 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 */\n\nexport function uuid4() {\n  var global = getGlobalObject();\n  var crypto = global.crypto || global.msCrypto;\n\n  if (!(crypto === void 0) && crypto.getRandomValues) {\n    // Use window.crypto API if available\n    var arr = new Uint16Array(8);\n    crypto.getRandomValues(arr); // set 4 in byte 7\n    // tslint:disable-next-line:no-bitwise\n\n    arr[3] = arr[3] & 0xfff | 0x4000; // set 2 most significant bits of byte 9 to '10'\n    // tslint:disable-next-line:no-bitwise\n\n    arr[4] = arr[4] & 0x3fff | 0x8000;\n\n    var pad = function pad(num) {\n      var v = num.toString(16);\n\n      while (v.length < 4) {\n        v = \"0\" + v;\n      }\n\n      return v;\n    };\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  } // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n\n\n  return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n    // tslint:disable-next-line:no-bitwise\n    var r = Math.random() * 16 | 0; // tslint:disable-next-line:no-bitwise\n\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 */\n\nexport function parseUrl(url) {\n  if (!url) {\n    return {};\n  }\n\n  var match = url.match(/^(([^:\\/?#]+):)?(\\/\\/([^\\/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  } // coerce to undefined values to empty string so we don't get 'undefined'\n\n\n  var query = match[6] || '';\n  var fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    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 */\n\nexport function getEventDescription(event) {\n  if (event.message) {\n    return event.message;\n  }\n\n  if (event.exception && event.exception.values && event.exception.values[0]) {\n    var exception = event.exception.values[0];\n\n    if (exception.type && exception.value) {\n      return exception.type + \": \" + exception.value;\n    }\n\n    return exception.type || exception.value || event.event_id || '<unknown>';\n  }\n\n  return event.event_id || '<unknown>';\n}\n/** JSDoc */\n\nexport function consoleSandbox(callback) {\n  var global = getGlobalObject();\n  var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n\n  if (!('console' in global)) {\n    return callback();\n  }\n\n  var originalConsole = global.console;\n  var wrappedLevels = {}; // Restore all wrapped console methods\n\n  levels.forEach(function (level) {\n    if (level in global.console && originalConsole[level].__sentry__) {\n      wrappedLevels[level] = originalConsole[level].__sentry_wrapped__;\n      originalConsole[level] = originalConsole[level].__sentry_original__;\n    }\n  }); // Perform callback manipulations\n\n  var result = callback(); // Revert restoration to wrapped state\n\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 * @param mechanism Mechanism of the exception.\n * @hidden\n */\n\nexport function addExceptionTypeValue(event, value, type, mechanism) {\n  if (mechanism === void 0) {\n    mechanism = {\n      handled: true,\n      type: 'generic'\n    };\n  }\n\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  event.exception.values[0].mechanism = event.exception.values[0].mechanism || mechanism;\n}","// shim for using process in browser\nvar process = module.exports = {}; // 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}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\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\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\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\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\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\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\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\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\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};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\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\n/* global Reflect, Promise */\nvar _extendStatics = function extendStatics(d, b) {\n  _extendStatics = Object.setPrototypeOf || {\n    __proto__: []\n  } 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\n  return _extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  _extendStatics(d, b);\n\n  function __() {\n    this.constructor = d;\n  }\n\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nvar _assign = function __assign() {\n  _assign = Object.assign || function __assign(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n\n      for (var p in s) {\n        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n    }\n\n    return t;\n  };\n\n  return _assign.apply(this, arguments);\n};\n\nexport { _assign as __assign };\nexport function __rest(s, e) {\n  var t = {};\n\n  for (var p in s) {\n    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\n  }\n\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}\nexport function __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  }\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\nexport function __param(paramIndex, decorator) {\n  return function (target, key) {\n    decorator(target, key, paramIndex);\n  };\n}\nexport function __metadata(metadataKey, metadataValue) {\n  if ((typeof Reflect === \"undefined\" ? \"undefined\" : _typeof(Reflect)) === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\nexport function __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\n    function rejected(value) {\n      try {\n        step(generator[\"throw\"](value));\n      } catch (e) {\n        reject(e);\n      }\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\n    step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\nexport function __generator(thisArg, body) {\n  var _ = {\n    label: 0,\n    sent: function sent() {\n      if (t[0] & 1) throw t[1];\n      return t[1];\n    },\n    trys: [],\n    ops: []\n  },\n      f,\n      y,\n      t,\n      g;\n  return g = {\n    next: verb(0),\n    \"throw\": verb(1),\n    \"return\": verb(2)\n  }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () {\n    return this;\n  }), g;\n\n  function verb(n) {\n    return function (v) {\n      return step([n, v]);\n    };\n  }\n\n  function step(op) {\n    if (f) throw new TypeError(\"Generator is already executing.\");\n\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\n        switch (op[0]) {\n          case 0:\n          case 1:\n            t = op;\n            break;\n\n          case 4:\n            _.label++;\n            return {\n              value: op[1],\n              done: false\n            };\n\n          case 5:\n            _.label++;\n            y = op[1];\n            op = [0];\n            continue;\n\n          case 7:\n            op = _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n\n          default:\n            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n              _ = 0;\n              continue;\n            }\n\n            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n              _.label = op[1];\n              break;\n            }\n\n            if (op[0] === 6 && _.label < t[1]) {\n              _.label = t[1];\n              t = op;\n              break;\n            }\n\n            if (t && _.label < t[2]) {\n              _.label = t[2];\n\n              _.ops.push(op);\n\n              break;\n            }\n\n            if (t[2]) _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n        }\n\n        op = body.call(thisArg, _);\n      } catch (e) {\n        op = [6, e];\n        y = 0;\n      } finally {\n        f = t = 0;\n      }\n    }\n\n    if (op[0] & 5) throw op[1];\n    return {\n      value: op[0] ? op[1] : void 0,\n      done: true\n    };\n  }\n}\nexport function __exportStar(m, exports) {\n  for (var p in m) {\n    if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n  }\n}\nexport function __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 {\n        value: o && o[i++],\n        done: !o\n      };\n    }\n  };\n}\nexport function __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\n  try {\n    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {\n      ar.push(r.value);\n    }\n  } catch (error) {\n    e = {\n      error: error\n    };\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\n  return ar;\n}\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++) {\n    ar = ar.concat(__read(arguments[i]));\n  }\n\n  return ar;\n}\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) {\n    s += arguments[i].length;\n  }\n\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  }\n\n  return r;\n}\n;\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\nexport function __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\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\n  function resume(n, v) {\n    try {\n      step(g[n](v));\n    } catch (e) {\n      settle(q[0][3], e);\n    }\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\n  function fulfill(value) {\n    resume(\"next\", value);\n  }\n\n  function reject(value) {\n    resume(\"throw\", value);\n  }\n\n  function settle(f, v) {\n    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);\n  }\n}\nexport function __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\n  function verb(n, f) {\n    i[n] = o[n] ? function (v) {\n      return (p = !p) ? {\n        value: __await(o[n](v)),\n        done: n === \"return\"\n      } : f ? f(v) : v;\n    } : f;\n  }\n}\nexport function __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\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\n  function settle(resolve, reject, d, v) {\n    Promise.resolve(v).then(function (v) {\n      resolve({\n        value: v,\n        done: d\n      });\n    }, reject);\n  }\n}\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) {\n    Object.defineProperty(cooked, \"raw\", {\n      value: raw\n    });\n  } else {\n    cooked.raw = raw;\n  }\n\n  return cooked;\n}\n;\nexport function __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  }\n  result.default = mod;\n  return result;\n}\nexport function __importDefault(mod) {\n  return mod && mod.__esModule ? mod : {\n    default: mod\n  };\n}","var EventListener =\n/** @class */\nfunction () {\n  function EventListener(eventTarget, eventName) {\n    this.eventTarget = eventTarget;\n    this.eventName = eventName;\n    this.unorderedBindings = new Set();\n  }\n\n  EventListener.prototype.connect = function () {\n    this.eventTarget.addEventListener(this.eventName, this, false);\n  };\n\n  EventListener.prototype.disconnect = function () {\n    this.eventTarget.removeEventListener(this.eventName, this, false);\n  }; // Binding observer delegate\n\n  /** @hidden */\n\n\n  EventListener.prototype.bindingConnected = function (binding) {\n    this.unorderedBindings.add(binding);\n  };\n  /** @hidden */\n\n\n  EventListener.prototype.bindingDisconnected = function (binding) {\n    this.unorderedBindings.delete(binding);\n  };\n\n  EventListener.prototype.handleEvent = function (event) {\n    var extendedEvent = extendEvent(event);\n\n    for (var _i = 0, _a = this.bindings; _i < _a.length; _i++) {\n      var binding = _a[_i];\n\n      if (extendedEvent.immediatePropagationStopped) {\n        break;\n      } else {\n        binding.handleEvent(extendedEvent);\n      }\n    }\n  };\n\n  Object.defineProperty(EventListener.prototype, \"bindings\", {\n    get: function get() {\n      return Array.from(this.unorderedBindings).sort(function (left, right) {\n        var leftIndex = left.index,\n            rightIndex = right.index;\n        return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;\n      });\n    },\n    enumerable: true,\n    configurable: true\n  });\n  return EventListener;\n}();\n\nexport { EventListener };\n\nfunction extendEvent(event) {\n  if (\"immediatePropagationStopped\" in event) {\n    return event;\n  } else {\n    var stopImmediatePropagation_1 = event.stopImmediatePropagation;\n    return Object.assign(event, {\n      immediatePropagationStopped: false,\n      stopImmediatePropagation: function stopImmediatePropagation() {\n        this.immediatePropagationStopped = true;\n        stopImmediatePropagation_1.call(this);\n      }\n    });\n  }\n}","import { EventListener } from \"./event_listener\";\n\nvar Dispatcher =\n/** @class */\nfunction () {\n  function Dispatcher(application) {\n    this.application = application;\n    this.eventListenerMaps = new Map();\n    this.started = false;\n  }\n\n  Dispatcher.prototype.start = function () {\n    if (!this.started) {\n      this.started = true;\n      this.eventListeners.forEach(function (eventListener) {\n        return eventListener.connect();\n      });\n    }\n  };\n\n  Dispatcher.prototype.stop = function () {\n    if (this.started) {\n      this.started = false;\n      this.eventListeners.forEach(function (eventListener) {\n        return eventListener.disconnect();\n      });\n    }\n  };\n\n  Object.defineProperty(Dispatcher.prototype, \"eventListeners\", {\n    get: function get() {\n      return Array.from(this.eventListenerMaps.values()).reduce(function (listeners, map) {\n        return listeners.concat(Array.from(map.values()));\n      }, []);\n    },\n    enumerable: true,\n    configurable: true\n  }); // Binding observer delegate\n\n  /** @hidden */\n\n  Dispatcher.prototype.bindingConnected = function (binding) {\n    this.fetchEventListenerForBinding(binding).bindingConnected(binding);\n  };\n  /** @hidden */\n\n\n  Dispatcher.prototype.bindingDisconnected = function (binding) {\n    this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);\n  }; // Error handling\n\n\n  Dispatcher.prototype.handleError = function (error, message, detail) {\n    if (detail === void 0) {\n      detail = {};\n    }\n\n    this.application.handleError(error, \"Error \" + message, detail);\n  };\n\n  Dispatcher.prototype.fetchEventListenerForBinding = function (binding) {\n    var eventTarget = binding.eventTarget,\n        eventName = binding.eventName;\n    return this.fetchEventListener(eventTarget, eventName);\n  };\n\n  Dispatcher.prototype.fetchEventListener = function (eventTarget, eventName) {\n    var eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);\n    var eventListener = eventListenerMap.get(eventName);\n\n    if (!eventListener) {\n      eventListener = this.createEventListener(eventTarget, eventName);\n      eventListenerMap.set(eventName, eventListener);\n    }\n\n    return eventListener;\n  };\n\n  Dispatcher.prototype.createEventListener = function (eventTarget, eventName) {\n    var eventListener = new EventListener(eventTarget, eventName);\n\n    if (this.started) {\n      eventListener.connect();\n    }\n\n    return eventListener;\n  };\n\n  Dispatcher.prototype.fetchEventListenerMapForEventTarget = function (eventTarget) {\n    var eventListenerMap = this.eventListenerMaps.get(eventTarget);\n\n    if (!eventListenerMap) {\n      eventListenerMap = new Map();\n      this.eventListenerMaps.set(eventTarget, eventListenerMap);\n    }\n\n    return eventListenerMap;\n  };\n\n  return Dispatcher;\n}();\n\nexport { Dispatcher };","// capture nos.:            12   23 4               43   1 5   56 7  76\nvar descriptorPattern = /^((.+?)(@(window|document))?->)?(.+?)(#(.+))?$/;\nexport function parseDescriptorString(descriptorString) {\n  var source = descriptorString.trim();\n  var matches = source.match(descriptorPattern) || [];\n  return {\n    eventTarget: parseEventTarget(matches[4]),\n    eventName: matches[2],\n    identifier: matches[5],\n    methodName: matches[7]\n  };\n}\n\nfunction parseEventTarget(eventTargetName) {\n  if (eventTargetName == \"window\") {\n    return window;\n  } else if (eventTargetName == \"document\") {\n    return document;\n  }\n}\n\nexport function stringifyEventTarget(eventTarget) {\n  if (eventTarget == window) {\n    return \"window\";\n  } else if (eventTarget == document) {\n    return \"document\";\n  }\n}","import { parseDescriptorString, stringifyEventTarget } from \"./action_descriptor\";\n\nvar Action =\n/** @class */\nfunction () {\n  function Action(element, index, descriptor) {\n    this.element = element;\n    this.index = index;\n    this.eventTarget = descriptor.eventTarget || element;\n    this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error(\"missing event name\");\n    this.identifier = descriptor.identifier || error(\"missing identifier\");\n    this.methodName = descriptor.methodName || error(\"missing method name\");\n  }\n\n  Action.forToken = function (token) {\n    return new this(token.element, token.index, parseDescriptorString(token.content));\n  };\n\n  Action.prototype.toString = function () {\n    var eventNameSuffix = this.eventTargetName ? \"@\" + this.eventTargetName : \"\";\n    return \"\" + this.eventName + eventNameSuffix + \"->\" + this.identifier + \"#\" + this.methodName;\n  };\n\n  Object.defineProperty(Action.prototype, \"eventTargetName\", {\n    get: function get() {\n      return stringifyEventTarget(this.eventTarget);\n    },\n    enumerable: true,\n    configurable: true\n  });\n  return Action;\n}();\n\nexport { Action };\nvar defaultEventNames = {\n  \"a\": function a(e) {\n    return \"click\";\n  },\n  \"button\": function button(e) {\n    return \"click\";\n  },\n  \"form\": function form(e) {\n    return \"submit\";\n  },\n  \"input\": function input(e) {\n    return e.getAttribute(\"type\") == \"submit\" ? \"click\" : \"change\";\n  },\n  \"select\": function select(e) {\n    return \"change\";\n  },\n  \"textarea\": function textarea(e) {\n    return \"change\";\n  }\n};\nexport function getDefaultEventNameForElement(element) {\n  var tagName = element.tagName.toLowerCase();\n\n  if (tagName in defaultEventNames) {\n    return defaultEventNames[tagName](element);\n  }\n}\n\nfunction error(message) {\n  throw new Error(message);\n}","var Binding =\n/** @class */\nfunction () {\n  function Binding(context, action) {\n    this.context = context;\n    this.action = action;\n  }\n\n  Object.defineProperty(Binding.prototype, \"index\", {\n    get: function get() {\n      return this.action.index;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Binding.prototype, \"eventTarget\", {\n    get: function get() {\n      return this.action.eventTarget;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Binding.prototype, \"identifier\", {\n    get: function get() {\n      return this.context.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Binding.prototype.handleEvent = function (event) {\n    if (this.willBeInvokedByEvent(event)) {\n      this.invokeWithEvent(event);\n    }\n  };\n\n  Object.defineProperty(Binding.prototype, \"eventName\", {\n    get: function get() {\n      return this.action.eventName;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Binding.prototype, \"method\", {\n    get: function get() {\n      var method = this.controller[this.methodName];\n\n      if (typeof method == \"function\") {\n        return method;\n      }\n\n      throw new Error(\"Action \\\"\" + this.action + \"\\\" references undefined method \\\"\" + this.methodName + \"\\\"\");\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Binding.prototype.invokeWithEvent = function (event) {\n    try {\n      this.method.call(this.controller, event);\n    } catch (error) {\n      var _a = this,\n          identifier = _a.identifier,\n          controller = _a.controller,\n          element = _a.element,\n          index = _a.index;\n\n      var detail = {\n        identifier: identifier,\n        controller: controller,\n        element: element,\n        index: index,\n        event: event\n      };\n      this.context.handleError(error, \"invoking action \\\"\" + this.action + \"\\\"\", detail);\n    }\n  };\n\n  Binding.prototype.willBeInvokedByEvent = function (event) {\n    var eventTarget = event.target;\n\n    if (this.element === eventTarget) {\n      return true;\n    } else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {\n      return this.scope.containsElement(eventTarget);\n    } else {\n      return true;\n    }\n  };\n\n  Object.defineProperty(Binding.prototype, \"controller\", {\n    get: function get() {\n      return this.context.controller;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Binding.prototype, \"methodName\", {\n    get: function get() {\n      return this.action.methodName;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Binding.prototype, \"element\", {\n    get: function get() {\n      return this.scope.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Binding.prototype, \"scope\", {\n    get: function get() {\n      return this.context.scope;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  return Binding;\n}();\n\nexport { Binding };","var ElementObserver =\n/** @class */\nfunction () {\n  function ElementObserver(element, delegate) {\n    var _this = this;\n\n    this.element = element;\n    this.started = false;\n    this.delegate = delegate;\n    this.elements = new Set();\n    this.mutationObserver = new MutationObserver(function (mutations) {\n      return _this.processMutations(mutations);\n    });\n  }\n\n  ElementObserver.prototype.start = function () {\n    if (!this.started) {\n      this.started = true;\n      this.mutationObserver.observe(this.element, {\n        attributes: true,\n        childList: true,\n        subtree: true\n      });\n      this.refresh();\n    }\n  };\n\n  ElementObserver.prototype.stop = function () {\n    if (this.started) {\n      this.mutationObserver.takeRecords();\n      this.mutationObserver.disconnect();\n      this.started = false;\n    }\n  };\n\n  ElementObserver.prototype.refresh = function () {\n    if (this.started) {\n      var matches = new Set(this.matchElementsInTree());\n\n      for (var _i = 0, _a = Array.from(this.elements); _i < _a.length; _i++) {\n        var element = _a[_i];\n\n        if (!matches.has(element)) {\n          this.removeElement(element);\n        }\n      }\n\n      for (var _b = 0, _c = Array.from(matches); _b < _c.length; _b++) {\n        var element = _c[_b];\n        this.addElement(element);\n      }\n    }\n  }; // Mutation record processing\n\n\n  ElementObserver.prototype.processMutations = function (mutations) {\n    if (this.started) {\n      for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        this.processMutation(mutation);\n      }\n    }\n  };\n\n  ElementObserver.prototype.processMutation = function (mutation) {\n    if (mutation.type == \"attributes\") {\n      this.processAttributeChange(mutation.target, mutation.attributeName);\n    } else if (mutation.type == \"childList\") {\n      this.processRemovedNodes(mutation.removedNodes);\n      this.processAddedNodes(mutation.addedNodes);\n    }\n  };\n\n  ElementObserver.prototype.processAttributeChange = function (node, attributeName) {\n    var element = node;\n\n    if (this.elements.has(element)) {\n      if (this.delegate.elementAttributeChanged && this.matchElement(element)) {\n        this.delegate.elementAttributeChanged(element, attributeName);\n      } else {\n        this.removeElement(element);\n      }\n    } else if (this.matchElement(element)) {\n      this.addElement(element);\n    }\n  };\n\n  ElementObserver.prototype.processRemovedNodes = function (nodes) {\n    for (var _i = 0, _a = Array.from(nodes); _i < _a.length; _i++) {\n      var node = _a[_i];\n      var element = this.elementFromNode(node);\n\n      if (element) {\n        this.processTree(element, this.removeElement);\n      }\n    }\n  };\n\n  ElementObserver.prototype.processAddedNodes = function (nodes) {\n    for (var _i = 0, _a = Array.from(nodes); _i < _a.length; _i++) {\n      var node = _a[_i];\n      var element = this.elementFromNode(node);\n\n      if (element && this.elementIsActive(element)) {\n        this.processTree(element, this.addElement);\n      }\n    }\n  }; // Element matching\n\n\n  ElementObserver.prototype.matchElement = function (element) {\n    return this.delegate.matchElement(element);\n  };\n\n  ElementObserver.prototype.matchElementsInTree = function (tree) {\n    if (tree === void 0) {\n      tree = this.element;\n    }\n\n    return this.delegate.matchElementsInTree(tree);\n  };\n\n  ElementObserver.prototype.processTree = function (tree, processor) {\n    for (var _i = 0, _a = this.matchElementsInTree(tree); _i < _a.length; _i++) {\n      var element = _a[_i];\n      processor.call(this, element);\n    }\n  };\n\n  ElementObserver.prototype.elementFromNode = function (node) {\n    if (node.nodeType == Node.ELEMENT_NODE) {\n      return node;\n    }\n  };\n\n  ElementObserver.prototype.elementIsActive = function (element) {\n    if (element.isConnected != this.element.isConnected) {\n      return false;\n    } else {\n      return this.element.contains(element);\n    }\n  }; // Element tracking\n\n\n  ElementObserver.prototype.addElement = function (element) {\n    if (!this.elements.has(element)) {\n      if (this.elementIsActive(element)) {\n        this.elements.add(element);\n\n        if (this.delegate.elementMatched) {\n          this.delegate.elementMatched(element);\n        }\n      }\n    }\n  };\n\n  ElementObserver.prototype.removeElement = function (element) {\n    if (this.elements.has(element)) {\n      this.elements.delete(element);\n\n      if (this.delegate.elementUnmatched) {\n        this.delegate.elementUnmatched(element);\n      }\n    }\n  };\n\n  return ElementObserver;\n}();\n\nexport { ElementObserver };","import { ElementObserver } from \"./element_observer\";\n\nvar AttributeObserver =\n/** @class */\nfunction () {\n  function AttributeObserver(element, attributeName, delegate) {\n    this.attributeName = attributeName;\n    this.delegate = delegate;\n    this.elementObserver = new ElementObserver(element, this);\n  }\n\n  Object.defineProperty(AttributeObserver.prototype, \"element\", {\n    get: function get() {\n      return this.elementObserver.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(AttributeObserver.prototype, \"selector\", {\n    get: function get() {\n      return \"[\" + this.attributeName + \"]\";\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  AttributeObserver.prototype.start = function () {\n    this.elementObserver.start();\n  };\n\n  AttributeObserver.prototype.stop = function () {\n    this.elementObserver.stop();\n  };\n\n  AttributeObserver.prototype.refresh = function () {\n    this.elementObserver.refresh();\n  };\n\n  Object.defineProperty(AttributeObserver.prototype, \"started\", {\n    get: function get() {\n      return this.elementObserver.started;\n    },\n    enumerable: true,\n    configurable: true\n  }); // Element observer delegate\n\n  AttributeObserver.prototype.matchElement = function (element) {\n    return element.hasAttribute(this.attributeName);\n  };\n\n  AttributeObserver.prototype.matchElementsInTree = function (tree) {\n    var match = this.matchElement(tree) ? [tree] : [];\n    var matches = Array.from(tree.querySelectorAll(this.selector));\n    return match.concat(matches);\n  };\n\n  AttributeObserver.prototype.elementMatched = function (element) {\n    if (this.delegate.elementMatchedAttribute) {\n      this.delegate.elementMatchedAttribute(element, this.attributeName);\n    }\n  };\n\n  AttributeObserver.prototype.elementUnmatched = function (element) {\n    if (this.delegate.elementUnmatchedAttribute) {\n      this.delegate.elementUnmatchedAttribute(element, this.attributeName);\n    }\n  };\n\n  AttributeObserver.prototype.elementAttributeChanged = function (element, attributeName) {\n    if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {\n      this.delegate.elementAttributeValueChanged(element, attributeName);\n    }\n  };\n\n  return AttributeObserver;\n}();\n\nexport { AttributeObserver };","export function add(map, key, value) {\n  fetch(map, key).add(value);\n}\nexport function del(map, key, value) {\n  fetch(map, key).delete(value);\n  prune(map, key);\n}\nexport function fetch(map, key) {\n  var values = map.get(key);\n\n  if (!values) {\n    values = new Set();\n    map.set(key, values);\n  }\n\n  return values;\n}\nexport function prune(map, key) {\n  var values = map.get(key);\n\n  if (values != null && values.size == 0) {\n    map.delete(key);\n  }\n}","import { add, del } from \"./set_operations\";\n\nvar Multimap =\n/** @class */\nfunction () {\n  function Multimap() {\n    this.valuesByKey = new Map();\n  }\n\n  Object.defineProperty(Multimap.prototype, \"values\", {\n    get: function get() {\n      var sets = Array.from(this.valuesByKey.values());\n      return sets.reduce(function (values, set) {\n        return values.concat(Array.from(set));\n      }, []);\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Multimap.prototype, \"size\", {\n    get: function get() {\n      var sets = Array.from(this.valuesByKey.values());\n      return sets.reduce(function (size, set) {\n        return size + set.size;\n      }, 0);\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Multimap.prototype.add = function (key, value) {\n    add(this.valuesByKey, key, value);\n  };\n\n  Multimap.prototype.delete = function (key, value) {\n    del(this.valuesByKey, key, value);\n  };\n\n  Multimap.prototype.has = function (key, value) {\n    var values = this.valuesByKey.get(key);\n    return values != null && values.has(value);\n  };\n\n  Multimap.prototype.hasKey = function (key) {\n    return this.valuesByKey.has(key);\n  };\n\n  Multimap.prototype.hasValue = function (value) {\n    var sets = Array.from(this.valuesByKey.values());\n    return sets.some(function (set) {\n      return set.has(value);\n    });\n  };\n\n  Multimap.prototype.getValuesForKey = function (key) {\n    var values = this.valuesByKey.get(key);\n    return values ? Array.from(values) : [];\n  };\n\n  Multimap.prototype.getKeysForValue = function (value) {\n    return Array.from(this.valuesByKey).filter(function (_a) {\n      var key = _a[0],\n          values = _a[1];\n      return values.has(value);\n    }).map(function (_a) {\n      var key = _a[0],\n          values = _a[1];\n      return key;\n    });\n  };\n\n  return Multimap;\n}();\n\nexport { Multimap };","var __extends = this && this.__extends || function () {\n  var extendStatics = Object.setPrototypeOf || {\n    __proto__: []\n  } 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\n  return function (d, b) {\n    extendStatics(d, b);\n\n    function __() {\n      this.constructor = d;\n    }\n\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n  };\n}();\n\nimport { Multimap } from \"./multimap\";\nimport { add, del } from \"./set_operations\";\n\nvar IndexedMultimap =\n/** @class */\nfunction (_super) {\n  __extends(IndexedMultimap, _super);\n\n  function IndexedMultimap() {\n    var _this = _super.call(this) || this;\n\n    _this.keysByValue = new Map();\n    return _this;\n  }\n\n  Object.defineProperty(IndexedMultimap.prototype, \"values\", {\n    get: function get() {\n      return Array.from(this.keysByValue.keys());\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  IndexedMultimap.prototype.add = function (key, value) {\n    _super.prototype.add.call(this, key, value);\n\n    add(this.keysByValue, value, key);\n  };\n\n  IndexedMultimap.prototype.delete = function (key, value) {\n    _super.prototype.delete.call(this, key, value);\n\n    del(this.keysByValue, value, key);\n  };\n\n  IndexedMultimap.prototype.hasValue = function (value) {\n    return this.keysByValue.has(value);\n  };\n\n  IndexedMultimap.prototype.getKeysForValue = function (value) {\n    var set = this.keysByValue.get(value);\n    return set ? Array.from(set) : [];\n  };\n\n  return IndexedMultimap;\n}(Multimap);\n\nexport { IndexedMultimap };","import { AttributeObserver } from \"./attribute_observer\";\nimport { Multimap } from \"@stimulus/multimap\";\n\nvar TokenListObserver =\n/** @class */\nfunction () {\n  function TokenListObserver(element, attributeName, delegate) {\n    this.attributeObserver = new AttributeObserver(element, attributeName, this);\n    this.delegate = delegate;\n    this.tokensByElement = new Multimap();\n  }\n\n  Object.defineProperty(TokenListObserver.prototype, \"started\", {\n    get: function get() {\n      return this.attributeObserver.started;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  TokenListObserver.prototype.start = function () {\n    this.attributeObserver.start();\n  };\n\n  TokenListObserver.prototype.stop = function () {\n    this.attributeObserver.stop();\n  };\n\n  TokenListObserver.prototype.refresh = function () {\n    this.attributeObserver.refresh();\n  };\n\n  Object.defineProperty(TokenListObserver.prototype, \"element\", {\n    get: function get() {\n      return this.attributeObserver.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(TokenListObserver.prototype, \"attributeName\", {\n    get: function get() {\n      return this.attributeObserver.attributeName;\n    },\n    enumerable: true,\n    configurable: true\n  }); // Attribute observer delegate\n\n  TokenListObserver.prototype.elementMatchedAttribute = function (element) {\n    this.tokensMatched(this.readTokensForElement(element));\n  };\n\n  TokenListObserver.prototype.elementAttributeValueChanged = function (element) {\n    var _a = this.refreshTokensForElement(element),\n        unmatchedTokens = _a[0],\n        matchedTokens = _a[1];\n\n    this.tokensUnmatched(unmatchedTokens);\n    this.tokensMatched(matchedTokens);\n  };\n\n  TokenListObserver.prototype.elementUnmatchedAttribute = function (element) {\n    this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));\n  };\n\n  TokenListObserver.prototype.tokensMatched = function (tokens) {\n    var _this = this;\n\n    tokens.forEach(function (token) {\n      return _this.tokenMatched(token);\n    });\n  };\n\n  TokenListObserver.prototype.tokensUnmatched = function (tokens) {\n    var _this = this;\n\n    tokens.forEach(function (token) {\n      return _this.tokenUnmatched(token);\n    });\n  };\n\n  TokenListObserver.prototype.tokenMatched = function (token) {\n    this.delegate.tokenMatched(token);\n    this.tokensByElement.add(token.element, token);\n  };\n\n  TokenListObserver.prototype.tokenUnmatched = function (token) {\n    this.delegate.tokenUnmatched(token);\n    this.tokensByElement.delete(token.element, token);\n  };\n\n  TokenListObserver.prototype.refreshTokensForElement = function (element) {\n    var previousTokens = this.tokensByElement.getValuesForKey(element);\n    var currentTokens = this.readTokensForElement(element);\n    var firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(function (_a) {\n      var previousToken = _a[0],\n          currentToken = _a[1];\n      return !tokensAreEqual(previousToken, currentToken);\n    });\n\n    if (firstDifferingIndex == -1) {\n      return [[], []];\n    } else {\n      return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];\n    }\n  };\n\n  TokenListObserver.prototype.readTokensForElement = function (element) {\n    var attributeName = this.attributeName;\n    var tokenString = element.getAttribute(attributeName) || \"\";\n    return parseTokenString(tokenString, element, attributeName);\n  };\n\n  return TokenListObserver;\n}();\n\nexport { TokenListObserver };\n\nfunction parseTokenString(tokenString, element, attributeName) {\n  return tokenString.trim().split(/\\s+/).filter(function (content) {\n    return content.length;\n  }).map(function (content, index) {\n    return {\n      element: element,\n      attributeName: attributeName,\n      content: content,\n      index: index\n    };\n  });\n}\n\nfunction zip(left, right) {\n  var length = Math.max(left.length, right.length);\n  return Array.from({\n    length: length\n  }, function (_, index) {\n    return [left[index], right[index]];\n  });\n}\n\nfunction tokensAreEqual(left, right) {\n  return left && right && left.index == right.index && left.content == right.content;\n}","import { TokenListObserver } from \"./token_list_observer\";\n\nvar ValueListObserver =\n/** @class */\nfunction () {\n  function ValueListObserver(element, attributeName, delegate) {\n    this.tokenListObserver = new TokenListObserver(element, attributeName, this);\n    this.delegate = delegate;\n    this.parseResultsByToken = new WeakMap();\n    this.valuesByTokenByElement = new WeakMap();\n  }\n\n  Object.defineProperty(ValueListObserver.prototype, \"started\", {\n    get: function get() {\n      return this.tokenListObserver.started;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  ValueListObserver.prototype.start = function () {\n    this.tokenListObserver.start();\n  };\n\n  ValueListObserver.prototype.stop = function () {\n    this.tokenListObserver.stop();\n  };\n\n  ValueListObserver.prototype.refresh = function () {\n    this.tokenListObserver.refresh();\n  };\n\n  Object.defineProperty(ValueListObserver.prototype, \"element\", {\n    get: function get() {\n      return this.tokenListObserver.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(ValueListObserver.prototype, \"attributeName\", {\n    get: function get() {\n      return this.tokenListObserver.attributeName;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  ValueListObserver.prototype.tokenMatched = function (token) {\n    var element = token.element;\n    var value = this.fetchParseResultForToken(token).value;\n\n    if (value) {\n      this.fetchValuesByTokenForElement(element).set(token, value);\n      this.delegate.elementMatchedValue(element, value);\n    }\n  };\n\n  ValueListObserver.prototype.tokenUnmatched = function (token) {\n    var element = token.element;\n    var value = this.fetchParseResultForToken(token).value;\n\n    if (value) {\n      this.fetchValuesByTokenForElement(element).delete(token);\n      this.delegate.elementUnmatchedValue(element, value);\n    }\n  };\n\n  ValueListObserver.prototype.fetchParseResultForToken = function (token) {\n    var parseResult = this.parseResultsByToken.get(token);\n\n    if (!parseResult) {\n      parseResult = this.parseToken(token);\n      this.parseResultsByToken.set(token, parseResult);\n    }\n\n    return parseResult;\n  };\n\n  ValueListObserver.prototype.fetchValuesByTokenForElement = function (element) {\n    var valuesByToken = this.valuesByTokenByElement.get(element);\n\n    if (!valuesByToken) {\n      valuesByToken = new Map();\n      this.valuesByTokenByElement.set(element, valuesByToken);\n    }\n\n    return valuesByToken;\n  };\n\n  ValueListObserver.prototype.parseToken = function (token) {\n    try {\n      var value = this.delegate.parseValueForToken(token);\n      return {\n        value: value\n      };\n    } catch (error) {\n      return {\n        error: error\n      };\n    }\n  };\n\n  return ValueListObserver;\n}();\n\nexport { ValueListObserver };","import { Action } from \"./action\";\nimport { Binding } from \"./binding\";\nimport { ValueListObserver } from \"@stimulus/mutation-observers\";\n\nvar BindingObserver =\n/** @class */\nfunction () {\n  function BindingObserver(context, delegate) {\n    this.context = context;\n    this.delegate = delegate;\n    this.bindingsByAction = new Map();\n  }\n\n  BindingObserver.prototype.start = function () {\n    if (!this.valueListObserver) {\n      this.valueListObserver = new ValueListObserver(this.element, this.actionAttribute, this);\n      this.valueListObserver.start();\n    }\n  };\n\n  BindingObserver.prototype.stop = function () {\n    if (this.valueListObserver) {\n      this.valueListObserver.stop();\n      delete this.valueListObserver;\n      this.disconnectAllActions();\n    }\n  };\n\n  Object.defineProperty(BindingObserver.prototype, \"element\", {\n    get: function get() {\n      return this.context.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(BindingObserver.prototype, \"identifier\", {\n    get: function get() {\n      return this.context.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(BindingObserver.prototype, \"actionAttribute\", {\n    get: function get() {\n      return this.schema.actionAttribute;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(BindingObserver.prototype, \"schema\", {\n    get: function get() {\n      return this.context.schema;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(BindingObserver.prototype, \"bindings\", {\n    get: function get() {\n      return Array.from(this.bindingsByAction.values());\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  BindingObserver.prototype.connectAction = function (action) {\n    var binding = new Binding(this.context, action);\n    this.bindingsByAction.set(action, binding);\n    this.delegate.bindingConnected(binding);\n  };\n\n  BindingObserver.prototype.disconnectAction = function (action) {\n    var binding = this.bindingsByAction.get(action);\n\n    if (binding) {\n      this.bindingsByAction.delete(action);\n      this.delegate.bindingDisconnected(binding);\n    }\n  };\n\n  BindingObserver.prototype.disconnectAllActions = function () {\n    var _this = this;\n\n    this.bindings.forEach(function (binding) {\n      return _this.delegate.bindingDisconnected(binding);\n    });\n    this.bindingsByAction.clear();\n  }; // Value observer delegate\n\n\n  BindingObserver.prototype.parseValueForToken = function (token) {\n    var action = Action.forToken(token);\n\n    if (action.identifier == this.identifier) {\n      return action;\n    }\n  };\n\n  BindingObserver.prototype.elementMatchedValue = function (element, action) {\n    this.connectAction(action);\n  };\n\n  BindingObserver.prototype.elementUnmatchedValue = function (element, action) {\n    this.disconnectAction(action);\n  };\n\n  return BindingObserver;\n}();\n\nexport { BindingObserver };","import { BindingObserver } from \"./binding_observer\";\n\nvar Context =\n/** @class */\nfunction () {\n  function Context(module, scope) {\n    this.module = module;\n    this.scope = scope;\n    this.controller = new module.controllerConstructor(this);\n    this.bindingObserver = new BindingObserver(this, this.dispatcher);\n\n    try {\n      this.controller.initialize();\n    } catch (error) {\n      this.handleError(error, \"initializing controller\");\n    }\n  }\n\n  Context.prototype.connect = function () {\n    this.bindingObserver.start();\n\n    try {\n      this.controller.connect();\n    } catch (error) {\n      this.handleError(error, \"connecting controller\");\n    }\n  };\n\n  Context.prototype.disconnect = function () {\n    try {\n      this.controller.disconnect();\n    } catch (error) {\n      this.handleError(error, \"disconnecting controller\");\n    }\n\n    this.bindingObserver.stop();\n  };\n\n  Object.defineProperty(Context.prototype, \"application\", {\n    get: function get() {\n      return this.module.application;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Context.prototype, \"identifier\", {\n    get: function get() {\n      return this.module.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Context.prototype, \"schema\", {\n    get: function get() {\n      return this.application.schema;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Context.prototype, \"dispatcher\", {\n    get: function get() {\n      return this.application.dispatcher;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Context.prototype, \"element\", {\n    get: function get() {\n      return this.scope.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Context.prototype, \"parentElement\", {\n    get: function get() {\n      return this.element.parentElement;\n    },\n    enumerable: true,\n    configurable: true\n  }); // Error handling\n\n  Context.prototype.handleError = function (error, message, detail) {\n    if (detail === void 0) {\n      detail = {};\n    }\n\n    var _a = this,\n        identifier = _a.identifier,\n        controller = _a.controller,\n        element = _a.element;\n\n    detail = Object.assign({\n      identifier: identifier,\n      controller: controller,\n      element: element\n    }, detail);\n    this.application.handleError(error, \"Error \" + message, detail);\n  };\n\n  return Context;\n}();\n\nexport { Context };","var __extends = this && this.__extends || function () {\n  var extendStatics = Object.setPrototypeOf || {\n    __proto__: []\n  } 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\n  return function (d, b) {\n    extendStatics(d, b);\n\n    function __() {\n      this.constructor = d;\n    }\n\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n  };\n}();\n/** @hidden */\n\n\nexport function blessDefinition(definition) {\n  return {\n    identifier: definition.identifier,\n    controllerConstructor: blessControllerConstructor(definition.controllerConstructor)\n  };\n}\n\nfunction blessControllerConstructor(controllerConstructor) {\n  var constructor = extend(controllerConstructor);\n  constructor.bless();\n  return constructor;\n}\n\nvar extend = function () {\n  function extendWithReflect(constructor) {\n    function Controller() {\n      var _newTarget = this && this instanceof Controller ? this.constructor : void 0;\n\n      return Reflect.construct(constructor, arguments, _newTarget);\n    }\n\n    Controller.prototype = Object.create(constructor.prototype, {\n      constructor: {\n        value: Controller\n      }\n    });\n    Reflect.setPrototypeOf(Controller, constructor);\n    return Controller;\n  }\n\n  function testReflectExtension() {\n    var a = function a() {\n      this.a.call(this);\n    };\n\n    var b = extendWithReflect(a);\n\n    b.prototype.a = function () {};\n\n    return new b();\n  }\n\n  try {\n    testReflectExtension();\n    return extendWithReflect;\n  } catch (error) {\n    return function (constructor) {\n      return (\n        /** @class */\n        function (_super) {\n          __extends(Controller, _super);\n\n          function Controller() {\n            return _super !== null && _super.apply(this, arguments) || this;\n          }\n\n          return Controller;\n        }(constructor)\n      );\n    };\n  }\n}();","import { Context } from \"./context\";\nimport { blessDefinition } from \"./definition\";\n\nvar Module =\n/** @class */\nfunction () {\n  function Module(application, definition) {\n    this.application = application;\n    this.definition = blessDefinition(definition);\n    this.contextsByScope = new WeakMap();\n    this.connectedContexts = new Set();\n  }\n\n  Object.defineProperty(Module.prototype, \"identifier\", {\n    get: function get() {\n      return this.definition.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Module.prototype, \"controllerConstructor\", {\n    get: function get() {\n      return this.definition.controllerConstructor;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Module.prototype, \"contexts\", {\n    get: function get() {\n      return Array.from(this.connectedContexts);\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Module.prototype.connectContextForScope = function (scope) {\n    var context = this.fetchContextForScope(scope);\n    this.connectedContexts.add(context);\n    context.connect();\n  };\n\n  Module.prototype.disconnectContextForScope = function (scope) {\n    var context = this.contextsByScope.get(scope);\n\n    if (context) {\n      this.connectedContexts.delete(context);\n      context.disconnect();\n    }\n  };\n\n  Module.prototype.fetchContextForScope = function (scope) {\n    var context = this.contextsByScope.get(scope);\n\n    if (!context) {\n      context = new Context(this, scope);\n      this.contextsByScope.set(scope, context);\n    }\n\n    return context;\n  };\n\n  return Module;\n}();\n\nexport { Module };","var DataMap =\n/** @class */\nfunction () {\n  function DataMap(scope) {\n    this.scope = scope;\n  }\n\n  Object.defineProperty(DataMap.prototype, \"element\", {\n    get: function get() {\n      return this.scope.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(DataMap.prototype, \"identifier\", {\n    get: function get() {\n      return this.scope.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  DataMap.prototype.get = function (key) {\n    key = this.getFormattedKey(key);\n    return this.element.getAttribute(key);\n  };\n\n  DataMap.prototype.set = function (key, value) {\n    key = this.getFormattedKey(key);\n    this.element.setAttribute(key, value);\n    return this.get(key);\n  };\n\n  DataMap.prototype.has = function (key) {\n    key = this.getFormattedKey(key);\n    return this.element.hasAttribute(key);\n  };\n\n  DataMap.prototype.delete = function (key) {\n    if (this.has(key)) {\n      key = this.getFormattedKey(key);\n      this.element.removeAttribute(key);\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  DataMap.prototype.getFormattedKey = function (key) {\n    return \"data-\" + this.identifier + \"-\" + dasherize(key);\n  };\n\n  return DataMap;\n}();\n\nexport { DataMap };\n\nfunction dasherize(value) {\n  return value.replace(/([A-Z])/g, function (_, char) {\n    return \"-\" + char.toLowerCase();\n  });\n}","/** @hidden */\nexport function attributeValueContainsToken(attributeName, token) {\n  return \"[\" + attributeName + \"~=\\\"\" + token + \"\\\"]\";\n}","import { attributeValueContainsToken } from \"./selectors\";\n\nvar TargetSet =\n/** @class */\nfunction () {\n  function TargetSet(scope) {\n    this.scope = scope;\n  }\n\n  Object.defineProperty(TargetSet.prototype, \"element\", {\n    get: function get() {\n      return this.scope.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(TargetSet.prototype, \"identifier\", {\n    get: function get() {\n      return this.scope.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(TargetSet.prototype, \"schema\", {\n    get: function get() {\n      return this.scope.schema;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  TargetSet.prototype.has = function (targetName) {\n    return this.find(targetName) != null;\n  };\n\n  TargetSet.prototype.find = function () {\n    var targetNames = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      targetNames[_i] = arguments[_i];\n    }\n\n    var selector = this.getSelectorForTargetNames(targetNames);\n    return this.scope.findElement(selector);\n  };\n\n  TargetSet.prototype.findAll = function () {\n    var targetNames = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      targetNames[_i] = arguments[_i];\n    }\n\n    var selector = this.getSelectorForTargetNames(targetNames);\n    return this.scope.findAllElements(selector);\n  };\n\n  TargetSet.prototype.getSelectorForTargetNames = function (targetNames) {\n    var _this = this;\n\n    return targetNames.map(function (targetName) {\n      return _this.getSelectorForTargetName(targetName);\n    }).join(\", \");\n  };\n\n  TargetSet.prototype.getSelectorForTargetName = function (targetName) {\n    var targetDescriptor = this.identifier + \".\" + targetName;\n    return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);\n  };\n\n  return TargetSet;\n}();\n\nexport { TargetSet };","import { DataMap } from \"./data_map\";\nimport { TargetSet } from \"./target_set\";\nimport { attributeValueContainsToken } from \"./selectors\";\n\nvar Scope =\n/** @class */\nfunction () {\n  function Scope(schema, identifier, element) {\n    this.schema = schema;\n    this.identifier = identifier;\n    this.element = element;\n    this.targets = new TargetSet(this);\n    this.data = new DataMap(this);\n  }\n\n  Scope.prototype.findElement = function (selector) {\n    return this.findAllElements(selector)[0];\n  };\n\n  Scope.prototype.findAllElements = function (selector) {\n    var head = this.element.matches(selector) ? [this.element] : [];\n    var tail = this.filterElements(Array.from(this.element.querySelectorAll(selector)));\n    return head.concat(tail);\n  };\n\n  Scope.prototype.filterElements = function (elements) {\n    var _this = this;\n\n    return elements.filter(function (element) {\n      return _this.containsElement(element);\n    });\n  };\n\n  Scope.prototype.containsElement = function (element) {\n    return element.closest(this.controllerSelector) === this.element;\n  };\n\n  Object.defineProperty(Scope.prototype, \"controllerSelector\", {\n    get: function get() {\n      return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);\n    },\n    enumerable: true,\n    configurable: true\n  });\n  return Scope;\n}();\n\nexport { Scope };","import { Scope } from \"./scope\";\nimport { ValueListObserver } from \"@stimulus/mutation-observers\";\n\nvar ScopeObserver =\n/** @class */\nfunction () {\n  function ScopeObserver(element, schema, delegate) {\n    this.element = element;\n    this.schema = schema;\n    this.delegate = delegate;\n    this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this);\n    this.scopesByIdentifierByElement = new WeakMap();\n    this.scopeReferenceCounts = new WeakMap();\n  }\n\n  ScopeObserver.prototype.start = function () {\n    this.valueListObserver.start();\n  };\n\n  ScopeObserver.prototype.stop = function () {\n    this.valueListObserver.stop();\n  };\n\n  Object.defineProperty(ScopeObserver.prototype, \"controllerAttribute\", {\n    get: function get() {\n      return this.schema.controllerAttribute;\n    },\n    enumerable: true,\n    configurable: true\n  }); // Value observer delegate\n\n  /** @hidden */\n\n  ScopeObserver.prototype.parseValueForToken = function (token) {\n    var element = token.element,\n        identifier = token.content;\n    var scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);\n    var scope = scopesByIdentifier.get(identifier);\n\n    if (!scope) {\n      scope = new Scope(this.schema, identifier, element);\n      scopesByIdentifier.set(identifier, scope);\n    }\n\n    return scope;\n  };\n  /** @hidden */\n\n\n  ScopeObserver.prototype.elementMatchedValue = function (element, value) {\n    var referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;\n    this.scopeReferenceCounts.set(value, referenceCount);\n\n    if (referenceCount == 1) {\n      this.delegate.scopeConnected(value);\n    }\n  };\n  /** @hidden */\n\n\n  ScopeObserver.prototype.elementUnmatchedValue = function (element, value) {\n    var referenceCount = this.scopeReferenceCounts.get(value);\n\n    if (referenceCount) {\n      this.scopeReferenceCounts.set(value, referenceCount - 1);\n\n      if (referenceCount == 1) {\n        this.delegate.scopeDisconnected(value);\n      }\n    }\n  };\n\n  ScopeObserver.prototype.fetchScopesByIdentifierForElement = function (element) {\n    var scopesByIdentifier = this.scopesByIdentifierByElement.get(element);\n\n    if (!scopesByIdentifier) {\n      scopesByIdentifier = new Map();\n      this.scopesByIdentifierByElement.set(element, scopesByIdentifier);\n    }\n\n    return scopesByIdentifier;\n  };\n\n  return ScopeObserver;\n}();\n\nexport { ScopeObserver };","import { Module } from \"./module\";\nimport { Multimap } from \"@stimulus/multimap\";\nimport { ScopeObserver } from \"./scope_observer\";\n\nvar Router =\n/** @class */\nfunction () {\n  function Router(application) {\n    this.application = application;\n    this.scopeObserver = new ScopeObserver(this.element, this.schema, this);\n    this.scopesByIdentifier = new Multimap();\n    this.modulesByIdentifier = new Map();\n  }\n\n  Object.defineProperty(Router.prototype, \"element\", {\n    get: function get() {\n      return this.application.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Router.prototype, \"schema\", {\n    get: function get() {\n      return this.application.schema;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Router.prototype, \"controllerAttribute\", {\n    get: function get() {\n      return this.schema.controllerAttribute;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Router.prototype, \"modules\", {\n    get: function get() {\n      return Array.from(this.modulesByIdentifier.values());\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Router.prototype, \"contexts\", {\n    get: function get() {\n      return this.modules.reduce(function (contexts, module) {\n        return contexts.concat(module.contexts);\n      }, []);\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Router.prototype.start = function () {\n    this.scopeObserver.start();\n  };\n\n  Router.prototype.stop = function () {\n    this.scopeObserver.stop();\n  };\n\n  Router.prototype.loadDefinition = function (definition) {\n    this.unloadIdentifier(definition.identifier);\n    var module = new Module(this.application, definition);\n    this.connectModule(module);\n  };\n\n  Router.prototype.unloadIdentifier = function (identifier) {\n    var module = this.modulesByIdentifier.get(identifier);\n\n    if (module) {\n      this.disconnectModule(module);\n    }\n  };\n\n  Router.prototype.getContextForElementAndIdentifier = function (element, identifier) {\n    var module = this.modulesByIdentifier.get(identifier);\n\n    if (module) {\n      return module.contexts.find(function (context) {\n        return context.element == element;\n      });\n    }\n  }; // Error handler delegate\n\n  /** @hidden */\n\n\n  Router.prototype.handleError = function (error, message, detail) {\n    this.application.handleError(error, message, detail);\n  }; // Scope observer delegate\n\n  /** @hidden */\n\n\n  Router.prototype.scopeConnected = function (scope) {\n    this.scopesByIdentifier.add(scope.identifier, scope);\n    var module = this.modulesByIdentifier.get(scope.identifier);\n\n    if (module) {\n      module.connectContextForScope(scope);\n    }\n  };\n  /** @hidden */\n\n\n  Router.prototype.scopeDisconnected = function (scope) {\n    this.scopesByIdentifier.delete(scope.identifier, scope);\n    var module = this.modulesByIdentifier.get(scope.identifier);\n\n    if (module) {\n      module.disconnectContextForScope(scope);\n    }\n  }; // Modules\n\n\n  Router.prototype.connectModule = function (module) {\n    this.modulesByIdentifier.set(module.identifier, module);\n    var scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);\n    scopes.forEach(function (scope) {\n      return module.connectContextForScope(scope);\n    });\n  };\n\n  Router.prototype.disconnectModule = function (module) {\n    this.modulesByIdentifier.delete(module.identifier);\n    var scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);\n    scopes.forEach(function (scope) {\n      return module.disconnectContextForScope(scope);\n    });\n  };\n\n  return Router;\n}();\n\nexport { Router };","export var defaultSchema = {\n  controllerAttribute: \"data-controller\",\n  actionAttribute: \"data-action\",\n  targetAttribute: \"data-target\"\n};","var __awaiter = this && this.__awaiter || function (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\n    function rejected(value) {\n      try {\n        step(generator[\"throw\"](value));\n      } catch (e) {\n        reject(e);\n      }\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\n    step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n};\n\nvar __generator = this && this.__generator || function (thisArg, body) {\n  var _ = {\n    label: 0,\n    sent: function sent() {\n      if (t[0] & 1) throw t[1];\n      return t[1];\n    },\n    trys: [],\n    ops: []\n  },\n      f,\n      y,\n      t,\n      g;\n  return g = {\n    next: verb(0),\n    \"throw\": verb(1),\n    \"return\": verb(2)\n  }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () {\n    return this;\n  }), g;\n\n  function verb(n) {\n    return function (v) {\n      return step([n, v]);\n    };\n  }\n\n  function step(op) {\n    if (f) throw new TypeError(\"Generator is already executing.\");\n\n    while (_) {\n      try {\n        if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n        if (y = 0, t) op = [0, t.value];\n\n        switch (op[0]) {\n          case 0:\n          case 1:\n            t = op;\n            break;\n\n          case 4:\n            _.label++;\n            return {\n              value: op[1],\n              done: false\n            };\n\n          case 5:\n            _.label++;\n            y = op[1];\n            op = [0];\n            continue;\n\n          case 7:\n            op = _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n\n          default:\n            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n              _ = 0;\n              continue;\n            }\n\n            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n              _.label = op[1];\n              break;\n            }\n\n            if (op[0] === 6 && _.label < t[1]) {\n              _.label = t[1];\n              t = op;\n              break;\n            }\n\n            if (t && _.label < t[2]) {\n              _.label = t[2];\n\n              _.ops.push(op);\n\n              break;\n            }\n\n            if (t[2]) _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n        }\n\n        op = body.call(thisArg, _);\n      } catch (e) {\n        op = [6, e];\n        y = 0;\n      } finally {\n        f = t = 0;\n      }\n    }\n\n    if (op[0] & 5) throw op[1];\n    return {\n      value: op[0] ? op[1] : void 0,\n      done: true\n    };\n  }\n};\n\nimport { Dispatcher } from \"./dispatcher\";\nimport { Router } from \"./router\";\nimport { defaultSchema } from \"./schema\";\n\nvar Application =\n/** @class */\nfunction () {\n  function Application(element, schema) {\n    if (element === void 0) {\n      element = document.documentElement;\n    }\n\n    if (schema === void 0) {\n      schema = defaultSchema;\n    }\n\n    this.element = element;\n    this.schema = schema;\n    this.dispatcher = new Dispatcher(this);\n    this.router = new Router(this);\n  }\n\n  Application.start = function (element, schema) {\n    var application = new Application(element, schema);\n    application.start();\n    return application;\n  };\n\n  Application.prototype.start = function () {\n    return __awaiter(this, void 0, void 0, function () {\n      return __generator(this, function (_a) {\n        switch (_a.label) {\n          case 0:\n            return [4\n            /*yield*/\n            , domReady()];\n\n          case 1:\n            _a.sent();\n\n            this.router.start();\n            this.dispatcher.start();\n            return [2\n            /*return*/\n            ];\n        }\n      });\n    });\n  };\n\n  Application.prototype.stop = function () {\n    this.router.stop();\n    this.dispatcher.stop();\n  };\n\n  Application.prototype.register = function (identifier, controllerConstructor) {\n    this.load({\n      identifier: identifier,\n      controllerConstructor: controllerConstructor\n    });\n  };\n\n  Application.prototype.load = function (head) {\n    var _this = this;\n\n    var rest = [];\n\n    for (var _i = 1; _i < arguments.length; _i++) {\n      rest[_i - 1] = arguments[_i];\n    }\n\n    var definitions = Array.isArray(head) ? head : [head].concat(rest);\n    definitions.forEach(function (definition) {\n      return _this.router.loadDefinition(definition);\n    });\n  };\n\n  Application.prototype.unload = function (head) {\n    var _this = this;\n\n    var rest = [];\n\n    for (var _i = 1; _i < arguments.length; _i++) {\n      rest[_i - 1] = arguments[_i];\n    }\n\n    var identifiers = Array.isArray(head) ? head : [head].concat(rest);\n    identifiers.forEach(function (identifier) {\n      return _this.router.unloadIdentifier(identifier);\n    });\n  };\n\n  Object.defineProperty(Application.prototype, \"controllers\", {\n    // Controllers\n    get: function get() {\n      return this.router.contexts.map(function (context) {\n        return context.controller;\n      });\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Application.prototype.getControllerForElementAndIdentifier = function (element, identifier) {\n    var context = this.router.getContextForElementAndIdentifier(element, identifier);\n    return context ? context.controller : null;\n  }; // Error handling\n\n\n  Application.prototype.handleError = function (error, message, detail) {\n    console.error(\"%s\\n\\n%o\\n\\n%o\", message, error, detail);\n  };\n\n  return Application;\n}();\n\nexport { Application };\n\nfunction domReady() {\n  return new Promise(function (resolve) {\n    if (document.readyState == \"loading\") {\n      document.addEventListener(\"DOMContentLoaded\", resolve);\n    } else {\n      resolve();\n    }\n  });\n}","/** @hidden */\nexport function defineTargetProperties(constructor) {\n  var prototype = constructor.prototype;\n  var targetNames = getTargetNamesForConstructor(constructor);\n  targetNames.forEach(function (name) {\n    var _a;\n\n    return defineLinkedProperties(prototype, (_a = {}, _a[name + \"Target\"] = {\n      get: function get() {\n        var target = this.targets.find(name);\n\n        if (target) {\n          return target;\n        } else {\n          throw new Error(\"Missing target element \\\"\" + this.identifier + \".\" + name + \"\\\"\");\n        }\n      }\n    }, _a[name + \"Targets\"] = {\n      get: function get() {\n        return this.targets.findAll(name);\n      }\n    }, _a[\"has\" + capitalize(name) + \"Target\"] = {\n      get: function get() {\n        return this.targets.has(name);\n      }\n    }, _a));\n  });\n}\n\nfunction getTargetNamesForConstructor(constructor) {\n  var ancestors = getAncestorsForConstructor(constructor);\n  return Array.from(ancestors.reduce(function (targetNames, constructor) {\n    getOwnTargetNamesForConstructor(constructor).forEach(function (name) {\n      return targetNames.add(name);\n    });\n    return targetNames;\n  }, new Set()));\n}\n\nfunction getAncestorsForConstructor(constructor) {\n  var ancestors = [];\n\n  while (constructor) {\n    ancestors.push(constructor);\n    constructor = Object.getPrototypeOf(constructor);\n  }\n\n  return ancestors;\n}\n\nfunction getOwnTargetNamesForConstructor(constructor) {\n  var definition = constructor[\"targets\"];\n  return Array.isArray(definition) ? definition : [];\n}\n\nfunction defineLinkedProperties(object, properties) {\n  Object.keys(properties).forEach(function (name) {\n    if (!(name in object)) {\n      var descriptor = properties[name];\n      Object.defineProperty(object, name, descriptor);\n    }\n  });\n}\n\nfunction capitalize(name) {\n  return name.charAt(0).toUpperCase() + name.slice(1);\n}","import { defineTargetProperties } from \"./target_properties\";\n\nvar Controller =\n/** @class */\nfunction () {\n  function Controller(context) {\n    this.context = context;\n  }\n\n  Controller.bless = function () {\n    defineTargetProperties(this);\n  };\n\n  Object.defineProperty(Controller.prototype, \"application\", {\n    get: function get() {\n      return this.context.application;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Controller.prototype, \"scope\", {\n    get: function get() {\n      return this.context.scope;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Controller.prototype, \"element\", {\n    get: function get() {\n      return this.scope.element;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Controller.prototype, \"identifier\", {\n    get: function get() {\n      return this.scope.identifier;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Controller.prototype, \"targets\", {\n    get: function get() {\n      return this.scope.targets;\n    },\n    enumerable: true,\n    configurable: true\n  });\n  Object.defineProperty(Controller.prototype, \"data\", {\n    get: function get() {\n      return this.scope.data;\n    },\n    enumerable: true,\n    configurable: true\n  });\n\n  Controller.prototype.initialize = function () {// Override in your subclass to set up initial controller state\n  };\n\n  Controller.prototype.connect = function () {// Override in your subclass to respond when the controller is connected to the DOM\n  };\n\n  Controller.prototype.disconnect = function () {// Override in your subclass to respond when the controller is disconnected from the DOM\n  };\n\n  Controller.targets = [];\n  return Controller;\n}();\n\nexport { Controller };","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n  switch (Object.prototype.toString.call(wat)) {\n    case '[object Error]':\n      return true;\n\n    case '[object Exception]':\n      return true;\n\n    case '[object DOMException]':\n      return true;\n\n    default:\n      return wat instanceof 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 */\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 */\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 */\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 */\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 */\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 */\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 regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\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 */\n\nexport function isThenable(wat) {\n  // tslint:disable:no-unsafe-any\n  return Boolean(wat && wat.then && typeof wat.then === 'function'); // 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 */\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}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nimport { isError, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\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 */\n\nexport function fill(source, name, replacement) {\n  if (!(name in source)) {\n    return;\n  }\n\n  var original = source[name];\n  var wrapped = replacement(original); // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  // tslint:disable-next-line:strict-type-predicates\n\n  if (typeof wrapped === 'function') {\n    try {\n      wrapped.prototype = wrapped.prototype || {};\n      Object.defineProperties(wrapped, {\n        __sentry__: {\n          enumerable: false,\n          value: true\n        },\n        __sentry_original__: {\n          enumerable: false,\n          value: original\n        },\n        __sentry_wrapped__: {\n          enumerable: false,\n          value: wrapped\n        }\n      });\n    } catch (_Oo) {// 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\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 */\n\nexport function urlEncode(object) {\n  return Object.keys(object).map( // tslint:disable-next-line:no-unsafe-any\n  function (key) {\n    return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]);\n  }).join('&');\n}\n/**\n * Transforms Error object into an object literal with all it's attributes\n * attached to it.\n *\n * Based on: https://github.com/ftlabs/js-abbreviate/blob/fa709e5f139e7770a71827b1893f22418097fbda/index.js#L95-L106\n *\n * @param error An Error containing all relevant information\n * @returns An object with all error properties\n */\n\nfunction objectifyError(error) {\n  // These properties are implemented as magical getters and don't show up in `for-in` loop\n  var err = {\n    message: error.message,\n    name: error.name,\n    stack: error.stack\n  };\n\n  for (var i in error) {\n    if (Object.prototype.hasOwnProperty.call(error, i)) {\n      err[i] = error[i];\n    }\n  }\n\n  return err;\n}\n/** Calculates bytes size of input string */\n\n\nfunction utf8Length(value) {\n  // tslint:disable-next-line:no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\n\n\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\n\n\nexport function normalizeToSize(object, // Default Node.js REPL depth\ndepth, // 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n  if (depth === void 0) {\n    depth = 3;\n  }\n\n  if (maxSize === void 0) {\n    maxSize = 100 * 1024;\n  }\n\n  var serialized = normalize(object, depth);\n\n  if (jsonSize(serialized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return serialized;\n}\n/** Transforms any input value into a string form, either primitive value or a type of the input */\n\nfunction serializeValue(value) {\n  var type = Object.prototype.toString.call(value); // Node.js REPL notation\n\n  if (typeof value === 'string') {\n    return value;\n  }\n\n  if (type === '[object Object]') {\n    return '[Object]';\n  }\n\n  if (type === '[object Array]') {\n    return '[Array]';\n  }\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\n\nfunction normalizeValue(value, key) {\n  if (key === 'domain' && _typeof(value) === 'object' && value._events) {\n    return '[Domain]';\n  }\n\n  if (key === 'domainEmitter') {\n    return '[DomainEmitter]';\n  }\n\n  if (typeof global !== 'undefined' && value === global) {\n    return '[Global]';\n  }\n\n  if (typeof window !== 'undefined' && value === window) {\n    return '[Window]';\n  }\n\n  if (typeof document !== 'undefined' && value === document) {\n    return '[Document]';\n  } // tslint:disable-next-line:strict-type-predicates\n\n\n  if (typeof Event !== 'undefined' && value instanceof Event) {\n    return Object.getPrototypeOf(value) ? value.constructor.name : 'Event';\n  } // React's SyntheticEvent thingy\n\n\n  if (isSyntheticEvent(value)) {\n    return '[SyntheticEvent]';\n  }\n\n  if (Number.isNaN(value)) {\n    return '[NaN]';\n  }\n\n  if (value === void 0) {\n    return '[undefined]';\n  }\n\n  if (typeof value === 'function') {\n    return \"[Function: \" + (value.name || '<unknown-function-name>') + \"]\";\n  }\n\n  return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n\n\nexport function walk(key, value, depth, memo) {\n  if (depth === void 0) {\n    depth = +Infinity;\n  }\n\n  if (memo === void 0) {\n    memo = new Memo();\n  } // If we reach the maximum depth, serialize whatever has left\n\n\n  if (depth === 0) {\n    return serializeValue(value);\n  } // If value implements `toJSON` method, call it and return early\n  // tslint:disable:no-unsafe-any\n\n\n  if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n    return value.toJSON();\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\n\n  var normalized = normalizeValue(value, key);\n\n  if (isPrimitive(normalized)) {\n    return normalized;\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\n\n  var source = isError(value) ? objectifyError(value) : value; // Create an accumulator that will act as a parent for all future itterations of that branch\n\n  var acc = Array.isArray(value) ? [] : {}; // If we already walked that branch, bail out, as it's circular reference\n\n  if (memo.memoize(value)) {\n    return '[Circular ~]';\n  } // Walk all keys of the source\n\n\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    } // Recursively walk through all the child nodes\n\n\n    acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n  } // Once walked through all the branches, remove the parent from memo storage\n\n\n  memo.unmemoize(value); // Return accumulated values\n\n  return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n\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) {\n      return walk(key, value, depth);\n    }));\n  } catch (_oO) {\n    return '**non-serializable**';\n  }\n}"],"sourceRoot":""}