{"version":3,"sources":["webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./src/components/GlobalErrorBoundary/index.ts","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/browser/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/types/esm/status.js","webpack:///./node_modules/@sentry/minimal/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/utils/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@sentry/utils/esm/polyfill.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/core/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/core/esm/transports/noop.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/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.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/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/utils/esm/instrument.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:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/browser/esm/index.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./src/components/GlobalErrorBoundary/Container.ts","webpack:///./src/components/GlobalErrorBoundary/GlobalErrorBoundary.tsx","webpack:///./src/assets/illustrations/Broken.tsx","webpack:///./src/components/GlobalErrorBoundary/GlobalErrorBoundary.scss?a0e4","webpack:///./src/components/GlobalErrorBoundary/GlobalErrorBoundary.scss","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./src/components/GlobalErrorBoundary/constants.ts","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./src/components/GlobalErrorBoundary/reducers.ts","webpack:///./node_modules/@sentry/hub/node_modules/tslib/tslib.es6.js"],"names":["fill","source","name","replacement","original","wrapped","prototype","Object","defineProperties","__sentry_original__","enumerable","value","_Oo","urlEncode","object","keys","map","key","encodeURIComponent","join","getWalkSource","error","err","message","stack","i","hasOwnProperty","call","event_1","type","target","toString","_oO","currentTarget","CustomEvent","detail","jsonSize","encodeURI","split","length","utf8Length","JSON","stringify","normalizeToSize","depth","maxSize","serialized","normalize","normalizeValue","_events","global","window","document","walk","memo","Infinity","normalized","serializeValue","toJSON","acc","Array","isArray","memoize","innerKey","unmemoize","input","parse","extractExceptionKeysForMessage","exception","maxLength","sort","includedKeys","slice","default","isError","wat","isInstanceOf","Error","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","then","isSyntheticEvent","base","_e","extendStatics","d","b","setPrototypeOf","__proto__","p","__extends","__","this","constructor","create","Severity","Status","__assign","assign","t","s","n","arguments","apply","__read","o","m","Symbol","iterator","r","e","ar","next","done","push","__spread","concat","fromString","level","Debug","Info","Warning","Fatal","Critical","Log","fromHttpCode","code","Success","RateLimit","Invalid","Failed","Unknown","callOnHub","method","args","_i","hub","captureException","syntheticException","originalException","captureMessage","captureEvent","event","configureScope","callback","addBreadcrumb","breadcrumb","setContext","context","setExtras","extras","setTags","tags","setExtra","extra","setTag","setUser","user","withScope","obj","proto","prop","_super","SentryError","_newTarget","_this","DSN_REGEX","Dsn","from","_fromString","_fromComponents","_validate","withPassword","_a","host","path","pass","port","projectId","protocol","str","match","exec","_b","_c","pop","components","forEach","component","isNaN","parseInt","API","dsn","_dsnObject","getDsn","getStoreEndpoint","_getBaseUrl","getStoreEndpointPath","getStoreEndpointWithUrlEncodedAuth","auth","sentry_key","sentry_version","getRequestHeaders","clientName","clientVersion","header","getReportDialogEndpoint","dialogOptions","endpoint","encodedOptions","email","installedIntegrations","setupIntegrations","options","integrations","defaultIntegrations","userIntegrations","userIntegrationsNames_1","pickedIntegrationsNames_1","defaultIntegration","indexOf","userIntegration","integrationsNames","splice","getIntegrationsToSetup","integration","setupOnce","logger","log","setupIntegration","BaseClient","backendClass","_integrations","_processing","_backend","_options","_dsn","_isEnabled","hint","scope","eventId","event_id","_getBackend","eventFromException","_processEvent","finalEvent","reason","is","eventFromMessage","getOptions","flush","timeout","_isClientProcessing","status","clearInterval","interval","getTransport","close","transportFlushed","ready","result","enabled","getIntegrations","getIntegration","id","warn","resolve","ticked","setInterval","undefined","_prepareEvent","environment","release","dist","maxValueLength","prepared","values","request","url","_addIntegrations","sdk","applyToEvent","sdkInfo","integrationsArray","beforeSend","sampleRate","Math","random","reject","data","__sentry__","sendEvent","beforeSendResult","_handleAsyncBeforeSend","processedEvent","NoopTransport","_","Skipped","BaseBackend","_transport","_setupTransport","_exception","_hint","_message","_level","supportsFetch","Headers","Request","Response","isNativeFetch","func","test","supportsReferrerPolicy","referrerPolicy","gecko","winjs","geckoEval","chromeEval","computeStackTrace","ex","popSize","framesToPop","stacktrace","parts","opera10Regex","opera11Regex","lines","line","element","column","extractMessage","computeStackTraceFromStacktraceProp","popFrames","submatch","isNative","columnNumber","computeStackTraceFromStackProp","failed","exceptionFromStacktrace","frames","prepareFramesForEvent","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","frame","colno","filename","function","in_app","lineno","reverse","eventFromUnknownInput","domException","name_1","eventFromString","rejection","__serialized__","frames_1","eventFromPlainObject","synthetic","attachStacktrace","originalFunctionToString","PromiseBuffer","_limit","_buffer","isReady","add","task","remove","drain","capturedSetTimeout","setTimeout","all","clearTimeout","BaseTransport","FetchTransport","_disabledUntil","Date","now","Promise","defaultOptions","body","fetch","response","headers","get","catch","XHRTransport","XMLHttpRequest","onreadystatechange","readyState","getResponseHeader","open","send","BrowserBackend","transportOptions","transport","handled","SDK_NAME","BrowserClient","platform","packages","version","showReportDialog","script","createElement","async","src","onLoad","onload","head","appendChild","FunctionToString","Function","DEFAULT_IGNORE_ERRORS","InboundFilters","self","client","getClient","clientOptions","_mergeOptions","_shouldDropEvent","_isSentryError","_isIgnoredError","_isBlacklistedUrl","_getEventFilterUrl","_isWhitelistedUrl","ignoreInternal","ignoreErrors","_getPossibleEventMessages","some","pattern","blacklistUrls","whitelistUrls","oO","frames_2","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","wrap","fn","before","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","handleEvent","addEventProcessor","mechanism","property","defineProperty","getOwnPropertyDescriptor","configurable","lastHref","TryCatch","_ignoreOnError","_wrapTimeFunction","originalCallback","_wrapRAF","handler","_wrapEventTarget","eventName","bind","_wrapXHR","originalSend","xhr","xmlHttpRequestProps","wrapOptions","handlers","instrumented","instrument","console","originalConsoleLevel","triggerHandlers","instrumentConsole","addEventListener","domEventHandler","keypressEventHandler","innerOriginal","instrumentDOM","xhrproto","originalOpen","__sentry_xhr__","toUpperCase","__sentry_own_request__","commonHandlerData","startTimestamp","onreadystatechangeHandler","status_code","endTimestamp","readyStateArgs","instrumentXHR","doc","sandbox","hidden","contentWindow","removeChild","supportsNativeFetch","originalFetch","fetchData","getFetchMethod","getFetchUrl","instrumentFetch","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","String","location","href","instrumentHistory","addInstrumentationHandler","e_1","e_1_1","return","fetchArgs","keypressTimeout","lastCapturedEvent","debounceTimer","debounce","tagName","isContentEditable","Breadcrumbs","dom","sentry","_consoleBreadcrumb","handlerData","category","_domBreadcrumb","_xhrBreadcrumb","addSentryBreadcrumb","_fetchBreadcrumb","filterUrl","_historyBreadcrumb","parsedLoc","parsedFrom","parsedTo","relative","serializedData","GlobalHandlers","_global","_oldOnErrorHandler","_oldOnUnhandledRejectionHandler","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","onerror","onunhandledrejection","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","msg","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","_eventFromIncompleteRejection","groups","LinkedErrors","_key","limit","_handler","linkedErrors","_walkErrorTree","UserAgent","navigator","userAgent","init","window_1","SENTRY_RELEASE","clientClass","debug","enable","bindClient","initAndBind","lastEventId","forceLoad","windowIntegrations","_window","Sentry","Integrations","INTEGRATIONS","Memo","_hasWeakSet","WeakSet","_inner","has","delete","connect","state","selectors","getPartition","emptyState","errorInfo","visible","stackTrace","onExitClick","StaticHeader","className","styles","xmlns","width","height","viewBox","fillRule","stroke","strokeWidth","transform","exitBtn","onClick","strokeLinecap","strokeLinejoin","props","config","datadog","applicationId","datadogRum","clientToken","site","service","env","sessionReplaySampleRate","trackResources","trackLongTasks","trackUserInteractions","defaultPrivacyLevel","allowedTracingUrls","apiBaseUrl","propagatorTypes","ofxUserInfo","username","maxBreadcrumbs","componentWillReceiveProps","nextProps","errorState","setState","globalText","TextErrorOccured","globalErrorInfo","replaceErrors","statusText","getCorrelationId","globalError","GLOBAL_ERROR_NAME","globalErrorToast","toastCreator","globalErrorLogout","redirectTo","routes","signouts","componentDidCatch","logDatadogRUM","mouseflow","mouseflowSessionId","getSessionId","render","React","Fragment","globalErrorStackTrace","content","controls","reload","children","displayName","Component","GlobalErrorBoundary","clipRule","module","locals","exports","Hub","_version","_stack","_invokeClient","top","getStackTop","isOlderThan","pushScope","getStack","parentScope","clone","popScope","getScope","_lastEventId","finalHint","beforeBreadcrumb","timestamp","mergedBreadcrumb","finalBreadcrumb","min","run","oldHub","makeMain","startSpan","spanOrSpanContext","forceNoChild","_callExtensionMethod","traceHeaders","carrier","getMainCarrier","__SENTRY__","extensions","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","active","registryHubTopStack","getHubFromActiveDomain","PREFIX","Logger","_enabled","disable","States","SyncPromise","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","REJECTED","_value","_executeHandlers","_attachHandler","onrejected","onfulfilled","collection","counter","resolvedCollection","item","index","TypeError","val","finally","onfinally","isRejected","OFX_GLOBAL_ERROR","OFX_GLOBAL_ERROR_LOGOUT","OFX_GLOBAL_ERROR_TOAST","UNAUTHENTICATED_ERROR_CODE","GRAPHQL_UNAUTHENTICATED_ERROR_CODE","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_context","addScopeListener","_notifyScopeListeners","_notifyEventProcessors","processors","processor","final","setFingerprint","fingerprint","_fingerprint","setLevel","setTransaction","transaction","_transaction","setSpan","span","_span","getSpan","newScope","clear","clearBreadcrumbs","_applyFingerprint","contexts","trace","getTraceContext","breadcrumbs","getGlobalEventProcessors","globalEventProcessors","addGlobalEventProcessor","dynamicRequire","mod","require","isNodeEnv","process","fallbackGlobalObject","getGlobalObject","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","replace","c","parseUrl","query","fragment","getEventDescription","consoleSandbox","originalConsole","wrappedLevels","addExceptionTypeValue","addExceptionMechanism","getLocationHref","htmlTreeAsString","elem","currentElem","out","len","sepLength","nextStr","_htmlElementAsString","parentNode","el","classes","attr","toLowerCase","attrWhitelist","getAttribute","timestampWithMs","getTime","parseRetryAfterHeader","headerDelay","headerDate","getFunctionName","truncate","max","substr","safeJoin","delimiter","output","isMatchingPattern","partition","initialState","getIn","actionTypes","reducers","handleActions","payload","setIn","Map"],"mappings":"yFAAA,8NAYO,SAASA,EAAKC,EAAQC,EAAMC,GAC/B,GAAMD,KAAQD,EAAd,CAGA,IAAIG,EAAWH,EAAOC,GAClBG,EAAUF,EAAYC,GAI1B,GAAuB,mBAAZC,EACP,IACIA,EAAQC,UAAYD,EAAQC,WAAa,GACzCC,OAAOC,iBAAiBH,EAAS,CAC7BI,oBAAqB,CACjBC,YAAY,EACZC,MAAOP,KAInB,MAAOQ,IAKXX,EAAOC,GAAQG,GAQZ,SAASQ,EAAUC,GACtB,OAAOP,OAAOQ,KAAKD,GACdE,KAEL,SAAUC,GAAO,OAAOC,mBAAmBD,GAAO,IAAMC,mBAAmBJ,EAAOG,OAC7EE,KAAK,KAQd,SAASC,EAAcT,GACnB,GAAI,YAAQA,GAAQ,CAChB,IAAIU,EAAQV,EACRW,EAAM,CACNC,QAASF,EAAME,QACfrB,KAAMmB,EAAMnB,KACZsB,MAAOH,EAAMG,OAEjB,IAAK,IAAIC,KAAKJ,EACNd,OAAOD,UAAUoB,eAAeC,KAAKN,EAAOI,KAC5CH,EAAIG,GAAKJ,EAAMI,IAGvB,OAAOH,EAEX,GAAI,YAAQX,GAAQ,CAChB,IAAIiB,EAAUjB,EACVV,EAAS,GACbA,EAAO4B,KAAOD,EAAQC,KAEtB,IACI5B,EAAO6B,OAAS,YAAUF,EAAQE,QAC5B,YAAiBF,EAAQE,QACzBvB,OAAOD,UAAUyB,SAASJ,KAAKC,EAAQE,QAEjD,MAAOE,GACH/B,EAAO6B,OAAS,YAEpB,IACI7B,EAAOgC,cAAgB,YAAUL,EAAQK,eACnC,YAAiBL,EAAQK,eACzB1B,OAAOD,UAAUyB,SAASJ,KAAKC,EAAQK,eAEjD,MAAOD,GACH/B,EAAOgC,cAAgB,YAM3B,IAAK,IAAIR,IAHkB,oBAAhBS,aAA+B,YAAavB,EAAOuB,eAC1DjC,EAAOkC,OAASP,EAAQO,QAEdP,EACNrB,OAAOD,UAAUoB,eAAeC,KAAKC,EAASH,KAC9CxB,EAAOwB,GAAKG,GAGpB,OAAO3B,EAEX,OAAOU,EAQX,SAASyB,EAASzB,GACd,OANJ,SAAoBA,GAEhB,QAAS0B,UAAU1B,GAAO2B,MAAM,SAASC,OAIlCC,CAAWC,KAAKC,UAAU/B,IAG9B,SAASgC,EAAgB7B,EAEhC8B,EAEAC,QACkB,IAAVD,IAAoBA,EAAQ,QAChB,IAAZC,IAAsBA,EAAU,QACpC,IAAIC,EAAaC,EAAUjC,EAAQ8B,GACnC,OAAIR,EAASU,GAAcD,EAChBF,EAAgB7B,EAAQ8B,EAAQ,EAAGC,GAEvCC,EA4BX,SAASE,EAAerC,EAAOM,GAC3B,MAAY,WAARA,GAAoBN,GAA0B,iBAAVA,GAAsBA,EAAMsC,QACzD,WAEC,kBAARhC,EACO,uBAEW,IAAXiC,GAA0BvC,IAAUuC,EACpC,WAEW,oBAAXC,QAA0BxC,IAAUwC,OACpC,WAEa,oBAAbC,UAA4BzC,IAAUyC,SACtC,aAGP,YAAiBzC,GACV,mBAGU,iBAAVA,GAAsBA,GAAUA,EAChC,aAEG,IAAVA,EACO,cAEU,mBAAVA,EACA,cAAgB,YAAgBA,GAAS,IAE7CA,EAUJ,SAAS0C,EAAKpC,EAAKN,EAAOiC,EAAOU,GAIpC,QAHc,IAAVV,IAAoBA,EAASW,UACpB,IAATD,IAAmBA,EAAO,IAAI,KAEpB,IAAVV,EACA,OAtER,SAAwBjC,GACpB,IAAIkB,EAAOtB,OAAOD,UAAUyB,SAASJ,KAAKhB,GAE1C,GAAqB,iBAAVA,EACP,OAAOA,EAEX,GAAa,oBAATkB,EACA,MAAO,WAEX,GAAa,mBAATA,EACA,MAAO,UAEX,IAAI2B,EAAaR,EAAerC,GAChC,OAAO,YAAY6C,GAAcA,EAAa3B,EAyDnC4B,CAAe9C,GAI1B,GAAIA,SAAiE,mBAAjBA,EAAM+C,OACtD,OAAO/C,EAAM+C,SAIjB,IAAIF,EAAaR,EAAerC,EAAOM,GACvC,GAAI,YAAYuC,GACZ,OAAOA,EAGX,IAAIvD,EAASmB,EAAcT,GAEvBgD,EAAMC,MAAMC,QAAQlD,GAAS,GAAK,GAEtC,GAAI2C,EAAKQ,QAAQnD,GACb,MAAO,eAGX,IAAK,IAAIoD,KAAY9D,EAEZM,OAAOD,UAAUoB,eAAeC,KAAK1B,EAAQ8D,KAIlDJ,EAAII,GAAYV,EAAKU,EAAU9D,EAAO8D,GAAWnB,EAAQ,EAAGU,IAKhE,OAFAA,EAAKU,UAAUrD,GAERgD,EAcJ,SAASZ,EAAUkB,EAAOrB,GAC7B,IAEI,OAAOH,KAAKyB,MAAMzB,KAAKC,UAAUuB,GAAO,SAAUhD,EAAKN,GAAS,OAAO0C,EAAKpC,EAAKN,EAAOiC,OAE5F,MAAOZ,GACH,MAAO,wBAQR,SAASmC,EAA+BC,EAAWC,QACpC,IAAdA,IAAwBA,EAAY,IAExC,IAAItD,EAAOR,OAAOQ,KAAKK,EAAcgD,IAErC,GADArD,EAAKuD,QACAvD,EAAKwB,OACN,MAAO,uBAEX,GAAIxB,EAAK,GAAGwB,QAAU8B,EAClB,OAAO,YAAStD,EAAK,GAAIsD,GAE7B,IAAK,IAAIE,EAAexD,EAAKwB,OAAQgC,EAAe,EAAGA,IAAgB,CACnE,IAAIzB,EAAa/B,EAAKyD,MAAM,EAAGD,GAAcpD,KAAK,MAClD,KAAI2B,EAAWP,OAAS8B,GAGxB,OAAIE,IAAiBxD,EAAKwB,OACfO,EAEJ,YAASA,EAAYuB,GAEhC,MAAO,M,oGC1RX,cAAS,EAAAI,QAAA,EAAAA,QACT,aAAS,aAAAA,S,iCCMF,SAASC,EAAQC,GACpB,OAAQpE,OAAOD,UAAUyB,SAASJ,KAAKgD,IACnC,IAAK,iBAEL,IAAK,qBAEL,IAAK,wBACD,OAAO,EACX,QACI,OAAOC,EAAaD,EAAKE,QAU9B,SAASC,EAAaH,GACzB,MAA+C,wBAAxCpE,OAAOD,UAAUyB,SAASJ,KAAKgD,GASnC,SAASI,EAAWJ,GACvB,MAA+C,sBAAxCpE,OAAOD,UAAUyB,SAASJ,KAAKgD,GASnC,SAASK,EAAeL,GAC3B,MAA+C,0BAAxCpE,OAAOD,UAAUyB,SAASJ,KAAKgD,GASnC,SAASM,EAASN,GACrB,MAA+C,oBAAxCpE,OAAOD,UAAUyB,SAASJ,KAAKgD,GASnC,SAASO,EAAYP,GACxB,OAAe,OAARA,GAAgC,iBAARA,GAAmC,mBAARA,EASvD,SAASQ,EAAcR,GAC1B,MAA+C,oBAAxCpE,OAAOD,UAAUyB,SAASJ,KAAKgD,GASnC,SAASS,EAAQT,GAEpB,MAAwB,oBAAVU,OAAyBT,EAAaD,EAAKU,OAStD,SAASC,EAAUX,GAEtB,MAA0B,oBAAZY,SAA2BX,EAAaD,EAAKY,SASxD,SAASC,EAASb,GACrB,MAA+C,oBAAxCpE,OAAOD,UAAUyB,SAASJ,KAAKgD,GAMnC,SAASc,EAAWd,GAEvB,OAAOe,QAAQf,GAAOA,EAAIgB,MAA4B,mBAAbhB,EAAIgB,MAU1C,SAASC,EAAiBjB,GAE7B,OAAOQ,EAAcR,IAAQ,gBAAiBA,GAAO,mBAAoBA,GAAO,oBAAqBA,EAUlG,SAASC,EAAaD,EAAKkB,GAC9B,IAEI,OAAOlB,aAAekB,EAE1B,MAAOC,GACH,OAAO,GAjJf,2b;;;;;;;;;;;;;;;ACgBA,IAAIC,EAAgB,SAASC,EAAGC,GAI5B,OAHAF,EAAgBxF,OAAO2F,gBAClB,CAAEC,UAAW,cAAgBvC,OAAS,SAAUoC,EAAGC,GAAKD,EAAEG,UAAYF,IACvE,SAAUD,EAAGC,GAAK,IAAK,IAAIG,KAAKH,EAAOA,EAAEvE,eAAe0E,KAAIJ,EAAEI,GAAKH,EAAEG,MACpDJ,EAAGC,IAGrB,SAASI,EAAUL,EAAGC,GAEzB,SAASK,IAAOC,KAAKC,YAAcR,EADnCD,EAAcC,EAAGC,GAEjBD,EAAE1F,UAAkB,OAAN2F,EAAa1F,OAAOkG,OAAOR,IAAMK,EAAGhG,UAAY2F,EAAE3F,UAAW,IAAIgG,GAG5E,IC5BII,ECAAC,EF4BAC,EAAW,WAQlB,OAPAA,EAAWrG,OAAOsG,QAAU,SAAkBC,GAC1C,IAAK,IAAIC,EAAGtF,EAAI,EAAGuF,EAAIC,UAAU1E,OAAQd,EAAIuF,EAAGvF,IAE5C,IAAK,IAAI2E,KADTW,EAAIE,UAAUxF,GACOlB,OAAOD,UAAUoB,eAAeC,KAAKoF,EAAGX,KAAIU,EAAEV,GAAKW,EAAEX,IAE9E,OAAOU,IAEKI,MAAMX,KAAMU,YAgFzB,SAASE,EAAOC,EAAGJ,GACtB,IAAIK,EAAsB,mBAAXC,QAAyBF,EAAEE,OAAOC,UACjD,IAAKF,EAAG,OAAOD,EACf,IAAmBI,EAAYC,EAA3BhG,EAAI4F,EAAE1F,KAAKyF,GAAOM,EAAK,GAC3B,IACI,WAAc,IAANV,GAAgBA,KAAM,MAAQQ,EAAI/F,EAAEkG,QAAQC,MAAMF,EAAGG,KAAKL,EAAE7G,OAExE,MAAOU,GAASoG,EAAI,CAAEpG,MAAOA,GAC7B,QACI,IACQmG,IAAMA,EAAEI,OAASP,EAAI5F,EAAU,SAAI4F,EAAE1F,KAAKF,GAElD,QAAU,GAAIgG,EAAG,MAAMA,EAAEpG,OAE7B,OAAOqG,EAGJ,SAASI,IACZ,IAAK,IAAIJ,EAAK,GAAIjG,EAAI,EAAGA,EAAIwF,UAAU1E,OAAQd,IAC3CiG,EAAKA,EAAGK,OAAOZ,EAAOF,UAAUxF,KACpC,OAAOiG,GCvIX,SAAWhB,GAEPA,EAAgB,MAAI,QAEpBA,EAAgB,MAAI,QAEpBA,EAAkB,QAAI,UAEtBA,EAAc,IAAI,MAElBA,EAAe,KAAI,OAEnBA,EAAgB,MAAI,QAEpBA,EAAmB,SAAI,WAd3B,CAeGA,IAAaA,EAAW,KAG3B,SAAWA,GA2BPA,EAASsB,WApBT,SAAoBC,GAChB,OAAQA,GACJ,IAAK,QACD,OAAOvB,EAASwB,MACpB,IAAK,OACD,OAAOxB,EAASyB,KACpB,IAAK,OACL,IAAK,UACD,OAAOzB,EAAS0B,QACpB,IAAK,QACD,OAAO1B,EAAS7B,MACpB,IAAK,QACD,OAAO6B,EAAS2B,MACpB,IAAK,WACD,OAAO3B,EAAS4B,SACpB,IAAK,MACL,QACI,OAAO5B,EAAS6B,MAxBhC,CA4BG7B,IAAaA,EAAW,KC9C3B,SAAWC,GAEPA,EAAgB,QAAI,UAEpBA,EAAgB,QAAI,UAEpBA,EAAgB,QAAI,UAEpBA,EAAkB,UAAI,aAEtBA,EAAgB,QAAI,UAEpBA,EAAe,OAAI,SAZvB,CAaGA,IAAWA,EAAS,KAGvB,SAAWA,GAsBPA,EAAO6B,aAfP,SAAsBC,GAClB,OAAIA,GAAQ,KAAOA,EAAO,IACf9B,EAAO+B,QAEL,MAATD,EACO9B,EAAOgC,UAEdF,GAAQ,KAAOA,EAAO,IACf9B,EAAOiC,QAEdH,GAAQ,IACD9B,EAAOkC,OAEXlC,EAAOmC,SApBtB,CAuBGnC,IAAWA,EAAS,K;;;;;;;;;;;;;;gFC4EhB,SAAS,EAAOS,EAAGJ,GACtB,IAAIK,EAAsB,mBAAXC,QAAyBF,EAAEE,OAAOC,UACjD,IAAKF,EAAG,OAAOD,EACf,IAAmBI,EAAYC,EAA3BhG,EAAI4F,EAAE1F,KAAKyF,GAAOM,EAAK,GAC3B,IACI,WAAc,IAANV,GAAgBA,KAAM,MAAQQ,EAAI/F,EAAEkG,QAAQC,MAAMF,EAAGG,KAAKL,EAAE7G,OAExE,MAAOU,GAASoG,EAAI,CAAEpG,MAAOA,GAC7B,QACI,IACQmG,IAAMA,EAAEI,OAASP,EAAI5F,EAAU,SAAI4F,EAAE1F,KAAKF,GAElD,QAAU,GAAIgG,EAAG,MAAMA,EAAEpG,OAE7B,OAAOqG,EAGJ,SAAS,IACZ,IAAK,IAAIA,EAAK,GAAIjG,EAAI,EAAGA,EAAIwF,UAAU1E,OAAQd,IAC3CiG,EAAKA,EAAGK,OAAO,EAAOd,UAAUxF,KACpC,OAAOiG,E,cClIX,SAASqB,EAAUC,GAEf,IADA,IAAIC,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,EAAK,GAAKjC,UAAUiC,GAE7B,IAAIC,EAAM,cACV,GAAIA,GAAOA,EAAIH,GAEX,OAAOG,EAAIH,GAAQ9B,MAAMiC,EAAK,EAAiBF,IAEnD,MAAM,IAAIpE,MAAM,qBAAuBmE,EAAS,wDAQ7C,SAASI,EAAiBhF,GAC7B,IAAIiF,EACJ,IACI,MAAM,IAAIxE,MAAM,6BAEpB,MAAOT,GACHiF,EAAqBjF,EAEzB,OAAO2E,EAAU,mBAAoB3E,EAAW,CAC5CkF,kBAAmBlF,EACnBiF,mBAAoBA,IAUrB,SAASE,EAAehI,EAAS0G,GACpC,IAAIoB,EACJ,IACI,MAAM,IAAIxE,MAAMtD,GAEpB,MAAO6C,GACHiF,EAAqBjF,EAEzB,OAAO2E,EAAU,iBAAkBxH,EAAS0G,EAAO,CAC/CqB,kBAAmB/H,EACnB8H,mBAAoBA,IASrB,SAASG,EAAaC,GACzB,OAAOV,EAAU,eAAgBU,GAM9B,SAASC,EAAeC,GAC3BZ,EAAU,iBAAkBY,GAUzB,SAASC,EAAcC,GAC1Bd,EAAU,gBAAiBc,GAOxB,SAASC,EAAW5J,EAAM6J,GAC7BhB,EAAU,aAAc7I,EAAM6J,GAM3B,SAASC,EAAUC,GACtBlB,EAAU,YAAakB,GAMpB,SAASC,EAAQC,GACpBpB,EAAU,UAAWoB,GAOlB,SAASC,EAASnJ,EAAKoJ,GAC1BtB,EAAU,WAAY9H,EAAKoJ,GAOxB,SAASC,EAAOrJ,EAAKN,GACxBoI,EAAU,SAAU9H,EAAKN,GAOtB,SAAS4J,EAAQC,GACpBzB,EAAU,UAAWyB,GAelB,SAASC,EAAUd,GACtBZ,EAAU,YAAaY;;;;;;;;;;;;;;;ACjI3B,IAAI,EAAgB,SAAS3D,EAAGC,GAI5B,OAHA,EAAgB1F,OAAO2F,gBAClB,CAAEC,UAAW,cAAgBvC,OAAS,SAAUoC,EAAGC,GAAKD,EAAEG,UAAYF,IACvE,SAAUD,EAAGC,GAAK,IAAK,IAAIG,KAAKH,EAAOA,EAAEvE,eAAe0E,KAAIJ,EAAEI,GAAKH,EAAEG,MACpDJ,EAAGC,IASrB,IAAI,EAAW,WAQlB,OAPA,EAAW1F,OAAOsG,QAAU,SAAkBC,GAC1C,IAAK,IAAIC,EAAGtF,EAAI,EAAGuF,EAAIC,UAAU1E,OAAQd,EAAIuF,EAAGvF,IAE5C,IAAK,IAAI2E,KADTW,EAAIE,UAAUxF,GACOlB,OAAOD,UAAUoB,eAAeC,KAAKoF,EAAGX,KAAIU,EAAEV,GAAKW,EAAEX,IAE9E,OAAOU,IAEKI,MAAMX,KAAMU,YAqEzB,SAAS,EAASG,GACrB,IAAIC,EAAsB,mBAAXC,QAAyBF,EAAEE,OAAOC,UAAW9F,EAAI,EAChE,OAAI4F,EAAUA,EAAE1F,KAAKyF,GACd,CACHO,KAAM,WAEF,OADIP,GAAK3F,GAAK2F,EAAE7E,SAAQ6E,OAAI,GACrB,CAAEzG,MAAOyG,GAAKA,EAAE3F,KAAMmG,MAAOR,KAKzC,SAAS,EAAOA,EAAGJ,GACtB,IAAIK,EAAsB,mBAAXC,QAAyBF,EAAEE,OAAOC,UACjD,IAAKF,EAAG,OAAOD,EACf,IAAmBI,EAAYC,EAA3BhG,EAAI4F,EAAE1F,KAAKyF,GAAOM,EAAK,GAC3B,IACI,WAAc,IAANV,GAAgBA,KAAM,MAAQQ,EAAI/F,EAAEkG,QAAQC,MAAMF,EAAGG,KAAKL,EAAE7G,OAExE,MAAOU,GAASoG,EAAI,CAAEpG,MAAOA,GAC7B,QACI,IACQmG,IAAMA,EAAEI,OAASP,EAAI5F,EAAU,SAAI4F,EAAE1F,KAAKF,GAElD,QAAU,GAAIgG,EAAG,MAAMA,EAAEpG,OAE7B,OAAOqG,ECnIJ,IAAIxB,EAAiB3F,OAAO2F,iBAAmB,CAAEC,UAAW,cAAgBvC,MAInF,SAAoB8G,EAAKC,GAGrB,OADAD,EAAIvE,UAAYwE,EACTD,GAKX,SAAyBA,EAAKC,GAC1B,IAAK,IAAIC,KAAQD,EACRD,EAAIhJ,eAAekJ,KAEpBF,EAAIE,GAAQD,EAAMC,IAG1B,OAAOF,IChBX,IAAI,EAA6B,SAAUG,GAEvC,SAASC,EAAYvJ,GACjB,IAAIwJ,EAAaxE,KAAKC,YAClBwE,EAAQH,EAAOlJ,KAAK4E,KAAMhF,IAAYgF,KAK1C,OAJAyE,EAAMzJ,QAAUA,EAEhByJ,EAAM9K,KAAO6K,EAAWzK,UAAUkG,YAAYtG,KAC9CgG,EAAe8E,EAAOD,EAAWzK,WAC1B0K,EAEX,OFSG,SAAmBhF,EAAGC,GAEzB,SAASK,IAAOC,KAAKC,YAAcR,EADnC,EAAcA,EAAGC,GAEjBD,EAAE1F,UAAkB,OAAN2F,EAAa1F,OAAOkG,OAAOR,IAAMK,EAAGhG,UAAY2F,EAAE3F,UAAW,IAAIgG,GEtB/E,CAAkBwE,EAAaD,GAUxBC,EAXqB,CAY9BjG,OCZEoG,EAAY,kEAIZ,EAAqB,WAErB,SAASC,EAAIC,GACW,iBAATA,EACP5E,KAAK6E,YAAYD,GAGjB5E,KAAK8E,gBAAgBF,GAEzB5E,KAAK+E,YA2DT,OAhDAJ,EAAI5K,UAAUyB,SAAW,SAAUwJ,QACV,IAAjBA,IAA2BA,GAAe,GAE9C,IAAIC,EAAKjF,KAAMkF,EAAOD,EAAGC,KAAMC,EAAOF,EAAGE,KAAMC,EAAOH,EAAGG,KAAMC,EAAOJ,EAAGI,KAAMC,EAAYL,EAAGK,UAC9F,OADoHL,EAAGM,SACpG,MADqHN,EAAGhB,MACxGe,GAAgBI,EAAO,IAAMA,EAAO,IAClE,IAAMF,GAAQG,EAAO,IAAMA,EAAO,IAAM,KAAOF,EAAOA,EAAO,IAAMA,GAAQG,GAGpFX,EAAI5K,UAAU8K,YAAc,SAAUW,GAClC,IAAIC,EAAQf,EAAUgB,KAAKF,GAC3B,IAAKC,EACD,MAAM,IAAI,EAjCF,eAmCZ,IAAIR,EAAK,EAAeQ,EAAMxH,MAAM,GAAI,GAAIsH,EAAWN,EAAG,GAAIhB,EAAOgB,EAAG,GAAIU,EAAKV,EAAG,GAAIG,OAAc,IAAPO,EAAgB,GAAKA,EAAIT,EAAOD,EAAG,GAAIW,EAAKX,EAAG,GAAII,OAAc,IAAPO,EAAgB,GAAKA,EAC1KT,EAAO,GACPG,EAFyLL,EAAG,GAG5LlJ,EAAQuJ,EAAUvJ,MAAM,KACxBA,EAAMC,OAAS,IACfmJ,EAAOpJ,EAAMkC,MAAM,GAAI,GAAGrD,KAAK,KAC/B0K,EAAYvJ,EAAM8J,OAEtB7F,KAAK8E,gBAAgB,CAAEI,KAAMA,EAAME,KAAMA,EAAMD,KAAMA,EAAMG,UAAWA,EAAWD,KAAMA,EAAME,SAAUA,EAAUtB,KAAMA,KAG3HU,EAAI5K,UAAU+K,gBAAkB,SAAUgB,GACtC9F,KAAKuF,SAAWO,EAAWP,SAC3BvF,KAAKiE,KAAO6B,EAAW7B,KACvBjE,KAAKoF,KAAOU,EAAWV,MAAQ,GAC/BpF,KAAKkF,KAAOY,EAAWZ,KACvBlF,KAAKqF,KAAOS,EAAWT,MAAQ,GAC/BrF,KAAKmF,KAAOW,EAAWX,MAAQ,GAC/BnF,KAAKsF,UAAYQ,EAAWR,WAGhCX,EAAI5K,UAAUgL,UAAY,WACtB,IAAIN,EAAQzE,KAMZ,GALA,CAAC,WAAY,OAAQ,OAAQ,aAAa+F,SAAQ,SAAUC,GACxD,IAAKvB,EAAMuB,GACP,MAAM,IAAI,EA5DN,kBA+DU,SAAlBhG,KAAKuF,UAAyC,UAAlBvF,KAAKuF,SACjC,MAAM,IAAI,EAhEF,eAkEZ,GAAIvF,KAAKqF,MAAQY,MAAMC,SAASlG,KAAKqF,KAAM,KACvC,MAAM,IAAI,EAnEF,gBAsETV,EApEa,G,iBCJpB,EAAqB,WAErB,SAASwB,EAAIC,GACTpG,KAAKoG,IAAMA,EACXpG,KAAKqG,WAAa,IAAI,EAAID,GA4E9B,OAzEAD,EAAIpM,UAAUuM,OAAS,WACnB,OAAOtG,KAAKqG,YAGhBF,EAAIpM,UAAUwM,iBAAmB,WAC7B,MAAO,GAAKvG,KAAKwG,cAAgBxG,KAAKyG,wBAG1CN,EAAIpM,UAAU2M,mCAAqC,WAC/C,IACIC,EAAO,CACPC,WAFM5G,KAAKqG,WAEKpC,KAChB4C,eArBa,KAyBjB,OAAO7G,KAAKuG,mBAAqB,IAAM,YAAUI,IAGrDR,EAAIpM,UAAUyM,YAAc,WACxB,IAAIJ,EAAMpG,KAAKqG,WACXd,EAAWa,EAAIb,SAAWa,EAAIb,SAAW,IAAM,GAC/CF,EAAOe,EAAIf,KAAO,IAAMe,EAAIf,KAAO,GACvC,OAAOE,EAAW,KAAOa,EAAIlB,KAAOG,GAGxCc,EAAIpM,UAAU0M,qBAAuB,WACjC,IAAIL,EAAMpG,KAAKqG,WACf,OAAQD,EAAIjB,KAAO,IAAMiB,EAAIjB,KAAO,IAAM,QAAUiB,EAAId,UAAY,WAGxEa,EAAIpM,UAAU+M,kBAAoB,SAAUC,EAAYC,GACpD,IAAIZ,EAAMpG,KAAKqG,WACXY,EAAS,CAAC,2BAOd,OANAA,EAAO3F,KAAK,oBAAsB,eAClC2F,EAAO3F,KAAK,iBAAmByF,EAAa,IAAMC,GAClDC,EAAO3F,KAAK,cAAgB8E,EAAInC,MAC5BmC,EAAIhB,MACJ6B,EAAO3F,KAAK,iBAAmB8E,EAAIhB,MAEhC,CACH,eAAgB,mBAChB,gBAAiB6B,EAAOrM,KAAK,QAIrCuL,EAAIpM,UAAUmN,wBAA0B,SAAUC,QACxB,IAAlBA,IAA4BA,EAAgB,IAChD,IAAIf,EAAMpG,KAAKqG,WACXe,EAAgBpH,KAAKwG,eAAiBJ,EAAIjB,KAAO,IAAMiB,EAAIjB,KAAO,IAAM,yBACxEkC,EAAiB,GAErB,IAAK,IAAI3M,KADT2M,EAAe/F,KAAK,OAAS8E,EAAI5K,YACjB2L,EACZ,GAAY,SAARzM,EAAgB,CAChB,IAAKyM,EAAclD,KACf,SAEAkD,EAAclD,KAAKtK,MACnB0N,EAAe/F,KAAK,QAAU3G,mBAAmBwM,EAAclD,KAAKtK,OAEpEwN,EAAclD,KAAKqD,OACnBD,EAAe/F,KAAK,SAAW3G,mBAAmBwM,EAAclD,KAAKqD,aAIzED,EAAe/F,KAAK3G,mBAAmBD,GAAO,IAAMC,mBAAmBwM,EAAczM,KAG7F,OAAI2M,EAAerL,OACRoL,EAAW,IAAMC,EAAezM,KAAK,KAEzCwM,GAEJjB,EAhFa,GC0BjB,IAAI,EAAW,WAQlB,OAPA,EAAWnM,OAAOsG,QAAU,SAAkBC,GAC1C,IAAK,IAAIC,EAAGtF,EAAI,EAAGuF,EAAIC,UAAU1E,OAAQd,EAAIuF,EAAGvF,IAE5C,IAAK,IAAI2E,KADTW,EAAIE,UAAUxF,GACOlB,OAAOD,UAAUoB,eAAeC,KAAKoF,EAAGX,KAAIU,EAAEV,GAAKW,EAAEX,IAE9E,OAAOU,IAEKI,MAAMX,KAAMU,YAgFzB,SAAS,EAAOG,EAAGJ,GACtB,IAAIK,EAAsB,mBAAXC,QAAyBF,EAAEE,OAAOC,UACjD,IAAKF,EAAG,OAAOD,EACf,IAAmBI,EAAYC,EAA3BhG,EAAI4F,EAAE1F,KAAKyF,GAAOM,EAAK,GAC3B,IACI,WAAc,IAANV,GAAgBA,KAAM,MAAQQ,EAAI/F,EAAEkG,QAAQC,MAAMF,EAAGG,KAAKL,EAAE7G,OAExE,MAAOU,GAASoG,EAAI,CAAEpG,MAAOA,GAC7B,QACI,IACQmG,IAAMA,EAAEI,OAASP,EAAI5F,EAAU,SAAI4F,EAAE1F,KAAKF,GAElD,QAAU,GAAIgG,EAAG,MAAMA,EAAEpG,OAE7B,OAAOqG,EAGJ,SAAS,IACZ,IAAK,IAAIA,EAAK,GAAIjG,EAAI,EAAGA,EAAIwF,UAAU1E,OAAQd,IAC3CiG,EAAKA,EAAGK,OAAO,EAAOd,UAAUxF,KACpC,OAAOiG,E,wCCtIAoG,EAAwB,GAuD5B,SAASC,EAAkBC,GAC9B,IAAIC,EAAe,GAKnB,OA3DG,SAAgCD,GACnC,IAAIE,EAAuBF,EAAQE,qBAAuB,EAAiBF,EAAQE,sBAAyB,GACxGC,EAAmBH,EAAQC,aAC3BA,EAAe,GACnB,GAAIrK,MAAMC,QAAQsK,GAAmB,CACjC,IAAIC,EAA0BD,EAAiBnN,KAAI,SAAUS,GAAK,OAAOA,EAAEvB,QACvEmO,EAA4B,GAEhCH,EAAoB5B,SAAQ,SAAUgC,IACgC,IAA9DF,EAAwBG,QAAQD,EAAmBpO,QACa,IAAhEmO,EAA0BE,QAAQD,EAAmBpO,QACrD+N,EAAapG,KAAKyG,GAClBD,EAA0BxG,KAAKyG,EAAmBpO,UAI1DiO,EAAiB7B,SAAQ,SAAUkC,IACkC,IAA7DH,EAA0BE,QAAQC,EAAgBtO,QAClD+N,EAAapG,KAAK2G,GAClBH,EAA0BxG,KAAK2G,EAAgBtO,cAItB,mBAArBiO,GACZF,EAAeE,EAAiBD,GAChCD,EAAerK,MAAMC,QAAQoK,GAAgBA,EAAe,CAACA,IAG7DA,EAAe,EAAiBC,GAGpC,IAAIO,EAAoBR,EAAajN,KAAI,SAAUS,GAAK,OAAOA,EAAEvB,QAKjE,OAHoD,IAAhDuO,EAAkBF,QADA,UAElBN,EAAapG,KAAKX,MAAM+G,EAAc,EAAiBA,EAAaS,OAAOD,EAAkBF,QAF3E,SAEqG,KAEpHN,EAmBPU,CAAuBX,GAAS1B,SAAQ,SAAUsC,GAC9CX,EAAaW,EAAY1O,MAAQ0O,EAjBlC,SAA0BA,IAC4B,IAArDd,EAAsBS,QAAQK,EAAY1O,QAG9C0O,EAAYC,UAAU,IAAyB,KAC/Cf,EAAsBjG,KAAK+G,EAAY1O,MACvC4O,EAAA,EAAOC,IAAI,0BAA4BH,EAAY1O,OAY/C8O,CAAiBJ,MAEdX,EC7BX,IAAI,EAA4B,WAO5B,SAASgB,EAAWC,EAAclB,GAE9BzH,KAAK4I,cAAgB,GAErB5I,KAAK6I,aAAc,EACnB7I,KAAK8I,SAAW,IAAIH,EAAalB,GACjCzH,KAAK+I,SAAWtB,EACZA,EAAQrB,MACRpG,KAAKgJ,KAAO,IAAI,EAAIvB,EAAQrB,MAE5BpG,KAAKiJ,eACLjJ,KAAK4I,cAAgBpB,EAAkBxH,KAAK+I,WAoTpD,OA9SAL,EAAW3O,UAAU8I,iBAAmB,SAAUhF,EAAWqL,EAAMC,GAC/D,IAAI1E,EAAQzE,KACRoJ,EAAUF,GAAQA,EAAKG,SAc3B,OAbArJ,KAAK6I,aAAc,EACnB7I,KAAKsJ,cACAC,mBAAmB1L,EAAWqL,GAC9B9J,MAAK,SAAU8D,GAAS,OAAOuB,EAAM+E,cAActG,EAAOgG,EAAMC,MAChE/J,MAAK,SAAUqK,GAEhBL,EAAUK,GAAcA,EAAWJ,SACnC5E,EAAMoE,aAAc,KAEnBzJ,KAAK,MAAM,SAAUsK,GACtBnB,EAAA,EAAOzN,MAAM4O,GACbjF,EAAMoE,aAAc,KAEjBO,GAKXV,EAAW3O,UAAUiJ,eAAiB,SAAUhI,EAAS0G,EAAOwH,EAAMC,GAClE,IAAI1E,EAAQzE,KACRoJ,EAAUF,GAAQA,EAAKG,SAgB3B,OAfArJ,KAAK6I,aAAc,GACC,OAAAc,EAAA,GAAY3O,GAC1BgF,KAAKsJ,cAAcM,iBAAiB,GAAK5O,EAAS0G,EAAOwH,GACzDlJ,KAAKsJ,cAAcC,mBAAmBvO,EAASkO,IAEhD9J,MAAK,SAAU8D,GAAS,OAAOuB,EAAM+E,cAActG,EAAOgG,EAAMC,MAChE/J,MAAK,SAAUqK,GAEhBL,EAAUK,GAAcA,EAAWJ,SACnC5E,EAAMoE,aAAc,KAEnBzJ,KAAK,MAAM,SAAUsK,GACtBnB,EAAA,EAAOzN,MAAM4O,GACbjF,EAAMoE,aAAc,KAEjBO,GAKXV,EAAW3O,UAAUkJ,aAAe,SAAUC,EAAOgG,EAAMC,GACvD,IAAI1E,EAAQzE,KACRoJ,EAAUF,GAAQA,EAAKG,SAY3B,OAXArJ,KAAK6I,aAAc,EACnB7I,KAAKwJ,cAActG,EAAOgG,EAAMC,GAC3B/J,MAAK,SAAUqK,GAEhBL,EAAUK,GAAcA,EAAWJ,SACnC5E,EAAMoE,aAAc,KAEnBzJ,KAAK,MAAM,SAAUsK,GACtBnB,EAAA,EAAOzN,MAAM4O,GACbjF,EAAMoE,aAAc,KAEjBO,GAKXV,EAAW3O,UAAUuM,OAAS,WAC1B,OAAOtG,KAAKgJ,MAKhBN,EAAW3O,UAAU8P,WAAa,WAC9B,OAAO7J,KAAK+I,UAKhBL,EAAW3O,UAAU+P,MAAQ,SAAUC,GACnC,IAAItF,EAAQzE,KACZ,OAAOA,KAAKgK,oBAAoBD,GAAS3K,MAAK,SAAU6K,GAEpD,OADAC,cAAcD,EAAOE,UACd1F,EAAM6E,cACRc,eACAC,MAAMN,GACN3K,MAAK,SAAUkL,GAAoB,OAAOL,EAAOM,OAASD,SAMvE5B,EAAW3O,UAAUsQ,MAAQ,SAAUN,GACnC,IAAItF,EAAQzE,KACZ,OAAOA,KAAK8J,MAAMC,GAAS3K,MAAK,SAAUoL,GAEtC,OADA/F,EAAMoF,aAAaY,SAAU,EACtBD,MAMf9B,EAAW3O,UAAU2Q,gBAAkB,WACnC,OAAO1K,KAAK4I,eAAiB,IAKjCF,EAAW3O,UAAU4Q,eAAiB,SAAUtC,GAC5C,IACI,OAAOrI,KAAK4I,cAAcP,EAAYuC,KAAO,KAEjD,MAAOnP,GAEH,OADA8M,EAAA,EAAOsC,KAAK,+BAAiCxC,EAAYuC,GAAK,4BACvD,OAIflC,EAAW3O,UAAUiQ,oBAAsB,SAAUD,GACjD,IAAItF,EAAQzE,KACZ,OAAO,IAAI,KAAY,SAAU8K,GAC7B,IAAIC,EAAS,EAETZ,EAAW,EACfD,cAAcC,GACdA,EAAWa,aAAY,WACdvG,EAAMoE,aAOPkC,GAXG,EAYChB,GAAWgB,GAAUhB,GACrBe,EAAQ,CACJX,SAAUA,EACVI,OAAO,KAVfO,EAAQ,CACJX,SAAUA,EACVI,OAAO,MAPR,OAuBnB7B,EAAW3O,UAAUuP,YAAc,WAC/B,OAAOtJ,KAAK8I,UAGhBJ,EAAW3O,UAAUkP,WAAa,WAC9B,OAAqC,IAA9BjJ,KAAK6J,aAAaY,cAAmCQ,IAAdjL,KAAKgJ,MAgBvDN,EAAW3O,UAAUmR,cAAgB,SAAUhI,EAAOiG,EAAOD,GACzD,IAAIjE,EAAKjF,KAAK6J,aAAcsB,EAAclG,EAAGkG,YAAaC,EAAUnG,EAAGmG,QAASC,EAAOpG,EAAGoG,KAAM1F,EAAKV,EAAGqG,eAAgBA,OAAwB,IAAP3F,EAAgB,IAAMA,EAC3J4F,EAAW,EAAiB,GAAIrI,QACP+H,IAAzBM,EAASJ,kBAA6CF,IAAhBE,IACtCI,EAASJ,YAAcA,QAEFF,IAArBM,EAASH,cAAqCH,IAAZG,IAClCG,EAASH,QAAUA,QAEDH,IAAlBM,EAASF,WAA+BJ,IAATI,IAC/BE,EAASF,KAAOA,GAEhBE,EAASvQ,UACTuQ,EAASvQ,QAAU,YAASuQ,EAASvQ,QAASsQ,IAElD,IAAIzN,EAAY0N,EAAS1N,WAAa0N,EAAS1N,UAAU2N,QAAUD,EAAS1N,UAAU2N,OAAO,GACzF3N,GAAaA,EAAUzD,QACvByD,EAAUzD,MAAQ,YAASyD,EAAUzD,MAAOkR,IAEhD,IAAIG,EAAUF,EAASE,QACnBA,GAAWA,EAAQC,MACnBD,EAAQC,IAAM,YAASD,EAAQC,IAAKJ,SAEdL,IAAtBM,EAASlC,WACTkC,EAASlC,SAAW,eAExBrJ,KAAK2L,iBAAiBJ,EAASK,KAE/B,IAAIpB,EAAS,IAAYM,QAAQS,GAOjC,OAJIpC,IAEAqB,EAASrB,EAAM0C,aAAaN,EAAUrC,IAEnCsB,GAMX9B,EAAW3O,UAAU4R,iBAAmB,SAAUG,GAC9C,IAAIC,EAAoB/R,OAAOQ,KAAKwF,KAAK4I,eACrCkD,GAAWC,EAAkB/P,OAAS,IACtC8P,EAAQpE,aAAeqE,IAgB/BrD,EAAW3O,UAAUyP,cAAgB,SAAUtG,EAAOgG,EAAMC,GACxD,IAAI1E,EAAQzE,KACRiF,EAAKjF,KAAK6J,aAAcmC,EAAa/G,EAAG+G,WAAYC,EAAahH,EAAGgH,WACxE,OAAKjM,KAAKiJ,aAKgB,iBAAfgD,GAA2BC,KAAKC,SAAWF,EAC3C,IAAYG,OAAO,qDAEvB,IAAI,KAAY,SAAUtB,EAASsB,GACtC3H,EAAMyG,cAAchI,EAAOiG,EAAOD,GAC7B9J,MAAK,SAAUmM,GAChB,GAAiB,OAAbA,EAAJ,CAIA,IAAI9B,EAAa8B,EACjB,IAEI,GAD0BrC,GAAQA,EAAKmD,OAAiC,IAAzBnD,EAAKmD,KAAKC,aAC7BN,EAGxB,OAFAvH,EAAM6E,cAAciD,UAAU9C,QAC9BqB,EAAQrB,GAGZ,IAAI+C,EAAmBR,EAAWT,EAAUrC,GAE5C,QAAgC,IAArBsD,EACPjE,EAAA,EAAOzN,MAAM,mEAEZ,GAAI,OAAA6O,EAAA,GAAW6C,GAChB/H,EAAMgI,uBAAuBD,EAAkB1B,EAASsB,OAEvD,CAED,GAAmB,QADnB3C,EAAa+C,GAIT,OAFAjE,EAAA,EAAOC,IAAI,2DACXsC,EAAQ,MAIZrG,EAAM6E,cAAciD,UAAU9C,GAC9BqB,EAAQrB,IAGhB,MAAO5L,GACH4G,EAAM5B,iBAAiBhF,EAAW,CAC9BwO,KAAM,CACFC,YAAY,GAEhBvJ,kBAAmBlF,IAEvBuO,EAAO,2DAtCPA,EAAO,6DAyCVhN,KAAK,MAAM,WACZgN,EAAO,2DArDJ,IAAYA,OAAO,0CA4DlC1D,EAAW3O,UAAU0S,uBAAyB,SAAUT,EAAYlB,EAASsB,GACzE,IAAI3H,EAAQzE,KACZgM,EACK5M,MAAK,SAAUsN,GACO,OAAnBA,GAKJjI,EAAM6E,cAAciD,UAAUG,GAC9B5B,EAAQ4B,IALJN,EAAO,yDAOVhN,KAAK,MAAM,SAAU8B,GACtBkL,EAAO,4BAA8BlL,OAGtCwH,EAtUoB,GChC3B,EAA+B,WAC/B,SAASiE,KAiBT,OAZAA,EAAc5S,UAAUwS,UAAY,SAAUK,GAC1C,OAAO,IAAY9B,QAAQ,CACvBpB,OAAQ,sEACRO,OAAQ7J,EAAOyM,WAMvBF,EAAc5S,UAAUsQ,MAAQ,SAAUuC,GACtC,OAAO,IAAY9B,SAAQ,IAExB6B,EAlBuB,GCG9B,EAA6B,WAE7B,SAASG,EAAYrF,GACjBzH,KAAK+I,SAAWtB,EACXzH,KAAK+I,SAAS3C,KACfmC,EAAA,EAAOsC,KAAK,kDAEhB7K,KAAK+M,WAAa/M,KAAKgN,kBAkC3B,OA7BAF,EAAY/S,UAAUiT,gBAAkB,WACpC,OAAO,IAAI,GAKfF,EAAY/S,UAAUwP,mBAAqB,SAAU0D,EAAYC,GAC7D,MAAM,IAAI,EAAY,yDAK1BJ,EAAY/S,UAAU6P,iBAAmB,SAAUuD,EAAUC,EAAQF,GACjE,MAAM,IAAI,EAAY,uDAK1BJ,EAAY/S,UAAUwS,UAAY,SAAUrJ,GACxClD,KAAK+M,WAAWR,UAAUrJ,GAAO9D,KAAK,MAAM,SAAUsK,GAClDnB,EAAA,EAAOzN,MAAM,8BAAgC4O,OAMrDoD,EAAY/S,UAAUqQ,aAAe,WACjC,OAAOpK,KAAK+M,YAETD,EAzCqB,GCsDzB,SAASO,IACZ,KAAM,UAAW,eACb,OAAO,EAEX,IAOI,OALA,IAAIC,QAEJ,IAAIC,QAAQ,IAEZ,IAAIC,UACG,EAEX,MAAOtM,GACH,OAAO,GAMf,SAASuM,GAAcC,GACnB,OAAOA,GAAQ,mDAAmDC,KAAKD,EAAKlS,YAuDzE,SAASoS,KAKZ,IAAKP,IACD,OAAO,EAEX,IAKI,OAHA,IAAIE,QAAQ,IAAK,CACbM,eAAgB,YAEb,EAEX,MAAO3M,GACH,OAAO,GCrJf,IAEI,GAAS,4IAIT4M,GAAQ,0KACRC,GAAQ,gHACRC,GAAY,gDACZC,GAAa,gCAEV,SAASC,GAAkBC,GAE9B,IAAIlT,EAAQ,KACRmT,EAAUD,GAAMA,EAAGE,YACvB,IAKI,GADApT,EA0GR,SAA6CkT,GACzC,IAAKA,IAAOA,EAAGG,WACX,OAAO,KAWX,IANA,IAKIC,EALAD,EAAaH,EAAGG,WAChBE,EAAe,8DACfC,EAAe,uGACfC,EAAQJ,EAAWvS,MAAM,MACzBd,EAAQ,GAEH0T,EAAO,EAAGA,EAAOD,EAAM1S,OAAQ2S,GAAQ,EAAG,CAE/C,IAAIC,EAAU,MACTL,EAAQC,EAAa9I,KAAKgJ,EAAMC,KACjCC,EAAU,CACNlD,IAAK6C,EAAM,GACXb,KAAMa,EAAM,GACZ7L,KAAM,GACNiM,MAAOJ,EAAM,GACbM,OAAQ,OAGNN,EAAQE,EAAa/I,KAAKgJ,EAAMC,OACtCC,EAAU,CACNlD,IAAK6C,EAAM,GACXb,KAAMa,EAAM,IAAMA,EAAM,GACxB7L,KAAM6L,EAAM,GAAKA,EAAM,GAAGxS,MAAM,KAAO,GACvC4S,MAAOJ,EAAM,GACbM,QAASN,EAAM,KAGnBK,KACKA,EAAQlB,MAAQkB,EAAQD,OACzBC,EAAQlB,KAjKD,KAmKXzS,EAAMqG,KAAKsN,IAGnB,IAAK3T,EAAMe,OACP,OAAO,KAEX,MAAO,CACHhB,QAAS8T,GAAeX,GACxBxU,KAAMwU,EAAGxU,KACTsB,MAAOA,GAzJC8T,CAAoCZ,GAExC,OAAOa,GAAU/T,EAAOmT,GAGhC,MAAOlN,IAGP,IAEI,GADAjG,EAiBR,SAAwCkT,GAEpC,IAAKA,IAAOA,EAAGlT,MACX,OAAO,KAQX,IANA,IAGIgU,EACAV,EACAK,EALA3T,EAAQ,GACRyT,EAAQP,EAAGlT,MAAMc,MAAM,MAKlBb,EAAI,EAAGA,EAAIwT,EAAM1S,SAAUd,EAAG,CACnC,GAAKqT,EAAQ,GAAO7I,KAAKgJ,EAAMxT,IAAM,CACjC,IAAIgU,EAAWX,EAAM,IAAqC,IAA/BA,EAAM,GAAGvG,QAAQ,UACnCuG,EAAM,IAAmC,IAA7BA,EAAM,GAAGvG,QAAQ,UACvBiH,EAAWhB,GAAWvI,KAAK6I,EAAM,OAE5CA,EAAM,GAAKU,EAAS,GACpBV,EAAM,GAAKU,EAAS,GACpBV,EAAM,GAAKU,EAAS,IAExBL,EAAU,CACNlD,IAAK6C,EAAM,GACXb,KAAMa,EAAM,IApEL,IAqEP7L,KAAMwM,EAAW,CAACX,EAAM,IAAM,GAC9BI,KAAMJ,EAAM,IAAMA,EAAM,GAAK,KAC7BM,OAAQN,EAAM,IAAMA,EAAM,GAAK,WAGlC,GAAKA,EAAQR,GAAMrI,KAAKgJ,EAAMxT,IAC/B0T,EAAU,CACNlD,IAAK6C,EAAM,GACXb,KAAMa,EAAM,IA7EL,IA8EP7L,KAAM,GACNiM,MAAOJ,EAAM,GACbM,OAAQN,EAAM,IAAMA,EAAM,GAAK,UAGlC,MAAKA,EAAQT,GAAMpI,KAAKgJ,EAAMxT,KAyB/B,SAxBSqT,EAAM,IAAMA,EAAM,GAAGvG,QAAQ,YAAc,IACrCiH,EAAWjB,GAAUtI,KAAK6I,EAAM,MAE3CA,EAAM,GAAKA,EAAM,IAAM,OACvBA,EAAM,GAAKU,EAAS,GACpBV,EAAM,GAAKU,EAAS,GACpBV,EAAM,GAAK,IAEA,IAANrT,GAAYqT,EAAM,SAA0B,IAApBJ,EAAGgB,eAKhClU,EAAM,GAAG4T,OAASV,EAAGgB,aAAe,GAExCP,EAAU,CACNlD,IAAK6C,EAAM,GACXb,KAAMa,EAAM,IArGL,IAsGP7L,KAAM6L,EAAM,GAAKA,EAAM,GAAGxS,MAAM,KAAO,GACvC4S,KAAMJ,EAAM,IAAMA,EAAM,GAAK,KAC7BM,OAAQN,EAAM,IAAMA,EAAM,GAAK,OAMlCK,EAAQlB,MAAQkB,EAAQD,OACzBC,EAAQlB,KA/GG,KAiHfzS,EAAMqG,KAAKsN,GAEf,IAAK3T,EAAMe,OACP,OAAO,KAEX,MAAO,CACHhB,QAAS8T,GAAeX,GACxBxU,KAAMwU,EAAGxU,KACTsB,MAAOA,GA7FCmU,CAA+BjB,GAEnC,OAAOa,GAAU/T,EAAOmT,GAGhC,MAAOlN,IAGP,MAAO,CACHlG,QAAS8T,GAAeX,GACxBxU,KAAMwU,GAAMA,EAAGxU,KACfsB,MAAO,GACPoU,QAAQ,GAwIhB,SAASL,GAAUV,EAAYF,GAC3B,IACI,OAAO,EAAiB,GAAIE,EAAY,CAAErT,MAAOqT,EAAWrT,MAAMgD,MAAMmQ,KAE5E,MAAOlN,GACH,OAAOoN,GAQf,SAASQ,GAAeX,GACpB,IAAInT,EAAUmT,GAAMA,EAAGnT,QACvB,OAAKA,EAGDA,EAAQF,OAA0C,iBAA1BE,EAAQF,MAAME,QAC/BA,EAAQF,MAAME,QAElBA,EALI,mBC3LR,SAASsU,GAAwBhB,GACpC,IAAIiB,EAASC,GAAsBlB,EAAWrT,OAC1C4C,EAAY,CACZvC,KAAMgT,EAAW3U,KACjBS,MAAOkU,EAAWtT,SAStB,OAPIuU,GAAUA,EAAOvT,SACjB6B,EAAUyQ,WAAa,CAAEiB,OAAQA,SAGdtE,IAAnBpN,EAAUvC,MAA0C,KAApBuC,EAAUzD,QAC1CyD,EAAUzD,MAAQ,8BAEfyD,EA+BJ,SAAS4R,GAAoBnB,GAEhC,MAAO,CACHzQ,UAAW,CACP2N,OAAQ,CAHA8D,GAAwBhB,MAUrC,SAASkB,GAAsBvU,GAClC,IAAKA,IAAUA,EAAMe,OACjB,MAAO,GAEX,IAAI0T,EAAazU,EACb0U,EAAqBD,EAAW,GAAGhC,MAAQ,GAC3CkC,EAAoBF,EAAWA,EAAW1T,OAAS,GAAG0R,MAAQ,GAUlE,OARsD,IAAlDiC,EAAmB3H,QAAQ,oBAAgF,IAApD2H,EAAmB3H,QAAQ,sBAClF0H,EAAaA,EAAWzR,MAAM,KAGkB,IAAhD2R,EAAkB5H,QAAQ,mBAC1B0H,EAAaA,EAAWzR,MAAM,GAAI,IAG/ByR,EACFjV,KAAI,SAAUoV,GAAS,MAAO,CAC/BC,MAAwB,OAAjBD,EAAMhB,YAAkB5D,EAAY4E,EAAMhB,OACjDkB,SAAUF,EAAMnE,KAAOgE,EAAW,GAAGhE,IACrCsE,SAAUH,EAAMnC,MAAQ,IACxBuC,QAAQ,EACRC,OAAuB,OAAfL,EAAMlB,UAAgB1D,EAAY4E,EAAMlB,SAE/C1Q,MAAM,EArFQ,IAsFdkS,UCpFF,SAASC,GAAsBvS,EAAWiF,EAAoB2E,GAEjE,IAAIvE,EACJ,QAFgB,IAAZuE,IAAsBA,EAAU,IAEhC,OAAAkC,EAAA,GAAa9L,IAAcA,EAAU/C,MAKrC,OADAoI,EAAQuM,GAAoBvB,GAD5BrQ,EADiBA,EACM/C,QAI3B,GAAI,OAAA6O,EAAA,GAAW9L,IAAc,OAAA8L,EAAA,GAAe9L,GAAY,CAKpD,IAAIwS,EAAexS,EACfyS,EAASD,EAAa1W,OAAS,OAAAgQ,EAAA,GAAW0G,GAAgB,WAAa,gBACvErV,EAAUqV,EAAarV,QAAUsV,EAAS,KAAOD,EAAarV,QAAUsV,EAG5E,OAFApN,EAAQqN,GAAgBvV,EAAS8H,EAAoB2E,GACrD,YAAsBvE,EAAOlI,GACtBkI,EAEX,OAAI,OAAAyG,EAAA,GAAQ9L,GAERqF,EAAQuM,GAAoBvB,GAAkBrQ,IAG9C,OAAA8L,EAAA,GAAc9L,IAAc,OAAA8L,EAAA,GAAQ9L,IAKpCqF,EDVD,SAA8BrF,EAAWiF,EAAoB0N,GAChE,IAAItN,EAAQ,CACRrF,UAAW,CACP2N,OAAQ,CACJ,CACIlQ,KAAM,OAAAqO,EAAA,GAAQ9L,GAAaA,EAAUoC,YAAYtG,KAAO6W,EAAY,qBAAuB,QAC3FpW,MAAO,cAAgBoW,EAAY,oBAAsB,aAAe,wBAA0B,YAA+B3S,MAI7IiG,MAAO,CACH2M,eAAgB,YAAgB5S,KAGxC,GAAIiF,EAAoB,CACpB,IACI4N,EAAWlB,GADEtB,GAAkBpL,GACa7H,OAChDiI,EAAMoL,WAAa,CACfiB,OAAQmB,GAGhB,OAAOxN,ECXKyN,CADc9S,EACwBiF,EAAoB2E,EAAQ+I,WAC1E,YAAsBtN,EAAO,CACzB0N,WAAW,IAER1N,IAWXA,EAAQqN,GAAgB1S,EAAWiF,EAAoB2E,GACvD,YAAsBvE,EAAO,GAAKrF,OAAWoN,GAC7C,YAAsB/H,EAAO,CACzB0N,WAAW,IAER1N,GAIJ,SAASqN,GAAgB7S,EAAOoF,EAAoB2E,QACvC,IAAZA,IAAsBA,EAAU,IACpC,IAAIvE,EAAQ,CACRlI,QAAS0C,GAEb,GAAI+J,EAAQoJ,kBAAoB/N,EAAoB,CAChD,IACI4N,EAAWlB,GADEtB,GAAkBpL,GACa7H,OAChDiI,EAAMoL,WAAa,CACfiB,OAAQmB,GAGhB,OAAOxN,ECrEX,ICHI4N,GDGA,GAA+B,WAC/B,SAASC,EAAcC,GACnBhR,KAAKgR,OAASA,EAEdhR,KAAKiR,QAAU,GAwEnB,OAnEAF,EAAchX,UAAUmX,QAAU,WAC9B,YAAuBjG,IAAhBjL,KAAKgR,QAAwBhR,KAAKhE,SAAWgE,KAAKgR,QAQ7DD,EAAchX,UAAUoX,IAAM,SAAUC,GACpC,IAAI3M,EAAQzE,KACZ,OAAKA,KAAKkR,YAG0B,IAAhClR,KAAKiR,QAAQjJ,QAAQoJ,IACrBpR,KAAKiR,QAAQ3P,KAAK8P,GAEtBA,EACKhS,MAAK,WAAc,OAAOqF,EAAM4M,OAAOD,MACvChS,KAAK,MAAM,WACZ,OAAOqF,EAAM4M,OAAOD,GAAMhS,KAAK,MAAM,kBAKlCgS,GAbI,IAAYhF,OAAO,IAAI,EAAY,qDAqBlD2E,EAAchX,UAAUsX,OAAS,SAAUD,GAEvC,OADkBpR,KAAKiR,QAAQ9I,OAAOnI,KAAKiR,QAAQjJ,QAAQoJ,GAAO,GAAG,IAMzEL,EAAchX,UAAUiC,OAAS,WAC7B,OAAOgE,KAAKiR,QAAQjV,QAQxB+U,EAAchX,UAAUuX,MAAQ,SAAUvH,GACtC,IAAItF,EAAQzE,KACZ,OAAO,IAAI,KAAY,SAAU8K,GAC7B,IAAIyG,EAAqBC,YAAW,WAC5BzH,GAAWA,EAAU,GACrBe,GAAQ,KAEbf,GACH,IAAY0H,IAAIhN,EAAMwM,SACjB7R,MAAK,WACNsS,aAAaH,GACbzG,GAAQ,MAEP1L,KAAK,MAAM,WACZ0L,GAAQ,UAIbiG,EA5EuB,GEA9B,GAA+B,WAC/B,SAASY,EAAclK,GACnBzH,KAAKyH,QAAUA,EAEfzH,KAAKiR,QAAU,IAAI,GAAc,IACjCjR,KAAK0L,IAAM,IAAI,EAAI1L,KAAKyH,QAAQrB,KAAKM,qCAczC,OATAiL,EAAc5X,UAAUwS,UAAY,SAAUK,GAC1C,MAAM,IAAI,EAAY,wDAK1B+E,EAAc5X,UAAUsQ,MAAQ,SAAUN,GACtC,OAAO/J,KAAKiR,QAAQK,MAAMvH,IAEvB4H,EAnBuB,GCC9B,GAAS,cAET,GAAgC,SAAUrN,GAE1C,SAASsN,IACL,IAAInN,EAAmB,OAAXH,GAAmBA,EAAO3D,MAAMX,KAAMU,YAAcV,KAGhE,OADAyE,EAAMoN,eAAiB,IAAIC,KAAKA,KAAKC,OAC9BtN,EA0CX,OA/CA,EAAkBmN,EAAgBtN,GAUlCsN,EAAe7X,UAAUwS,UAAY,SAAUrJ,GAC3C,IAAIuB,EAAQzE,KACZ,GAAI,IAAI8R,KAAKA,KAAKC,OAAS/R,KAAK6R,eAC5B,OAAOG,QAAQ5F,OAAO,CAClBlJ,MAAOA,EACPwG,OAAQ,yBAA2B1J,KAAK6R,eAAiB,6BACzD5H,OAAQ,MAGhB,IAAIgI,EAAiB,CACjBC,KAAMhW,KAAKC,UAAU+G,GACrBT,OAAQ,OAKRoL,eAAiBD,KAA2B,SAAW,IAE3D,OAAO5N,KAAKiR,QAAQE,IAAI,IAAI,KAAY,SAAUrG,EAASsB,GACvD,GACK+F,MAAM1N,EAAMiH,IAAKuG,GACjB7S,MAAK,SAAUgT,GAChB,IAAInI,EAAS7J,EAAO6B,aAAamQ,EAASnI,QAC1C,GAAIA,IAAW7J,EAAO+B,QAAtB,CAIA,GAAI8H,IAAW7J,EAAOgC,UAAW,CAC7B,IAAI2P,EAAMD,KAAKC,MACftN,EAAMoN,eAAiB,IAAIC,KAAKC,EAAM,YAAsBA,EAAKK,EAASC,QAAQC,IAAI,iBACtF/J,EAAA,EAAOsC,KAAK,wCAA0CpG,EAAMoN,gBAEhEzF,EAAOgG,QARHtH,EAAQ,CAAEb,OAAQA,OAUrBsI,MAAMnG,QAGZwF,EAhDwB,CAiDjC,IClDE,GAA8B,SAAUtN,GAExC,SAASkO,IACL,IAAI/N,EAAmB,OAAXH,GAAmBA,EAAO3D,MAAMX,KAAMU,YAAcV,KAGhE,OADAyE,EAAMoN,eAAiB,IAAIC,KAAKA,KAAKC,OAC9BtN,EAoCX,OAzCA,EAAkB+N,EAAclO,GAUhCkO,EAAazY,UAAUwS,UAAY,SAAUrJ,GACzC,IAAIuB,EAAQzE,KACZ,OAAI,IAAI8R,KAAKA,KAAKC,OAAS/R,KAAK6R,eACrBG,QAAQ5F,OAAO,CAClBlJ,MAAOA,EACPwG,OAAQ,yBAA2B1J,KAAK6R,eAAiB,6BACzD5H,OAAQ,MAGTjK,KAAKiR,QAAQE,IAAI,IAAI,KAAY,SAAUrG,EAASsB,GACvD,IAAIX,EAAU,IAAIgH,eAClBhH,EAAQiH,mBAAqB,WACzB,GAA2B,IAAvBjH,EAAQkH,WAAZ,CAGA,IAAI1I,EAAS7J,EAAO6B,aAAawJ,EAAQxB,QACzC,GAAIA,IAAW7J,EAAO+B,QAAtB,CAIA,GAAI8H,IAAW7J,EAAOgC,UAAW,CAC7B,IAAI2P,EAAMD,KAAKC,MACftN,EAAMoN,eAAiB,IAAIC,KAAKC,EAAM,YAAsBA,EAAKtG,EAAQmH,kBAAkB,iBAC3FrK,EAAA,EAAOsC,KAAK,wCAA0CpG,EAAMoN,gBAEhEzF,EAAOX,QARHX,EAAQ,CAAEb,OAAQA,MAU1BwB,EAAQoH,KAAK,OAAQpO,EAAMiH,KAC3BD,EAAQqH,KAAK5W,KAAKC,UAAU+G,SAG7BsP,EA1CsB,CA2C/B,ICtCE,GAAgC,SAAUlO,GAE1C,SAASyO,IACL,OAAkB,OAAXzO,GAAmBA,EAAO3D,MAAMX,KAAMU,YAAcV,KAoD/D,OAtDA,EAAkB+S,EAAgBzO,GAOlCyO,EAAehZ,UAAUiT,gBAAkB,WACvC,IAAKhN,KAAK+I,SAAS3C,IAEf,OAAO9B,EAAOvK,UAAUiT,gBAAgB5R,KAAK4E,MAEjD,IAAIgT,EAAmB,EAAiB,GAAIhT,KAAK+I,SAASiK,iBAAkB,CAAE5M,IAAKpG,KAAK+I,SAAS3C,MACjG,OAAIpG,KAAK+I,SAASkK,UACP,IAAIjT,KAAK+I,SAASkK,UAAUD,GAEnC3F,IACO,IAAI,GAAe2F,GAEvB,IAAI,GAAaA,IAK5BD,EAAehZ,UAAUwP,mBAAqB,SAAU1L,EAAWqL,GAC/D,IACIhG,EAAQkN,GAAsBvS,EADRqL,GAAQA,EAAKpG,yBAAuBmI,EACG,CAC7D4F,iBAAkB7Q,KAAK+I,SAAS8H,mBAUpC,OARA,YAAsB3N,EAAO,CACzBgQ,SAAS,EACT5X,KAAM,YAEV4H,EAAMxB,MAAQvB,EAAS7B,MACnB4K,GAAQA,EAAKG,WACbnG,EAAMmG,SAAWH,EAAKG,UAEnB,IAAYyB,QAAQ5H,IAK/B6P,EAAehZ,UAAU6P,iBAAmB,SAAU5O,EAAS0G,EAAOwH,QACpD,IAAVxH,IAAoBA,EAAQvB,EAASyB,MACzC,IACIsB,EAAQqN,GAAgBvV,EADFkO,GAAQA,EAAKpG,yBAAuBmI,EACL,CACrD4F,iBAAkB7Q,KAAK+I,SAAS8H,mBAMpC,OAJA3N,EAAMxB,MAAQA,EACVwH,GAAQA,EAAKG,WACbnG,EAAMmG,SAAWH,EAAKG,UAEnB,IAAYyB,QAAQ5H,IAExB6P,EAvDwB,CAwDjC,GClESI,GAAW,4BCWlB,GAA+B,SAAU7O,GAOzC,SAAS8O,EAAc3L,GAEnB,YADgB,IAAZA,IAAsBA,EAAU,IAC7BnD,EAAOlJ,KAAK4E,KAAM,GAAgByH,IAAYzH,KAgDzD,OAxDA,EAAkBoT,EAAe9O,GAajC8O,EAAcrZ,UAAUmR,cAAgB,SAAUhI,EAAOiG,EAAOD,GAQ5D,OAPAhG,EAAMmQ,SAAWnQ,EAAMmQ,UAAY,aACnCnQ,EAAM0I,IAAM,EAAiB,GAAI1I,EAAM0I,IAAK,CAAEjS,KAAMwZ,GAAUG,SAAU,EAAmBpQ,EAAM0I,KAAO1I,EAAM0I,IAAI0H,UAAa,GAAK,CAC5H,CACI3Z,KAAM,sBACN4Z,QD7BK,YC+BTA,QD/BS,WCgCVjP,EAAOvK,UAAUmR,cAAc9P,KAAK4E,KAAMkD,EAAOiG,EAAOD,IAOnEkK,EAAcrZ,UAAUyZ,iBAAmB,SAAU/L,QACjC,IAAZA,IAAsBA,EAAU,IAEpC,IAAI5K,EAAW,cAAkBA,SACjC,GAAKA,EAGL,GAAKmD,KAAKiJ,aAAV,CAIA,IAAI7C,EAAMqB,EAAQrB,KAAOpG,KAAKsG,SAC9B,GAAKmB,EAAQ2B,QAIb,GAAKhD,EAAL,CAIA,IAAIqN,EAAS5W,EAAS6W,cAAc,UACpCD,EAAOE,OAAQ,EACfF,EAAOG,IAAM,IAAI,EAAIxN,GAAKc,wBAAwBO,GAC9CA,EAAQoM,SACRJ,EAAOK,OAASrM,EAAQoM,SAE3BhX,EAASkX,MAAQlX,EAASqV,MAAM8B,YAAYP,QATzClL,EAAA,EAAOzN,MAAM,sDAJbyN,EAAA,EAAOzN,MAAM,0DALbyN,EAAA,EAAOzN,MAAM,mEAoBdsY,EAzDuB,CA0DhC,GNnEEa,GAAkC,WAClC,SAASA,IAILjU,KAAKrG,KAAOsa,EAAiBrJ,GAqBjC,OAhBAqJ,EAAiBla,UAAUuO,UAAY,WACnCwI,GAA2BoD,SAASna,UAAUyB,SAC9C0Y,SAASna,UAAUyB,SAAW,WAE1B,IADA,IAAIkH,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAIa,EAAUxD,KAAK9F,qBAAuB8F,KAE1C,OAAO8Q,GAAyBnQ,MAAM6C,EAASd,KAMvDuR,EAAiBrJ,GAAK,mBACfqJ,EA1B0B,GOGjCE,GAAwB,CAAC,oBAAqB,iDAE9C,GAAgC,WAChC,SAASC,EAAerL,QACH,IAAbA,IAAuBA,EAAW,IACtC/I,KAAK+I,SAAWA,EAIhB/I,KAAKrG,KAAOya,EAAexJ,GA6I/B,OAxIAwJ,EAAera,UAAUuO,UAAY,WACjC,aAAwB,SAAUpF,GAC9B,IAAIN,EAAM,cACV,IAAKA,EACD,OAAOM,EAEX,IAAImR,EAAOzR,EAAI+H,eAAeyJ,GAC9B,GAAIC,EAAM,CACN,IAAIC,EAAS1R,EAAI2R,YACbC,EAAgBF,EAASA,EAAOzK,aAAe,GAC/CpC,EAAU4M,EAAKI,cAAcD,GACjC,GAAIH,EAAKK,iBAAiBxR,EAAOuE,GAC7B,OAAO,KAGf,OAAOvE,MAIfkR,EAAera,UAAU2a,iBAAmB,SAAUxR,EAAOuE,GACzD,OAAIzH,KAAK2U,eAAezR,EAAOuE,IAC3Bc,EAAA,EAAOsC,KAAK,6DAA+D,YAAoB3H,KACxF,GAEPlD,KAAK4U,gBAAgB1R,EAAOuE,IAC5Bc,EAAA,EAAOsC,KAAK,wEAA0E,YAAoB3H,KACnG,GAEPlD,KAAK6U,kBAAkB3R,EAAOuE,IAC9Bc,EAAA,EAAOsC,KAAK,yEAA2E,YAAoB3H,GAAS,WAAalD,KAAK8U,mBAAmB5R,KAClJ,IAENlD,KAAK+U,kBAAkB7R,EAAOuE,KAC/Bc,EAAA,EAAOsC,KAAK,6EAA+E,YAAoB3H,GAAS,WAAalD,KAAK8U,mBAAmB5R,KACtJ,IAKfkR,EAAera,UAAU4a,eAAiB,SAAUzR,EAAOuE,GAEvD,QADgB,IAAZA,IAAsBA,EAAU,KAC/BA,EAAQuN,eACT,OAAO,EAEX,IACI,OAAS9R,GACLA,EAAMrF,WACNqF,EAAMrF,UAAU2N,QAChBtI,EAAMrF,UAAU2N,OAAO,IACY,gBAAnCtI,EAAMrF,UAAU2N,OAAO,GAAGlQ,OAC1B,EAER,MAAOG,GACH,OAAO,IAIf2Y,EAAera,UAAU6a,gBAAkB,SAAU1R,EAAOuE,GAExD,YADgB,IAAZA,IAAsBA,EAAU,OAC/BA,EAAQwN,eAAiBxN,EAAQwN,aAAajZ,SAG5CgE,KAAKkV,0BAA0BhS,GAAOiS,MAAK,SAAUna,GAExD,OAAOyM,EAAQwN,aAAaE,MAAK,SAAUC,GAAW,OAAO,YAAkBpa,EAASoa,UAIhGhB,EAAera,UAAU8a,kBAAoB,SAAU3R,EAAOuE,GAG1D,QAFgB,IAAZA,IAAsBA,EAAU,KAE/BA,EAAQ4N,gBAAkB5N,EAAQ4N,cAAcrZ,OACjD,OAAO,EAEX,IAAI0P,EAAM1L,KAAK8U,mBAAmB5R,GAClC,QAAQwI,GAAcjE,EAAQ4N,cAAcF,MAAK,SAAUC,GAAW,OAAO,YAAkB1J,EAAK0J,OAGxGhB,EAAera,UAAUgb,kBAAoB,SAAU7R,EAAOuE,GAG1D,QAFgB,IAAZA,IAAsBA,EAAU,KAE/BA,EAAQ6N,gBAAkB7N,EAAQ6N,cAActZ,OACjD,OAAO,EAEX,IAAI0P,EAAM1L,KAAK8U,mBAAmB5R,GAClC,OAAQwI,GAAajE,EAAQ6N,cAAcH,MAAK,SAAUC,GAAW,OAAO,YAAkB1J,EAAK0J,OAGvGhB,EAAera,UAAU0a,cAAgB,SAAUD,GAE/C,YADsB,IAAlBA,IAA4BA,EAAgB,IACzC,CACHa,cAAe,EAAkBrV,KAAK+I,SAASsM,eAAiB,GAAMb,EAAca,eAAiB,IACrGJ,aAAc,EAAkBjV,KAAK+I,SAASkM,cAAgB,GAAMT,EAAcS,cAAgB,GAAKd,IACvGa,oBAAwD,IAAjChV,KAAK+I,SAASiM,gBAAiChV,KAAK+I,SAASiM,eACpFM,cAAe,EAAkBtV,KAAK+I,SAASuM,eAAiB,GAAMd,EAAcc,eAAiB,MAI7GlB,EAAera,UAAUmb,0BAA4B,SAAUhS,GAC3D,GAAIA,EAAMlI,QACN,MAAO,CAACkI,EAAMlI,SAElB,GAAIkI,EAAMrF,UACN,IACI,IAAIoH,EAAM/B,EAAMrF,UAAU2N,QAAUtI,EAAMrF,UAAU2N,OAAO,IAAO,GAAI7F,EAAKV,EAAG3J,KAAMA,OAAc,IAAPqK,EAAgB,GAAKA,EAAIC,EAAKX,EAAG7K,MAAOA,OAAe,IAAPwL,EAAgB,GAAKA,EAChK,MAAO,CAAC,GAAKxL,EAAOkB,EAAO,KAAOlB,GAEtC,MAAOmb,GAEH,OADAhN,EAAA,EAAOzN,MAAM,oCAAsC,YAAoBoI,IAChE,GAGf,MAAO,IAGXkR,EAAera,UAAU+a,mBAAqB,SAAU5R,GACpD,IACI,GAAIA,EAAMoL,WAAY,CAClB,IAAIoC,EAAWxN,EAAMoL,WAAWiB,OAChC,OAAQmB,GAAYA,EAASA,EAAS1U,OAAS,GAAG+T,UAAa,KAEnE,GAAI7M,EAAMrF,UAAW,CACjB,IAAI2X,EAAWtS,EAAMrF,UAAU2N,QAAUtI,EAAMrF,UAAU2N,OAAO,GAAG8C,YAAcpL,EAAMrF,UAAU2N,OAAO,GAAG8C,WAAWiB,OACtH,OAAQiG,GAAYA,EAASA,EAASxZ,OAAS,GAAG+T,UAAa,KAEnE,OAAO,KAEX,MAAOwF,GAEH,OADAhN,EAAA,EAAOzN,MAAM,gCAAkC,YAAoBoI,IAC5D,OAMfkR,EAAexJ,GAAK,iBACbwJ,EApJwB,GCJnC,IAAIqB,GAAgB,EAIb,SAASC,KACZ,OAAOD,GAAgB,EAKpB,SAASE,KAEZF,IAAiB,EACjBjE,YAAW,WACPiE,IAAiB,KAWlB,SAASG,GAAKC,EAAIpO,EAASqO,GAG9B,QAFgB,IAAZrO,IAAsBA,EAAU,IAElB,mBAAPoO,EACP,OAAOA,EAEX,IAEI,GAAIA,EAAGvJ,WACH,OAAOuJ,EAGX,GAAIA,EAAGE,mBACH,OAAOF,EAAGE,mBAGlB,MAAO7U,GAIH,OAAO2U,EAEX,IAAIG,EAAgB,WAChB,IAAItT,EAAOrF,MAAMtD,UAAUkE,MAAM7C,KAAKsF,WAEtC,IAEQoV,GAA4B,mBAAXA,GACjBA,EAAOnV,MAAMX,KAAMU,WAEvB,IAAIuV,EAAmBvT,EAAKjI,KAAI,SAAUyb,GAAO,OAAON,GAAKM,EAAKzO,MAClE,OAAIoO,EAAGM,YAKIN,EAAGM,YAAYxV,MAAMX,KAAMiW,GAM/BJ,EAAGlV,MAAMX,KAAMiW,GAG1B,MAAO9H,GAcH,MAbAwH,KACAzR,GAAU,SAAUiF,GAChBA,EAAMiN,mBAAkB,SAAUlT,GAC9B,IAAIwJ,EAAiB,EAAiB,GAAIxJ,GAM1C,OALIuE,EAAQ4O,YACR,YAAsB3J,OAAgBzB,OAAWA,GACjD,YAAsByB,EAAgBjF,EAAQ4O,YAElD3J,EAAe5I,MAAQ,EAAiB,GAAI4I,EAAe5I,MAAO,CAAEpD,UAAW,YAAUgC,EAAM,KACxFgK,KAEX7J,EAAiBsL,MAEfA,IAKd,IACI,IAAK,IAAImI,KAAYT,EACb7b,OAAOD,UAAUoB,eAAeC,KAAKya,EAAIS,KACzCN,EAAcM,GAAYT,EAAGS,IAIzC,MAAO7a,IACPoa,EAAG9b,UAAY8b,EAAG9b,WAAa,GAC/Bic,EAAcjc,UAAY8b,EAAG9b,UAC7BC,OAAOuc,eAAeV,EAAI,qBAAsB,CAC5C1b,YAAY,EACZC,MAAO4b,IAIXhc,OAAOC,iBAAiB+b,EAAe,CACnC1J,WAAY,CACRnS,YAAY,EACZC,OAAO,GAEXF,oBAAqB,CACjBC,YAAY,EACZC,MAAOyb,KAIf,IACqB7b,OAAOwc,yBAAyBR,EAAe,QACjDS,cACXzc,OAAOuc,eAAeP,EAAe,OAAQ,CACzC1D,IAAK,WACD,OAAOuD,EAAGlc,QAK1B,MAAO8B,IAGP,OAAOua,ECjIX,ICwOIU,GDxOA,GAA0B,WAC1B,SAASC,IAEL3W,KAAK4W,eAAiB,EAItB5W,KAAKrG,KAAOgd,EAAS/L,GA2LzB,OAxLA+L,EAAS5c,UAAU8c,kBAAoB,SAAUhd,GAC7C,OAAO,WAEH,IADA,IAAI6I,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAImU,EAAmBpU,EAAK,GAQ5B,OAPAA,EAAK,GAAKkT,GAAKkB,EAAkB,CAC7BT,UAAW,CACPhK,KAAM,CAAE2D,SAAU,YAAgBnW,IAClCqZ,SAAS,EACT5X,KAAM,gBAGPzB,EAAS8G,MAAMX,KAAM0C,KAIpCiU,EAAS5c,UAAUgd,SAAW,SAAUld,GACpC,OAAO,SAAUuJ,GACb,OAAOvJ,EAAS+b,GAAKxS,EAAU,CAC3BiT,UAAW,CACPhK,KAAM,CACF2D,SAAU,wBACVgH,QAAS,YAAgBnd,IAE7BqZ,SAAS,EACT5X,KAAM,mBAMtBqb,EAAS5c,UAAUkd,iBAAmB,SAAU1b,GAC5C,IAAIoB,EAAS,cACTyH,EAAQzH,EAAOpB,IAAWoB,EAAOpB,GAAQxB,UACxCqK,GAAUA,EAAMjJ,gBAAmBiJ,EAAMjJ,eAAe,sBAG7D,YAAKiJ,EAAO,oBAAoB,SAAUvK,GACtC,OAAO,SAAUqd,EAAWrB,EAAIpO,GAC5B,IAEkC,mBAAnBoO,EAAGM,cACVN,EAAGM,YAAcP,GAAKC,EAAGM,YAAYgB,KAAKtB,GAAK,CAC3CQ,UAAW,CACPhK,KAAM,CACF2D,SAAU,cACVgH,QAAS,YAAgBnB,GACzBta,OAAQA,GAEZ2X,SAAS,EACT5X,KAAM,iBAKtB,MAAOP,IAGP,OAAOlB,EAASuB,KAAK4E,KAAMkX,EAAWtB,GAAKC,EAAI,CAC3CQ,UAAW,CACPhK,KAAM,CACF2D,SAAU,mBACVgH,QAAS,YAAgBnB,GACzBta,OAAQA,GAEZ2X,SAAS,EACT5X,KAAM,gBAEVmM,OAGZ,YAAKrD,EAAO,uBAAuB,SAAUvK,GACzC,OAAO,SAAUqd,EAAWrB,EAAIpO,GAC5B,IAAIrE,EAAWyS,EACf,IACIzS,EAAWA,IAAaA,EAAS2S,oBAAsB3S,GAE3D,MAAOlC,IAGP,OAAOrH,EAASuB,KAAK4E,KAAMkX,EAAW9T,EAAUqE,SAK5DkP,EAAS5c,UAAUqd,SAAW,SAAUC,GACpC,OAAO,WAGH,IAFA,IAAI5S,EAAQzE,KACR0C,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAI2U,EAAMtX,KACNuX,EAAsB,CAAC,SAAU,UAAW,cAqChD,OApCAA,EAAoBxR,SAAQ,SAAU1B,GAC9BA,KAAQI,GAAgC,mBAAhBA,EAAMJ,IAC9B,YAAKI,EAAOJ,GAAM,SAAUxK,GACxB,OAAO+b,GAAK/b,EAAU,CAClBwc,UAAW,CACPhK,KAAM,CACF2D,SAAU3L,EACV2S,QAAS,YAAgBnd,IAE7BqZ,SAAS,EACT5X,KAAM,sBAMtB,uBAAwBgc,GAAyC,mBAA3BA,EAAI5E,oBAC1C,YAAK4E,EAAK,sBAAsB,SAAUzd,GACtC,IAAI2d,EAAc,CACdnB,UAAW,CACPhK,KAAM,CACF2D,SAAU,qBACVgH,QAAS,YAAgBnd,IAE7BqZ,SAAS,EACT5X,KAAM,eAQd,OAJIzB,EAASK,sBACTsd,EAAYnB,UAAUhK,KAAK2K,QAAU,YAAgBnd,EAASK,sBAG3D0b,GAAK/b,EAAU2d,MAGvBH,EAAa1W,MAAMX,KAAM0C,KAOxCiU,EAAS5c,UAAUuO,UAAY,WAC3BtI,KAAK4W,eAAiB5W,KAAK4W,eAC3B,IAAIja,EAAS,cACb,YAAKA,EAAQ,aAAcqD,KAAK6W,kBAAkBM,KAAKnX,OACvD,YAAKrD,EAAQ,cAAeqD,KAAK6W,kBAAkBM,KAAKnX,OACxD,YAAKrD,EAAQ,wBAAyBqD,KAAK+W,SAASI,KAAKnX,OACrD,mBAAoBrD,GACpB,YAAK8V,eAAe1Y,UAAW,OAAQiG,KAAKoX,SAASD,KAAKnX,OAE9D,CACI,cACA,SACA,OACA,mBACA,iBACA,oBACA,kBACA,cACA,aACA,qBACA,cACA,aACA,iBACA,eACA,kBACA,cACA,cACA,eACA,qBACA,SACA,YACA,eACA,gBACA,YACA,kBACA,SACA,iBACA,4BACA,wBACF+F,QAAQ/F,KAAKiX,iBAAiBE,KAAKnX,QAKzC2W,EAAS/L,GAAK,WACP+L,EAlMkB,GCIzB,GAAS,cASTc,GAAW,GACXC,GAAe,GAEnB,SAASC,GAAWrc,GAChB,IAAIoc,GAAapc,GAIjB,OADAoc,GAAapc,IAAQ,EACbA,GACJ,IAAK,WA2Db,WACI,KAAM,YAAa,IACf,OAEJ,CAAC,QAAS,OAAQ,OAAQ,QAAS,MAAO,UAAUyK,SAAQ,SAAUrE,GAC5DA,KAAS,GAAOkW,SAGtB,YAAK,GAAOA,QAASlW,GAAO,SAAUmW,GAClC,OAAO,WAEH,IADA,IAAInV,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzBmV,GAAgB,UAAW,CAAEpV,KAAMA,EAAMhB,MAAOA,IAE5CmW,GACA3D,SAASna,UAAU4G,MAAMvF,KAAKyc,EAAsB,GAAOD,QAASlV,UA3E5EqV,GACA,MACJ,IAAK,OAiQb,WACI,KAAM,aAAc,IAChB,OAIJ,GAAOlb,SAASmb,iBAAiB,QAASC,GAAgB,QAASH,GAAgBX,KAAK,KAAM,SAAS,GACvG,GAAOta,SAASmb,iBAAiB,WAAYE,GAAqBJ,GAAgBX,KAAK,KAAM,SAAS,GAEtG,CAAC,cAAe,QAAQpR,SAAQ,SAAUxK,GACtC,IAAI6I,EAAQ,GAAO7I,IAAW,GAAOA,GAAQxB,UACxCqK,GAAUA,EAAMjJ,gBAAmBiJ,EAAMjJ,eAAe,sBAG7D,YAAKiJ,EAAO,oBAAoB,SAAUvK,GACtC,OAAO,SAAUqd,EAAWrB,EAAIpO,GA2B5B,OA1BIoO,GAAMA,EAAGM,aACS,UAAde,GACA,YAAKrB,EAAI,eAAe,SAAUsC,GAC9B,OAAO,SAAUjV,GAEb,OADA+U,GAAgB,QAASH,GAAgBX,KAAK,KAAM,OAApDc,CAA4D/U,GACrDiV,EAAc/c,KAAK4E,KAAMkD,OAI1B,aAAdgU,GACA,YAAKrB,EAAI,eAAe,SAAUsC,GAC9B,OAAO,SAAUjV,GAEb,OADAgV,GAAqBJ,GAAgBX,KAAK,KAAM,OAAhDe,CAAwDhV,GACjDiV,EAAc/c,KAAK4E,KAAMkD,SAM1B,UAAdgU,GACAe,GAAgB,QAASH,GAAgBX,KAAK,KAAM,QAAQ,EAA5Dc,CAAkEjY,MAEpD,aAAdkX,GACAgB,GAAqBJ,GAAgBX,KAAK,KAAM,OAAhDe,CAAwDlY,OAGzDnG,EAASuB,KAAK4E,KAAMkX,EAAWrB,EAAIpO,OAGlD,YAAKrD,EAAO,uBAAuB,SAAUvK,GACzC,OAAO,SAAUqd,EAAWrB,EAAIpO,GAC5B,IAAIrE,EAAWyS,EACf,IACIzS,EAAWA,IAAaA,EAAS2S,oBAAsB3S,GAE3D,MAAOlC,IAGP,OAAOrH,EAASuB,KAAK4E,KAAMkX,EAAW9T,EAAUqE,WAtTpD2Q,GACA,MACJ,IAAK,OAiIb,WACI,KAAM,mBAAoB,IACtB,OAEJ,IAAIC,EAAW5F,eAAe1Y,UAC9B,YAAKse,EAAU,QAAQ,SAAUC,GAC7B,OAAO,WAEH,IADA,IAAI5V,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAI+I,EAAMhJ,EAAK,GASf,OARA1C,KAAKuY,eAAiB,CAClB9V,OAAQ,OAAAkH,EAAA,GAASjH,EAAK,IAAMA,EAAK,GAAG8V,cAAgB9V,EAAK,GACzDgJ,IAAKhJ,EAAK,IAGV,OAAAiH,EAAA,GAAS+B,IAAuC,SAA/B1L,KAAKuY,eAAe9V,QAAqBiJ,EAAIjG,MAAM,gBACpEzF,KAAKyY,wBAAyB,GAE3BH,EAAa3X,MAAMX,KAAM0C,OAGxC,YAAK2V,EAAU,QAAQ,SAAUhB,GAC7B,OAAO,WAEH,IADA,IAAI3U,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAI2U,EAAMtX,KACN0Y,EAAoB,CACpBhW,KAAMA,EACNiW,eAAgB7G,KAAKC,MACrBuF,IAAKA,GAMT,SAASsB,IACL,GAAuB,IAAnBtB,EAAI3E,WAAkB,CACtB,IAGQ2E,EAAIiB,iBACJjB,EAAIiB,eAAeM,YAAcvB,EAAIrN,QAG7C,MAAO/I,IAGP4W,GAAgB,MAAO,EAAiB,GAAIY,EAAmB,CAAEI,aAAchH,KAAKC,UAoB5F,OApCA+F,GAAgB,MAAO,EAAiB,GAAIY,IAmBxC,uBAAwBpB,GAAyC,mBAA3BA,EAAI5E,mBAC1C,YAAK4E,EAAK,sBAAsB,SAAUzd,GACtC,OAAO,WAEH,IADA,IAAIkf,EAAiB,GACZpW,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCoW,EAAepW,GAAMjC,UAAUiC,GAGnC,OADAiW,IACO/e,EAAS8G,MAAM2W,EAAKyB,OAOnCzB,EAAI5E,mBAAqBkG,EAEtBvB,EAAa1W,MAAMX,KAAM0C,OAvMhCsW,GACA,MACJ,IAAK,SA0Eb,WACI,IfpBG,WACH,IAAK3L,IACD,OAAO,EAEX,IAAI1Q,EAAS,cAGb,GAAI8Q,GAAc9Q,EAAOwV,OACrB,OAAO,EAIX,IAAI3H,GAAS,EACTyO,EAAMtc,EAAOE,SACjB,GAAIoc,EAAK,CACL,IAAIC,EAAUD,EAAIvF,cAAc,UAChCwF,EAAQC,QAAS,EACjB,IACIF,EAAIlF,KAAKC,YAAYkF,GACjBA,EAAQE,eAAiBF,EAAQE,cAAcjH,QAE/C3H,EAASiD,GAAcyL,EAAQE,cAAcjH,QAEjD8G,EAAIlF,KAAKsF,YAAYH,GAEzB,MAAOne,GACHwN,EAAA,EAAOsC,KAAK,kFAAmF9P,IAGvG,OAAOyP,EeTF8O,GACD,OAEJ,YAAK,GAAQ,SAAS,SAAUC,GAC5B,OAAO,WAEH,IADA,IAAI7W,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAI+V,EAAoB,CACpBhW,KAAMA,EACN8W,UAAW,CACP/W,OAAQgX,GAAe/W,GACvBgJ,IAAKgO,GAAYhX,IAErBiW,eAAgB7G,KAAKC,OAGzB,OADA+F,GAAgB,QAAS,EAAiB,GAAIY,IACvCa,EAAc5Y,MAAM,GAAQ+B,GAAMtD,MAAK,SAAUgT,GAEpD,OADA0F,GAAgB,QAAS,EAAiB,GAAIY,EAAmB,CAAEI,aAAchH,KAAKC,MAAOK,SAAUA,KAChGA,KACR,SAAUtX,GAET,MADAgd,GAAgB,QAAS,EAAiB,GAAIY,EAAmB,CAAEI,aAAchH,KAAKC,MAAOjX,MAAOA,KAC9FA,SAjGV6e,GACA,MACJ,IAAK,WAwMb,WACI,GfzEIhd,EAAS,cACTid,EAASjd,EAAOid,OAEhBC,EAAsBD,GAAUA,EAAOE,KAAOF,EAAOE,IAAIC,QACzDC,EAAgB,YAAard,KAAYA,EAAOsd,QAAQC,aAAevd,EAAOsd,QAAQE,aAClFN,IAAuBG,EeqE3B,Of9ED,IAICrd,EACAid,EAEAC,EACAG,EewEJ,IAAII,EAAgB,GAAOC,WAmB3B,SAASC,EAA2BC,GAChC,OAAO,WAEH,IADA,IAAI7X,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAI+I,EAAMhJ,EAAK1G,OAAS,EAAI0G,EAAK,QAAKuI,EACtC,GAAIS,EAAK,CAEL,IAAI9G,EAAO8R,GACP8D,EAAKC,OAAO/O,GAEhBgL,GAAW8D,EACX1C,GAAgB,UAAW,CACvBlT,KAAMA,EACN4V,GAAIA,IAGZ,OAAOD,EAAwB5Z,MAAMX,KAAM0C,IApCnD,GAAO2X,WAAa,WAEhB,IADA,IAAI3X,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB,IAAI6X,EAAK,GAAOE,SAASC,KAErB/V,EAAO8R,GAMX,GALAA,GAAW8D,EACX1C,GAAgB,UAAW,CACvBlT,KAAMA,EACN4V,GAAIA,IAEJJ,EACA,OAAOA,EAAczZ,MAAMX,KAAM0C,IAyBzC,YAAK,GAAOuX,QAAS,YAAaK,GAClC,YAAK,GAAOL,QAAS,eAAgBK,GApP7BM,GACA,MACJ,QACIrS,EAAA,EAAOsC,KAAK,gCAAiCvP,IAQlD,SAASuf,GAA0B7D,GAEjCA,GAAmC,iBAAjBA,EAAQ1b,MAAiD,mBAArB0b,EAAQ5T,WAGnEqU,GAAST,EAAQ1b,MAAQmc,GAAST,EAAQ1b,OAAS,GACnDmc,GAAST,EAAQ1b,MAAMgG,KAAK0V,EAAQ5T,UACpCuU,GAAWX,EAAQ1b,OAGvB,SAASwc,GAAgBxc,EAAM+Q,GAC3B,IAAIyO,EAAK7V,EACT,GAAK3J,GAASmc,GAASnc,GAGvB,IACI,IAAK,IAAIqK,EAAK,EAAiB8R,GAASnc,IAAS,IAAKsK,EAAKD,EAAGvE,QAASwE,EAAGvE,KAAMuE,EAAKD,EAAGvE,OAAQ,CAC5F,IAAI4V,EAAUpR,EAAGxL,MACjB,IACI4c,EAAQ3K,GAEZ,MAAOnL,GACHqH,EAAA,EAAOzN,MAAM,0DAA4DQ,EAAO,WAAa,YAAgB0b,GAAW,YAAc9V,KAIlJ,MAAO6Z,GAASD,EAAM,CAAEhgB,MAAOigB,GAC/B,QACI,IACQnV,IAAOA,EAAGvE,OAAS4D,EAAKU,EAAGqV,SAAS/V,EAAG7J,KAAKuK,GAEpD,QAAU,GAAImV,EAAK,MAAMA,EAAIhgB,QA0DrC,SAAS2e,GAAewB,GAEpB,YADkB,IAAdA,IAAwBA,EAAY,IACpC,YAAa,IAAU,OAAAtR,EAAA,GAAasR,EAAU,GAAI1N,UAAY0N,EAAU,GAAGxY,OACpEgY,OAAOQ,EAAU,GAAGxY,QAAQ+V,cAEnCyC,EAAU,IAAMA,EAAU,GAAGxY,OACtBgY,OAAOQ,EAAU,GAAGxY,QAAQ+V,cAEhC,MAGX,SAASkB,GAAYuB,GAEjB,YADkB,IAAdA,IAAwBA,EAAY,IACZ,iBAAjBA,EAAU,GACVA,EAAU,GAEjB,YAAa,IAAU,OAAAtR,EAAA,GAAasR,EAAU,GAAI1N,SAC3C0N,EAAU,GAAGvP,IAEjB+O,OAAOQ,EAAU,IA2L5B,IAEIC,GACAC,GAFAC,GAAgB,EAWpB,SAASnD,GAAgBte,EAAMqd,EAASqE,GAEpC,YADiB,IAAbA,IAAuBA,GAAW,GAC/B,SAAUnY,GAIbgY,QAAkBjQ,EAIb/H,GAASiY,KAAsBjY,IAGpCiY,GAAoBjY,EAChBkY,IACA1J,aAAa0J,IAEbC,EACAD,GAAgB5J,YAAW,WACvBwF,EAAQ,CAAE9T,MAAOA,EAAOvJ,KAAMA,OAIlCqd,EAAQ,CAAE9T,MAAOA,EAAOvJ,KAAMA,MAU1C,SAASue,GAAqBlB,GAI1B,OAAO,SAAU9T,GACb,IAAI3H,EACJ,IACIA,EAAS2H,EAAM3H,OAEnB,MAAO2F,GAGH,OAEJ,IAAIoa,EAAU/f,GAAUA,EAAO+f,QAI1BA,IAAwB,UAAZA,GAAmC,aAAZA,GAA2B/f,EAAOggB,qBAKrEL,IACDjD,GAAgB,QAASjB,EAAzBiB,CAAkC/U,GAEtCwO,aAAawJ,IACbA,GAAkB1J,YAAW,WACzB0J,QAAkBjQ,IAzEP,OChVvB,IAAI,GAA6B,WAI7B,SAASuQ,EAAY/T,GAIjBzH,KAAKrG,KAAO6hB,EAAY5Q,GACxB5K,KAAK+I,SAAW,EAAiB,CAAE6O,SAAS,EAAM6D,KAAK,EAAMtJ,OAAO,EAAM8H,SAAS,EAAMyB,QAAQ,EAAMpE,KAAK,GAAQ7P,GAwOxH,OAnOA+T,EAAYzhB,UAAU4hB,mBAAqB,SAAUC,GACjD,IAAItY,EAAa,CACbuY,SAAU,UACVxP,KAAM,CACFvI,MAAO,CACHpD,UAAW,YAAUkb,EAAYlZ,KAAM,IAE3C6F,OAAQ,WAEZ7G,MAAOvB,EAASsB,WAAWma,EAAYla,OACvC1G,QAAS,YAAS4gB,EAAYlZ,KAAM,MAExC,GAA0B,WAAtBkZ,EAAYla,MAAoB,CAChC,IAA4B,IAAxBka,EAAYlZ,KAAK,GAMjB,OALAY,EAAWtI,QAAU,sBAAwB,YAAS4gB,EAAYlZ,KAAKzE,MAAM,GAAI,MAAQ,kBACzFqF,EAAW+I,KAAKvI,MAAMpD,UAAY,YAAUkb,EAAYlZ,KAAKzE,MAAM,GAAI,GAO/E,cAAgBoF,cAAcC,EAAY,CACtC5F,MAAOke,EAAYlZ,KACnBhB,MAAOka,EAAYla,SAM3B8Z,EAAYzhB,UAAU+hB,eAAiB,SAAUF,GAC7C,IAAIrgB,EAEJ,IACIA,EAASqgB,EAAY1Y,MAAM3H,OACrB,YAAiBqgB,EAAY1Y,MAAM3H,QACnC,YAAiBqgB,EAAY1Y,OAEvC,MAAOhC,GACH3F,EAAS,YAES,IAAlBA,EAAOS,QAGX,cAAgBqH,cAAc,CAC1BwY,SAAU,MAAQD,EAAYjiB,KAC9BqB,QAASO,GACV,CACC2H,MAAOA,MACPvJ,KAAMiiB,EAAYjiB,QAM1B6hB,EAAYzhB,UAAUgiB,eAAiB,SAAUH,GAC7C,GAAIA,EAAY9C,aAAhB,CAEI,GAAI8C,EAAYtE,IAAImB,uBAChB,OAEJ,cAAgBpV,cAAc,CAC1BwY,SAAU,MACVxP,KAAMuP,EAAYtE,IAAIiB,eACtBjd,KAAM,QACP,CACCgc,IAAKsE,EAAYtE,WAKrBsE,EAAYtE,IAAImB,wBAChBuD,GAAoBJ,EAAYlZ,KAAK,KAM7C8Y,EAAYzhB,UAAUkiB,iBAAmB,SAAUL,GAE/C,GAAKA,EAAY9C,aAAjB,CAGA,IAAIxE,EAAS,cAAgBC,YACzBnO,EAAMkO,GAAUA,EAAOhO,SAC3B,GAAIF,EAAK,CACL,IAAI8V,EAAY,IAAI,EAAI9V,GAAKG,mBAG7B,GAAI2V,IACkD,IAAlDN,EAAYpC,UAAU9N,IAAI1D,QAAQkU,IACD,SAAjCN,EAAYpC,UAAU/W,QACtBmZ,EAAYlZ,KAAK,IACjBkZ,EAAYlZ,KAAK,GAAGwP,KAEpB,YADA8J,GAAoBJ,EAAYlZ,KAAK,GAAGwP,MAI5C0J,EAAY9gB,MACZ,cAAgBuI,cAAc,CAC1BwY,SAAU,QACVxP,KAAM,EAAiB,GAAIuP,EAAYpC,UAAW,CAAEX,YAAa+C,EAAYxJ,SAASnI,SACtFvI,MAAOvB,EAAS7B,MAChBhD,KAAM,QACP,CACC+Q,KAAMuP,EAAY9gB,MAClB4C,MAAOke,EAAYlZ,OAIvB,cAAgBW,cAAc,CAC1BwY,SAAU,QACVxP,KAAM,EAAiB,GAAIuP,EAAYpC,UAAW,CAAEX,YAAa+C,EAAYxJ,SAASnI,SACtF3O,KAAM,QACP,CACCoC,MAAOke,EAAYlZ,KACnB0P,SAAUwJ,EAAYxJ,aAOlCoJ,EAAYzhB,UAAUoiB,mBAAqB,SAAUP,GACjD,IAAIjf,EAAS,cACTiI,EAAOgX,EAAYhX,KACnB4V,EAAKoB,EAAYpB,GACjB4B,EAAY,YAASzf,EAAO+d,SAASC,MACrC0B,EAAa,YAASzX,GACtB0X,EAAW,YAAS9B,GAEnB6B,EAAWlX,OACZkX,EAAaD,GAIbA,EAAU7W,WAAa+W,EAAS/W,UAAY6W,EAAUlX,OAASoX,EAASpX,OAExEsV,EAAK8B,EAASC,UAEdH,EAAU7W,WAAa8W,EAAW9W,UAAY6W,EAAUlX,OAASmX,EAAWnX,OAE5EN,EAAOyX,EAAWE,UAEtB,cAAgBlZ,cAAc,CAC1BwY,SAAU,aACVxP,KAAM,CACFzH,KAAMA,EACN4V,GAAIA,MAYhBgB,EAAYzhB,UAAUuO,UAAY,WAC9B,IAAI7D,EAAQzE,KACRA,KAAK+I,SAAS6O,SACdiD,GAA0B,CACtBzX,SAAU,WAEN,IADA,IAAIV,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB8B,EAAMkX,mBAAmBhb,MAAM8D,EAAO,EAAiB/B,KAE3DpH,KAAM,YAGV0E,KAAK+I,SAAS0S,KACdZ,GAA0B,CACtBzX,SAAU,WAEN,IADA,IAAIV,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB8B,EAAMqX,eAAenb,MAAM8D,EAAO,EAAiB/B,KAEvDpH,KAAM,QAGV0E,KAAK+I,SAASuO,KACduD,GAA0B,CACtBzX,SAAU,WAEN,IADA,IAAIV,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB8B,EAAMsX,eAAepb,MAAM8D,EAAO,EAAiB/B,KAEvDpH,KAAM,QAGV0E,KAAK+I,SAASoJ,OACd0I,GAA0B,CACtBzX,SAAU,WAEN,IADA,IAAIV,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB8B,EAAMwX,iBAAiBtb,MAAM8D,EAAO,EAAiB/B,KAEzDpH,KAAM,UAGV0E,KAAK+I,SAASkR,SACdY,GAA0B,CACtBzX,SAAU,WAEN,IADA,IAAIV,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEzB8B,EAAM0X,mBAAmBxb,MAAM8D,EAAO,EAAiB/B,KAE3DpH,KAAM,aAOlBkgB,EAAY5Q,GAAK,cACV4Q,EAjPqB,GAuPhC,SAASQ,GAAoBQ,GAEzB,IACI,IAAInhB,EAAUa,KAAKyB,MAAM6e,GACzB,cAAgBnZ,cAAc,CAC1BwY,SAAU,SACVxS,SAAUhO,EAAQgO,SAClB3H,MAAOrG,EAAQqG,OAASvB,EAASsB,WAAW,SAC5CzG,QAAS,YAAoBK,IAC9B,CACC6H,MAAO7H,IAGf,MAAOI,GACH8M,EAAA,EAAOzN,MAAM,8CCtQrB,IAAI,GAAgC,WAEhC,SAAS2hB,EAAehV,GAIpBzH,KAAKrG,KAAO8iB,EAAe7R,GAE3B5K,KAAK0c,QAAU,cAEf1c,KAAK2c,mBAAqB,KAE1B3c,KAAK4c,gCAAkC,KAEvC5c,KAAK6c,0BAA2B,EAEhC7c,KAAK8c,uCAAwC,EAC7C9c,KAAK+I,SAAW,EAAiB,CAAEgU,SAAS,EAAMC,sBAAsB,GAAQvV,GAuKpF,OAlKAgV,EAAe1iB,UAAUuO,UAAY,WACjChK,MAAM2e,gBAAkB,GACpBjd,KAAK+I,SAASgU,UACdxU,EAAA,EAAOC,IAAI,oCACXxI,KAAKkd,gCAELld,KAAK+I,SAASiU,uBACdzU,EAAA,EAAOC,IAAI,iDACXxI,KAAKmd,8CAIbV,EAAe1iB,UAAUmjB,6BAA+B,WACpD,IAAIld,KAAK6c,yBAAT,CAGA,IAAIxI,EAAOrU,KACXA,KAAK2c,mBAAqB3c,KAAK0c,QAAQK,QACvC/c,KAAK0c,QAAQK,QAAU,SAAUK,EAAK1R,EAAKiD,EAAME,EAAQ/T,GACrD,IAAIuiB,EAAa,cACbC,EAAiBD,EAAW1S,eAAe8R,GAC3Cc,EAAsBziB,IAA0C,IAAjCA,EAAM2d,uBACzC,IAAK6E,GAAkB5H,MAAyB6H,EAC5C,QAAIlJ,EAAKsI,oBACEtI,EAAKsI,mBAAmBhc,MAAMX,KAAMU,WAInD,IAAI4T,EAAS+I,EAAW9I,YACpBrR,EAAQ,OAAAyG,EAAA,GAAY7O,GAClBuZ,EAAKmJ,4BAA4BJ,EAAK1R,EAAKiD,EAAME,GACjDwF,EAAKoJ,8BAA8BrN,GAAsBtV,OAAOmQ,EAAW,CACzE4F,iBAAkByD,GAAUA,EAAOzK,aAAagH,iBAChDL,WAAW,IACX9E,EAAKiD,EAAME,GAQnB,OAPA,YAAsB3L,EAAO,CACzBgQ,SAAS,EACT5X,KAAM,YAEV+hB,EAAWpa,aAAaC,EAAO,CAC3BH,kBAAmBjI,MAEnBuZ,EAAKsI,oBACEtI,EAAKsI,mBAAmBhc,MAAMX,KAAMU,YAInDV,KAAK6c,0BAA2B,IAGpCJ,EAAe1iB,UAAUojB,0CAA4C,WACjE,IAAInd,KAAK8c,sCAAT,CAGA,IAAIzI,EAAOrU,KACXA,KAAK4c,gCAAkC5c,KAAK0c,QAAQM,qBACpDhd,KAAK0c,QAAQM,qBAAuB,SAAU9b,GAC1C,IAAIpG,EAAQoG,EACZ,IACIpG,EAAQoG,GAAK,WAAYA,EAAIA,EAAEwI,OAASxI,EAE5C,MAAOzF,IAGP,IAAI4hB,EAAa,cACbC,EAAiBD,EAAW1S,eAAe8R,GAC3Cc,EAAsBziB,IAA0C,IAAjCA,EAAM2d,uBACzC,IAAK6E,GAAkB5H,MAAyB6H,EAC5C,OAAIlJ,EAAKuI,iCACEvI,EAAKuI,gCAAgCjc,MAAMX,KAAMU,WAIhE,IAAI4T,EAAS+I,EAAW9I,YACpBrR,EAAQ,OAAAyG,EAAA,GAAY7O,GAClBuZ,EAAKqJ,8BAA8B5iB,GACnCsV,GAAsBtV,OAAOmQ,EAAW,CACtC4F,iBAAkByD,GAAUA,EAAOzK,aAAagH,iBAChDL,WAAW,IAUnB,OARAtN,EAAMxB,MAAQvB,EAAS7B,MACvB,YAAsB4E,EAAO,CACzBgQ,SAAS,EACT5X,KAAM,yBAEV+hB,EAAWpa,aAAaC,EAAO,CAC3BH,kBAAmBjI,KAEnBuZ,EAAKuI,iCACEvI,EAAKuI,gCAAgCjc,MAAMX,KAAMU,YAIhEV,KAAK8c,uCAAwC,IAKjDL,EAAe1iB,UAAUyjB,4BAA8B,SAAUJ,EAAK1R,EAAKiD,EAAME,GAC7E,IAGIlV,EADAqB,EAAU,OAAA2O,EAAA,GAAayT,GAAOA,EAAIpiB,QAAUoiB,EAEhD,GAAI,OAAAzT,EAAA,GAAS3O,GAAU,CACnB,IAAI2iB,EAAS3iB,EAAQyK,MALJ,4GAMbkY,IACAhkB,EAAOgkB,EAAO,GACd3iB,EAAU2iB,EAAO,IAGzB,IAAIza,EAAQ,CACRrF,UAAW,CACP2N,OAAQ,CACJ,CACIlQ,KAAM3B,GAAQ,QACdS,MAAOY,MAKvB,OAAOgF,KAAKyd,8BAA8Bva,EAAOwI,EAAKiD,EAAME,IAKhE4N,EAAe1iB,UAAU2jB,8BAAgC,SAAU5iB,GAC/D,MAAO,CACH+C,UAAW,CACP2N,OAAQ,CACJ,CACIlQ,KAAM,qBACNlB,MAAO,oDAAsDU,OAOjF2hB,EAAe1iB,UAAU0jB,8BAAgC,SAAUva,EAAOwI,EAAKiD,EAAME,GACjF3L,EAAMrF,UAAYqF,EAAMrF,WAAa,GACrCqF,EAAMrF,UAAU2N,OAAStI,EAAMrF,UAAU2N,QAAU,GACnDtI,EAAMrF,UAAU2N,OAAO,GAAKtI,EAAMrF,UAAU2N,OAAO,IAAM,GACzDtI,EAAMrF,UAAU2N,OAAO,GAAG8C,WAAapL,EAAMrF,UAAU2N,OAAO,GAAG8C,YAAc,GAC/EpL,EAAMrF,UAAU2N,OAAO,GAAG8C,WAAWiB,OAASrM,EAAMrF,UAAU2N,OAAO,GAAG8C,WAAWiB,QAAU,GAC7F,IAAIO,EAAQ7J,MAAMC,SAAS2I,EAAQ,UAAO5D,EAAY4D,EAClDqB,EAASjK,MAAMC,SAASyI,EAAM,UAAO1D,EAAY0D,EACjDoB,EAAW,OAAApG,EAAA,GAAS+B,IAAQA,EAAI1P,OAAS,EAAI0P,EAAM,cAUvD,OAT2D,IAAvDxI,EAAMrF,UAAU2N,OAAO,GAAG8C,WAAWiB,OAAOvT,QAC5CkH,EAAMrF,UAAU2N,OAAO,GAAG8C,WAAWiB,OAAOjO,KAAK,CAC7CwO,MAAOA,EACPC,SAAUA,EACVC,SAAU,IACVC,QAAQ,EACRC,OAAQA,IAGThN,GAKXuZ,EAAe7R,GAAK,iBACb6R,EAxLwB,GCC/B,GAA8B,WAI9B,SAASmB,EAAanW,QACF,IAAZA,IAAsBA,EAAU,IAIpCzH,KAAKrG,KAAOikB,EAAahT,GACzB5K,KAAK6d,KAAOpW,EAAQ/M,KAbV,QAcVsF,KAAKgR,OAASvJ,EAAQqW,OAbV,EAsDhB,OApCAF,EAAa7jB,UAAUuO,UAAY,WAC/B,aAAwB,SAAUpF,EAAOgG,GACrC,IAAImL,EAAO,cAAgB1J,eAAeiT,GAC1C,OAAIvJ,EACOA,EAAK0J,SAAS7a,EAAOgG,GAEzBhG,MAMf0a,EAAa7jB,UAAUgkB,SAAW,SAAU7a,EAAOgG,GAC/C,KAAKhG,EAAMrF,WAAcqF,EAAMrF,UAAU2N,QAAWtC,GAAS,OAAAS,EAAA,GAAaT,EAAKnG,kBAAmBzE,QAC9F,OAAO4E,EAEX,IAAI8a,EAAehe,KAAKie,eAAe/U,EAAKnG,kBAAmB/C,KAAK6d,MAEpE,OADA3a,EAAMrF,UAAU2N,OAAS,EAAiBwS,EAAc9a,EAAMrF,UAAU2N,QACjEtI,GAKX0a,EAAa7jB,UAAUkkB,eAAiB,SAAUnjB,EAAOJ,EAAKO,GAE1D,QADc,IAAVA,IAAoBA,EAAQ,KAC3B,OAAA0O,EAAA,GAAa7O,EAAMJ,GAAM4D,QAAUrD,EAAMe,OAAS,GAAKgE,KAAKgR,OAC7D,OAAO/V,EAEX,IACI4C,EAAYyR,GADCpB,GAAkBpT,EAAMJ,KAEzC,OAAOsF,KAAKie,eAAenjB,EAAMJ,GAAMA,EAAK,EAAiB,CAACmD,GAAY5C,KAK9E2iB,EAAahT,GAAK,eACXgT,EApDsB,GCL7B,GAAS,cAET,GAA2B,WAC3B,SAASM,IAILle,KAAKrG,KAAOukB,EAAUtT,GAyB1B,OApBAsT,EAAUnkB,UAAUuO,UAAY,WAC5B,aAAwB,SAAUpF,GAC9B,GAAI,cAAgByH,eAAeuT,GAAY,CAC3C,IAAK,GAAOC,YAAc,GAAOzD,SAC7B,OAAOxX,EAGX,IAAIuI,EAAUvI,EAAMuI,SAAW,GAI/B,OAHAA,EAAQC,IAAMD,EAAQC,KAAO,GAAOgP,SAASC,KAC7ClP,EAAQ4G,QAAU5G,EAAQ4G,SAAW,GACrC5G,EAAQ4G,QAAQ,cAAgB,GAAO8L,UAAUC,UAC1C,EAAiB,GAAIlb,EAAO,CAAEuI,QAASA,IAElD,OAAOvI,MAMfgb,EAAUtT,GAAK,YACRsT,EA9BmB,GCAnB,GAAsB,CAC7B,IAAI,EAAiB9J,eACrB,IAAI,EAAiBH,iBACrB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,IA2DD,SAASoK,GAAK5W,GAKjB,QAJgB,IAAZA,IAAsBA,EAAU,SACAwD,IAAhCxD,EAAQE,sBACRF,EAAQE,oBAAsB,SAEVsD,IAApBxD,EAAQ2D,QAAuB,CAC/B,IAAIkT,EAAW,cAEXA,EAASC,gBAAkBD,EAASC,eAAe3T,KACnDnD,EAAQ2D,QAAUkT,EAASC,eAAe3T,KCvE/C,SAAqB4T,EAAa/W,IACf,IAAlBA,EAAQgX,OACRlW,EAAA,EAAOmW,SAEX,cAAgBC,WAAW,IAAIH,EAAY/W,IDsE3CmX,CAAY,GAAenX,GAOxB,SAAS+L,GAAiB/L,QACb,IAAZA,IAAsBA,EAAU,IAC/BA,EAAQ2B,UACT3B,EAAQ2B,QAAU,cAAgByV,eAEtC,IAAIvK,EAAS,cAAgBC,YACzBD,GACAA,EAAOd,iBAAiB/L,GAQzB,SAASoX,KACZ,OAAO,cAAgBA,cAMpB,SAASC,MAOT,SAASjL,GAAOzQ,GACnBA,IAQG,SAAS0G,GAAMC,GAClB,IAAIuK,EAAS,cAAgBC,YAC7B,OAAID,EACOA,EAAOxK,MAAMC,GAEjB,IAAYqC,QAAO,GAQvB,SAAS,GAAMrC,GAClB,IAAIuK,EAAS,cAAgBC,YAC7B,OAAID,EACOA,EAAOjK,MAAMN,GAEjB,IAAYqC,QAAO,GASvB,SAAS,GAAKyJ,GACjB,OAAO,GAAaA,EAAb,GE5JX,m3CZCyB,YYDzB,2CAUA,IAAIkJ,GAAqB,GAGrBC,GAAU,cACVA,GAAQC,QAAUD,GAAQC,OAAOC,eACjCH,GAAqBC,GAAQC,OAAOC,cAGxC,IAAIC,GAAe,EAAiB,GAAIJ,GAAoB,EAAkB,I,kCClB9E,kCAIA,IAAIK,EAAsB,WACtB,SAASA,IAELpf,KAAKqf,YAAiC,mBAAZC,QAC1Btf,KAAKuf,OAASvf,KAAKqf,YAAc,IAAIC,QAAY,GAyCrD,OAnCAF,EAAKrlB,UAAUwD,QAAU,SAAU4G,GAC/B,GAAInE,KAAKqf,YACL,QAAIrf,KAAKuf,OAAOC,IAAIrb,KAGpBnE,KAAKuf,OAAOpO,IAAIhN,IACT,GAGX,IAAK,IAAIjJ,EAAI,EAAGA,EAAI8E,KAAKuf,OAAOvjB,OAAQd,IAAK,CAEzC,GADY8E,KAAKuf,OAAOrkB,KACViJ,EACV,OAAO,EAIf,OADAnE,KAAKuf,OAAOje,KAAK6C,IACV,GAMXib,EAAKrlB,UAAU0D,UAAY,SAAU0G,GACjC,GAAInE,KAAKqf,YACLrf,KAAKuf,OAAOE,OAAOtb,QAGnB,IAAK,IAAIjJ,EAAI,EAAGA,EAAI8E,KAAKuf,OAAOvjB,OAAQd,IACpC,GAAI8E,KAAKuf,OAAOrkB,KAAOiJ,EAAK,CACxBnE,KAAKuf,OAAOpX,OAAOjN,EAAG,GACtB,QAKTkkB,EA7Cc,I,+QCJzB,WACA,UACA,SAMA,UAAe,EAAAM,SAJS,SAACC,GACrB,OAAO,EAAP,GAAY,EAAAC,UAAUC,aAAaF,MAGxB,CAAyB,Y,6jBCRxC,WACA,UACA,QACA,QACA,QACA,SACA,QACA,UACA,SACA,UACA,UAkCMG,EAAyB,CAC3BhlB,WAAOmQ,EACP8U,eAAW9U,EACX+U,SAAS,EACTC,gBAAYhV,GAKViV,EAAc,WAChBtjB,OAAO8d,SAASC,KAHD,wBAMbwF,EAAe,WAiDjB,OACI,0BAAQC,UAAWC,EAAOpZ,QACtB,iBAlDK,WAAM,OACf,qBAAG0T,KARQ,wBASP,uBAAK2F,MAAM,6BAA6BC,MAAM,KAAKC,OAAO,KAAKC,QAAQ,aACnE,qBAAGhnB,KAAK,OAAOinB,SAAS,UAAUC,OAAO,OAAOC,YAAY,KACxD,qBAAGnnB,KAAK,UAAUinB,SAAS,UAAUG,UAAU,sBAC3C,yBACI,qBAAGA,UAAU,oBACT,wBAAMphB,EAAE,u/CA2CvB,MACL,iBAnCW,WAAM,OACrB,0BAAQ2gB,UAAW,OAAOC,EAAOS,QAAWC,QAASb,GACjD,uBAAKI,MAAM,6BAA6BC,MAAM,KAAKC,OAAO,KAAKC,QAAQ,aACnE,qBACIhnB,KAAK,OACLinB,SAAS,UACTC,OAAO,OACPK,cAAc,QACdC,eAAe,QACfL,YAAY,KAEZ,qBACIF,SAAS,UACTC,OAAO,UACPC,YAAY,IACZC,UAAU,wBAEV,yBACI,qBAAGA,UAAU,sBACT,qBAAGA,UAAU,oBACT,yBACI,wBAAMphB,EAAE,0CAczB,QAKvB,cAGI,WAAYyhB,GAAZ,MACI,YAAMA,IAAM,K,OACZ,EAAKvB,MAAQG,EACTqB,EAAOC,QAAQC,gBACf,EAAAC,WAAWjD,KAAK,CACZgD,cAAeF,EAAOC,QAAQC,cAC9BE,YAAaJ,EAAOC,QAAQG,YAC5BC,KAAM,gBACNC,QAAS,SACTC,IAAKP,EAAOC,QAAQjW,YAEpBoI,QAAS4N,EAAOC,QAAQ7N,QACxBtH,WAAY,IACZ0V,wBAAyB,EACzBC,gBAAgB,EAChBC,gBAAgB,EAChBC,uBAAuB,EACvBC,oBAAqB,kBACrBC,mBAAoB,CAChB,CACIvc,MAAO0b,EAAOc,WACdC,gBAAiB,CAAC,oBAI9B,EAAAZ,WAAWtd,QAAQ,CACfrK,MAAOwoB,GAAe,CAAEC,SAAU,iBAAkBA,YAIxDjB,EAAOzF,OAAOtV,MACd,EAAKsV,OAASuD,EACd,EAAKvD,OAAO2C,KAAK,CACbjY,IAAK+a,EAAOzF,OAAOtV,IACnBic,eAAgB,GAChBxR,kBAAkB,EAClB1F,YAAagW,EAAOzF,OAAOvQ,aAAe,MAC1CC,QAAS+V,EAAOzF,OAAOtQ,SAAW,cAClC6J,aAAc,CACV,gJAGR,EAAKyG,OAAOvY,gBAAe,SAACgG,GACxBA,EAAMnF,QAAQ,CACVoe,UAAWD,GAAe,CAAEC,SAAU,iBAAkBA,e,EAoG5E,OAnJkC,OAqD9B,YAAAE,0BAAA,SAA0BpB,EAAmBqB,GACrCrB,EAAMsB,aAAeD,EAAUC,YAC/BxiB,KAAKyiB,SAAS3C,GAElB,IACIG,EADAjlB,EAAUmmB,EAAOuB,WAAWC,iBAE5BzB,EAAM0B,kBACF1B,EAAM0B,2BAA2BtkB,QACjCtD,EAAUkmB,EAAM0B,gBAAgB5nB,QAChCilB,EAAa/jB,KAAKC,UAAU+kB,EAAM0B,gBAAiB,EAAAC,gBAEnD3B,EAAM0B,2BAA2BpV,WAC7B0T,EAAM0B,gBAAgBE,aACtB9nB,EAAUkmB,EAAM0B,gBAAgBE,YAEpC7C,EAAa,EAAA8C,iBAAiB7B,EAAM0B,mBAIxC1B,EAAM8B,cAAgBT,EAAUS,aAC5B9B,EAAM8B,aACNhjB,KAAKyiB,SAAS,CACVxC,WAAU,EACVnlB,MAAO,CACHE,QAAO,EACPrB,KAAM,EAAAspB,qBAKlB/B,EAAMgC,kBACN,EAAAC,aAAaroB,MAAME,GAAS,GAE5BkmB,EAAMkC,mBACN,EAAAC,WAAWlC,EAAOmC,OAAOC,WAIjC,YAAAC,kBAAA,SAAkB1oB,EAAcilB,GAAhC,WACI,EAAA0D,cAAc,EAAD,GAAM3oB,EAAUilB,IAC7B/f,KAAKyiB,SAAS,CACV3nB,MAAK,EACLilB,UAAS,IAGT/f,KAAK0b,QACL1b,KAAK0b,OAAOxX,WAAU,SAACiF,GACnBnP,OAAOQ,KAAKulB,GAAWha,SAAQ,SAACrL,GAC5ByO,EAAMtF,SAASnJ,EAAKqlB,EAAUrlB,OAG9BkC,OAAO8mB,WACPva,EAAM1F,UAAU,CACZkgB,mBAAoB/mB,OAAO8mB,UAAUE,iBAI7C,EAAKlI,OAAQ7Y,iBAAiB/H,MAItC8c,QAAQ9c,MAAM,MAAOA,IAGzB,YAAA+oB,OAAA,WACI,OAAI7jB,KAAK2f,MAAM7kB,MAEP,gBAACgpB,EAAMC,SAAQ,KACX,gBAAC5D,EAAY,MACb,uBAAKC,UAAWC,EAAO2D,uBACnB,uBAAK5D,UAAWC,EAAO4D,SACnB,gBAAC,UAAM,MACP,2DACA,yBACI,6EAEJ,uBAAK7D,UAAWC,EAAO6D,UACnB,0BAAQ9D,UAAU,MAAMW,QAASb,GAAW,QAG5C,0BACIE,UAAU,kBACVW,QAAS,WAAM,OAAArG,SAASyJ,WAAQ,eAUrDnkB,KAAKkhB,MAAMkD,UAhJf,EAAAC,YAAc,sBAkJzB,EAnJA,CAAkCP,EAAMQ,WAqJxC,UAAeC,G,mFCvQf,WA+CA,UA7CuB,WAAM,OACzB,uBAAKjE,MAAM,6BAA6BC,MAAM,KAAKC,OAAO,KAAK/mB,KAAK,OAAOgnB,QAAQ,aAC/E,wBACIhnB,KAAK,UACLinB,SAAS,UACTjhB,EAAE,oRACF+kB,SAAS,YAEb,wBACI7D,OAAO,UACPK,cAAc,QACdJ,YAAY,IACZnhB,EAAE,2DAEN,wBACIhG,KAAK,UACLgG,EAAE,qHAEN,wBACIhG,KAAK,UACLgG,EAAE,2EAEN,wBACIhG,KAAK,UACLinB,SAAS,UACTjhB,EAAE,8CACF+kB,SAAS,YAEb,wBACI7D,OAAO,UACPK,cAAc,QACdJ,YAAY,IACZnhB,EAAE,6EAEN,wBACIhG,KAAK,UACLgG,EAAE,gKAEN,wBACIhG,KAAK,UACLgG,EAAE,4G,qBCzCd,IAAIwkB,EAAU,EAAQ,MAEA,iBAAZA,IAAsBA,EAAU,CAAC,CAACQ,EAAOvpB,EAAI+oB,EAAS,MAOhE,IAAIxc,EAAU,CAAC,WAAY,EAAK,SAAW,MAAM,KAAM,EAEvD,eAPIoZ,EAQJ,gBAAqB5V,GAER,EAAQ,IAAR,CAAgEgZ,EAASxc,GAEnFwc,EAAQS,SAAQD,EAAOE,QAAUV,EAAQS,S,sBCjB5CC,EAAUF,EAAOE,QAAU,EAAQ,IAAR,EAA4D,IAK/ErjB,KAAK,CAACmjB,EAAOvpB,EAAI,y1EAA01E,KAGn3EypB,EAAQD,OAAS,CAChB,OAAU,sCACV,QAAW,uCACX,sBAAyB,qDACzB,QAAW,uCACX,SAAY,0C,mCCbb,wJAyBIE,EAAqB,WASrB,SAASA,EAAItQ,EAAQnL,EAAO0b,QACV,IAAV1b,IAAoBA,EAAQ,IAAI,UACnB,IAAb0b,IAAuBA,EAzBV,GA0BjB7kB,KAAK6kB,SAAWA,EAEhB7kB,KAAK8kB,OAAS,GACd9kB,KAAK8kB,OAAOxjB,KAAK,CAAEgT,OAAQA,EAAQnL,MAAOA,IAyS9C,OAjSAyb,EAAI7qB,UAAUgrB,cAAgB,SAAUtiB,GAGpC,IAFA,IAAIwC,EACAvC,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,EAAK,GAAKjC,UAAUiC,GAE7B,IAAIqiB,EAAMhlB,KAAKilB,cACXD,GAAOA,EAAI1Q,QAAU0Q,EAAI1Q,OAAO7R,KAC/BwC,EAAK+f,EAAI1Q,QAAQ7R,GAAQ9B,MAAMsE,EAAI,IAAiBvC,EAAM,CAACsiB,EAAI7b,UAMxEyb,EAAI7qB,UAAUmrB,YAAc,SAAU3R,GAClC,OAAOvT,KAAK6kB,SAAWtR,GAK3BqR,EAAI7qB,UAAU4kB,WAAa,SAAUrK,GACvBtU,KAAKilB,cACX3Q,OAASA,GAKjBsQ,EAAI7qB,UAAUorB,UAAY,WAEtB,IAAIlqB,EAAQ+E,KAAKolB,WACbC,EAAcpqB,EAAMe,OAAS,EAAIf,EAAMA,EAAMe,OAAS,GAAGmN,WAAQ8B,EACjE9B,EAAQ,IAAMmc,MAAMD,GAKxB,OAJArlB,KAAKolB,WAAW9jB,KAAK,CACjBgT,OAAQtU,KAAKuU,YACbpL,MAAOA,IAEJA,GAKXyb,EAAI7qB,UAAUwrB,SAAW,WACrB,YAAiCta,IAA1BjL,KAAKolB,WAAWvf,OAK3B+e,EAAI7qB,UAAUmK,UAAY,SAAUd,GAChC,IAAI+F,EAAQnJ,KAAKmlB,YACjB,IACI/hB,EAAS+F,GAEb,QACInJ,KAAKulB,aAMbX,EAAI7qB,UAAUwa,UAAY,WACtB,OAAOvU,KAAKilB,cAAc3Q,QAG9BsQ,EAAI7qB,UAAUyrB,SAAW,WACrB,OAAOxlB,KAAKilB,cAAc9b,OAG9Byb,EAAI7qB,UAAUqrB,SAAW,WACrB,OAAOplB,KAAK8kB,QAGhBF,EAAI7qB,UAAUkrB,YAAc,WACxB,OAAOjlB,KAAK8kB,OAAO9kB,KAAK8kB,OAAO9oB,OAAS,IAK5C4oB,EAAI7qB,UAAU8I,iBAAmB,SAAUhF,EAAWqL,GAClD,IAAIE,EAAWpJ,KAAKylB,aAAe,cAC/BC,EAAYxc,EAKhB,IAAKA,EAAM,CACP,IAAIpG,OAAqB,EACzB,IACI,MAAM,IAAIxE,MAAM,6BAEpB,MAAOT,GACHiF,EAAqBjF,EAEzB6nB,EAAY,CACR3iB,kBAAmBlF,EACnBiF,mBAAoBA,GAI5B,OADA9C,KAAK+kB,cAAc,mBAAoBlnB,EAAW,IAAiB,GAAI6nB,EAAW,CAAErc,SAAUD,KACvFA,GAKXwb,EAAI7qB,UAAUiJ,eAAiB,SAAUhI,EAAS0G,EAAOwH,GACrD,IAAIE,EAAWpJ,KAAKylB,aAAe,cAC/BC,EAAYxc,EAKhB,IAAKA,EAAM,CACP,IAAIpG,OAAqB,EACzB,IACI,MAAM,IAAIxE,MAAMtD,GAEpB,MAAO6C,GACHiF,EAAqBjF,EAEzB6nB,EAAY,CACR3iB,kBAAmB/H,EACnB8H,mBAAoBA,GAI5B,OADA9C,KAAK+kB,cAAc,iBAAkB/pB,EAAS0G,EAAO,IAAiB,GAAIgkB,EAAW,CAAErc,SAAUD,KAC1FA,GAKXwb,EAAI7qB,UAAUkJ,aAAe,SAAUC,EAAOgG,GAC1C,IAAIE,EAAWpJ,KAAKylB,aAAe,cAEnC,OADAzlB,KAAK+kB,cAAc,eAAgB7hB,EAAO,IAAiB,GAAIgG,EAAM,CAAEG,SAAUD,KAC1EA,GAKXwb,EAAI7qB,UAAU8kB,YAAc,WACxB,OAAO7e,KAAKylB,cAKhBb,EAAI7qB,UAAUsJ,cAAgB,SAAUC,EAAY4F,GAChD,IAAI8b,EAAMhlB,KAAKilB,cACf,GAAKD,EAAI7b,OAAU6b,EAAI1Q,OAAvB,CAGA,IAAIrP,EAAM+f,EAAI1Q,OAAOzK,YAAcmb,EAAI1Q,OAAOzK,cAAiB,GAAIlE,EAAKV,EAAG0gB,iBAAkBA,OAA0B,IAAPhgB,EAAgB,KAAOA,EAAIC,EAAKX,EAAGod,eAAgBA,OAAwB,IAAPzc,EApLlK,GAoLwMA,EAC1N,KAAIyc,GAAkB,GAAtB,CAGA,IAAIuD,EAAY,cACZC,EAAmB,IAAiB,CAAED,UAAWA,GAAatiB,GAC9DwiB,EAAkBH,EAChB,aAAe,WAAc,OAAOA,EAAiBE,EAAkB3c,MACvE2c,EACkB,OAApBC,GAGJd,EAAI7b,MAAM9F,cAAcyiB,EAAiB5Z,KAAK6Z,IAAI1D,EA3LpC,SAgMlBuC,EAAI7qB,UAAUiK,QAAU,SAAUC,GAC9B,IAAI+gB,EAAMhlB,KAAKilB,cACVD,EAAI7b,OAGT6b,EAAI7b,MAAMnF,QAAQC,IAKtB2gB,EAAI7qB,UAAU4J,QAAU,SAAUC,GAC9B,IAAIohB,EAAMhlB,KAAKilB,cACVD,EAAI7b,OAGT6b,EAAI7b,MAAMxF,QAAQC,IAKtBghB,EAAI7qB,UAAU0J,UAAY,SAAUC,GAChC,IAAIshB,EAAMhlB,KAAKilB,cACVD,EAAI7b,OAGT6b,EAAI7b,MAAM1F,UAAUC,IAKxBkhB,EAAI7qB,UAAUgK,OAAS,SAAUrJ,EAAKN,GAClC,IAAI4qB,EAAMhlB,KAAKilB,cACVD,EAAI7b,OAGT6b,EAAI7b,MAAMpF,OAAOrJ,EAAKN,IAK1BwqB,EAAI7qB,UAAU8J,SAAW,SAAUnJ,EAAKoJ,GACpC,IAAIkhB,EAAMhlB,KAAKilB,cACVD,EAAI7b,OAGT6b,EAAI7b,MAAMtF,SAASnJ,EAAKoJ,IAK5B8gB,EAAI7qB,UAAUwJ,WAAa,SAAU5J,EAAM6J,GACvC,IAAIwhB,EAAMhlB,KAAKilB,cACVD,EAAI7b,OAGT6b,EAAI7b,MAAM5F,WAAW5J,EAAM6J,IAK/BohB,EAAI7qB,UAAUoJ,eAAiB,SAAUC,GACrC,IAAI4hB,EAAMhlB,KAAKilB,cACXD,EAAI7b,OAAS6b,EAAI1Q,QACjBlR,EAAS4hB,EAAI7b,QAMrByb,EAAI7qB,UAAUisB,IAAM,SAAU5iB,GAC1B,IAAI6iB,EAASC,EAASlmB,MACtB,IACIoD,EAASpD,MAEb,QACIkmB,EAASD,KAMjBrB,EAAI7qB,UAAU4Q,eAAiB,SAAUtC,GACrC,IAAIiM,EAAStU,KAAKuU,YAClB,IAAKD,EACD,OAAO,KAEX,IACI,OAAOA,EAAO3J,eAAetC,GAEjC,MAAO5M,GAEH,OADA,IAAOoP,KAAK,+BAAiCxC,EAAYuC,GAAK,yBACvD,OAMfga,EAAI7qB,UAAUosB,UAAY,SAAUC,EAAmBC,GAEnD,YADqB,IAAjBA,IAA2BA,GAAe,GACvCrmB,KAAKsmB,qBAAqB,YAAaF,EAAmBC,IAKrEzB,EAAI7qB,UAAUwsB,aAAe,WACzB,OAAOvmB,KAAKsmB,qBAAqB,iBAMrC1B,EAAI7qB,UAAUusB,qBAAuB,SAAU7jB,GAE3C,IADA,IAAIC,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,EAAK,GAAKjC,UAAUiC,GAE7B,IAAI6jB,EAAUC,IACV/K,EAAS8K,EAAQE,WAErB,GAAIhL,GAAUA,EAAOiL,YAAmD,mBAA9BjL,EAAOiL,WAAWlkB,GACxD,OAAOiZ,EAAOiL,WAAWlkB,GAAQ9B,MAAMX,KAAM0C,GAEjD,IAAOmI,KAAK,oBAAsBpI,EAAS,uCAExCmiB,EAxTa,GA4TjB,SAAS6B,IACZ,IAAID,EAAU,cAKd,OAJAA,EAAQE,WAAaF,EAAQE,YAAc,CACvCC,WAAY,GACZ/jB,SAAKqI,GAEFub,EAOJ,SAASN,EAAStjB,GACrB,IAAIgkB,EAAWH,IACXR,EAASY,EAAkBD,GAE/B,OADAE,EAAgBF,EAAUhkB,GACnBqjB,EASJ,SAASc,IAEZ,IAAIH,EAAWH,IAMf,OAJKO,EAAgBJ,KAAaC,EAAkBD,GAAU1B,YAxWzC,IAyWjB4B,EAAgBF,EAAU,IAAIhC,GAG9B,cAUR,SAAgCgC,GAC5B,IAII,IACIK,EADS,YAAexC,EAAQ,UACVyC,OAE1B,IAAKD,EACD,OAAOJ,EAAkBD,GAG7B,IAAKI,EAAgBC,IAAiBJ,EAAkBI,GAAc/B,YAlYrD,GAkY+E,CAC5F,IAAIiC,EAAsBN,EAAkBD,GAAU3B,cACtD6B,EAAgBG,EAAc,IAAIrC,EAAIuC,EAAoB7S,OAAQ,IAAMgR,MAAM6B,EAAoBhe,SAGtG,OAAO0d,EAAkBI,GAE7B,MAAO5sB,GAEH,OAAOwsB,EAAkBD,IA9BlBQ,CAAuBR,GAG3BC,EAAkBD,GAkC7B,SAASI,EAAgBR,GACrB,SAAIA,GAAWA,EAAQE,YAAcF,EAAQE,WAAW9jB,KAWrD,SAASikB,EAAkBL,GAC9B,OAAIA,GAAWA,EAAQE,YAAcF,EAAQE,WAAW9jB,MAGxD4jB,EAAQE,WAAaF,EAAQE,YAAc,GAC3CF,EAAQE,WAAW9jB,IAAM,IAAIgiB,GAHlB4B,EAAQE,WAAW9jB,IAW3B,SAASkkB,EAAgBN,EAAS5jB,GACrC,QAAK4jB,IAGLA,EAAQE,WAAaF,EAAQE,YAAc,GAC3CF,EAAQE,WAAW9jB,IAAMA,GAClB,M,uDC5bX,8CAEIjG,EAAS,cAET0qB,EAAS,iBAETC,EAAwB,WAExB,SAASA,IACLtnB,KAAKunB,UAAW,EAiDpB,OA9CAD,EAAOvtB,UAAUytB,QAAU,WACvBxnB,KAAKunB,UAAW,GAGpBD,EAAOvtB,UAAU2kB,OAAS,WACtB1e,KAAKunB,UAAW,GAGpBD,EAAOvtB,UAAUyO,IAAM,WAEnB,IADA,IAAI9F,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEpB3C,KAAKunB,UAGV,aAAe,WACX5qB,EAAOib,QAAQpP,IAAI6e,EAAS,UAAY3kB,EAAK9H,KAAK,UAI1D0sB,EAAOvtB,UAAU8Q,KAAO,WAEpB,IADA,IAAInI,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEpB3C,KAAKunB,UAGV,aAAe,WACX5qB,EAAOib,QAAQ/M,KAAKwc,EAAS,WAAa3kB,EAAK9H,KAAK,UAI5D0sB,EAAOvtB,UAAUe,MAAQ,WAErB,IADA,IAAI4H,EAAO,GACFC,EAAK,EAAGA,EAAKjC,UAAU1E,OAAQ2G,IACpCD,EAAKC,GAAMjC,UAAUiC,GAEpB3C,KAAKunB,UAGV,aAAe,WACX5qB,EAAOib,QAAQ9c,MAAMusB,EAAS,YAAc3kB,EAAK9H,KAAK,UAGvD0sB,EApDgB,GAuD3B3qB,EAAO+pB,WAAa/pB,EAAO+pB,YAAc,GACzC,IAAIne,EAAS5L,EAAO+pB,WAAWne,SAAW5L,EAAO+pB,WAAWne,OAAS,IAAI+e,I,iCC9DzE,sCAEIG,EAFJ,UAGA,SAAWA,GAEPA,EAAgB,QAAI,UAEpBA,EAAiB,SAAI,WAErBA,EAAiB,SAAI,WANzB,CAOGA,IAAWA,EAAS,KAKvB,IAAIC,EAA6B,WAC7B,SAASA,EAAYC,GACjB,IAAIljB,EAAQzE,KACZA,KAAK4nB,OAASH,EAAOI,QACrB7nB,KAAK8nB,UAAY,GAEjB9nB,KAAK+nB,SAAW,SAAU3tB,GACtBqK,EAAMujB,WAAWP,EAAOQ,SAAU7tB,IAGtC4F,KAAKkoB,QAAU,SAAUxe,GACrBjF,EAAMujB,WAAWP,EAAOU,SAAUze,IAGtC1J,KAAKgoB,WAAa,SAAUrI,EAAOvlB,GAC3BqK,EAAMmjB,SAAWH,EAAOI,UAGxB,YAAWztB,GACXA,EAAMgF,KAAKqF,EAAMsjB,SAAUtjB,EAAMyjB,UAGrCzjB,EAAMmjB,OAASjI,EACflb,EAAM2jB,OAAShuB,EACfqK,EAAM4jB,sBAIVroB,KAAKsoB,eAAiB,SAAUtR,GAC5BvS,EAAMqjB,UAAYrjB,EAAMqjB,UAAUtmB,OAAOwV,GACzCvS,EAAM4jB,oBAGVroB,KAAKqoB,iBAAmB,WAChB5jB,EAAMmjB,SAAWH,EAAOI,UAGxBpjB,EAAMmjB,SAAWH,EAAOU,SACxB1jB,EAAMqjB,UAAU/hB,SAAQ,SAAUiR,GAC1BA,EAAQuR,YACRvR,EAAQuR,WAAW9jB,EAAM2jB,WAKjC3jB,EAAMqjB,UAAU/hB,SAAQ,SAAUiR,GAC1BA,EAAQwR,aAERxR,EAAQwR,YAAY/jB,EAAM2jB,WAItC3jB,EAAMqjB,UAAY,KAEtB,IACIH,EAAS3nB,KAAK+nB,SAAU/nB,KAAKkoB,SAEjC,MAAOhnB,GACHlB,KAAKkoB,QAAQhnB,IAoHrB,OAhHAwmB,EAAY3tB,UAAUyB,SAAW,WAC7B,MAAO,wBAGXksB,EAAY5c,QAAU,SAAU1Q,GAC5B,OAAO,IAAIstB,GAAY,SAAU5c,GAC7BA,EAAQ1Q,OAIhBstB,EAAYtb,OAAS,SAAU1C,GAC3B,OAAO,IAAIge,GAAY,SAAU9a,EAAGR,GAChCA,EAAO1C,OAIfge,EAAYjW,IAAM,SAAUgX,GACxB,OAAO,IAAIf,GAAY,SAAU5c,EAASsB,GACtC,GAAK/O,MAAMC,QAAQmrB,GAInB,GAA0B,IAAtBA,EAAWzsB,OAAf,CAIA,IAAI0sB,EAAUD,EAAWzsB,OACrB2sB,EAAqB,GACzBF,EAAW1iB,SAAQ,SAAU6iB,EAAMC,GAC/BnB,EAAY5c,QAAQ8d,GACfxpB,MAAK,SAAUhF,GAChBuuB,EAAmBE,GAASzuB,EAEZ,KADhBsuB,GAAW,IAIX5d,EAAQ6d,MAEPvpB,KAAK,KAAMgN,WAfhBtB,EAAQ,SAJRsB,EAAO,IAAI0c,UAAU,gDAwBjCpB,EAAY3tB,UAAUqF,KAAO,SAAUopB,EAAaD,GAChD,IAAI9jB,EAAQzE,KACZ,OAAO,IAAI0nB,GAAY,SAAU5c,EAASsB,GACtC3H,EAAM6jB,eAAe,CACjBE,YAAa,SAAUhe,GACnB,GAAKge,EAML,IAEI,YADA1d,EAAQ0d,EAAYhe,IAGxB,MAAOtJ,GAEH,YADAkL,EAAOlL,QARP4J,EAAQN,IAYhB+d,WAAY,SAAU7e,GAClB,GAAK6e,EAIL,IAEI,YADAzd,EAAQyd,EAAW7e,IAGvB,MAAOxI,GAEH,YADAkL,EAAOlL,QARPkL,EAAO1C,UAgB3Bge,EAAY3tB,UAAUwY,MAAQ,SAAUgW,GACpC,OAAOvoB,KAAKZ,MAAK,SAAU2pB,GAAO,OAAOA,IAAQR,IAGrDb,EAAY3tB,UAAUivB,QAAU,SAAUC,GACtC,IAAIxkB,EAAQzE,KACZ,OAAO,IAAI0nB,GAAY,SAAU5c,EAASsB,GACtC,IAAI2c,EACAG,EACJ,OAAOzkB,EAAMrF,MAAK,SAAUhF,GACxB8uB,GAAa,EACbH,EAAM3uB,EACF6uB,GACAA,OAEL,SAAUvf,GACTwf,GAAa,EACbH,EAAMrf,EACFuf,GACAA,OAEL7pB,MAAK,WACA8pB,EACA9c,EAAO2c,GAIXje,EAAQie,UAIbrB,EA9KqB,I,kFCfnB,EAAAzE,kBAAoB,mBACpB,EAAAkG,iBAAmB,mBACnB,EAAAC,wBAA0B,0BAC1B,EAAAC,uBAAyB,yBACzB,EAAAC,2BAA6B,wBAC7B,EAAAC,mCAAqC,mB,iCCLlD,mHAMIC,EAAuB,WACvB,SAASA,IAELxpB,KAAKypB,qBAAsB,EAE3BzpB,KAAK0pB,gBAAkB,GAEvB1pB,KAAK2pB,iBAAmB,GAExB3pB,KAAK4pB,aAAe,GAEpB5pB,KAAK6pB,MAAQ,GAEb7pB,KAAK8pB,MAAQ,GAEb9pB,KAAK+pB,OAAS,GAEd/pB,KAAKgqB,SAAW,GAoQpB,OA9PAR,EAAMzvB,UAAUkwB,iBAAmB,SAAU7mB,GACzCpD,KAAK0pB,gBAAgBpoB,KAAK8B,IAK9BomB,EAAMzvB,UAAUqc,kBAAoB,SAAUhT,GAE1C,OADApD,KAAK2pB,iBAAiBroB,KAAK8B,GACpBpD,MAKXwpB,EAAMzvB,UAAUmwB,sBAAwB,WACpC,IAAIzlB,EAAQzE,KACPA,KAAKypB,sBACNzpB,KAAKypB,qBAAsB,EAC3BjY,YAAW,WACP/M,EAAMilB,gBAAgB3jB,SAAQ,SAAU3C,GACpCA,EAASqB,MAEbA,EAAMglB,qBAAsB,OAOxCD,EAAMzvB,UAAUowB,uBAAyB,SAAUC,EAAYlnB,EAAOgG,EAAM2f,GACxE,IAAIpkB,EAAQzE,KAEZ,YADc,IAAV6oB,IAAoBA,EAAQ,GACzB,IAAI,KAAY,SAAU/d,EAASsB,GACtC,IAAIie,EAAYD,EAAWvB,GAE3B,GAAc,OAAV3lB,GAAuC,mBAAdmnB,EACzBvf,EAAQ5H,OAEP,CACD,IAAIsH,EAAS6f,EAAU,IAAiB,GAAInnB,GAAQgG,GAChD,YAAWsB,GACXA,EACKpL,MAAK,SAAUkrB,GAAS,OAAO7lB,EAAM0lB,uBAAuBC,EAAYE,EAAOphB,EAAM2f,EAAQ,GAAGzpB,KAAK0L,MACrG1L,KAAK,KAAMgN,GAGhB3H,EAAM0lB,uBAAuBC,EAAY5f,EAAQtB,EAAM2f,EAAQ,GAC1DzpB,KAAK0L,GACL1L,KAAK,KAAMgN,QAQhCod,EAAMzvB,UAAUiK,QAAU,SAAUC,GAGhC,OAFAjE,KAAK6pB,MAAQ,YAAU5lB,GACvBjE,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAU4J,QAAU,SAAUC,GAGhC,OAFA5D,KAAK8pB,MAAQ,IAAiB,GAAI9pB,KAAK8pB,MAAO,YAAUlmB,IACxD5D,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAUgK,OAAS,SAAUrJ,EAAKN,GACpC,IAAI6K,EAGJ,OAFAjF,KAAK8pB,MAAQ,IAAiB,GAAI9pB,KAAK8pB,QAAQ7kB,EAAK,IAAOvK,GAAO,YAAUN,GAAQ6K,IACpFjF,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAU0J,UAAY,SAAUK,GAGlC,OAFA9D,KAAK+pB,OAAS,IAAiB,GAAI/pB,KAAK+pB,OAAQ,YAAUjmB,IAC1D9D,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAU8J,SAAW,SAAUnJ,EAAKoJ,GACtC,IAAImB,EAGJ,OAFAjF,KAAK+pB,OAAS,IAAiB,GAAI/pB,KAAK+pB,SAAS9kB,EAAK,IAAOvK,GAAO,YAAUoJ,GAAQmB,IACtFjF,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAUwwB,eAAiB,SAAUC,GAGvC,OAFAxqB,KAAKyqB,aAAe,YAAUD,GAC9BxqB,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAU2wB,SAAW,SAAUhpB,GAGjC,OAFA1B,KAAKoN,OAAS,YAAU1L,GACxB1B,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAU4wB,eAAiB,SAAUC,GAGvC,OAFA5qB,KAAK6qB,aAAeD,EACpB5qB,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAUwJ,WAAa,SAAU5J,EAAM6J,GAGzC,OAFAxD,KAAKgqB,SAASrwB,GAAQ6J,EAAU,YAAUA,QAAWyH,EACrDjL,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAU+wB,QAAU,SAAUC,GAGhC,OAFA/qB,KAAKgrB,MAAQD,EACb/qB,KAAKkqB,wBACElqB,MAMXwpB,EAAMzvB,UAAUkxB,QAAU,WACtB,OAAOjrB,KAAKgrB,OAMhBxB,EAAMlE,MAAQ,SAAUnc,GACpB,IAAI+hB,EAAW,IAAI1B,EAanB,OAZIrgB,IACA+hB,EAAStB,aAAe,IAAiBzgB,EAAMygB,cAC/CsB,EAASpB,MAAQ,IAAiB,GAAI3gB,EAAM2gB,OAC5CoB,EAASnB,OAAS,IAAiB,GAAI5gB,EAAM4gB,QAC7CmB,EAASlB,SAAW,IAAiB,GAAI7gB,EAAM6gB,UAC/CkB,EAASrB,MAAQ1gB,EAAM0gB,MACvBqB,EAAS9d,OAASjE,EAAMiE,OACxB8d,EAASF,MAAQ7hB,EAAM6hB,MACvBE,EAASL,aAAe1hB,EAAM0hB,aAC9BK,EAAST,aAAethB,EAAMshB,aAC9BS,EAASvB,iBAAmB,IAAiBxgB,EAAMwgB,mBAEhDuB,GAKX1B,EAAMzvB,UAAUoxB,MAAQ,WAWpB,OAVAnrB,KAAK4pB,aAAe,GACpB5pB,KAAK8pB,MAAQ,GACb9pB,KAAK+pB,OAAS,GACd/pB,KAAK6pB,MAAQ,GACb7pB,KAAKgqB,SAAW,GAChBhqB,KAAKoN,YAASnC,EACdjL,KAAK6qB,kBAAe5f,EACpBjL,KAAKyqB,kBAAexf,EACpBjL,KAAKgrB,WAAQ/f,EACbjL,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAUsJ,cAAgB,SAAUC,EAAY+e,GAClD,IAAIuD,EAAY,cACZC,EAAmB,IAAiB,CAAED,UAAWA,GAAatiB,GAMlE,OALAtD,KAAK4pB,kBACkB3e,IAAnBoX,GAAgCA,GAAkB,EAC5C,IAAiBriB,KAAK4pB,aAAc,CAAC,YAAU/D,KAAoB5nB,OAAOokB,GAC1E,IAAiBriB,KAAK4pB,aAAc,CAAC,YAAU/D,KACzD7lB,KAAKkqB,wBACElqB,MAKXwpB,EAAMzvB,UAAUqxB,iBAAmB,WAG/B,OAFAprB,KAAK4pB,aAAe,GACpB5pB,KAAKkqB,wBACElqB,MAMXwpB,EAAMzvB,UAAUsxB,kBAAoB,SAAUnoB,GAE1CA,EAAMsnB,YAActnB,EAAMsnB,YACpBntB,MAAMC,QAAQ4F,EAAMsnB,aAChBtnB,EAAMsnB,YACN,CAACtnB,EAAMsnB,aACX,GAEFxqB,KAAKyqB,eACLvnB,EAAMsnB,YAActnB,EAAMsnB,YAAYhpB,OAAOxB,KAAKyqB,eAGlDvnB,EAAMsnB,cAAgBtnB,EAAMsnB,YAAYxuB,eACjCkH,EAAMsnB,aAWrBhB,EAAMzvB,UAAU8R,aAAe,SAAU3I,EAAOgG,GA0B5C,OAzBIlJ,KAAK+pB,QAAU/vB,OAAOQ,KAAKwF,KAAK+pB,QAAQ/tB,SACxCkH,EAAMY,MAAQ,IAAiB,GAAI9D,KAAK+pB,OAAQ7mB,EAAMY,QAEtD9D,KAAK8pB,OAAS9vB,OAAOQ,KAAKwF,KAAK8pB,OAAO9tB,SACtCkH,EAAMU,KAAO,IAAiB,GAAI5D,KAAK8pB,MAAO5mB,EAAMU,OAEpD5D,KAAK6pB,OAAS7vB,OAAOQ,KAAKwF,KAAK6pB,OAAO7tB,SACtCkH,EAAMe,KAAO,IAAiB,GAAIjE,KAAK6pB,MAAO3mB,EAAMe,OAEpDjE,KAAKgqB,UAAYhwB,OAAOQ,KAAKwF,KAAKgqB,UAAUhuB,SAC5CkH,EAAMooB,SAAW,IAAiB,GAAItrB,KAAKgqB,SAAU9mB,EAAMooB,WAE3DtrB,KAAKoN,SACLlK,EAAMxB,MAAQ1B,KAAKoN,QAEnBpN,KAAK6qB,eACL3nB,EAAM0nB,YAAc5qB,KAAK6qB,cAEzB7qB,KAAKgrB,QACL9nB,EAAMooB,SAAWpoB,EAAMooB,UAAY,GACnCpoB,EAAMooB,SAASC,MAAQvrB,KAAKgrB,MAAMQ,mBAEtCxrB,KAAKqrB,kBAAkBnoB,GACvBA,EAAMuoB,YAAc,IAAkBvoB,EAAMuoB,aAAe,GAAKzrB,KAAK4pB,cACrE1mB,EAAMuoB,YAAcvoB,EAAMuoB,YAAYzvB,OAAS,EAAIkH,EAAMuoB,iBAAcxgB,EAChEjL,KAAKmqB,uBAAuB,IAAiBuB,IAA4B1rB,KAAK2pB,kBAAmBzmB,EAAOgG,IAE5GsgB,EArRe,GA2R1B,SAASkC,IACL,IAAI/uB,EAAS,cAGb,OAFAA,EAAO+pB,WAAa/pB,EAAO+pB,YAAc,GACzC/pB,EAAO+pB,WAAWiF,sBAAwBhvB,EAAO+pB,WAAWiF,uBAAyB,GAC9EhvB,EAAO+pB,WAAWiF,sBAMtB,SAASC,EAAwBxoB,GACpCsoB,IAA2BpqB,KAAK8B,K,iCC5SpC,ufAMO,SAASyoB,EAAeC,EAAKrgB,GAEhC,OAAOqgB,EAAIC,QAAQtgB,GAOhB,SAASugB,IAEZ,MAAwF,qBAAjFhyB,OAAOD,UAAUyB,SAASJ,UAAwB,IAAZ6wB,EAA0BA,EAAU,GAErF,IAAIC,EAAuB,GAMpB,SAASC,IACZ,OAAQH,IACFrvB,EACkB,oBAAXC,OACHA,OACgB,oBAATyX,KACHA,KACA6X,EAOX,SAASE,IACZ,IAAIzvB,EAASwvB,IACTE,EAAS1vB,EAAO0vB,QAAU1vB,EAAO2vB,SACrC,QAAiB,IAAXD,GAAsBA,EAAOE,gBAAiB,CAEhD,IAAIC,EAAM,IAAIC,YAAY,GAC1BJ,EAAOE,gBAAgBC,GAGvBA,EAAI,GAAe,KAATA,EAAI,GAAc,MAG5BA,EAAI,GAAe,MAATA,EAAI,GAAe,MAC7B,IAAIE,EAAM,SAAUC,GAEhB,IADA,IAAIC,EAAID,EAAInxB,SAAS,IACdoxB,EAAE5wB,OAAS,GACd4wB,EAAI,IAAMA,EAEd,OAAOA,GAEX,OAAQF,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAAME,EAAIF,EAAI,IAGtH,MAAO,mCAAmCK,QAAQ,SAAS,SAAUC,GAEjE,IAAI7rB,EAAqB,GAAhBiL,KAAKC,SAAiB,EAG/B,OADc,MAAN2gB,EAAY7rB,EAAS,EAAJA,EAAW,GAC3BzF,SAAS,OAUnB,SAASuxB,EAASrhB,GACrB,IAAKA,EACD,MAAO,GAEX,IAAIjG,EAAQiG,EAAIjG,MAAM,kEACtB,IAAKA,EACD,MAAO,GAGX,IAAIunB,EAAQvnB,EAAM,IAAM,GACpBwnB,EAAWxnB,EAAM,IAAM,GAC3B,MAAO,CACHP,KAAMO,EAAM,GACZN,KAAMM,EAAM,GACZF,SAAUE,EAAM,GAChB8W,SAAU9W,EAAM,GAAKunB,EAAQC,GAO9B,SAASC,EAAoBhqB,GAChC,GAAIA,EAAMlI,QACN,OAAOkI,EAAMlI,QAEjB,GAAIkI,EAAMrF,WAAaqF,EAAMrF,UAAU2N,QAAUtI,EAAMrF,UAAU2N,OAAO,GAAI,CACxE,IAAI3N,EAAYqF,EAAMrF,UAAU2N,OAAO,GACvC,OAAI3N,EAAUvC,MAAQuC,EAAUzD,MACrByD,EAAUvC,KAAO,KAAOuC,EAAUzD,MAEtCyD,EAAUvC,MAAQuC,EAAUzD,OAAS8I,EAAMmG,UAAY,YAElE,OAAOnG,EAAMmG,UAAY,YAGtB,SAAS8jB,EAAe/pB,GAC3B,IAAIzG,EAASwvB,IAEb,KAAM,YAAaxvB,GACf,OAAOyG,IAEX,IAAIgqB,EAAkBzwB,EAAOib,QACzByV,EAAgB,GALP,CAAC,QAAS,OAAQ,OAAQ,QAAS,MAAO,UAOhDtnB,SAAQ,SAAUrE,GACjBA,KAAS/E,EAAOib,SAAWwV,EAAgB1rB,GAAOxH,sBAClDmzB,EAAc3rB,GAAS0rB,EAAgB1rB,GACvC0rB,EAAgB1rB,GAAS0rB,EAAgB1rB,GAAOxH,wBAIxD,IAAIsQ,EAASpH,IAKb,OAHApJ,OAAOQ,KAAK6yB,GAAetnB,SAAQ,SAAUrE,GACzC0rB,EAAgB1rB,GAAS2rB,EAAc3rB,MAEpC8I,EASJ,SAAS8iB,EAAsBpqB,EAAO9I,EAAOkB,GAChD4H,EAAMrF,UAAYqF,EAAMrF,WAAa,GACrCqF,EAAMrF,UAAU2N,OAAStI,EAAMrF,UAAU2N,QAAU,GACnDtI,EAAMrF,UAAU2N,OAAO,GAAKtI,EAAMrF,UAAU2N,OAAO,IAAM,GACzDtI,EAAMrF,UAAU2N,OAAO,GAAGpR,MAAQ8I,EAAMrF,UAAU2N,OAAO,GAAGpR,OAASA,GAAS,GAC9E8I,EAAMrF,UAAU2N,OAAO,GAAGlQ,KAAO4H,EAAMrF,UAAU2N,OAAO,GAAGlQ,MAAQA,GAAQ,QAQxE,SAASiyB,EAAsBrqB,EAAOmT,QACvB,IAAdA,IAAwBA,EAAY,IAExC,IAGInT,EAAMrF,UAAU2N,OAAO,GAAG6K,UAAYnT,EAAMrF,UAAU2N,OAAO,GAAG6K,WAAa,GAC7Erc,OAAOQ,KAAK6b,GAAWtQ,SAAQ,SAAUrL,GAErCwI,EAAMrF,UAAU2N,OAAO,GAAG6K,UAAU3b,GAAO2b,EAAU3b,MAG7D,MAAOe,KAOJ,SAAS+xB,IACZ,IACI,OAAO3wB,SAAS6d,SAASC,KAE7B,MAAOpF,GACH,MAAO,IASR,SAASkY,EAAiBC,GAK7B,IAUI,IATA,IAAIC,EAAcD,EAGdE,EAAM,GACNpN,EAAS,EACTqN,EAAM,EAENC,EADY,MACU9xB,OACtB+xB,OAAU,EACPJ,GAAenN,IARI,KAcN,UALhBuN,EAAUC,EAAqBL,KAKJnN,EAAS,GAAKqN,EAAMD,EAAI5xB,OAAS8xB,EAAYC,EAAQ/xB,QAb/D,KAgBjB4xB,EAAItsB,KAAKysB,GACTF,GAAOE,EAAQ/xB,OACf2xB,EAAcA,EAAYM,WAE9B,OAAOL,EAAIzd,UAAUvV,KAhBL,OAkBpB,MAAOa,GACH,MAAO,aAQf,SAASuyB,EAAqBE,GAC1B,IAEI9N,EACA+N,EACAzzB,EACA0zB,EACAlzB,EANAwyB,EAAOQ,EACPN,EAAM,GAMV,IAAKF,IAASA,EAAKpS,QACf,MAAO,GAOX,GALAsS,EAAItsB,KAAKosB,EAAKpS,QAAQ+S,eAClBX,EAAK9iB,IACLgjB,EAAItsB,KAAK,IAAMosB,EAAK9iB,KAExBwV,EAAYsN,EAAKtN,YACA,YAASA,GAEtB,IADA+N,EAAU/N,EAAUrkB,MAAM,OACrBb,EAAI,EAAGA,EAAIizB,EAAQnyB,OAAQd,IAC5B0yB,EAAItsB,KAAK,IAAM6sB,EAAQjzB,IAG/B,IAAIozB,EAAgB,CAAC,OAAQ,OAAQ,QAAS,OAC9C,IAAKpzB,EAAI,EAAGA,EAAIozB,EAActyB,OAAQd,IAClCR,EAAM4zB,EAAcpzB,IACpBkzB,EAAOV,EAAKa,aAAa7zB,KAErBkzB,EAAItsB,KAAK,IAAM5G,EAAM,KAAQ0zB,EAAO,MAG5C,OAAOR,EAAIhzB,KAAK,IAKb,SAAS4zB,IACZ,OAAO,IAAI1c,MAAO2c,UAAY,IA2B3B,SAASC,EAAsB3c,EAAK9K,GACvC,IAAKA,EACD,OARgB,IAUpB,IAAI0nB,EAAczoB,SAAS,GAAKe,EAAQ,IACxC,IAAKhB,MAAM0oB,GACP,OAAqB,IAAdA,EAEX,IAAIC,EAAa9c,KAAKnU,MAAM,GAAKsJ,GACjC,OAAKhB,MAAM2oB,GAfS,IAgBTA,EAAa7c,EAQrB,SAAS8c,EAAgBhZ,GAC5B,IACI,OAAKA,GAAoB,mBAAPA,GAGXA,EAAGlc,MATQ,cAWtB,MAAOuH,GAGH,MAdkB,kB,0DCjT1B,mHAQO,SAAS4tB,EAAStpB,EAAKupB,GAG1B,YAFY,IAARA,IAAkBA,EAAM,GAET,iBAARvpB,GAA4B,IAARupB,GAGxBvpB,EAAIxJ,QAAU+yB,EAFVvpB,EAEsBA,EAAIwpB,OAAO,EAAGD,GAAO,MA6CnD,SAASE,EAASvxB,EAAOwxB,GAC5B,IAAK7xB,MAAMC,QAAQI,GACf,MAAO,GAIX,IAFA,IAAIyxB,EAAS,GAEJj0B,EAAI,EAAGA,EAAIwC,EAAM1B,OAAQd,IAAK,CACnC,IAAId,EAAQsD,EAAMxC,GAClB,IACIi0B,EAAO7tB,KAAKmZ,OAAOrgB,IAEvB,MAAO8G,GACHiuB,EAAO7tB,KAAK,iCAGpB,OAAO6tB,EAAOv0B,KAAKs0B,GAOhB,SAASE,EAAkBh1B,EAAOgb,GACrC,OAAI,YAASA,GACFA,EAAQzH,KAAKvT,GAED,iBAAZgb,IAC4B,IAA5Bhb,EAAM4N,QAAQoN,K,wFCtF7B,YACA,QAEA,SAEMia,EACmB,sBAUnBC,EAA2B,CAC7BtM,aAAa,EACbE,kBAAkB,EAClBE,mBAAmB,EACnBR,qBAAiB3X,GAOR,EAAA2U,UAAY,CACrBC,aAAc,SAACF,GACX,IAAMqD,EAAcrD,EAAM0P,GAA+BE,MAAM,CAC3D,gBAEE3M,EAAkBjD,EAAM0P,GAA+BE,MAAM,CAC/D,oBAEErM,EAAmBvD,EAAM0P,GAA+BE,MAAM,CAChE,qBAKJ,MAAO,CACHvM,YAAW,EACXJ,gBAAe,EACfQ,kBANsBzD,EAAM0P,GAA+BE,MAAM,CACjE,sBAMArM,iBAAgB,KAI5B,IAAMsM,EACc,mBADdA,EAEoB,yBAFpBA,EAGqB,0BAGrBC,EAAW,EAAAC,gBAAa,MAErBF,GAA+B,SAAC7P,EAAO,G,IAAEgQ,EAAA,EAAAA,QACtC,OAAOhQ,EACFiQ,MAAM,CAAC,gBAAgB,GACvBA,MAAM,CAAC,mBAAoBD,IAEpC,EAACH,GAAqC,SAAC7P,GACnC,OAAOA,EAAMiQ,MAAM,CAAC,qBAAqB,IAE7C,EAACJ,GAAsC,SAAC7P,GACpC,OAAOA,EAAMiQ,MAAM,CAAC,sBAAsB,I,GAGlD,EAAAC,IAAIP,IAGR,UAAeG,G,gCCxEf,oEA6BO,IAAIpvB,EAAW,WAQlB,OAPAA,EAAWrG,OAAOsG,QAAU,SAAkBC,GAC1C,IAAK,IAAIC,EAAGtF,EAAI,EAAGuF,EAAIC,UAAU1E,OAAQd,EAAIuF,EAAGvF,IAE5C,IAAK,IAAI2E,KADTW,EAAIE,UAAUxF,GACOlB,OAAOD,UAAUoB,eAAeC,KAAKoF,EAAGX,KAAIU,EAAEV,GAAKW,EAAEX,IAE9E,OAAOU,IAEKI,MAAMX,KAAMU,YAgFzB,SAASE,EAAOC,EAAGJ,GACtB,IAAIK,EAAsB,mBAAXC,QAAyBF,EAAEE,OAAOC,UACjD,IAAKF,EAAG,OAAOD,EACf,IAAmBI,EAAYC,EAA3BhG,EAAI4F,EAAE1F,KAAKyF,GAAOM,EAAK,GAC3B,IACI,WAAc,IAANV,GAAgBA,KAAM,MAAQQ,EAAI/F,EAAEkG,QAAQC,MAAMF,EAAGG,KAAKL,EAAE7G,OAExE,MAAOU,GAASoG,EAAI,CAAEpG,MAAOA,GAC7B,QACI,IACQmG,IAAMA,EAAEI,OAASP,EAAI5F,EAAU,SAAI4F,EAAE1F,KAAKF,GAElD,QAAU,GAAIgG,EAAG,MAAMA,EAAEpG,OAE7B,OAAOqG,EAGJ,SAASI,IACZ,IAAK,IAAIJ,EAAK,GAAIjG,EAAI,EAAGA,EAAIwF,UAAU1E,OAAQd,IAC3CiG,EAAKA,EAAGK,OAAOZ,EAAOF,UAAUxF,KACpC,OAAOiG","file":"bundle.7eefe1acc16af0bcc428.js","sourcesContent":["import { isElement, isError, isEvent, isInstanceOf, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName, htmlTreeAsString } from './misc';\nimport { truncate } from './string';\n/**\n * Wrap a given object method with a higher-order function\n *\n * @param source An object that contains a method to be wrapped.\n * @param name A name of method to be wrapped.\n * @param replacement A function that should be used to wrap a given method.\n * @returns void\n */\nexport function fill(source, name, replacement) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacement(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    // tslint:disable-next-line:strict-type-predicates\n    if (typeof wrapped === 'function') {\n        try {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(\n    // tslint:disable-next-line:no-unsafe-any\n    function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all it's attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (isError(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (isEvent(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = isElement(event_1.target)\n                ? htmlTreeAsString(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = isElement(event_1.currentTarget)\n                ? htmlTreeAsString(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        // tslint:disable-next-line:strict-type-predicates\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // tslint:disable-next-line:no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nexport function normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/** Transforms any input value into a string form, either primitive value or a type of the input */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return isPrimitive(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\n// tslint:disable-next-line:cyclomatic-complexity\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n        return '[SyntheticEvent]';\n    }\n    // tslint:disable-next-line:no-tautology-expression\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + getFunctionName(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\nexport function walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new Memo(); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    // If value implements `toJSON` method, call it and return early\n    // tslint:disable:no-unsafe-any\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    // tslint:enable:no-unsafe-any\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (isPrimitive(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\nexport function normalize(input, depth) {\n    try {\n        // tslint:disable-next-line:no-unsafe-any\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\n    }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    // tslint:disable:strict-type-predicates\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return truncate(serialized, maxLength);\n    }\n    return '';\n}\n//# sourceMappingURL=object.js.map","export { default } from './Container';\nexport { default as reducers } from './reducers';\n","/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat) {\n    // tslint:disable-next-line:strict-type-predicates\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat) {\n    // tslint:disable-next-line:strict-type-predicates\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // tslint:disable:no-unsafe-any\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n    // tslint:enable:no-unsafe-any\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat) {\n    // tslint:disable-next-line:no-unsafe-any\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat, base) {\n    try {\n        // tslint:disable-next-line:no-unsafe-any\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","/** JSDoc */\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map","/** The status of an event. */\nexport var Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// tslint:disable:completed-docs\n// tslint:disable:no-unnecessary-qualifier no-namespace\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import * as tslib_1 from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // tslint:disable-next-line:no-unsafe-any\n        return hub[method].apply(hub, tslib_1.__spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\nexport function captureException(exception) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param level Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, level) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureMessage', message, level, {\n        originalException: message,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normailzed.\n */\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normailzed.\n */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n * @param key String key of tag\n * @param value String value of tag\n */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, tslib_1.__spread(['_invokeClient', method], args));\n}\n//# sourceMappingURL=index.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties); // tslint:disable-line:no-unbound-method\n/**\n * setPrototypeOf polyfill using __proto__\n */\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map","import * as tslib_1 from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    tslib_1.__extends(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        // tslint:disable:no-unsafe-any\n        _this.name = _newTarget.prototype.constructor.name;\n        setPrototypeOf(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\nexport { SentryError };\n//# sourceMappingURL=error.js.map","import * as tslib_1 from \"tslib\";\nimport { SentryError } from './error';\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w\\.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\n    }\n    /**\n     * Renders the string representation of this Dsn.\n     *\n     * By default, this will render the public representation without the password\n     * component. To get the deprecated private _representation, set `withPassword`\n     * to true.\n     *\n     * @param withPassword When set to true, the password will be included.\n     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        // tslint:disable-next-line:no-this-assignment\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, user = _a.user;\n        return (protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') +\n            (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId));\n    };\n    /** Parses a string into this Dsn. */\n    Dsn.prototype._fromString = function (str) {\n        var match = DSN_REGEX.exec(str);\n        if (!match) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        var _a = tslib_1.__read(match.slice(1), 6), protocol = _a[0], user = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];\n        var path = '';\n        var projectId = lastPath;\n        var split = projectId.split('/');\n        if (split.length > 1) {\n            path = split.slice(0, -1).join('/');\n            projectId = split.pop();\n        }\n        this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, user: user });\n    };\n    /** Maps Dsn components into this instance. */\n    Dsn.prototype._fromComponents = function (components) {\n        this.protocol = components.protocol;\n        this.user = components.user;\n        this.pass = components.pass || '';\n        this.host = components.host;\n        this.port = components.port || '';\n        this.path = components.path || '';\n        this.projectId = components.projectId;\n    };\n    /** Validates this Dsn and throws on error. */\n    Dsn.prototype._validate = function () {\n        var _this = this;\n        ['protocol', 'user', 'host', 'projectId'].forEach(function (component) {\n            if (!_this[component]) {\n                throw new SentryError(ERROR_MESSAGE);\n            }\n        });\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n    };\n    return Dsn;\n}());\nexport { Dsn };\n//# sourceMappingURL=dsn.js.map","import { Dsn, timestampWithMs, urlEncode } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/** Helper class to provide urls to different Sentry endpoints. */\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn) {\n        this.dsn = dsn;\n        this._dsnObject = new Dsn(dsn);\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns a string with auth headers in the url to the store endpoint. */\n    API.prototype.getStoreEndpoint = function () {\n        return \"\" + this._getBaseUrl() + this.getStoreEndpointPath();\n    };\n    /** Returns the store endpoint with auth added in url encoded. */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        // Auth is intentionally sent as part of query string (NOT as custom HTTP header)\n        // to avoid preflight CORS requests\n        return this.getStoreEndpoint() + \"?\" + urlEncode(auth);\n    };\n    /** Returns the base path of the url including the port. */\n    API.prototype._getBaseUrl = function () {\n        var dsn = this._dsnObject;\n        var protocol = dsn.protocol ? dsn.protocol + \":\" : '';\n        var port = dsn.port ? \":\" + dsn.port : '';\n        return protocol + \"//\" + dsn.host + port;\n    };\n    /** Returns only the path component for the store endpoint. */\n    API.prototype.getStoreEndpointPath = function () {\n        var dsn = this._dsnObject;\n        return (dsn.path ? \"/\" + dsn.path : '') + \"/api/\" + dsn.projectId + \"/store/\";\n    };\n    /** Returns an object that can be used in request headers. */\n    API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n        var dsn = this._dsnObject;\n        var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n        header.push(\"sentry_timestamp=\" + timestampWithMs()); // TODO: This can be removed\n        header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n        header.push(\"sentry_key=\" + dsn.user);\n        if (dsn.pass) {\n            header.push(\"sentry_secret=\" + dsn.pass);\n        }\n        return {\n            'Content-Type': 'application/json',\n            'X-Sentry-Auth': header.join(', '),\n        };\n    };\n    /** Returns the url to the report dialog endpoint. */\n    API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n        if (dialogOptions === void 0) { dialogOptions = {}; }\n        var dsn = this._dsnObject;\n        var endpoint = \"\" + this._getBaseUrl() + (dsn.path ? \"/\" + dsn.path : '') + \"/api/embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\n            if (key === 'user') {\n                if (!dialogOptions.user) {\n                    continue;\n                }\n                if (dialogOptions.user.name) {\n                    encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n                }\n                if (dialogOptions.user.email) {\n                    encodedOptions.push(\"email=\" + encodeURIComponent(dialogOptions.user.email));\n                }\n            }\n            else {\n                encodedOptions.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(dialogOptions[key]));\n            }\n        }\n        if (encodedOptions.length) {\n            return endpoint + \"?\" + encodedOptions.join('&');\n        }\n        return endpoint;\n    };\n    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\nexport var installedIntegrations = [];\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && tslib_1.__spread(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) { return i.name; });\n        var pickedIntegrationsNames_1 = [];\n        // Leave only unique default integrations, that were not overridden with provided user integrations\n        defaultIntegrations.forEach(function (defaultIntegration) {\n            if (userIntegrationsNames_1.indexOf(defaultIntegration.name) === -1 &&\n                pickedIntegrationsNames_1.indexOf(defaultIntegration.name) === -1) {\n                integrations.push(defaultIntegration);\n                pickedIntegrationsNames_1.push(defaultIntegration.name);\n            }\n        });\n        // Don't add same user integration twice\n        userIntegrations.forEach(function (userIntegration) {\n            if (pickedIntegrationsNames_1.indexOf(userIntegration.name) === -1) {\n                integrations.push(userIntegration);\n                pickedIntegrationsNames_1.push(userIntegration.name);\n            }\n        });\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    else {\n        integrations = tslib_1.__spread(defaultIntegrations);\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) { return i.name; });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, tslib_1.__spread(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));\n    }\n    return integrations;\n}\n/** Setup given integration */\nexport function setupIntegration(integration) {\n    if (installedIntegrations.indexOf(integration.name) !== -1) {\n        return;\n    }\n    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n    installedIntegrations.push(integration.name);\n    logger.log(\"Integration installed: \" + integration.name);\n}\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(options) {\n    var integrations = {};\n    getIntegrationsToSetup(options).forEach(function (integration) {\n        integrations[integration.name] = integration;\n        setupIntegration(integration);\n    });\n    return integrations;\n}\n//# sourceMappingURL=integration.js.map","import * as tslib_1 from \"tslib\";\nimport { Dsn, isPrimitive, isThenable, logger, SyncPromise, truncate, uuid4 } from '@sentry/utils';\nimport { setupIntegrations } from './integration';\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event via the backend, it is passed through\n * {@link BaseClient.prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nvar BaseClient = /** @class */ (function () {\n    /**\n     * Initializes this client instance.\n     *\n     * @param backendClass A constructor function to create the backend.\n     * @param options Options for the client.\n     */\n    function BaseClient(backendClass, options) {\n        /** Array of used integrations. */\n        this._integrations = {};\n        /** Is the client still processing a call? */\n        this._processing = false;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new Dsn(options.dsn);\n        }\n        if (this._isEnabled()) {\n            this._integrations = setupIntegrations(this._options);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._processEvent(event, hint, scope); })\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(\"\" + message, level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        promisedEvent\n            .then(function (event) { return _this._processEvent(event, hint, scope); })\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._processing = true;\n        this._processEvent(event, hint, scope)\n            .then(function (finalEvent) {\n            // We need to check for finalEvent in case beforeSend returned null\n            eventId = finalEvent && finalEvent.event_id;\n            _this._processing = false;\n        })\n            .then(null, function (reason) {\n            logger.error(reason);\n            _this._processing = false;\n        });\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getDsn = function () {\n        return this._dsn;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getOptions = function () {\n        return this._options;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.flush = function (timeout) {\n        var _this = this;\n        return this._isClientProcessing(timeout).then(function (status) {\n            clearInterval(status.interval);\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return status.ready && transportFlushed; });\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.close = function (timeout) {\n        var _this = this;\n        return this.flush(timeout).then(function (result) {\n            _this.getOptions().enabled = false;\n            return result;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegrations = function () {\n        return this._integrations || {};\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = 0;\n            clearInterval(interval);\n            interval = setInterval(function () {\n                if (!_this._processing) {\n                    resolve({\n                        interval: interval,\n                        ready: true,\n                    });\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        resolve({\n                            interval: interval,\n                            ready: false,\n                        });\n                    }\n                }\n            }, tick);\n        });\n    };\n    /** Returns the current backend. */\n    BaseClient.prototype._getBackend = function () {\n        return this._backend;\n    };\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n    BaseClient.prototype._isEnabled = function () {\n        return this.getOptions().enabled !== false && this._dsn !== undefined;\n    };\n    /**\n     * Adds common information to events.\n     *\n     * The information includes release and environment from `options`,\n     * breadcrumbs and context (extra, tags and user) from the scope.\n     *\n     * Information that is already present in the event is never overwritten. For\n     * nested objects, such as the context, keys are merged.\n     *\n     * @param event The original event.\n     * @param hint May contain additional informartion about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A new event with more information.\n     */\n    BaseClient.prototype._prepareEvent = function (event, scope, hint) {\n        var _a = this.getOptions(), environment = _a.environment, release = _a.release, dist = _a.dist, _b = _a.maxValueLength, maxValueLength = _b === void 0 ? 250 : _b;\n        var prepared = tslib_1.__assign({}, event);\n        if (prepared.environment === undefined && environment !== undefined) {\n            prepared.environment = environment;\n        }\n        if (prepared.release === undefined && release !== undefined) {\n            prepared.release = release;\n        }\n        if (prepared.dist === undefined && dist !== undefined) {\n            prepared.dist = dist;\n        }\n        if (prepared.message) {\n            prepared.message = truncate(prepared.message, maxValueLength);\n        }\n        var exception = prepared.exception && prepared.exception.values && prepared.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = truncate(exception.value, maxValueLength);\n        }\n        var request = prepared.request;\n        if (request && request.url) {\n            request.url = truncate(request.url, maxValueLength);\n        }\n        if (prepared.event_id === undefined) {\n            prepared.event_id = uuid4();\n        }\n        this._addIntegrations(prepared.sdk);\n        // We prepare the result here with a resolved Event.\n        var result = SyncPromise.resolve(prepared);\n        // This should be the last thing called, since we want that\n        // {@link Hub.addEventProcessor} gets the finished prepared event.\n        if (scope) {\n            // In case we have a hub we reassign it.\n            result = scope.applyToEvent(prepared, hint);\n        }\n        return result;\n    };\n    /**\n     * This function adds all used integrations to the SDK info in the event.\n     * @param sdkInfo The sdkInfo of the event that will be filled with all integrations.\n     */\n    BaseClient.prototype._addIntegrations = function (sdkInfo) {\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\n        }\n    };\n    /**\n     * Processes an event (either error or message) and sends it to Sentry.\n     *\n     * This also adds breadcrumbs and context information to the event. However,\n     * platform specific meta data (such as the User's IP address) must be added\n     * by the SDK implementor.\n     *\n     *\n     * @param event The event to send to Sentry.\n     * @param hint May contain additional informartion about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n     */\n    BaseClient.prototype._processEvent = function (event, hint, scope) {\n        var _this = this;\n        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject('SDK not enabled, will not send event.');\n        }\n        // 1.0 === 100% events are sent\n        // 0.0 === 0% events are sent\n        if (typeof sampleRate === 'number' && Math.random() > sampleRate) {\n            return SyncPromise.reject('This event has been sampled, will not send event.');\n        }\n        return new SyncPromise(function (resolve, reject) {\n            _this._prepareEvent(event, scope, hint)\n                .then(function (prepared) {\n                if (prepared === null) {\n                    reject('An event processor returned null, will not send event.');\n                    return;\n                }\n                var finalEvent = prepared;\n                try {\n                    var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n                    if (isInternalException || !beforeSend) {\n                        _this._getBackend().sendEvent(finalEvent);\n                        resolve(finalEvent);\n                        return;\n                    }\n                    var beforeSendResult = beforeSend(prepared, hint);\n                    // tslint:disable-next-line:strict-type-predicates\n                    if (typeof beforeSendResult === 'undefined') {\n                        logger.error('`beforeSend` method has to return `null` or a valid event.');\n                    }\n                    else if (isThenable(beforeSendResult)) {\n                        _this._handleAsyncBeforeSend(beforeSendResult, resolve, reject);\n                    }\n                    else {\n                        finalEvent = beforeSendResult;\n                        if (finalEvent === null) {\n                            logger.log('`beforeSend` returned `null`, will not send event.');\n                            resolve(null);\n                            return;\n                        }\n                        // From here on we are really async\n                        _this._getBackend().sendEvent(finalEvent);\n                        resolve(finalEvent);\n                    }\n                }\n                catch (exception) {\n                    _this.captureException(exception, {\n                        data: {\n                            __sentry__: true,\n                        },\n                        originalException: exception,\n                    });\n                    reject('`beforeSend` threw an error, will not send event.');\n                }\n            })\n                .then(null, function () {\n                reject('`beforeSend` threw an error, will not send event.');\n            });\n        });\n    };\n    /**\n     * Resolves before send Promise and calls resolve/reject on parent SyncPromise.\n     */\n    BaseClient.prototype._handleAsyncBeforeSend = function (beforeSend, resolve, reject) {\n        var _this = this;\n        beforeSend\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                reject('`beforeSend` returned `null`, will not send event.');\n                return;\n            }\n            // From here on we are really async\n            _this._getBackend().sendEvent(processedEvent);\n            resolve(processedEvent);\n        })\n            .then(null, function (e) {\n            reject(\"beforeSend rejected with \" + e);\n        });\n    };\n    return BaseClient;\n}());\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map","import { Status } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n/** Noop transport */\nvar NoopTransport = /** @class */ (function () {\n    function NoopTransport() {\n    }\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.sendEvent = function (_) {\n        return SyncPromise.resolve({\n            reason: \"NoopTransport: Event has been skipped because no Dsn is configured.\",\n            status: Status.Skipped,\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    NoopTransport.prototype.close = function (_) {\n        return SyncPromise.resolve(true);\n    };\n    return NoopTransport;\n}());\nexport { NoopTransport };\n//# sourceMappingURL=noop.js.map","import { logger, SentryError } from '@sentry/utils';\nimport { NoopTransport } from './transports/noop';\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nvar BaseBackend = /** @class */ (function () {\n    /** Creates a new backend instance. */\n    function BaseBackend(options) {\n        this._options = options;\n        if (!this._options.dsn) {\n            logger.warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\n    }\n    /**\n     * Sets up the transport so it can be used later to send requests.\n     */\n    BaseBackend.prototype._setupTransport = function () {\n        return new NoopTransport();\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new SentryError('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new SentryError('Backend has to implement `eventFromMessage` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendEvent = function (event) {\n        this._transport.sendEvent(event).then(null, function (reason) {\n            logger.error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent() {\n    try {\n        // tslint:disable:no-unused-expression\n        new ErrorEvent('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError() {\n    try {\n        // It really needs 1 argument, not 0.\n        // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n        // 1 argument required, but only 0 present.\n        // @ts-ignore\n        // tslint:disable:no-unused-expression\n        new DOMError('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException() {\n    try {\n        // tslint:disable:no-unused-expression\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch() {\n    if (!('fetch' in getGlobalObject())) {\n        return false;\n    }\n    try {\n        // tslint:disable-next-line:no-unused-expression\n        new Headers();\n        // tslint:disable-next-line:no-unused-expression\n        new Request('');\n        // tslint:disable-next-line:no-unused-expression\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch() {\n    if (!supportsFetch()) {\n        return false;\n    }\n    var global = getGlobalObject();\n    // Fast path to avoid DOM I/O\n    // tslint:disable-next-line:no-unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\n    }\n    // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n    // so create a \"pure\" iframe to see if that has native fetch\n    var result = false;\n    var doc = global.document;\n    if (doc) {\n        var sandbox = doc.createElement('iframe');\n        sandbox.hidden = true;\n        try {\n            doc.head.appendChild(sandbox);\n            if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                // tslint:disable-next-line:no-unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver() {\n    // tslint:disable-next-line: no-unsafe-any\n    return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy() {\n    // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        // tslint:disable:no-unused-expression\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory() {\n    // NOTE: in Chrome App environment, touching history.pushState, *even inside\n    //       a try/catch block*, will cause Chrome to output an error to console.error\n    // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n    var global = getGlobalObject();\n    var chrome = global.chrome;\n    // tslint:disable-next-line:no-unsafe-any\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map","// tslint:disable:object-literal-sort-keys\nimport * as tslib_1 from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|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.\nvar gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js))(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n/** JSDoc */\nexport function computeStackTrace(ex) {\n    // tslint:disable:no-unsafe-any\n    var stack = null;\n    var popSize = ex && ex.framesToPop;\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// tslint:disable-next-line:cyclomatic-complexity\nfunction computeStackTraceFromStackProp(ex) {\n    // tslint:disable:no-conditional-assignment\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\n                // throw out eval line/column and use top-most line/column number\n                parts[2] = submatch[1]; // url\n                parts[3] = submatch[2]; // line\n                parts[4] = submatch[3]; // column\n            }\n            element = {\n                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        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\n                // throw out eval line/column and use top-most line number\n                parts[1] = parts[1] || \"eval\";\n                parts[3] = submatch[1];\n                parts[4] = submatch[2];\n                parts[5] = ''; // no column when eval\n            }\n            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            element = {\n                url: parts[3],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\n    }\n    // Access and store the stacktrace property before doing ANYTHING\n    // else to it because Opera is not very good at providing it\n    // reliably in other circumstances.\n    var stacktrace = ex.stacktrace;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^\\)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        // tslint:disable:no-conditional-assignment\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return tslib_1.__assign({}, stacktrace, { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\n    }\n}\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n    var message = ex && ex.message;\n    if (!message) {\n        return 'No error message';\n    }\n    if (message.error && typeof message.error.message === 'string') {\n        return message.error.message;\n    }\n    return message;\n}\n//# sourceMappingURL=tracekit.js.map","import { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\nimport { computeStackTrace } from './tracekit';\nvar STACKTRACE_LIMIT = 50;\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    // tslint:disable-next-line:strict-type-predicates\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nexport function eventFromPlainObject(exception, syntheticException, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\n    // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n    if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n        localStack = localStack.slice(1);\n    }\n    // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n    if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n        localStack = localStack.slice(0, -1);\n    }\n    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .slice(0, STACKTRACE_LIMIT)\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map","import { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/** JSDoc */\nexport function eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event;\n    if (isErrorEvent(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        exception = errorEvent.error; // tslint:disable-line:no-parameter-reassignment\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isDOMError(exception) || isDOMException(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\n        var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        addExceptionTypeValue(event, message);\n        return event;\n    }\n    if (isError(exception)) {\n        // we have a real Error object, do nothing\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, options.rejection);\n        addExceptionMechanism(event, {\n            synthetic: true,\n        });\n        return event;\n    }\n    // If none of previous checks were valid, then it means that it's not:\n    // - an instance of DOMError\n    // - an instance of DOMException\n    // - an instance of Event\n    // - an instance of Error\n    // - a valid ErrorEvent (one with an error property)\n    // - a plain Object\n    //\n    // So bail out and capture it as a simple message:\n    event = eventFromString(exception, syntheticException, options);\n    addExceptionTypeValue(event, \"\" + exception, undefined);\n    addExceptionMechanism(event, {\n        synthetic: true,\n    });\n    return event;\n}\n// this._options.attachStacktrace\n/** JSDoc */\nexport function eventFromString(input, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map","import { SentryError } from './error';\nimport { SyncPromise } from './syncpromise';\n/** A simple queue that holds promises. */\nvar PromiseBuffer = /** @class */ (function () {\n    function PromiseBuffer(_limit) {\n        this._limit = _limit;\n        /** Internal set of queued Promises */\n        this._buffer = [];\n    }\n    /**\n     * Says if the buffer is ready to take more requests\n     */\n    PromiseBuffer.prototype.isReady = function () {\n        return this._limit === undefined || this.length() < this._limit;\n    };\n    /**\n     * Add a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns The original promise.\n     */\n    PromiseBuffer.prototype.add = function (task) {\n        var _this = this;\n        if (!this.isReady()) {\n            return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));\n        }\n        if (this._buffer.indexOf(task) === -1) {\n            this._buffer.push(task);\n        }\n        task\n            .then(function () { return _this.remove(task); })\n            .then(null, function () {\n            return _this.remove(task).then(null, function () {\n                // We have to add this catch here otherwise we have an unhandledPromiseRejection\n                // because it's a new Promise chain.\n            });\n        });\n        return task;\n    };\n    /**\n     * Remove a promise to the queue.\n     *\n     * @param task Can be any PromiseLike<T>\n     * @returns Removed promise.\n     */\n    PromiseBuffer.prototype.remove = function (task) {\n        var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];\n        return removedTask;\n    };\n    /**\n     * This function returns the number of unresolved promises in the queue.\n     */\n    PromiseBuffer.prototype.length = function () {\n        return this._buffer.length;\n    };\n    /**\n     * This will drain the whole queue, returns true if queue is empty or drained.\n     * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.\n     *\n     * @param timeout Number in ms to wait until it resolves with false.\n     */\n    PromiseBuffer.prototype.drain = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var capturedSetTimeout = setTimeout(function () {\n                if (timeout && timeout > 0) {\n                    resolve(false);\n                }\n            }, timeout);\n            SyncPromise.all(_this._buffer)\n                .then(function () {\n                clearTimeout(capturedSetTimeout);\n                resolve(true);\n            })\n                .then(null, function () {\n                resolve(true);\n            });\n        });\n    };\n    return PromiseBuffer;\n}());\nexport { PromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map","var originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\nvar FunctionToString = /** @class */ (function () {\n    function FunctionToString() {\n        /**\n         * @inheritDoc\n         */\n        this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.prototype.setupOnce = function () {\n        originalFunctionToString = Function.prototype.toString;\n        Function.prototype.toString = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var context = this.__sentry_original__ || this;\n            // tslint:disable-next-line:no-unsafe-any\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}());\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map","import { API } from '@sentry/core';\nimport { PromiseBuffer, SentryError } from '@sentry/utils';\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = new PromiseBuffer(30);\n        this.url = new API(this.options.dsn).getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new SentryError('Transport Class has to implement `sendEvent` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import * as tslib_1 from \"tslib\";\nimport { Status } from '@sentry/types';\nimport { getGlobalObject, logger, parseRetryAfterHeader, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    tslib_1.__extends(FetchTransport, _super);\n    function FetchTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var defaultOptions = {\n            body: JSON.stringify(event),\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),\n        };\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            global\n                .fetch(_this.url, defaultOptions)\n                .then(function (response) {\n                var status = Status.fromHttpCode(response.status);\n                if (status === Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + parseRetryAfterHeader(now, response.headers.get('Retry-After')));\n                    logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(response);\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map","import * as tslib_1 from \"tslib\";\nimport { Status } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    tslib_1.__extends(XHRTransport, _super);\n    function XHRTransport() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        /** Locks transport after receiving 429 response */\n        _this._disabledUntil = new Date(Date.now());\n        return _this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        var _this = this;\n        if (new Date(Date.now()) < this._disabledUntil) {\n            return Promise.reject({\n                event: event,\n                reason: \"Transport locked till \" + this._disabledUntil + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState !== 4) {\n                    return;\n                }\n                var status = Status.fromHttpCode(request.status);\n                if (status === Status.Success) {\n                    resolve({ status: status });\n                    return;\n                }\n                if (status === Status.RateLimit) {\n                    var now = Date.now();\n                    _this._disabledUntil = new Date(now + parseRetryAfterHeader(now, request.getResponseHeader('Retry-After')));\n                    logger.warn(\"Too many requests, backing off till: \" + _this._disabledUntil);\n                }\n                reject(request);\n            };\n            request.open('POST', _this.url);\n            request.send(JSON.stringify(event));\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map","import * as tslib_1 from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, supportsFetch, SyncPromise } from '@sentry/utils';\nimport { eventFromString, eventFromUnknownInput } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    tslib_1.__extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = tslib_1.__assign({}, this._options.transportOptions, { dsn: this._options.dsn });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            return new FetchTransport(transportOptions);\n        }\n        return new XHRTransport(transportOptions);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        var syntheticException = (hint && hint.syntheticException) || undefined;\n        var event = eventFromUnknownInput(exception, syntheticException, {\n            attachStacktrace: this._options.attachStacktrace,\n        });\n        addExceptionMechanism(event, {\n            handled: true,\n            type: 'generic',\n        });\n        event.level = Severity.Error;\n        if (hint && hint.event_id) {\n            event.event_id = hint.event_id;\n        }\n        return SyncPromise.resolve(event);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        var syntheticException = (hint && hint.syntheticException) || undefined;\n        var event = eventFromString(message, syntheticException, {\n            attachStacktrace: this._options.attachStacktrace,\n        });\n        event.level = level;\n        if (hint && hint.event_id) {\n            event.event_id = hint.event_id;\n        }\n        return SyncPromise.resolve(event);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","export var SDK_NAME = 'sentry.javascript.browser';\nexport var SDK_VERSION = '5.10.2';\n//# sourceMappingURL=version.js.map","import * as tslib_1 from \"tslib\";\nimport { API, BaseClient } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { SDK_NAME, SDK_VERSION } from './version';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    tslib_1.__extends(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        return _super.call(this, BrowserBackend, options) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        event.sdk = tslib_1.__assign({}, event.sdk, { name: SDK_NAME, packages: tslib_1.__spread(((event.sdk && event.sdk.packages) || []), [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: SDK_VERSION,\n                },\n            ]), version: SDK_VERSION });\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = getGlobalObject().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            logger.error('Trying to call showReportDialog with Sentry Client is disabled');\n            return;\n        }\n        var dsn = options.dsn || this.getDsn();\n        if (!options.eventId) {\n            logger.error('Missing `eventId` option in showReportDialog call');\n            return;\n        }\n        if (!dsn) {\n            logger.error('Missing `Dsn` option in showReportDialog call');\n            return;\n        }\n        var script = document.createElement('script');\n        script.async = true;\n        script.src = new API(dsn).getReportDialogEndpoint(options);\n        if (options.onLoad) {\n            script.onload = options.onLoad;\n        }\n        (document.head || document.body).appendChild(script);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils';\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n/** Inbound filters configurable by the user */\nvar InboundFilters = /** @class */ (function () {\n    function InboundFilters(_options) {\n        if (_options === void 0) { _options = {}; }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var hub = getCurrentHub();\n            if (!hub) {\n                return event;\n            }\n            var self = hub.getIntegration(InboundFilters);\n            if (self) {\n                var client = hub.getClient();\n                var clientOptions = client ? client.getOptions() : {};\n                var options = self._mergeOptions(clientOptions);\n                if (self._shouldDropEvent(event, options)) {\n                    return null;\n                }\n            }\n            return event;\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._shouldDropEvent = function (event, options) {\n        if (this._isSentryError(event, options)) {\n            logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isBlacklistedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `blacklistUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isWhitelistedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `whitelistUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isSentryError = function (event, options) {\n        if (options === void 0) { options = {}; }\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return ((event &&\n                event.exception &&\n                event.exception.values &&\n                event.exception.values[0] &&\n                event.exception.values[0].type === 'SentryError') ||\n                false);\n        }\n        catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (options === void 0) { options = {}; }\n        if (!options.ignoreErrors || !options.ignoreErrors.length) {\n            return false;\n        }\n        return this._getPossibleEventMessages(event).some(function (message) {\n            // Not sure why TypeScript complains here...\n            return options.ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isBlacklistedUrl = function (event, options) {\n        if (options === void 0) { options = {}; }\n        // TODO: Use Glob instead?\n        if (!options.blacklistUrls || !options.blacklistUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.blacklistUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isWhitelistedUrl = function (event, options) {\n        if (options === void 0) { options = {}; }\n        // TODO: Use Glob instead?\n        if (!options.whitelistUrls || !options.whitelistUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.whitelistUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) { clientOptions = {}; }\n        return {\n            blacklistUrls: tslib_1.__spread((this._options.blacklistUrls || []), (clientOptions.blacklistUrls || [])),\n            ignoreErrors: tslib_1.__spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n            whitelistUrls: tslib_1.__spread((this._options.whitelistUrls || []), (clientOptions.whitelistUrls || [])),\n        };\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getPossibleEventMessages = function (event) {\n        if (event.message) {\n            return [event.message];\n        }\n        if (event.exception) {\n            try {\n                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            }\n            catch (oO) {\n                logger.error(\"Cannot extract message for event \" + getEventDescription(event));\n                return [];\n            }\n        }\n        return [];\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getEventFilterUrl = function (event) {\n        try {\n            if (event.stacktrace) {\n                var frames_1 = event.stacktrace.frames;\n                return (frames_1 && frames_1[frames_1.length - 1].filename) || null;\n            }\n            if (event.exception) {\n                var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n                return (frames_2 && frames_2[frames_2.length - 1].filename) || null;\n            }\n            return null;\n        }\n        catch (oO) {\n            logger.error(\"Cannot extract url for event \" + getEventDescription(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}());\nexport { InboundFilters };\n//# sourceMappingURL=inboundfilters.js.map","import * as tslib_1 from \"tslib\";\nimport { captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, normalize } from '@sentry/utils';\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nexport function ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\n    });\n}\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(fn, options, before) {\n    if (options === void 0) { options = {}; }\n    // tslint:disable-next-line:strict-type-predicates\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\n        }\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        // Bail on wrapping and return the function as-is (defers to window.onerror).\n        return fn;\n    }\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        // tslint:disable:no-unsafe-any\n        try {\n            // tslint:disable-next-line:strict-type-predicates\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            if (fn.handleEvent) {\n                // Attempt to invoke user-land function\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n                //       means the sentry.javascript SDK caught an error invoking your application code. This\n                //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n                return fn.handleEvent.apply(this, wrappedArguments);\n            }\n            // Attempt to invoke user-land function\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n            //       means the sentry.javascript SDK caught an error invoking your application code. This\n            //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n            return fn.apply(this, wrappedArguments);\n            // tslint:enable:no-unsafe-any\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = tslib_1.__assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = tslib_1.__assign({}, processedEvent.extra, { arguments: normalize(args, 3) });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // tslint:disable-line:no-empty\n    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\n    });\n    // Restore original function name (not all browsers allow that)\n    try {\n        var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n        if (descriptor.configurable) {\n            Object.defineProperty(sentryWrapped, 'name', {\n                get: function () {\n                    return fn.name;\n                },\n            });\n        }\n    }\n    catch (_oO) {\n        /*no-empty*/\n    }\n    return sentryWrapped;\n}\n//# sourceMappingURL=helpers.js.map","import { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    function TryCatch() {\n        /** JSDoc */\n        this._ignoreOnError = 0;\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n    }\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var originalCallback = args[0];\n            args[0] = wrap(originalCallback, {\n                mechanism: {\n                    data: { function: getFunctionName(original) },\n                    handled: true,\n                    type: 'instrument',\n                },\n            });\n            return original.apply(this, args);\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapRAF = function (original) {\n        return function (callback) {\n            return original(wrap(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: getFunctionName(original),\n                    },\n                    handled: true,\n                    type: 'instrument',\n                },\n            }));\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        var global = getGlobalObject();\n        var proto = global[target] && global[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    // tslint:disable-next-line:no-unbound-method strict-type-predicates\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: getFunctionName(fn),\n                                    target: target,\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    }\n                }\n                catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, wrap(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: getFunctionName(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }), options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        return function () {\n            var _this = this;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var xhr = this; // tslint:disable-line:no-this-assignment\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in _this && typeof _this[prop] === 'function') {\n                    fill(_this, prop, function (original) {\n                        return wrap(original, {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: getFunctionName(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    });\n                }\n            });\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    var wrapOptions = {\n                        mechanism: {\n                            data: {\n                                function: 'onreadystatechange',\n                                handler: getFunctionName(original),\n                            },\n                            handled: true,\n                            type: 'instrument',\n                        },\n                    };\n                    // If Instrument integration has been called before TryCatch, get the name of original function\n                    if (original.__sentry_original__) {\n                        wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\n                    }\n                    // Otherwise wrap directly\n                    return wrap(original, wrapOptions);\n                });\n            }\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        this._ignoreOnError = this._ignoreOnError;\n        var global = getGlobalObject();\n        fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        if ('XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        [\n            'EventTarget',\n            'Window',\n            'Node',\n            'ApplicationCache',\n            'AudioTrackList',\n            'ChannelMergerNode',\n            'CryptoOperation',\n            'EventSource',\n            'FileReader',\n            'HTMLUnknownElement',\n            'IDBDatabase',\n            'IDBRequest',\n            'IDBTransaction',\n            'KeyOperation',\n            'MediaController',\n            'MessagePort',\n            'ModalWindow',\n            'Notification',\n            'SVGElementInstance',\n            'Screen',\n            'TextTrack',\n            'TextTrackCue',\n            'TextTrackList',\n            'WebSocket',\n            'WebSocketWorker',\n            'Worker',\n            'XMLHttpRequest',\n            'XMLHttpRequestEventTarget',\n            'XMLHttpRequestUpload',\n        ].forEach(this._wrapEventTarget.bind(this));\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map","/* tslint:disable:only-arrow-functions no-unsafe-any */\nimport * as tslib_1 from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getFunctionName, getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nvar global = getGlobalObject();\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\n    switch (type) {\n        case 'console':\n            instrumentConsole();\n            break;\n        case 'dom':\n            instrumentDOM();\n            break;\n        case 'xhr':\n            instrumentXHR();\n            break;\n        case 'fetch':\n            instrumentFetch();\n            break;\n        case 'history':\n            instrumentHistory();\n            break;\n        default:\n            logger.warn('unknown instrumentation type:', type);\n    }\n}\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addInstrumentationHandler(handler) {\n    // tslint:disable-next-line:strict-type-predicates\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = tslib_1.__values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + getFunctionName(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        fill(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!supportsNativeFetch()) {\n        return;\n    }\n    fill(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var commonHandlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData));\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now(), error: error }));\n                throw error;\n            });\n        };\n    });\n}\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n        return String(fetchArgs[0].method).toUpperCase();\n    }\n    if (fetchArgs[1] && fetchArgs[1].method) {\n        return String(fetchArgs[1].method).toUpperCase();\n    }\n    return 'GET';\n}\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if (typeof fetchArgs[0] === 'string') {\n        return fetchArgs[0];\n    }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n        return fetchArgs[0].url;\n    }\n    return String(fetchArgs[0]);\n}\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var url = args[1];\n            this.__sentry_xhr__ = {\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            if (isString(url) && this.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                this.__sentry_own_request__ = true;\n            }\n            return originalOpen.apply(this, args);\n        };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var xhr = this; // tslint:disable-line:no-this-assignment\n            var commonHandlerData = {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: xhr,\n            };\n            triggerHandlers('xhr', tslib_1.__assign({}, commonHandlerData));\n            /**\n             * @hidden\n             */\n            function onreadystatechangeHandler() {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', tslib_1.__assign({}, commonHandlerData, { endTimestamp: Date.now() }));\n                }\n            }\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                // if onreadystatechange wasn't actually set by the page on this xhr, we\n                // are free to set our own and capture the breadcrumb\n                xhr.onreadystatechange = onreadystatechangeHandler;\n            }\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!supportsHistory()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var to = global.location.href;\n        // keep track of the current URL state, as we always receive only the updated state\n        var from = lastHref;\n        lastHref = to;\n        triggerHandlers('history', {\n            from: from,\n            to: to,\n        });\n        if (oldOnPopState) {\n            return oldOnPopState.apply(this, args);\n        }\n    };\n    /** @hidden */\n    function historyReplacementFunction(originalHistoryFunction) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var url = args.length > 2 ? args[2] : undefined;\n            if (url) {\n                // coerce to string (this is what pushState does)\n                var from = lastHref;\n                var to = String(url);\n                // keep track of the current URL state, as we always receive only the updated state\n                lastHref = to;\n                triggerHandlers('history', {\n                    from: from,\n                    to: to,\n                });\n            }\n            return originalHistoryFunction.apply(this, args);\n        };\n    }\n    fill(global.history, 'pushState', historyReplacementFunction);\n    fill(global.history, 'replaceState', historyReplacementFunction);\n}\n/** JSDoc */\nfunction instrumentDOM() {\n    if (!('document' in global)) {\n        return;\n    }\n    // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n    // to the document. Do this before we instrument addEventListener.\n    global.document.addEventListener('click', domEventHandler('click', triggerHandlers.bind(null, 'dom')), false);\n    global.document.addEventListener('keypress', keypressEventHandler(triggerHandlers.bind(null, 'dom')), false);\n    // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n    ['EventTarget', 'Node'].forEach(function (target) {\n        var proto = global[target] && global[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                if (fn && fn.handleEvent) {\n                    if (eventName === 'click') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                domEventHandler('click', triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                    if (eventName === 'keypress') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                keypressEventHandler(triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                }\n                else {\n                    if (eventName === 'click') {\n                        domEventHandler('click', triggerHandlers.bind(null, 'dom'), true)(this);\n                    }\n                    if (eventName === 'keypress') {\n                        keypressEventHandler(triggerHandlers.bind(null, 'dom'))(this);\n                    }\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                var callback = fn;\n                try {\n                    callback = callback && (callback.__sentry_wrapped__ || callback);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, callback, options);\n            };\n        });\n    });\n}\nvar debounceDuration = 1000;\nvar debounceTimer = 0;\nvar keypressTimeout;\nvar lastCapturedEvent;\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param name the event name (e.g. \"click\")\n * @param handler function that will be triggered\n * @param debounce decides whether it should wait till another event loop\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction domEventHandler(name, handler, debounce) {\n    if (debounce === void 0) { debounce = false; }\n    return function (event) {\n        // reset keypress timeout; e.g. triggering a 'click' after\n        // a 'keypress' will reset the keypress debounce so that a new\n        // set of keypresses can be recorded\n        keypressTimeout = undefined;\n        // It's possible this handler might trigger multiple times for the same\n        // event (e.g. event propagation through node ancestors). Ignore if we've\n        // already captured the event.\n        if (!event || lastCapturedEvent === event) {\n            return;\n        }\n        lastCapturedEvent = event;\n        if (debounceTimer) {\n            clearTimeout(debounceTimer);\n        }\n        if (debounce) {\n            debounceTimer = setTimeout(function () {\n                handler({ event: event, name: name });\n            });\n        }\n        else {\n            handler({ event: event, name: name });\n        }\n    };\n}\n/**\n * Wraps addEventListener to capture keypress UI events\n * @param handler function that will be triggered\n * @returns wrapped keypress events handler\n * @hidden\n */\nfunction keypressEventHandler(handler) {\n    // TODO: if somehow user switches keypress target before\n    //       debounce timeout is triggered, we will only capture\n    //       a single breadcrumb from the FIRST target (acceptable?)\n    return function (event) {\n        var target;\n        try {\n            target = event.target;\n        }\n        catch (e) {\n            // just accessing event properties can throw an exception in some rare circumstances\n            // see: https://github.com/getsentry/raven-js/issues/838\n            return;\n        }\n        var tagName = target && target.tagName;\n        // only consider keypress events on actual input elements\n        // this will disregard keypresses targeting body (e.g. tabbing\n        // through elements, hotkeys, etc)\n        if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {\n            return;\n        }\n        // record first keypress in a series, but ignore subsequent\n        // keypresses until debounce clears\n        if (!keypressTimeout) {\n            domEventHandler('input', handler)(event);\n        }\n        clearTimeout(keypressTimeout);\n        keypressTimeout = setTimeout(function () {\n            keypressTimeout = undefined;\n        }, debounceDuration);\n    };\n}\n//# sourceMappingURL=instrument.js.map","import * as tslib_1 from \"tslib\";\nimport { API, getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, logger, normalize, parseUrl, safeJoin, } from '@sentry/utils';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = tslib_1.__assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                extra: {\n                    arguments: normalize(handlerData.args, 3),\n                },\n                logger: 'console',\n            },\n            level: Severity.fromString(handlerData.level),\n            message: safeJoin(handlerData.args, ' '),\n        };\n        if (handlerData.level === 'assert') {\n            if (handlerData.args[0] === false) {\n                breadcrumb.message = \"Assertion failed: \" + (safeJoin(handlerData.args.slice(1), ' ') || 'console.assert');\n                breadcrumb.data.extra.arguments = normalize(handlerData.args.slice(1), 3);\n            }\n            else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        getCurrentHub().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level,\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? htmlTreeAsString(handlerData.event.target)\n                : htmlTreeAsString(handlerData.event);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: event,\n            name: handlerData.name,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    Breadcrumbs.prototype._xhrBreadcrumb = function (handlerData) {\n        if (handlerData.endTimestamp) {\n            // We only capture complete, non-sentry requests\n            if (handlerData.xhr.__sentry_own_request__) {\n                return;\n            }\n            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: handlerData.xhr.__sentry_xhr__,\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n            });\n            return;\n        }\n        // We only capture issued sentry requests\n        if (handlerData.xhr.__sentry_own_request__) {\n            addSentryBreadcrumb(handlerData.args[0]);\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\n        }\n        var client = getCurrentHub().getClient();\n        var dsn = client && client.getDsn();\n        if (dsn) {\n            var filterUrl = new API(dsn).getStoreEndpoint();\n            // if Sentry key appears in URL, don't capture it as a request\n            // but rather as our own 'sentry' type breadcrumb\n            if (filterUrl &&\n                handlerData.fetchData.url.indexOf(filterUrl) !== -1 &&\n                handlerData.fetchData.method === 'POST' &&\n                handlerData.args[1] &&\n                handlerData.args[1].body) {\n                addSentryBreadcrumb(handlerData.args[1].body);\n                return;\n            }\n        }\n        if (handlerData.error) {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: tslib_1.__assign({}, handlerData.fetchData, { status_code: handlerData.response.status }),\n                level: Severity.Error,\n                type: 'http',\n            }, {\n                data: handlerData.error,\n                input: handlerData.args,\n            });\n        }\n        else {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: tslib_1.__assign({}, handlerData.fetchData, { status_code: handlerData.response.status }),\n                type: 'http',\n            }, {\n                input: handlerData.args,\n                response: handlerData.response,\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from history API calls\n     */\n    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = getGlobalObject();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = parseUrl(global.location.href);\n        var parsedFrom = parseUrl(from);\n        var parsedTo = parseUrl(to);\n        // Initial pushState doesn't provide `from` information\n        if (!parsedFrom.path) {\n            parsedFrom = parsedLoc;\n        }\n        // Use only the path component of the URL if the URL matches the current\n        // document (almost all the time when using pushState)\n        if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n            // tslint:disable-next-line:no-parameter-reassignment\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            // tslint:disable-next-line:no-parameter-reassignment\n            from = parsedFrom.relative;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, tslib_1.__spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n/**\n * Create a breadcrumb of `sentry` from the events themselves\n */\nfunction addSentryBreadcrumb(serializedData) {\n    // There's always something that can go wrong with deserialization...\n    try {\n        var event_1 = JSON.parse(serializedData);\n        getCurrentHub().addBreadcrumb({\n            category: 'sentry',\n            event_id: event_1.event_id,\n            level: event_1.level || Severity.fromString('error'),\n            message: getEventDescription(event_1),\n        }, {\n            event: event_1,\n        });\n    }\n    catch (_oO) {\n        logger.error('Error while adding sentry type breadcrumb');\n    }\n}\n//# sourceMappingURL=breadcrumbs.js.map","import * as tslib_1 from \"tslib\";\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, getGlobalObject, getLocationHref, isErrorEvent, isPrimitive, isString, logger, } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /** JSDoc */\n        this._global = getGlobalObject();\n        /** JSDoc */\n        this._oldOnErrorHandler = null;\n        /** JSDoc */\n        this._oldOnUnhandledRejectionHandler = null;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = tslib_1.__assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        var self = this; // tslint:disable-line:no-this-assignment\n        this._oldOnErrorHandler = this._global.onerror;\n        this._global.onerror = function (msg, url, line, column, error) {\n            var currentHub = getCurrentHub();\n            var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n            var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n            if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                if (self._oldOnErrorHandler) {\n                    return self._oldOnErrorHandler.apply(this, arguments);\n                }\n                return false;\n            }\n            var client = currentHub.getClient();\n            var event = isPrimitive(error)\n                ? self._eventFromIncompleteOnError(msg, url, line, column)\n                : self._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {\n                    attachStacktrace: client && client.getOptions().attachStacktrace,\n                    rejection: false,\n                }), url, line, column);\n            addExceptionMechanism(event, {\n                handled: false,\n                type: 'onerror',\n            });\n            currentHub.captureEvent(event, {\n                originalException: error,\n            });\n            if (self._oldOnErrorHandler) {\n                return self._oldOnErrorHandler.apply(this, arguments);\n            }\n            return false;\n        };\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        var self = this; // tslint:disable-line:no-this-assignment\n        this._oldOnUnhandledRejectionHandler = this._global.onunhandledrejection;\n        this._global.onunhandledrejection = function (e) {\n            var error = e;\n            try {\n                error = e && 'reason' in e ? e.reason : e;\n            }\n            catch (_oO) {\n                // no-empty\n            }\n            var currentHub = getCurrentHub();\n            var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n            var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n            if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                if (self._oldOnUnhandledRejectionHandler) {\n                    return self._oldOnUnhandledRejectionHandler.apply(this, arguments);\n                }\n                return true;\n            }\n            var client = currentHub.getClient();\n            var event = isPrimitive(error)\n                ? self._eventFromIncompleteRejection(error)\n                : eventFromUnknownInput(error, undefined, {\n                    attachStacktrace: client && client.getOptions().attachStacktrace,\n                    rejection: true,\n                });\n            event.level = Severity.Error;\n            addExceptionMechanism(event, {\n                handled: false,\n                type: 'onunhandledrejection',\n            });\n            currentHub.captureEvent(event, {\n                originalException: error,\n            });\n            if (self._oldOnUnhandledRejectionHandler) {\n                return self._oldOnUnhandledRejectionHandler.apply(this, arguments);\n            }\n            return true;\n        };\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (msg, url, line, column) {\n        var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n        // If 'message' is ErrorEvent, get real message from inside\n        var message = isErrorEvent(msg) ? msg.message : msg;\n        var name;\n        if (isString(message)) {\n            var groups = message.match(ERROR_TYPES_RE);\n            if (groups) {\n                name = groups[1];\n                message = groups[2];\n            }\n        }\n        var event = {\n            exception: {\n                values: [\n                    {\n                        type: name || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\n    };\n    /**\n     * This function creates an Event from an TraceKitStackTrace that has part of it missing.\n     */\n    GlobalHandlers.prototype._eventFromIncompleteRejection = function (error) {\n        return {\n            exception: {\n                values: [\n                    {\n                        type: 'UnhandledRejection',\n                        value: \"Non-Error promise rejection captured with value: \" + error,\n                    },\n                ],\n            },\n        };\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];\n        var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n        var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n        var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event, hint) {\n            var self = getCurrentHub().getIntegration(LinkedErrors);\n            if (self) {\n                return self._handler(event, hint);\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = tslib_1.__spread(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = computeStackTrace(error[key]);\n        var exception = exceptionFromStacktrace(stacktrace);\n        return this._walkErrorTree(error[key], key, tslib_1.__spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map","import * as tslib_1 from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            if (getCurrentHub().getIntegration(UserAgent)) {\n                if (!global.navigator || !global.location) {\n                    return event;\n                }\n                // Request Interface: https://docs.sentry.io/development/sdk-dev/event-payloads/request/\n                var request = event.request || {};\n                request.url = request.url || global.location.href;\n                request.headers = request.headers || {};\n                request.headers['User-Agent'] = global.navigator.userAgent;\n                return tslib_1.__assign({}, event, { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\nexport { UserAgent };\n//# sourceMappingURL=useragent.js.map","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject, SyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [\n    new CoreIntegrations.InboundFilters(),\n    new CoreIntegrations.FunctionToString(),\n    new TryCatch(),\n    new Breadcrumbs(),\n    new GlobalHandlers(),\n    new LinkedErrors(),\n    new UserAgent(),\n];\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    initAndBind(BrowserClient, options);\n}\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        options.eventId = getCurrentHub().lastEventId();\n    }\n    var client = getCurrentHub().getClient();\n    if (client) {\n        client.showReportDialog(options);\n    }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId() {\n    return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad() {\n    // Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback) {\n    callback();\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function flush(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function close(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\nexport function wrap(fn) {\n    return internalWrap(fn)(); // tslint:disable-line:no-unsafe-any\n}\n//# sourceMappingURL=sdk.js.map","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instanciate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind(clientClass, options) {\n    if (options.debug === true) {\n        logger.enable();\n    }\n    getCurrentHub().bindClient(new clientClass(options));\n}\n//# sourceMappingURL=sdk.js.map","import * as tslib_1 from \"tslib\";\nexport { Severity, Status, } from '@sentry/types';\nexport { addGlobalEventProcessor, addBreadcrumb, captureException, captureEvent, captureMessage, configureScope, getHubFromCarrier, getCurrentHub, Hub, Scope, setContext, setExtra, setExtras, setTag, setTags, setUser, withScope, } from '@sentry/core';\nexport { BrowserClient } from './client';\nexport { defaultIntegrations, forceLoad, init, lastEventId, onLoad, showReportDialog, flush, close, wrap } from './sdk';\nexport { SDK_NAME, SDK_VERSION } from './version';\nimport { Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nimport * as BrowserIntegrations from './integrations';\nimport * as Transports from './transports';\nvar windowIntegrations = {};\n// This block is needed to add compatibility with the integrations packages when used with a CDN\n// tslint:disable: no-unsafe-any\nvar _window = getGlobalObject();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\n// tslint:enable: no-unsafe-any\nvar INTEGRATIONS = tslib_1.__assign({}, windowIntegrations, CoreIntegrations, BrowserIntegrations);\nexport { INTEGRATIONS as Integrations, Transports };\n//# sourceMappingURL=index.js.map","// tslint:disable:no-unsafe-any\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        // tslint:disable-next-line\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // tslint:disable-next-line:prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\nexport { Memo };\n//# sourceMappingURL=memo.js.map","import { connect } from 'react-redux';\nimport GlobalErrorBoundary from './GlobalErrorBoundary';\nimport { selectors, IRootState } from './reducers';\n\nconst mapStateToProps = (state: IRootState) => {\n    return { ...selectors.getPartition(state) };\n};\n\nexport default connect(mapStateToProps)(GlobalErrorBoundary);\n","import * as React from 'react';\nimport * as Sentry from '@sentry/browser';\nimport * as ofxUserInfo from 'ofxUserInfo';\nimport * as config from 'ofxSettings';\nimport { redirectTo } from 'libs/events';\nimport { replaceErrors, getCorrelationId, logDatadogRUM } from 'libs/errors';\nimport { toastCreator } from 'components/Toast';\nimport Broken from 'assets/illustrations/Broken';\nimport { GLOBAL_ERROR_NAME } from './constants';\nimport * as styles from './GlobalErrorBoundary.scss';\nimport { datadogRum } from '@datadog/browser-rum';\n\ntype ErrorProps = {\n    globalError: boolean;\n    globalErrorToast: boolean;\n    globalErrorLogout: boolean;\n    globalErrorInfo: IGlobalErrorInfo;\n    errorState?: ErrorState;\n    children: JSX.Element;\n};\n\ninterface IGlobalErrorInfoClient {\n    errors: {};\n    message: string;\n    name: string;\n    stack: string;\n}\n\ninterface IGlobalErrorInfoResponse {\n    method: string;\n    status: number;\n    statusText: string;\n    url: string;\n}\n\nexport type IGlobalErrorInfo = IGlobalErrorInfoClient & IGlobalErrorInfoResponse;\n\nexport type ErrorState = {\n    error?: Error;\n    stackTrace?: string;\n    errorInfo?: IGlobalErrorInfoResponse | {};\n    visible: boolean;\n};\n\nconst emptyState: ErrorState = {\n    error: undefined,\n    errorInfo: undefined,\n    visible: false,\n    stackTrace: undefined,\n};\n\nconst ofxWebsite = 'https://www.ofx.com/';\n\nconst onExitClick = () => {\n    window.location.href = ofxWebsite;\n};\n\nconst StaticHeader = () => {\n    const Logo = () => (\n        <a href={ofxWebsite}>\n            <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"87\" height=\"32\" viewBox=\"0 0 87 32\">\n                <g fill=\"none\" fillRule=\"evenodd\" stroke=\"none\" strokeWidth=\"1\">\n                    <g fill=\"#F59E38\" fillRule=\"nonzero\" transform=\"translate(-30 -24)\">\n                        <g>\n                            <g transform=\"translate(24 18)\">\n                                <path d=\"M65.202 29.988c0 1.163.934 2.106 2.086 2.106a2.097 2.097 0 002.087-2.106c0-3.257 2.616-5.897 5.843-5.897a2.096 2.096 0 002.086-2.106 2.096 2.096 0 00-2.086-2.106c-5.532 0-10.016 4.526-10.016 10.11m-5.885-8.004c0 3.257-2.616 5.897-5.843 5.897-3.226 0-5.842-2.64-5.842-5.897 0-3.256 2.616-5.896 5.842-5.896 3.227 0 5.843 2.64 5.843 5.896m4.174 0c0-5.583-4.485-10.109-10.017-10.109-5.531 0-10.016 4.526-10.016 10.11 0 5.582 4.485 10.108 10.016 10.108 5.532 0 10.017-4.526 10.017-10.109m29.081-6.722l-3.658 5.273a2.546 2.546 0 000 2.9l3.708 5.344c.674.97.423 2.315-.565 2.97-.955.633-2.248.319-2.904-.626l-3.108-4.481a.83.83 0 00-1.368 0l-3.16 4.553a2.075 2.075 0 01-2.957.48c-.916-.69-1.066-2.023-.41-2.968l3.658-5.273a2.546 2.546 0 000-2.899l-2.837-4.088a.832.832 0 00-.684-.36H70.21a.838.838 0 00-.835.843v1.264c0 1.184-.97 2.14-2.15 2.105-1.143-.035-2.023-1.04-2.023-2.194v-4.123c0-1.163.934-2.107 2.086-2.107h12.52c.707 0 1.33.358 1.707.9l3.162 4.553a.83.83 0 001.367 0l3.16-4.554a2.074 2.074 0 012.958-.48c.916.69 1.066 2.024.41 2.968zM13.928 8.146C21.51 3.728 31.203 6.35 35.581 14c4.377 7.652 1.779 17.436-5.802 21.853C22.198 40.272 12.503 37.65 8.126 30c-4.377-7.652-1.78-17.436 5.802-21.853zM32.228 22a2.316 2.316 0 00-2.305-2.327h-1.747a8.632 8.632 0 01-7.487-4.363l-.874-1.527a2.295 2.295 0 00-3.187-.83c-1.087.661-1.403 2.114-.768 3.224l.835 1.46a8.795 8.795 0 010 8.726l-.873 1.527a2.338 2.338 0 00.843 3.178 2.294 2.294 0 003.15-.851l.873-1.527a8.63 8.63 0 017.488-4.363h1.747A2.316 2.316 0 0032.228 22z\" />\n                            </g>\n                        </g>\n                    </g>\n                </g>\n            </svg>\n        </a>\n    );\n\n    const ExitButton = () => (\n        <button className={`btn ${styles.exitBtn}`} onClick={onExitClick}>\n            <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\">\n                <g\n                    fill=\"none\"\n                    fillRule=\"evenodd\"\n                    stroke=\"none\"\n                    strokeLinecap=\"round\"\n                    strokeLinejoin=\"round\"\n                    strokeWidth=\"1\"\n                >\n                    <g\n                        fillRule=\"nonzero\"\n                        stroke=\"#3C3C3B\"\n                        strokeWidth=\"2\"\n                        transform=\"translate(-1216 -40)\"\n                    >\n                        <g>\n                            <g transform=\"translate(1200 24)\">\n                                <g transform=\"translate(12 12)\">\n                                    <g>\n                                        <path d=\"M19 5l-7 7 7 7M5 19l7-7-7-7\" />\n                                    </g>\n                                </g>\n                            </g>\n                        </g>\n                    </g>\n                </g>\n            </svg>\n        </button>\n    );\n\n    return (\n        <header className={styles.header}>\n            <Logo />\n            <ExitButton />\n        </header>\n    );\n};\n\nclass GlobalErrorBoundary extends React.Component<ErrorProps, ErrorState> {\n    static displayName = 'GlobalErrorBoundary';\n    private sentry: typeof Sentry | undefined;\n    constructor(props: ErrorProps) {\n        super(props);\n        this.state = emptyState;\n        if (config.datadog.applicationId) {\n            datadogRum.init({\n                applicationId: config.datadog.applicationId,\n                clientToken: config.datadog.clientToken,\n                site: 'datadoghq.com',\n                service: 'secure',\n                env: config.datadog.environment,\n                // Specify a version number to identify the deployed version of your application in Datadog\n                version: config.datadog.version,\n                sampleRate: 100,\n                sessionReplaySampleRate: 0,\n                trackResources: true,\n                trackLongTasks: true,\n                trackUserInteractions: true,\n                defaultPrivacyLevel: 'mask-user-input',\n                allowedTracingUrls: [\n                    {\n                        match: config.apiBaseUrl,\n                        propagatorTypes: ['tracecontext'],\n                    },\n                ],\n            });\n            datadogRum.setUser({\n                name: (ofxUserInfo || { username: 'unidentified' }).username,\n            });\n        }\n\n        if (config.sentry.dsn) {\n            this.sentry = Sentry;\n            this.sentry.init({\n                dsn: config.sentry.dsn,\n                maxBreadcrumbs: 50,\n                attachStacktrace: true,\n                environment: config.sentry.environment || 'dev',\n                release: config.sentry.release || 'unversioned',\n                ignoreErrors: [\n                    \"NetworkError: Failed to execute 'send' on 'XMLHttpRequest': Failed to load 'https://events.launchdarkly.com/a/579828dacb2bcb078f412a23.gif\",\n                ],\n            });\n            this.sentry.configureScope((scope) => {\n                scope.setUser({\n                    username: (ofxUserInfo || { username: 'unidentified' }).username,\n                });\n            });\n        }\n    }\n\n    componentWillReceiveProps(props: ErrorProps, nextProps: ErrorProps) {\n        if (props.errorState !== nextProps.errorState) {\n            this.setState(emptyState);\n        }\n        let message = config.globalText.TextErrorOccured;\n        let stackTrace;\n        if (props.globalErrorInfo) {\n            if (props.globalErrorInfo instanceof Error) {\n                message = props.globalErrorInfo.message;\n                stackTrace = JSON.stringify(props.globalErrorInfo, replaceErrors);\n            }\n            if (props.globalErrorInfo instanceof Response) {\n                if (props.globalErrorInfo.statusText) {\n                    message = props.globalErrorInfo.statusText;\n                }\n                stackTrace = getCorrelationId(props.globalErrorInfo);\n            }\n        }\n\n        if (props.globalError !== nextProps.globalError) {\n            if (props.globalError) {\n                this.setState({\n                    stackTrace,\n                    error: {\n                        message,\n                        name: GLOBAL_ERROR_NAME,\n                    },\n                });\n            }\n        }\n        if (props.globalErrorToast) {\n            toastCreator.error(message, false);\n        }\n        if (props.globalErrorLogout) {\n            redirectTo(config.routes.signouts);\n        }\n    }\n\n    componentDidCatch(error: Error, errorInfo: {}) {\n        logDatadogRUM({ ...error, ...errorInfo });\n        this.setState({\n            error,\n            errorInfo,\n        });\n\n        if (this.sentry) {\n            this.sentry.withScope((scope) => {\n                Object.keys(errorInfo).forEach((key) => {\n                    scope.setExtra(key, errorInfo[key]);\n                });\n\n                if (window.mouseflow) {\n                    scope.setExtras({\n                        mouseflowSessionId: window.mouseflow.getSessionId(),\n                    });\n                }\n\n                this.sentry!.captureException(error);\n            });\n        }\n\n        console.error('@@@', error);\n    }\n\n    render() {\n        if (this.state.error && process.env.NODE_ENV !== 'development') {\n            return (\n                <React.Fragment>\n                    <StaticHeader />\n                    <div className={styles.globalErrorStackTrace}>\n                        <div className={styles.content}>\n                            <Broken />\n                            <p>Sorry, something went wrong...</p>\n                            <p>\n                                <small>Please refresh the page or try again later.</small>\n                            </p>\n                            <div className={styles.controls}>\n                                <button className=\"btn\" onClick={onExitClick}>\n                                    Exit\n                                </button>\n                                <button\n                                    className=\"btn btn-primary\"\n                                    onClick={() => location.reload()}\n                                >\n                                    Refresh\n                                </button>\n                            </div>\n                        </div>\n                    </div>\n                </React.Fragment>\n            );\n        }\n        return this.props.children;\n    }\n}\n\nexport default GlobalErrorBoundary;\n","import * as React from 'react';\n\nconst Icon: React.FC = () => (\n    <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"96\" height=\"96\" fill=\"none\" viewBox=\"0 0 96 96\">\n        <path\n            fill=\"#F3F3F3\"\n            fillRule=\"evenodd\"\n            d=\"M95 53a4 4 0 01-4 4h-7a4 4 0 000 8h3a4 4 0 010 8h-7.773C71.897 82.145 60.632 88 48 88 25.909 88 8 70.091 8 48c0-1.35.067-2.684.197-4H4a4 4 0 010-8h10a4 4 0 000-8h-3a4 4 0 010-8h8.434C26.694 12.595 36.81 8 48 8c22.091 0 40 17.909 40 40 0 .334-.004.668-.012 1H91a4 4 0 014 4z\"\n            clipRule=\"evenodd\"\n        />\n        <path\n            stroke=\"#F9C487\"\n            strokeLinecap=\"round\"\n            strokeWidth=\"4\"\n            d=\"M69 30h4a4 4 0 004-4v-6a4 4 0 00-4-4h-4a4 4 0 010-8h24\"\n        />\n        <path\n            fill=\"#F59E38\"\n            d=\"M51 36.001A9.956 9.956 0 0149 30c0-2.252.744-4.33 2-6.001V20h8c5.523 0 10 4.477 10 10s-4.477 10-10 10h-8v-3.999z\"\n        />\n        <path\n            fill=\"#F9C487\"\n            d=\"M45.5 24H49v5h-3.5a2.5 2.5 0 010-5zM45.5 31H49v5h-3.5a2.5 2.5 0 010-5z\"\n        />\n        <path\n            fill=\"#F7B15F\"\n            fillRule=\"evenodd\"\n            d=\"M51 20a2 2 0 00-2 2v16a2 2 0 002 2h4V20h-4z\"\n            clipRule=\"evenodd\"\n        />\n        <path\n            stroke=\"#CFCFCF\"\n            strokeLinecap=\"round\"\n            strokeWidth=\"4\"\n            d=\"M32 62L21.172 72.828A4 4 0 0020 75.657V84a4 4 0 01-8 0V74a4 4 0 00-4-4H3\"\n        />\n        <path\n            fill=\"#8A8A89\"\n            d=\"M31.586 48.615c-3.905 3.905-3.905 10.237 0 14.142 3.905 3.906 10.237 3.906 14.142 0l5.657-5.657a2 2 0 000-2.828L40.07 42.958a2 2 0 00-2.828 0l-5.657 5.657z\"\n        />\n        <path\n            fill=\"#A0A0A0\"\n            d=\"M34.414 45.787l2.829-2.829a2 2 0 012.828 0l11.314 11.314a2 2 0 010 2.828l-2.829 2.829-14.142-14.142z\"\n        />\n    </svg>\n);\n\nexport default Icon;\n","\nvar content = require(\"!!../../../node_modules/css-loader/index.js??ref--10-1!../../../node_modules/postcss-loader/src/index.js??ref--10-2!../../../node_modules/resolve-url-loader/index.js!../../../node_modules/sass-loader/dist/cjs.js??ref--10-4!./GlobalErrorBoundary.scss\");\n\nif(typeof content === 'string') content = [[module.id, content, '']];\n\nvar transform;\nvar insertInto;\n\n\n\nvar options = {\"singleton\":true,\"insertAt\":\"top\",\"hmr\":true}\n\noptions.transform = transform\noptions.insertInto = undefined;\n\nvar update = require(\"!../../../node_modules/style-loader/lib/addStyles.js\")(content, options);\n\nif(content.locals) module.exports = content.locals;\n\nif(module.hot) {\n\tmodule.hot.accept(\"!!../../../node_modules/css-loader/index.js??ref--10-1!../../../node_modules/postcss-loader/src/index.js??ref--10-2!../../../node_modules/resolve-url-loader/index.js!../../../node_modules/sass-loader/dist/cjs.js??ref--10-4!./GlobalErrorBoundary.scss\", function() {\n\t\tvar newContent = require(\"!!../../../node_modules/css-loader/index.js??ref--10-1!../../../node_modules/postcss-loader/src/index.js??ref--10-2!../../../node_modules/resolve-url-loader/index.js!../../../node_modules/sass-loader/dist/cjs.js??ref--10-4!./GlobalErrorBoundary.scss\");\n\n\t\tif(typeof newContent === 'string') newContent = [[module.id, newContent, '']];\n\n\t\tvar locals = (function(a, b) {\n\t\t\tvar key, idx = 0;\n\n\t\t\tfor(key in a) {\n\t\t\t\tif(!b || a[key] !== b[key]) return false;\n\t\t\t\tidx++;\n\t\t\t}\n\n\t\t\tfor(key in b) idx--;\n\n\t\t\treturn idx === 0;\n\t\t}(content.locals, newContent.locals));\n\n\t\tif(!locals) throw new Error('Aborting CSS HMR due to changed css-modules locals.');\n\n\t\tupdate(newContent);\n\t});\n\n\tmodule.hot.dispose(function() { update(); });\n}","exports = module.exports = require(\"../../../node_modules/css-loader/lib/css-base.js\")(false);\n// imports\n\n\n// module\nexports.push([module.id, \".GlobalErrorBoundary__header___39juG{position:absolute;z-index:1;min-width:100vw;height:96px;border-bottom:1px solid #f3f3f3;display:-ms-flexbox;display:flex;-ms-flex-pack:justify;justify-content:space-between;-ms-flex-align:center;align-items:center;padding:16px 32px 16px 24px;background-color:#fff}.GlobalErrorBoundary__header___39juG .GlobalErrorBoundary__exitBtn___Xntbf{width:48px!important;height:48px;border-radius:100%;position:relative;display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;-ms-flex-align:center;align-items:center;padding:0;background-color:#f3f3f3}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG{background-color:#fff;position:absolute;min-width:100vw;min-height:100vh;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;-ms-flex-pack:center;justify-content:center;-ms-flex-align:center;align-items:center;padding:24px}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG svg{margin-bottom:16px;display:none}@media(min-width:576px){.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG svg{display:block}}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG p{font-family:ciutadella_rounded_medium;font-weight:700;font-size:23px;margin-bottom:8px}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG p small{font-family:Nunito;font-weight:400;font-size:14px}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG .GlobalErrorBoundary__controls___3KIOC{margin-top:24px;display:-ms-flexbox;display:flex;-ms-flex-pack:distribute;justify-content:space-around;min-width:242px;width:100%;-ms-flex-direction:column-reverse;flex-direction:column-reverse}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG .GlobalErrorBoundary__controls___3KIOC button{min-width:100%;margin-bottom:16px}@media(min-width:576px){.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG .GlobalErrorBoundary__controls___3KIOC{-ms-flex-direction:row;flex-direction:row;width:auto}.GlobalErrorBoundary__globalErrorStackTrace___3lJFY .GlobalErrorBoundary__content___121mG .GlobalErrorBoundary__controls___3KIOC button{min-width:80%;margin:0 8px}}\", \"\"]);\n\n// exports\nexports.locals = {\n\t\"header\": \"GlobalErrorBoundary__header___39juG\",\n\t\"exitBtn\": \"GlobalErrorBoundary__exitBtn___Xntbf\",\n\t\"globalErrorStackTrace\": \"GlobalErrorBoundary__globalErrorStackTrace___3lJFY\",\n\t\"content\": \"GlobalErrorBoundary__content___121mG\",\n\t\"controls\": \"GlobalErrorBoundary__controls___3KIOC\"\n};","import * as tslib_1 from \"tslib\";\nimport { consoleSandbox, dynamicRequire, getGlobalObject, isNodeEnv, logger, timestampWithMs, uuid4, } from '@sentry/utils';\nimport { Scope } from './scope';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be incresed when the global interface\n * changes a and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 30;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [];\n        this._stack.push({ client: client, scope: scope });\n    }\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var top = this.getStackTop();\n        if (top && top.client && top.client[method]) {\n            (_a = top.client)[method].apply(_a, tslib_1.__spread(args, [top.scope]));\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var stack = this.getStack();\n        var parentScope = stack.length > 0 ? stack[stack.length - 1].scope : undefined;\n        var scope = Scope.clone(parentScope);\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        return this.getStack().pop() !== undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, tslib_1.__assign({}, finalHint, { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, tslib_1.__assign({}, finalHint, { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, tslib_1.__assign({}, hint, { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var top = this.getStackTop();\n        if (!top.scope || !top.client) {\n            return;\n        }\n        var _a = (top.client.getOptions && top.client.getOptions()) || {}, _b = _a.beforeBreadcrumb, beforeBreadcrumb = _b === void 0 ? null : _b, _c = _a.maxBreadcrumbs, maxBreadcrumbs = _c === void 0 ? DEFAULT_BREADCRUMBS : _c;\n        if (maxBreadcrumbs <= 0) {\n            return;\n        }\n        var timestamp = timestampWithMs();\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null) {\n            return;\n        }\n        top.scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setContext = function (name, context) {\n        var top = this.getStackTop();\n        if (!top.scope) {\n            return;\n        }\n        top.scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var top = this.getStackTop();\n        if (top.scope && top.client) {\n            callback(top.scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client) {\n            return null;\n        }\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (spanOrSpanContext, forceNoChild) {\n        if (forceNoChild === void 0) { forceNoChild = false; }\n        return this._callExtensionMethod('startSpan', spanOrSpanContext, forceNoChild);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        // tslint:disable-next-line: strict-type-predicates\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/** Returns the global shim registry. */\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Try to read the hub from an active domain, fallback to the registry if one doesnt exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        // We need to use `dynamicRequire` because `require` on it's own will be optimized by webpack.\n        // We do not want this to happen, we need to try to `require` the domain node module and fail if we are in browser\n        // for example so we do not have to shim it and use `getCurrentHub` universally.\n        var domain = dynamicRequire(module, 'domain');\n        var activeDomain = domain.active;\n        // If there no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or its an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n        return true;\n    }\n    return false;\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub) {\n        return carrier.__SENTRY__.hub;\n    }\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier) {\n        return false;\n    }\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { consoleSandbox, getGlobalObject } from './misc';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' ')); // tslint:disable-line:no-console\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' ')); // tslint:disable-line:no-console\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' ')); // tslint:disable-line:no-console\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };\n//# sourceMappingURL=logger.js.map","import { isThenable } from './is';\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (isThenable(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            if (_this._state === States.REJECTED) {\n                _this._handlers.forEach(function (handler) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                });\n            }\n            else {\n                _this._handlers.forEach(function (handler) {\n                    if (handler.onfulfilled) {\n                        // tslint:disable-next-line:no-unsafe-any\n                        handler.onfulfilled(_this._value);\n                    }\n                });\n            }\n            _this._handlers = [];\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                // tslint:disable-next-line:no-unsafe-any\n                resolve(val);\n            });\n        });\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map","export const GLOBAL_ERROR_NAME = 'Ofx Global Error';\nexport const OFX_GLOBAL_ERROR = 'OFX_GLOBAL_ERROR';\nexport const OFX_GLOBAL_ERROR_LOGOUT = 'OFX_GLOBAL_ERROR_LOGOUT';\nexport const OFX_GLOBAL_ERROR_TOAST = 'OFX_GLOBAL_ERROR_TOAST';\nexport const UNAUTHENTICATED_ERROR_CODE = 'AUTHN:UNAUTHENTICATED';\nexport const GRAPHQL_UNAUTHENTICATED_ERROR_CODE = 'UNAUTHENTICATED';\n","import * as tslib_1 from \"tslib\";\nimport { getGlobalObject, isThenable, normalize, SyncPromise, timestampWithMs } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._context = {};\n    }\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            setTimeout(function () {\n                _this._scopeListeners.forEach(function (callback) {\n                    callback(_this);\n                });\n                _this._notifyingListeners = false;\n            });\n        }\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            // tslint:disable-next-line:strict-type-predicates\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(tslib_1.__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = normalize(user);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = tslib_1.__assign({}, this._tags, normalize(tags));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = tslib_1.__assign({}, this._tags, (_a = {}, _a[key] = normalize(value), _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extra) {\n        this._extra = tslib_1.__assign({}, this._extra, normalize(extra));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = tslib_1.__assign({}, this._extra, (_a = {}, _a[key] = normalize(extra), _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = normalize(fingerprint);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = normalize(level);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransaction = function (transaction) {\n        this._transaction = transaction;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (name, context) {\n        this._context[name] = context ? normalize(context) : undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Internal getter for Span, used in Hub.\n     * @hidden\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = tslib_1.__spread(scope._breadcrumbs);\n            newScope._tags = tslib_1.__assign({}, scope._tags);\n            newScope._extra = tslib_1.__assign({}, scope._extra);\n            newScope._context = tslib_1.__assign({}, scope._context);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._transaction = scope._transaction;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = tslib_1.__spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._context = {};\n        this._level = undefined;\n        this._transaction = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var timestamp = timestampWithMs();\n        var mergedBreadcrumb = tslib_1.__assign({ timestamp: timestamp }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? tslib_1.__spread(this._breadcrumbs, [normalize(mergedBreadcrumb)]).slice(-maxBreadcrumbs)\n                : tslib_1.__spread(this._breadcrumbs, [normalize(mergedBreadcrumb)]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = tslib_1.__assign({}, this._extra, event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = tslib_1.__assign({}, this._tags, event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = tslib_1.__assign({}, this._user, event.user);\n        }\n        if (this._context && Object.keys(this._context).length) {\n            event.contexts = tslib_1.__assign({}, this._context, event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transaction) {\n            event.transaction = this._transaction;\n        }\n        if (this._span) {\n            event.contexts = event.contexts || {};\n            event.contexts.trace = this._span.getTraceContext();\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = tslib_1.__spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(tslib_1.__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","import { isString } from './is';\n/**\n * Requires a module which is protected _against bundler minification.\n *\n * @param request The module path to resolve\n */\nexport function dynamicRequire(mod, request) {\n    // tslint:disable-next-line: no-unsafe-any\n    return mod.require(request);\n}\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    // tslint:disable:strict-type-predicates\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // tslint:disable-next-line:no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // tslint:disable-next-line:no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // tslint:disable-next-line:no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // tslint:disable-next-line:no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:\\/?#]+):)?(\\/\\/([^\\/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore\n        // tslint:disable:no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var attrWhitelist = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < attrWhitelist.length; i++) {\n        key = attrWhitelist[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n/**\n * Returns a timestamp in seconds with milliseconds precision.\n */\nexport function timestampWithMs() {\n    return new Date().getTime() / 1000;\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\n}\nvar defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn) {\n    try {\n        if (!fn || typeof fn !== 'function') {\n            return defaultFunctionName;\n        }\n        return fn.name || defaultFunctionName;\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        return defaultFunctionName;\n    }\n}\n//# sourceMappingURL=misc.js.map","import { isRegExp } from './is';\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    // tslint:disable-next-line:strict-type-predicates\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        colno = ll; // tslint:disable-line:no-parameter-reassignment\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // tslint:disable-next-line:prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value, pattern) {\n    if (isRegExp(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n//# sourceMappingURL=string.js.map","import { handleActions } from 'redux-actions';\nimport { Map } from 'immutable';\nimport { IGlobalErrorInfo } from './GlobalErrorBoundary';\nimport { OFX_GLOBAL_ERROR, OFX_GLOBAL_ERROR_LOGOUT, OFX_GLOBAL_ERROR_TOAST } from './constants';\n\nconst partition = {\n    globalErrorBoundary: 'globalErrorBoundary',\n};\n\nexport interface IPartition {\n    globalError: boolean;\n    globalErrorToast: boolean;\n    globalErrorLogout: boolean;\n    globalErrorInfo?: IGlobalErrorInfo | string;\n}\n\nconst initialState: IPartition = {\n    globalError: false,\n    globalErrorToast: false,\n    globalErrorLogout: false,\n    globalErrorInfo: undefined,\n};\n\nexport interface IRootState {\n    [key: string]: Map<IPartition, IPartition>;\n}\n\nexport const selectors = {\n    getPartition: (state: IRootState): IPartition => {\n        const globalError = state[partition.globalErrorBoundary].getIn([\n            \"globalError\",\n        ]);\n        const globalErrorInfo = state[partition.globalErrorBoundary].getIn([\n            \"globalErrorInfo\",\n        ]);\n        const globalErrorToast = state[partition.globalErrorBoundary].getIn([\n            \"globalErrorToast\",\n        ]);\n        const globalErrorLogout = state[partition.globalErrorBoundary].getIn([\n            \"globalErrorLogout\",\n        ]);\n        return {\n            globalError,\n            globalErrorInfo,\n            globalErrorLogout,\n            globalErrorToast,\n        };\n    },\n};\nconst actionTypes = {\n    OFX_GLOBAL_ERROR,\n    OFX_GLOBAL_ERROR_TOAST,\n    OFX_GLOBAL_ERROR_LOGOUT,\n};\n\nconst reducers = handleActions<Map<IPartition, IPartition>, IPartition>(\n    {\n        [actionTypes.OFX_GLOBAL_ERROR]: (state, { payload }) => {\n            return state\n                .setIn([\"globalError\"], true)\n                .setIn([\"globalErrorInfo\"], payload);\n        },\n        [actionTypes.OFX_GLOBAL_ERROR_TOAST]: (state) => {\n            return state.setIn([\"globalErrorToast\"], true);\n        },\n        [actionTypes.OFX_GLOBAL_ERROR_LOGOUT]: (state) => {\n            return state.setIn([\"globalErrorLogout\"], true);\n        },\n    },\n    Map(initialState),\n);\n\nexport default reducers;\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***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n"],"sourceRoot":""}