{"version":3,"sources":["webpack:///./node_modules/@sentry/core/esm/basebackend.js","webpack:///./node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/browser/esm/tracekit.js","webpack:///./node_modules/@sentry/utils/esm/polyfill.js","webpack:///./node_modules/@sentry/utils/esm/error.js","webpack:///./node_modules/@sentry/browser/esm/parsers.js","webpack:///./node_modules/@sentry/types/esm/status.js","webpack:///./node_modules/@sentry/types/esm/session.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///./node_modules/@sentry/browser/esm/transports/base.js","webpack:///./node_modules/@sentry/utils/esm/supports.js","webpack:///./node_modules/@sentry/types/esm/severity.js","webpack:///./node_modules/@sentry/core/esm/transports/noop.js","webpack:///./node_modules/@sentry/hub/esm/scope.js","webpack:///./node_modules/@sentry/utils/esm/browser.js","webpack:///./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/backend.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/utils/esm/time.js","webpack:///./node_modules/@sentry/utils/esm/memo.js","webpack:///./node_modules/@sentry/hub/esm/session.js","webpack:///./node_modules/@sentry/hub/esm/hub.js","webpack:///./node_modules/@sentry/browser/esm/integrations/useragent.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/core/esm/integration.js","webpack:///./node_modules/@sentry/core/esm/baseclient.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/core/esm/request.js","webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///./node_modules/@sentry/core/esm/sdk.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/@sentry/utils/esm/dsn.js","webpack:///./node_modules/@sentry/browser/esm/version.js","webpack:///./node_modules/@sentry/browser/esm/index.js","webpack:///./node_modules/@sentry/core/esm/api.js","webpack:///./node_modules/@sentry/minimal/esm/index.js","webpack:///./node_modules/@sentry/browser/esm/integrations/index.js","webpack:///./node_modules/@sentry/utils/esm/node.js","webpack:///./node_modules/@sentry/utils/esm/instrument.js","webpack:///./node_modules/@sentry/core/esm/version.js","webpack:///./node_modules/@sentry/utils/esm/stacktrace.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/browser/esm/transports/index.js","webpack:///./node_modules/@sentry/utils/esm/is.js"],"names":["BaseBackend","options","this","_options","dsn","warn","_transport","_setupTransport","prototype","eventFromException","_exception","_hint","eventFromMessage","_message","_level","sendEvent","event","then","reason","error","sendSession","session","getTransport","exception","hint","eventFromUnknownInput","syntheticException","undefined","attachStacktrace","handled","type","level","Error","event_id","resolve","message","Info","eventFromString","domException","name_1","name","tags","code","objectException","rejection","synthetic","input","stacktrace","frames_1","stack","frames","chrome","gecko","winjs","geckoEval","chromeEval","reactMinifiedRegexp","computeStackTrace","ex","popSize","framesToPop","test","parts","opera10Regex","opera11Regex","lines","split","line","length","element","exec","url","func","args","column","push","extractMessage","computeStackTraceFromStacktraceProp","popFrames","e","submatch","i","isNative","indexOf","substr","columnNumber","computeStackTraceFromStackProp","failed","slice","setPrototypeOf","Object","__proto__","Array","obj","proto","prop","hasOwnProperty","_super","SentryError","_newTarget","constructor","_this","call","exceptionFromStacktrace","prepareFramesForEvent","value","eventFromPlainObject","values","extra","__serialized__","eventFromStacktrace","localStack","firstFrameFunction","lastFrameFunction","map","frame","colno","filename","function","in_app","lineno","reverse","Status","fromHttpCode","Success","RateLimit","Invalid","Failed","Unknown","SessionStatus","LinkedErrors","id","_key","key","_limit","limit","setupOnce","self","getIntegration","_handler","originalException","linkedErrors","_walkErrorTree","PromiseBuffer","_buffer","isReady","add","task","remove","reject","splice","drain","timeout","capturedSetTimeout","setTimeout","all","clearTimeout","BaseTransport","_rateLimits","_api","_metadata","getStoreEndpointWithUrlEncodedAuth","_","close","_handleResponse","_a","requestType","response","headers","status","_handleRateLimit","logger","_disabledUntil","category","_isRateLimited","Date","now","e_1","e_2","_b","rlHeader","raHeader","_c","trim","_d","next","done","parameters","headerDelay","parseInt","delay","isNaN","_e","_f","e_2_1","return","e_1_1","supportsFetch","Headers","Request","Response","isNativeFetch","toString","supportsNativeFetch","global","fetch","result","doc","document","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","err","supportsReferrerPolicy","referrerPolicy","supportsHistory","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","Severity","fromString","Debug","Warning","Fatal","Critical","Log","NoopTransport","Skipped","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","clone","scope","newScope","_span","_session","_transactionName","_fingerprint","addScopeListener","callback","addEventProcessor","setUser","user","update","_notifyScopeListeners","getUser","setTags","setTag","setExtras","extras","setExtra","setFingerprint","fingerprint","setLevel","setTransactionName","setTransaction","setContext","context","setSpan","span","getSpan","getTransaction","transaction","spanRecorder","spans","setSession","getSession","captureContext","updatedScope","keys","contexts","clear","addBreadcrumb","breadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","clearBreadcrumbs","applyToEvent","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","_notifyEventProcessors","getGlobalEventProcessors","processors","index","processor","final","forEach","isArray","concat","__SENTRY__","globalEventProcessors","addGlobalEventProcessor","htmlTreeAsString","elem","currentElem","out","height","len","sepLength","nextStr","_htmlElementAsString","parentNode","join","_oO","el","className","classes","attr","tagName","toLowerCase","allowedAttrs","getAttribute","Breadcrumbs","console","dom","sentry","xhr","addSentryBreadcrumb","_i","arguments","_consoleBreadcrumb","apply","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","handlerData","data","target","endTimestamp","__sentry_own_request__","__sentry_xhr__","method","status_code","body","fetchData","match","from","to","parsedLoc","location","href","parsedFrom","parsedTo","path","protocol","host","relative","BrowserBackend","transportOptions","transport","supports","BrowserClient","showReportDialog","_isEnabled","getDsn","_prepareEvent","platform","_sendEvent","integration","dateTimestampSource","nowSeconds","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","bind","timing","navigationStart","Memo","_hasWeakSet","WeakSet","_inner","memoize","has","unmemoize","delete","Session","errors","sid","started","duration","Ok","ip_address","ipAddress","did","email","username","release","environment","userAgent","Exited","toJSON","init","toISOString","attrs","user_agent","Hub","client","_version","_stack","getStackTop","bindClient","isOlderThan","version","setupIntegrations","pushScope","getScope","getStack","getClient","popScope","pop","withScope","captureException","eventId","_lastEventId","finalHint","_invokeClient","captureMessage","captureEvent","lastEventId","getOptions","beforeBreadcrumb","finalBreadcrumb","Math","min","configureScope","run","oldHub","makeMain","startSpan","_callExtensionMethod","startTransaction","customSamplingContext","traceHeaders","startSession","endSession","captureSession","carrier","getMainCarrier","extensions","hub","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","UserAgent","navigator","request","referrer","Referer","States","SyncPromise","executor","_state","PENDING","_handlers","_resolve","_setResult","RESOLVED","_reject","REJECTED","state","_value","_executeHandlers","_attachHandler","handler","cachedHandlers","onfulfilled","onrejected","collection","counter","resolvedCollection","item","TypeError","catch","val","finally","onfinally","isRejected","fallbackGlobalObject","getGlobalObject","window","uuid4","crypto","msCrypto","getRandomValues","arr","Uint16Array","pad","num","v","replace","c","r","random","parseUrl","query","fragment","getEventDescription","consoleSandbox","originalConsole","wrappedLevels","__sentry_original__","addExceptionTypeValue","addExceptionMechanism","mechanism","getLocationHref","oO","parseRetryAfterHeader","header","headerDate","parse","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","onerror","onunhandledrejection","stackTraceLimit","log","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","currentHub","hasIntegration","isFailedOwnDelivery","_eventFromIncompleteOnError","msg","_enhanceEventWithInitialFrame","detail","_eventFromRejectionWithPrimitive","groups","String","installedIntegrations","integrations","defaultIntegrations","userIntegrations","userIntegrationsNames_1","pickedIntegrationsNames_1","defaultIntegration","userIntegration","integrationsNames","getIntegrationsToSetup","setupIntegration","BaseClient","backendClass","_integrations","_processing","_backend","_dsn","_process","_getBackend","_captureEvent","promisedEvent","is","_sendSession","flush","_isClientProcessing","ready","transportFlushed","enabled","_updateSessionFromEvent","crashed","errored","exceptions","exceptions_1","exceptions_1_1","Crashed","Number","ticked","interval","setInterval","clearInterval","normalizeDepth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","evt","_normalizeEvent","depth","normalized","b","dist","maxValueLength","sdkInfo","sdk","integrationsArray","_processEvent","finalEvent","beforeSend","sampleRate","isTransaction","__sentry__","beforeSendResult","processedEvent","promise","PREFIX","Logger","_enabled","disable","enable","XHRTransport","_sendRequest","sentryRequest","originalPayload","Promise","XMLHttpRequest","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","send","FetchTransport","fetchParameters","assign","get","getSdkMetadataForEnvelopeHeader","api","metadata","enhanceEventWithSdkInfo","packages","sessionToSentryRequest","JSON","stringify","sent_at","getEnvelopeEndpointWithUrlEncodedAuth","eventToSentryRequest","samplingMethod","__sentry_samplingMethod","__sentry_sampleRate","otherTags","eventType","useEnvelope","req","envelope","sample_rates","rate","fill","source","replacementFactory","original","wrapped","defineProperties","enumerable","urlEncode","object","encodeURIComponent","getWalkSource","event_1","currentTarget","CustomEvent","jsonSize","encodeURI","utf8Length","normalizeToSize","maxSize","serialized","normalize","normalizeValue","_events","walk","memo","Infinity","serializeValue","acc","innerKey","extractExceptionKeysForMessage","maxLength","sort","includedKeys","dropUndefinedKeys","rv","originalFunctionToString","FunctionToString","Function","DEFAULT_IGNORE_ERRORS","InboundFilters","clientOptions","_mergeOptions","_shouldDropEvent","_isSentryError","_isIgnoredError","_isDeniedUrl","_getEventFilterUrl","_isAllowedUrl","ignoreInternal","ignoreErrors","_getPossibleEventMessages","some","pattern","denyUrls","allowUrls","whitelistUrls","blacklistUrls","frames_2","initAndBind","clientClass","debug","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","_wrapEventTarget","originalCallback","eventName","fn","handleEvent","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","__sentry_wrapped__","originalSend","xmlHttpRequestProps","wrapOptions","window_1","SENTRY_RELEASE","autoSessionTracking","loadResolved","fcpResolved","possiblyEndSession","resolveWindowLoaded","removeEventListener","addEventListener","po","PerformanceObserver","entryList","getEntries","entry","startTime","firstHiddenTime_1","disconnect","visibilityState","timeStamp","once","observe","buffered","startSessionTracking","forceLoad","onLoad","wrap","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","before","sentryWrapped","wrappedArguments","arg","property","defineProperty","getOwnPropertyDescriptor","configurable","injectReportDialog","script","async","src","getReportDialogEndpoint","onload","DSN_REGEX","Dsn","_fromString","_fromComponents","_validate","withPassword","pass","port","projectId","str","projectMatch","components","component","ERROR_MESSAGE","SDK_NAME","windowIntegrations","_window","Sentry","Integrations","INTEGRATIONS","API","_dsnObject","getBaseApiEndpoint","getStoreEndpoint","_getIngestEndpoint","_encodedAuth","_getEnvelopeEndpoint","getStoreEndpointPath","getRequestHeaders","clientName","clientVersion","dialogOptions","endpoint","encodedOptions","auth","sentry_key","sentry_version","callOnHub","isNodeEnv","process","dynamicRequire","mod","require","lastHref","handlers","instrumented","instrument","originalConsoleLevel","triggerHandlers","instrumentConsole","domEventHandler","keypressEventHandler","innerOriginal","instrumentDOM","requestKeys","requestValues","xhrproto","originalOpen","toUpperCase","onreadystatechangeHandler","requestPos","args_1","startTimestamp","readyStateArgs","instrumentXHR","originalFetch","getFetchMethod","getFetchUrl","instrumentFetch","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","instrumentHistory","_oldOnErrorHandler","_oldOnUnhandledRejectionHandler","addInstrumentationHandler","fetchArgs","keypressTimeout","lastCapturedEvent","debounceTimer","debounce","isContentEditable","SDK_VERSION","getFunctionName","truncate","max","snipLine","newLine","ll","start","end","safeJoin","delimiter","output","isMatchingPattern","isError","wat","isInstanceOf","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base"],"mappings":"kGAAA,sFAMIA,EAA6B,WAE7B,SAASA,EAAYC,GACjBC,KAAKC,SAAWF,EACXC,KAAKC,SAASC,KACf,IAAOC,KAAK,kDAEhBH,KAAKI,WAAaJ,KAAKK,kBA+C3B,OAzCAP,EAAYQ,UAAUC,mBAAqB,SAAUC,EAAYC,GAC7D,MAAM,IAAI,IAAY,yDAK1BX,EAAYQ,UAAUI,iBAAmB,SAAUC,EAAUC,EAAQH,GACjE,MAAM,IAAI,IAAY,uDAK1BX,EAAYQ,UAAUO,UAAY,SAAUC,GACxCd,KAAKI,WAAWS,UAAUC,GAAOC,KAAK,MAAM,SAAUC,GAClD,IAAOC,MAAM,8BAAgCD,OAMrDlB,EAAYQ,UAAUY,YAAc,SAAUC,GACrCnB,KAAKI,WAAWc,YAIrBlB,KAAKI,WAAWc,YAAYC,GAASJ,KAAK,MAAM,SAAUC,GACtD,IAAOC,MAAM,gCAAkCD,MAJ/C,IAAOb,KAAK,4EAUpBL,EAAYQ,UAAUc,aAAe,WACjC,OAAOpB,KAAKI,YAKhBN,EAAYQ,UAAUD,gBAAkB,WACpC,OAAO,IAAI,KAERP,EAtDqB,I,wCCNhC,0NASO,SAASS,EAAmBR,EAASsB,EAAWC,GACnD,IACIR,EAAQS,EAAsBF,EADRC,GAAQA,EAAKE,yBAAuBC,EACG,CAC7DC,iBAAkB3B,EAAQ2B,mBAU9B,OARA,YAAsBZ,EAAO,CACzBa,SAAS,EACTC,KAAM,YAEVd,EAAMe,MAAQ,IAASC,MACnBR,GAAQA,EAAKS,WACbjB,EAAMiB,SAAWT,EAAKS,UAEnB,IAAYC,QAAQlB,GAMxB,SAASJ,EAAiBX,EAASkC,EAASJ,EAAOP,QACxC,IAAVO,IAAoBA,EAAQ,IAASK,MACzC,IACIpB,EAAQqB,EAAgBF,EADFX,GAAQA,EAAKE,yBAAuBC,EACL,CACrDC,iBAAkB3B,EAAQ2B,mBAM9B,OAJAZ,EAAMe,MAAQA,EACVP,GAAQA,EAAKS,WACbjB,EAAMiB,SAAWT,EAAKS,UAEnB,IAAYC,QAAQlB,GAKxB,SAASS,EAAsBF,EAAWG,EAAoBzB,GAEjE,IAAIe,EACJ,QAFgB,IAAZf,IAAsBA,EAAU,IAEhC,YAAasB,IAAcA,EAAUJ,MAMrC,OAFAI,EAFiBA,EAEMJ,MACvBH,EAAQ,YAAoB,YAAkBO,IAGlD,GAAI,YAAWA,IAAc,YAAeA,GAAY,CAKpD,IAAIe,EAAef,EACfgB,EAASD,EAAaE,OAAS,YAAWF,GAAgB,WAAa,gBACvEH,EAAUG,EAAaH,QAAUI,EAAS,KAAOD,EAAaH,QAAUI,EAM5E,OALAvB,EAAQqB,EAAgBF,EAAST,EAAoBzB,GACrD,YAAsBe,EAAOmB,GACzB,SAAUG,IACVtB,EAAMyB,KAAO,YAAS,YAAS,GAAIzB,EAAMyB,MAAO,CAAE,oBAAqB,GAAKH,EAAaI,QAEtF1B,EAEX,GAAI,YAAQO,GAGR,OADAP,EAAQ,YAAoB,YAAkBO,IAGlD,GAAI,YAAcA,IAAc,YAAQA,GAAY,CAIhD,IAAIoB,EAAkBpB,EAKtB,OAJAP,EAAQ,YAAqB2B,EAAiBjB,EAAoBzB,EAAQ2C,WAC1E,YAAsB5B,EAAO,CACzB6B,WAAW,IAER7B,EAgBX,OALAA,EAAQqB,EAAgBd,EAAWG,EAAoBzB,GACvD,YAAsBe,EAAO,GAAKO,OAAWI,GAC7C,YAAsBX,EAAO,CACzB6B,WAAW,IAER7B,EAKJ,SAASqB,EAAgBS,EAAOpB,EAAoBzB,QACvC,IAAZA,IAAsBA,EAAU,IACpC,IAAIe,EAAQ,CACRmB,QAASW,GAEb,GAAI7C,EAAQ2B,kBAAoBF,EAAoB,CAChD,IAAIqB,EAAa,YAAkBrB,GAC/BsB,EAAW,YAAsBD,EAAWE,OAChDjC,EAAM+B,WAAa,CACfG,OAAQF,GAGhB,OAAOhC,I,wCCpHX,sDAQImC,EAAS,6JAITC,EAAQ,kMACRC,EAAQ,gHACRC,EAAY,gDACZC,EAAa,gCAEbC,EAAsB,8BAGnB,SAASC,EAAkBC,GAC9B,IAAIT,EAAQ,KACRU,EAAU,EACVD,IAC8B,iBAAnBA,EAAGE,YACVD,EAAUD,EAAGE,YAERJ,EAAoBK,KAAKH,EAAGvB,WACjCwB,EAAU,IAGlB,IAKI,GADAV,EA4GR,SAA6CS,GACzC,IAAKA,IAAOA,EAAGX,WACX,OAAO,KAWX,IANA,IAKIe,EALAf,EAAaW,EAAGX,WAChBgB,EAAe,8DACfC,EAAe,sGACfC,EAAQlB,EAAWmB,MAAM,MACzBjB,EAAQ,GAEHkB,EAAO,EAAGA,EAAOF,EAAMG,OAAQD,GAAQ,EAAG,CAC/C,IAAIE,EAAU,MACTP,EAAQC,EAAaO,KAAKL,EAAME,KACjCE,EAAU,CACNE,IAAKT,EAAM,GACXU,KAAMV,EAAM,GACZW,KAAM,GACNN,MAAOL,EAAM,GACbY,OAAQ,OAGNZ,EAAQE,EAAaM,KAAKL,EAAME,OACtCE,EAAU,CACNE,IAAKT,EAAM,GACXU,KAAMV,EAAM,IAAMA,EAAM,GACxBW,KAAMX,EAAM,GAAKA,EAAM,GAAGI,MAAM,KAAO,GACvCC,MAAOL,EAAM,GACbY,QAASZ,EAAM,KAGnBO,KACKA,EAAQG,MAAQH,EAAQF,OACzBE,EAAQG,KA5KD,KA8KXvB,EAAM0B,KAAKN,IAGnB,IAAKpB,EAAMmB,OACP,OAAO,KAEX,MAAO,CACHjC,QAASyC,EAAelB,GACxBlB,KAAMkB,EAAGlB,KACTS,MAAOA,GA1JC4B,CAAoCnB,GAExC,OAAOoB,EAAU7B,EAAOU,GAGhC,MAAOoB,IAGP,IAEI,GADA9B,EAiBR,SAAwCS,GACpC,IAAKA,IAAOA,EAAGT,MACX,OAAO,KAQX,IANA,IAGI+B,EACAlB,EACAO,EALApB,EAAQ,GACRgB,EAAQP,EAAGT,MAAMiB,MAAM,MAKlBe,EAAI,EAAGA,EAAIhB,EAAMG,SAAUa,EAAG,CACnC,GAAKnB,EAAQX,EAAOmB,KAAKL,EAAMgB,IAAM,CACjC,IAAIC,EAAWpB,EAAM,IAAqC,IAA/BA,EAAM,GAAGqB,QAAQ,UACnCrB,EAAM,IAAmC,IAA7BA,EAAM,GAAGqB,QAAQ,UACvBH,EAAWzB,EAAWe,KAAKR,EAAM,OAE5CA,EAAM,GAAKkB,EAAS,GACpBlB,EAAM,GAAKkB,EAAS,GACpBlB,EAAM,GAAKkB,EAAS,IAExBX,EAAU,CAGNE,IAAKT,EAAM,IAA0C,IAApCA,EAAM,GAAGqB,QAAQ,eAAuBrB,EAAM,GAAGsB,OAAO,cAAchB,QAAUN,EAAM,GACvGU,KAAMV,EAAM,IA/EL,IAgFPW,KAAMS,EAAW,CAACpB,EAAM,IAAM,GAC9BK,KAAML,EAAM,IAAMA,EAAM,GAAK,KAC7BY,OAAQZ,EAAM,IAAMA,EAAM,GAAK,WAGlC,GAAKA,EAAQT,EAAMiB,KAAKL,EAAMgB,IAC/BZ,EAAU,CACNE,IAAKT,EAAM,GACXU,KAAMV,EAAM,IAxFL,IAyFPW,KAAM,GACNN,MAAOL,EAAM,GACbY,OAAQZ,EAAM,IAAMA,EAAM,GAAK,UAGlC,MAAKA,EAAQV,EAAMkB,KAAKL,EAAMgB,KAyB/B,SAxBSnB,EAAM,IAAMA,EAAM,GAAGqB,QAAQ,YAAc,IACrCH,EAAW1B,EAAUgB,KAAKR,EAAM,MAE3CA,EAAM,GAAKA,EAAM,IAAM,OACvBA,EAAM,GAAKkB,EAAS,GACpBlB,EAAM,GAAKkB,EAAS,GACpBlB,EAAM,GAAK,IAEA,IAANmB,GAAYnB,EAAM,SAA0B,IAApBJ,EAAG2B,eAKhCpC,EAAM,GAAGyB,OAAShB,EAAG2B,aAAe,GAExChB,EAAU,CACNE,IAAKT,EAAM,GACXU,KAAMV,EAAM,IAhHL,IAiHPW,KAAMX,EAAM,GAAKA,EAAM,GAAGI,MAAM,KAAO,GACvCC,KAAML,EAAM,IAAMA,EAAM,GAAK,KAC7BY,OAAQZ,EAAM,IAAMA,EAAM,GAAK,OAMlCO,EAAQG,MAAQH,EAAQF,OACzBE,EAAQG,KA1HG,KA4HfvB,EAAM0B,KAAKN,GAEf,IAAKpB,EAAMmB,OACP,OAAO,KAEX,MAAO,CACHjC,QAASyC,EAAelB,GACxBlB,KAAMkB,EAAGlB,KACTS,MAAOA,GA9FCqC,CAA+B5B,GAEnC,OAAOoB,EAAU7B,EAAOU,GAGhC,MAAOoB,IAGP,MAAO,CACH5C,QAASyC,EAAelB,GACxBlB,KAAMkB,GAAMA,EAAGlB,KACfS,MAAO,GACPsC,QAAQ,GAyIhB,SAAST,EAAU/B,EAAYY,GAC3B,IACI,OAAO,YAAS,YAAS,GAAIZ,GAAa,CAAEE,MAAOF,EAAWE,MAAMuC,MAAM7B,KAE9E,MAAOoB,GACH,OAAOhC,GASf,SAAS6B,EAAelB,GACpB,IAAIvB,EAAUuB,GAAMA,EAAGvB,QACvB,OAAKA,EAGDA,EAAQhB,OAA0C,iBAA1BgB,EAAQhB,MAAMgB,QAC/BA,EAAQhB,MAAMgB,QAElBA,EALI,qB,8FClNJsD,EAAiBC,OAAOD,iBAAmB,CAAEE,UAAW,cAAgBC,MAKnF,SAAoBC,EAAKC,GAGrB,OADAD,EAAIF,UAAYG,EACTD,GAMX,SAAyBA,EAAKC,GAC1B,IAAK,IAAIC,KAAQD,EAERD,EAAIG,eAAeD,KAEpBF,EAAIE,GAAQD,EAAMC,IAG1B,OAAOF,ICnBX,IAAI,EAA6B,SAAUI,GAEvC,SAASC,EAAY/D,GACjB,IAAIgE,EAAajG,KAAKkG,YAClBC,EAAQJ,EAAOK,KAAKpG,KAAMiC,IAAYjC,KAI1C,OAHAmG,EAAMlE,QAAUA,EAChBkE,EAAM7D,KAAO2D,EAAW3F,UAAU4F,YAAY5D,KAC9CiD,EAAeY,EAAOF,EAAW3F,WAC1B6F,EAEX,OATA,YAAUH,EAAaD,GAShBC,EAVqB,CAW9BlE,Q,wCCdF,4LAQO,SAASuE,EAAwBxD,GACpC,IAAIG,EAASsD,EAAsBzD,EAAWE,OAC1C1B,EAAY,CACZO,KAAMiB,EAAWP,KACjBiE,MAAO1D,EAAWZ,SAQtB,OANIe,GAAUA,EAAOkB,SACjB7C,EAAUwB,WAAa,CAAEG,OAAQA,SAEdvB,IAAnBJ,EAAUO,MAA0C,KAApBP,EAAUkF,QAC1ClF,EAAUkF,MAAQ,8BAEflF,EAKJ,SAASmF,EAAqBnF,EAAWG,EAAoBkB,GAChE,IAAI5B,EAAQ,CACRO,UAAW,CACPoF,OAAQ,CACJ,CACI7E,KAAM,YAAQP,GAAaA,EAAU6E,YAAY5D,KAAOI,EAAY,qBAAuB,QAC3F6D,MAAO,cAAgB7D,EAAY,oBAAsB,aAAe,wBAA0B,YAA+BrB,MAI7IqF,MAAO,CACHC,eAAgB,YAAgBtF,KAGxC,GAAIG,EAAoB,CACpB,IACIsB,EAAWwD,EADE,YAAkB9E,GACauB,OAChDjC,EAAM+B,WAAa,CACfG,OAAQF,GAGhB,OAAOhC,EAKJ,SAAS8F,EAAoB/D,GAEhC,MAAO,CACHxB,UAAW,CACPoF,OAAQ,CAHAJ,EAAwBxD,MAUrC,SAASyD,EAAsBvD,GAClC,IAAKA,IAAUA,EAAMmB,OACjB,MAAO,GAEX,IAAI2C,EAAa9D,EACb+D,EAAqBD,EAAW,GAAGvC,MAAQ,GAC3CyC,EAAoBF,EAAWA,EAAW3C,OAAS,GAAGI,MAAQ,GAUlE,OARsD,IAAlDwC,EAAmB7B,QAAQ,oBAAgF,IAApD6B,EAAmB7B,QAAQ,sBAClF4B,EAAaA,EAAWvB,MAAM,KAGkB,IAAhDyB,EAAkB9B,QAAQ,mBAC1B4B,EAAaA,EAAWvB,MAAM,GAAI,IAG/BuB,EACFvB,MAAM,EA7EQ,IA8Ed0B,KAAI,SAAUC,GAAS,MAAO,CAC/BC,MAAwB,OAAjBD,EAAMzC,YAAkB/C,EAAYwF,EAAMzC,OACjD2C,SAAUF,EAAM5C,KAAOwC,EAAW,GAAGxC,IACrC+C,SAAUH,EAAM3C,MAAQ,IACxB+C,QAAQ,EACRC,OAAuB,OAAfL,EAAMhD,UAAgBxC,EAAYwF,EAAMhD,SAE/CsD,Y,wCCrFF,IAAIC,EAFX,kCAGA,SAAWA,GAEPA,EAAgB,QAAI,UAEpBA,EAAgB,QAAI,UAEpBA,EAAgB,QAAI,UAEpBA,EAAkB,UAAI,aAEtBA,EAAgB,QAAI,UAEpBA,EAAe,OAAI,SAZvB,CAaGA,IAAWA,EAAS,KAEvB,SAAWA,GAsBPA,EAAOC,aAfP,SAAsBjF,GAClB,OAAIA,GAAQ,KAAOA,EAAO,IACfgF,EAAOE,QAEL,MAATlF,EACOgF,EAAOG,UAEdnF,GAAQ,KAAOA,EAAO,IACfgF,EAAOI,QAEdpF,GAAQ,IACDgF,EAAOK,OAEXL,EAAOM,SApBtB,CAuBGN,IAAWA,EAAS,M,wCCtChB,IAAIO,EAHX,kCAIA,SAAWA,GAEPA,EAAkB,GAAI,KAEtBA,EAAsB,OAAI,SAE1BA,EAAuB,QAAI,UAE3BA,EAAwB,SAAI,WARhC,CASGA,IAAkBA,EAAgB,M,wCCbrC,sIAQIC,EAA8B,WAI9B,SAASA,EAAajI,QACF,IAAZA,IAAsBA,EAAU,IAIpCC,KAAKsC,KAAO0F,EAAaC,GACzBjI,KAAKkI,KAAOnI,EAAQoI,KAbV,QAcVnI,KAAKoI,OAASrI,EAAQsI,OAbV,EAsDhB,OApCAL,EAAa1H,UAAUgI,UAAY,WAC/B,aAAwB,SAAUxH,EAAOQ,GACrC,IAAIiH,EAAO,cAAgBC,eAAeR,GAC1C,OAAIO,EACOA,EAAKE,SAAS3H,EAAOQ,GAEzBR,MAMfkH,EAAa1H,UAAUmI,SAAW,SAAU3H,EAAOQ,GAC/C,KAAKR,EAAMO,WAAcP,EAAMO,UAAUoF,QAAWnF,GAAS,YAAaA,EAAKoH,kBAAmB5G,QAC9F,OAAOhB,EAEX,IAAI6H,EAAe3I,KAAK4I,eAAetH,EAAKoH,kBAAmB1I,KAAKkI,MAEpE,OADApH,EAAMO,UAAUoF,OAAS,YAASkC,EAAc7H,EAAMO,UAAUoF,QACzD3F,GAKXkH,EAAa1H,UAAUsI,eAAiB,SAAU3H,EAAOkH,EAAKpF,GAE1D,QADc,IAAVA,IAAoBA,EAAQ,KAC3B,YAAa9B,EAAMkH,GAAMrG,QAAUiB,EAAMmB,OAAS,GAAKlE,KAAKoI,OAC7D,OAAOrF,EAEX,IAAIF,EAAa,YAAkB5B,EAAMkH,IACrC9G,EAAY,YAAwBwB,GACxC,OAAO7C,KAAK4I,eAAe3H,EAAMkH,GAAMA,EAAK,YAAS,CAAC9G,GAAY0B,KAKtEiF,EAAaC,GAAK,eACXD,EApDsB,I,8JCL7B,EAA+B,WAC/B,SAASa,EAAcT,GACnBpI,KAAKoI,OAASA,EAEdpI,KAAK8I,QAAU,GAwEnB,OAnEAD,EAAcvI,UAAUyI,QAAU,WAC9B,YAAuBtH,IAAhBzB,KAAKoI,QAAwBpI,KAAKkE,SAAWlE,KAAKoI,QAQ7DS,EAAcvI,UAAU0I,IAAM,SAAUC,GACpC,IAAI9C,EAAQnG,KACZ,OAAKA,KAAK+I,YAG0B,IAAhC/I,KAAK8I,QAAQ7D,QAAQgE,IACrBjJ,KAAK8I,QAAQrE,KAAKwE,GAEtBA,EACKlI,MAAK,WAAc,OAAOoF,EAAM+C,OAAOD,MACvClI,KAAK,MAAM,WACZ,OAAOoF,EAAM+C,OAAOD,GAAMlI,KAAK,MAAM,kBAKlCkI,GAbI,IAAYE,OAAO,IAAI,IAAY,qDAqBlDN,EAAcvI,UAAU4I,OAAS,SAAUD,GAEvC,OADkBjJ,KAAK8I,QAAQM,OAAOpJ,KAAK8I,QAAQ7D,QAAQgE,GAAO,GAAG,IAMzEJ,EAAcvI,UAAU4D,OAAS,WAC7B,OAAOlE,KAAK8I,QAAQ5E,QAQxB2E,EAAcvI,UAAU+I,MAAQ,SAAUC,GACtC,IAAInD,EAAQnG,KACZ,OAAO,IAAI,KAAY,SAAUgC,GAC7B,IAAIuH,EAAqBC,YAAW,WAC5BF,GAAWA,EAAU,GACrBtH,GAAQ,KAEbsH,GACH,IAAYG,IAAItD,EAAM2C,SACjB/H,MAAK,WACN2I,aAAaH,GACbvH,GAAQ,MAEPjB,KAAK,MAAM,WACZiB,GAAQ,UAIb6G,EA5EuB,G,gCCE9B,EAA+B,WAC/B,SAASc,EAAc5J,GACnBC,KAAKD,QAAUA,EAEfC,KAAK8I,QAAU,IAAI,EAAc,IAEjC9I,KAAK4J,YAAc,GACnB5J,KAAK6J,KAAO,IAAI,IAAI9J,EAAQG,IAAKH,EAAQ+J,WAEzC9J,KAAKqE,IAAMrE,KAAK6J,KAAKE,qCAoGzB,OA/FAJ,EAAcrJ,UAAUO,UAAY,SAAUmJ,GAC1C,MAAM,IAAI,IAAY,wDAK1BL,EAAcrJ,UAAU2J,MAAQ,SAAUX,GACtC,OAAOtJ,KAAK8I,QAAQO,MAAMC,IAK9BK,EAAcrJ,UAAU4J,gBAAkB,SAAUC,GAChD,IAAIC,EAAcD,EAAGC,YAAaC,EAAWF,EAAGE,SAAUC,EAAUH,EAAGG,QAAStI,EAAUmI,EAAGnI,QAASmH,EAASgB,EAAGhB,OAC9GoB,EAAS,IAAO9C,aAAa4C,EAASE,QAK5BvK,KAAKwK,iBAAiBF,IAEhCG,EAAA,EAAOtK,KAAK,yCAA2CH,KAAK0K,eAAeN,IAC3EG,IAAW,IAAO7C,QAItByB,EAAOkB,GAHHrI,EAAQ,CAAEuI,OAAQA,KAQ1BZ,EAAcrJ,UAAUoK,eAAiB,SAAUC,GAC/C,OAAO3K,KAAK4J,YAAYe,IAAa3K,KAAK4J,YAAYH,KAK1DE,EAAcrJ,UAAUsK,eAAiB,SAAUD,GAC/C,OAAO3K,KAAK0K,eAAeC,GAAY,IAAIE,KAAKA,KAAKC,QAKzDnB,EAAcrJ,UAAUkK,iBAAmB,SAAUF,GACjD,IAAIS,EAAKZ,EAAIa,EAAKC,EACdH,EAAMD,KAAKC,MACXI,EAAWZ,EAAQ,wBACnBa,EAAWb,EAAQ,eACvB,GAAIY,EAAU,CACV,IAWI,IAAK,IAAIE,EAAK,YAASF,EAASG,OAAOrH,MAAM,MAAOsH,EAAKF,EAAGG,QAASD,EAAGE,KAAMF,EAAKF,EAAGG,OAAQ,CAC1F,IACIE,EADQH,EAAG/E,MACQvC,MAAM,IAAK,GAC9B0H,EAAcC,SAASF,EAAW,GAAI,IACtCG,EAAmD,KAAzCC,MAAMH,GAA6B,GAAdA,GACnC,IACI,IAAK,IAAII,GAAMd,OAAM,EAAQ,YAASS,EAAW,GAAGzH,MAAM,OAAQ+H,EAAKD,EAAGP,QAASQ,EAAGP,KAAMO,EAAKD,EAAGP,OAAQ,CACxG,IAAIZ,EAAWoB,EAAGxF,MAClBvG,KAAK4J,YAAYe,GAAY,OAAS,IAAIE,KAAKC,EAAMc,IAG7D,MAAOI,GAAShB,EAAM,CAAE/J,MAAO+K,GAC/B,QACI,IACQD,IAAOA,EAAGP,OAASP,EAAKa,EAAGG,SAAShB,EAAG7E,KAAK0F,GAEpD,QAAU,GAAId,EAAK,MAAMA,EAAI/J,SAIzC,MAAOiL,GAASnB,EAAM,CAAE9J,MAAOiL,GAC/B,QACI,IACQZ,IAAOA,EAAGE,OAASrB,EAAKiB,EAAGa,SAAS9B,EAAG/D,KAAKgF,GAEpD,QAAU,GAAIL,EAAK,MAAMA,EAAI9J,OAEjC,OAAO,EAEN,QAAIkK,IACLnL,KAAK4J,YAAYH,IAAM,IAAIoB,KAAKC,EAAM,YAAsBA,EAAKK,KAC1D,IAIRxB,EA7GuB,I,wCCLlC,4KAwDO,SAASwC,IACZ,KAAM,UAAW,eACb,OAAO,EAEX,IAII,OAHA,IAAIC,QACJ,IAAIC,QAAQ,IACZ,IAAIC,UACG,EAEX,MAAOzH,GACH,OAAO,GAOf,SAAS0H,EAAcjI,GACnB,OAAOA,GAAQ,mDAAmDX,KAAKW,EAAKkI,YAQzE,SAASC,IACZ,IAAKN,IACD,OAAO,EAEX,IAAIO,EAAS,cAGb,GAAIH,EAAcG,EAAOC,OACrB,OAAO,EAIX,IAAIC,GAAS,EACTC,EAAMH,EAAOI,SAEjB,GAAID,GAAoC,mBAAtBA,EAAIE,cAClB,IACI,IAAIC,EAAUH,EAAIE,cAAc,UAChCC,EAAQC,QAAS,EACjBJ,EAAIK,KAAKC,YAAYH,GACjBA,EAAQI,eAAiBJ,EAAQI,cAAcT,QAE/CC,EAASL,EAAcS,EAAQI,cAAcT,QAEjDE,EAAIK,KAAKG,YAAYL,GAEzB,MAAOM,GACH,IAAOnN,KAAK,kFAAmFmN,GAGvG,OAAOV,EAiBJ,SAASW,IAKZ,IAAKpB,IACD,OAAO,EAEX,IAII,OAHA,IAAIE,QAAQ,IAAK,CACbmB,eAAgB,YAEb,EAEX,MAAO3I,GACH,OAAO,GASR,SAAS4I,IAIZ,IAAIf,EAAS,cAGTzJ,EAASyJ,EAAOzJ,OAChByK,EAAsBzK,GAAUA,EAAO0K,KAAO1K,EAAO0K,IAAIC,QAEzDC,EAAgB,YAAanB,KAAYA,EAAOoB,QAAQC,aAAerB,EAAOoB,QAAQE,aAC1F,OAAQN,GAAuBG,I,wCCnK5B,IAAII,EAFX,kCAGA,SAAWA,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,KAE3B,SAAWA,GA2BPA,EAASC,WApBT,SAAoBrM,GAChB,OAAQA,GACJ,IAAK,QACD,OAAOoM,EAASE,MACpB,IAAK,OACD,OAAOF,EAAS/L,KACpB,IAAK,OACL,IAAK,UACD,OAAO+L,EAASG,QACpB,IAAK,QACD,OAAOH,EAASnM,MACpB,IAAK,QACD,OAAOmM,EAASI,MACpB,IAAK,WACD,OAAOJ,EAASK,SACpB,IAAK,MACL,QACI,OAAOL,EAASM,MAxBhC,CA4BGN,IAAaA,EAAW,M,wCChD3B,sEAGIO,EAA+B,WAC/B,SAASA,KAiBT,OAZAA,EAAclO,UAAUO,UAAY,SAAUmJ,GAC1C,OAAO,IAAYhI,QAAQ,CACvBhB,OAAQ,sEACRuJ,OAAQ,IAAOkE,WAMvBD,EAAclO,UAAU2J,MAAQ,SAAUD,GACtC,OAAO,IAAYhI,SAAQ,IAExBwM,EAlBuB,I,wCCHlC,wJAMIE,EAAuB,WACvB,SAASA,IAEL1O,KAAK2O,qBAAsB,EAE3B3O,KAAK4O,gBAAkB,GAEvB5O,KAAK6O,iBAAmB,GAExB7O,KAAK8O,aAAe,GAEpB9O,KAAK+O,MAAQ,GAEb/O,KAAKgP,MAAQ,GAEbhP,KAAKiP,OAAS,GAEdjP,KAAKkP,UAAY,GAkXrB,OA5WAR,EAAMS,MAAQ,SAAUC,GACpB,IAAIC,EAAW,IAAIX,EAcnB,OAbIU,IACAC,EAASP,aAAe,YAASM,EAAMN,cACvCO,EAASL,MAAQ,YAAS,GAAII,EAAMJ,OACpCK,EAASJ,OAAS,YAAS,GAAIG,EAAMH,QACrCI,EAASH,UAAY,YAAS,GAAIE,EAAMF,WACxCG,EAASN,MAAQK,EAAML,MACvBM,EAASzO,OAASwO,EAAMxO,OACxByO,EAASC,MAAQF,EAAME,MACvBD,EAASE,SAAWH,EAAMG,SAC1BF,EAASG,iBAAmBJ,EAAMI,iBAClCH,EAASI,aAAeL,EAAMK,aAC9BJ,EAASR,iBAAmB,YAASO,EAAMP,mBAExCQ,GAMXX,EAAMpO,UAAUoP,iBAAmB,SAAUC,GACzC3P,KAAK4O,gBAAgBnK,KAAKkL,IAK9BjB,EAAMpO,UAAUsP,kBAAoB,SAAUD,GAE1C,OADA3P,KAAK6O,iBAAiBpK,KAAKkL,GACpB3P,MAKX0O,EAAMpO,UAAUuP,QAAU,SAAUC,GAMhC,OALA9P,KAAK+O,MAAQe,GAAQ,GACjB9P,KAAKuP,UACLvP,KAAKuP,SAASQ,OAAO,CAAED,KAAMA,IAEjC9P,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAU2P,QAAU,WACtB,OAAOjQ,KAAK+O,OAKhBL,EAAMpO,UAAU4P,QAAU,SAAU3N,GAGhC,OAFAvC,KAAKgP,MAAQ,YAAS,YAAS,GAAIhP,KAAKgP,OAAQzM,GAChDvC,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAU6P,OAAS,SAAUhI,EAAK5B,GACpC,IAAI4D,EAGJ,OAFAnK,KAAKgP,MAAQ,YAAS,YAAS,GAAIhP,KAAKgP,SAAS7E,EAAK,IAAOhC,GAAO5B,EAAO4D,IAC3EnK,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAU8P,UAAY,SAAUC,GAGlC,OAFArQ,KAAKiP,OAAS,YAAS,YAAS,GAAIjP,KAAKiP,QAASoB,GAClDrQ,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUgQ,SAAW,SAAUnI,EAAKzB,GACtC,IAAIyD,EAGJ,OAFAnK,KAAKiP,OAAS,YAAS,YAAS,GAAIjP,KAAKiP,UAAU9E,EAAK,IAAOhC,GAAOzB,EAAOyD,IAC7EnK,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUiQ,eAAiB,SAAUC,GAGvC,OAFAxQ,KAAKyP,aAAee,EACpBxQ,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUmQ,SAAW,SAAU5O,GAGjC,OAFA7B,KAAKY,OAASiB,EACd7B,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUoQ,mBAAqB,SAAUpO,GAG3C,OAFAtC,KAAKwP,iBAAmBlN,EACxBtC,KAAKgQ,wBACEhQ,MAMX0O,EAAMpO,UAAUqQ,eAAiB,SAAUrO,GACvC,OAAOtC,KAAK0Q,mBAAmBpO,IAKnCoM,EAAMpO,UAAUsQ,WAAa,SAAUzI,EAAK0I,GACxC,IAAI1G,EASJ,OARgB,OAAZ0G,SAEO7Q,KAAKkP,UAAU/G,GAGtBnI,KAAKkP,UAAY,YAAS,YAAS,GAAIlP,KAAKkP,aAAa/E,EAAK,IAAOhC,GAAO0I,EAAS1G,IAEzFnK,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUwQ,QAAU,SAAUC,GAGhC,OAFA/Q,KAAKsP,MAAQyB,EACb/Q,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAU0Q,QAAU,WACtB,OAAOhR,KAAKsP,OAKhBZ,EAAMpO,UAAU2Q,eAAiB,WAC7B,IAAI9G,EAAIc,EAAIG,EAAIE,EAEZyF,EAAO/Q,KAAKgR,UAEhB,OAAoB,QAAf7G,EAAK4G,SAAyB,IAAP5G,OAAgB,EAASA,EAAG+G,aAC7B,QAAfjG,EAAK8F,SAAyB,IAAP9F,OAAgB,EAASA,EAAGiG,aAGiB,QAA3E5F,EAAqB,QAAfF,EAAK2F,SAAyB,IAAP3F,OAAgB,EAASA,EAAG+F,oBAAiC,IAAP7F,OAAgB,EAASA,EAAG8F,MAAM,IAC/GL,EAAKI,aAAaC,MAAM,QADnC,GASJ1C,EAAMpO,UAAU+Q,WAAa,SAAUlQ,GAQnC,OAPKA,EAIDnB,KAAKuP,SAAWpO,SAHTnB,KAAKuP,SAKhBvP,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUgR,WAAa,WACzB,OAAOtR,KAAKuP,UAKhBb,EAAMpO,UAAUyP,OAAS,SAAUwB,GAC/B,IAAKA,EACD,OAAOvR,KAEX,GAA8B,mBAAnBuR,EAA+B,CACtC,IAAIC,EAAeD,EAAevR,MAClC,OAAOwR,aAAwB9C,EAAQ8C,EAAexR,KAgC1D,OA9BIuR,aAA0B7C,GAC1B1O,KAAKgP,MAAQ,YAAS,YAAS,GAAIhP,KAAKgP,OAAQuC,EAAevC,OAC/DhP,KAAKiP,OAAS,YAAS,YAAS,GAAIjP,KAAKiP,QAASsC,EAAetC,QACjEjP,KAAKkP,UAAY,YAAS,YAAS,GAAIlP,KAAKkP,WAAYqC,EAAerC,WACnEqC,EAAexC,OAASvJ,OAAOiM,KAAKF,EAAexC,OAAO7K,SAC1DlE,KAAK+O,MAAQwC,EAAexC,OAE5BwC,EAAe3Q,SACfZ,KAAKY,OAAS2Q,EAAe3Q,QAE7B2Q,EAAe9B,eACfzP,KAAKyP,aAAe8B,EAAe9B,eAGlC,YAAc8B,KAEnBA,EAAiBA,EACjBvR,KAAKgP,MAAQ,YAAS,YAAS,GAAIhP,KAAKgP,OAAQuC,EAAehP,MAC/DvC,KAAKiP,OAAS,YAAS,YAAS,GAAIjP,KAAKiP,QAASsC,EAAe7K,OACjE1G,KAAKkP,UAAY,YAAS,YAAS,GAAIlP,KAAKkP,WAAYqC,EAAeG,UACnEH,EAAezB,OACf9P,KAAK+O,MAAQwC,EAAezB,MAE5ByB,EAAe1P,QACf7B,KAAKY,OAAS2Q,EAAe1P,OAE7B0P,EAAef,cACfxQ,KAAKyP,aAAe8B,EAAef,cAGpCxQ,MAKX0O,EAAMpO,UAAUqR,MAAQ,WAYpB,OAXA3R,KAAK8O,aAAe,GACpB9O,KAAKgP,MAAQ,GACbhP,KAAKiP,OAAS,GACdjP,KAAK+O,MAAQ,GACb/O,KAAKkP,UAAY,GACjBlP,KAAKY,YAASa,EACdzB,KAAKwP,sBAAmB/N,EACxBzB,KAAKyP,kBAAehO,EACpBzB,KAAKsP,WAAQ7N,EACbzB,KAAKuP,cAAW9N,EAChBzB,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAUsR,cAAgB,SAAUC,EAAYC,GAClD,IAAIC,EAAmB,YAAS,CAAEC,UAAW,eAA4BH,GAMzE,OALA7R,KAAK8O,kBACkBrN,IAAnBqQ,GAAgCA,GAAkB,EAC5C,YAAS9R,KAAK8O,aAAc,CAACiD,IAAmBzM,OAAOwM,GACvD,YAAS9R,KAAK8O,aAAc,CAACiD,IACvC/R,KAAKgQ,wBACEhQ,MAKX0O,EAAMpO,UAAU2R,iBAAmB,WAG/B,OAFAjS,KAAK8O,aAAe,GACpB9O,KAAKgQ,wBACEhQ,MAUX0O,EAAMpO,UAAU4R,aAAe,SAAUpR,EAAOQ,GAC5C,IAAI6I,EAsBJ,GArBInK,KAAKiP,QAAUzJ,OAAOiM,KAAKzR,KAAKiP,QAAQ/K,SACxCpD,EAAM4F,MAAQ,YAAS,YAAS,GAAI1G,KAAKiP,QAASnO,EAAM4F,QAExD1G,KAAKgP,OAASxJ,OAAOiM,KAAKzR,KAAKgP,OAAO9K,SACtCpD,EAAMyB,KAAO,YAAS,YAAS,GAAIvC,KAAKgP,OAAQlO,EAAMyB,OAEtDvC,KAAK+O,OAASvJ,OAAOiM,KAAKzR,KAAK+O,OAAO7K,SACtCpD,EAAMgP,KAAO,YAAS,YAAS,GAAI9P,KAAK+O,OAAQjO,EAAMgP,OAEtD9P,KAAKkP,WAAa1J,OAAOiM,KAAKzR,KAAKkP,WAAWhL,SAC9CpD,EAAM4Q,SAAW,YAAS,YAAS,GAAI1R,KAAKkP,WAAYpO,EAAM4Q,WAE9D1R,KAAKY,SACLE,EAAMe,MAAQ7B,KAAKY,QAEnBZ,KAAKwP,mBACL1O,EAAMoQ,YAAclR,KAAKwP,kBAKzBxP,KAAKsP,MAAO,CACZxO,EAAM4Q,SAAW,YAAS,CAAES,MAAOnS,KAAKsP,MAAM8C,mBAAqBtR,EAAM4Q,UACzE,IAAIW,EAAoD,QAAjClI,EAAKnK,KAAKsP,MAAM4B,mBAAgC,IAAP/G,OAAgB,EAASA,EAAG7H,KACxF+P,IACAvR,EAAMyB,KAAO,YAAS,CAAE2O,YAAamB,GAAmBvR,EAAMyB,OAMtE,OAHAvC,KAAKsS,kBAAkBxR,GACvBA,EAAMyR,YAAc,YAAUzR,EAAMyR,aAAe,GAAKvS,KAAK8O,cAC7DhO,EAAMyR,YAAczR,EAAMyR,YAAYrO,OAAS,EAAIpD,EAAMyR,iBAAc9Q,EAChEzB,KAAKwS,uBAAuB,YAASC,IAA4BzS,KAAK6O,kBAAmB/N,EAAOQ,IAK3GoN,EAAMpO,UAAUkS,uBAAyB,SAAUE,EAAY5R,EAAOQ,EAAMqR,GACxE,IAAIxM,EAAQnG,KAEZ,YADc,IAAV2S,IAAoBA,EAAQ,GACzB,IAAI,KAAY,SAAU3Q,EAASmH,GACtC,IAAIyJ,EAAYF,EAAWC,GAC3B,GAAc,OAAV7R,GAAuC,mBAAd8R,EACzB5Q,EAAQlB,OAEP,CACD,IAAI8L,EAASgG,EAAU,YAAS,GAAI9R,GAAQQ,GACxC,YAAWsL,GACXA,EACK7L,MAAK,SAAU8R,GAAS,OAAO1M,EAAMqM,uBAAuBE,EAAYG,EAAOvR,EAAMqR,EAAQ,GAAG5R,KAAKiB,MACrGjB,KAAK,KAAMoI,GAGhBhD,EAAMqM,uBAAuBE,EAAY9F,EAAQtL,EAAMqR,EAAQ,GAC1D5R,KAAKiB,GACLjB,KAAK,KAAMoI,QAQhCuF,EAAMpO,UAAU0P,sBAAwB,WACpC,IAAI7J,EAAQnG,KAIPA,KAAK2O,sBACN3O,KAAK2O,qBAAsB,EAC3B3O,KAAK4O,gBAAgBkE,SAAQ,SAAUnD,GACnCA,EAASxJ,MAEbnG,KAAK2O,qBAAsB,IAOnCD,EAAMpO,UAAUgS,kBAAoB,SAAUxR,GAE1CA,EAAM0P,YAAc1P,EAAM0P,YACpB9K,MAAMqN,QAAQjS,EAAM0P,aAChB1P,EAAM0P,YACN,CAAC1P,EAAM0P,aACX,GAEFxQ,KAAKyP,eACL3O,EAAM0P,YAAc1P,EAAM0P,YAAYwC,OAAOhT,KAAKyP,eAGlD3O,EAAM0P,cAAgB1P,EAAM0P,YAAYtM,eACjCpD,EAAM0P,aAGd9B,EAnYe,GAyY1B,SAAS+D,IAEL,IAAI/F,EAAS,cAGb,OAFAA,EAAOuG,WAAavG,EAAOuG,YAAc,GACzCvG,EAAOuG,WAAWC,sBAAwBxG,EAAOuG,WAAWC,uBAAyB,GAC9ExG,EAAOuG,WAAWC,sBAOtB,SAASC,EAAwBxD,GACpC8C,IAA2BhO,KAAKkL,K,wCC5ZpC,sDAOO,SAASyD,EAAiBC,GAK7B,IAWI,IAVA,IAAIC,EAAcD,EAGdE,EAAM,GACNC,EAAS,EACTC,EAAM,EAENC,EADY,MACUxP,OACtByP,OAAU,EAEPL,GAAeE,IATI,KAeN,UALhBG,EAAUC,EAAqBN,KAKJE,EAAS,GAAKC,EAAMF,EAAIrP,OAASwP,EAAYC,EAAQzP,QAd/D,KAiBjBqP,EAAI9O,KAAKkP,GACTF,GAAOE,EAAQzP,OACfoP,EAAcA,EAAYO,WAE9B,OAAON,EAAIhM,UAAUuM,KAjBL,OAmBpB,MAAOC,GACH,MAAO,aAQf,SAASH,EAAqBI,GAC1B,IAEIC,EACAC,EACA/L,EACAgM,EACApP,EANAsO,EAAOW,EACPT,EAAM,GAMV,IAAKF,IAASA,EAAKe,QACf,MAAO,GAQX,GANAb,EAAI9O,KAAK4O,EAAKe,QAAQC,eAClBhB,EAAKpL,IACLsL,EAAI9O,KAAK,IAAM4O,EAAKpL,KAGxBgM,EAAYZ,EAAKY,YACA,YAASA,GAEtB,IADAC,EAAUD,EAAUjQ,MAAM,OACrBe,EAAI,EAAGA,EAAImP,EAAQhQ,OAAQa,IAC5BwO,EAAI9O,KAAK,IAAMyP,EAAQnP,IAG/B,IAAIuP,EAAe,CAAC,OAAQ,OAAQ,QAAS,OAC7C,IAAKvP,EAAI,EAAGA,EAAIuP,EAAapQ,OAAQa,IACjCoD,EAAMmM,EAAavP,IACnBoP,EAAOd,EAAKkB,aAAapM,KAErBoL,EAAI9O,KAAK,IAAM0D,EAAM,KAAQgM,EAAO,MAG5C,OAAOZ,EAAIO,KAAK,M,wCC9EpB,sJAUIU,EAA6B,WAI7B,SAASA,EAAYzU,GAIjBC,KAAKsC,KAAOkS,EAAYvM,GACxBjI,KAAKC,SAAW,YAAS,CAAEwU,SAAS,EAAMC,KAAK,EAAM/H,OAAO,EAAMmB,SAAS,EAAM6G,QAAQ,EAAMC,KAAK,GAAQ7U,GAgPhH,OA3OAyU,EAAYlU,UAAUuU,oBAAsB,SAAU/T,GAC7Cd,KAAKC,SAAS0U,QAGnB,cAAgB/C,cAAc,CAC1BjH,SAAU,WAA4B,gBAAf7J,EAAMc,KAAyB,cAAgB,SACtEG,SAAUjB,EAAMiB,SAChBF,MAAOf,EAAMe,MACbI,QAAS,YAAoBnB,IAC9B,CACCA,MAAOA,KAWf0T,EAAYlU,UAAUgI,UAAY,WAC9B,IAAInC,EAAQnG,KACRA,KAAKC,SAASwU,SACd,YAA0B,CACtB9E,SAAU,WAEN,IADA,IAAIpL,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB3O,EAAM6O,mBAAmBC,MAAM9O,EAAO,YAAS5B,KAEnD3C,KAAM,YAGV5B,KAAKC,SAASyU,KACd,YAA0B,CACtB/E,SAAU,WAEN,IADA,IAAIpL,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB3O,EAAM+O,eAAeD,MAAM9O,EAAO,YAAS5B,KAE/C3C,KAAM,QAGV5B,KAAKC,SAAS2U,KACd,YAA0B,CACtBjF,SAAU,WAEN,IADA,IAAIpL,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB3O,EAAMgP,eAAeF,MAAM9O,EAAO,YAAS5B,KAE/C3C,KAAM,QAGV5B,KAAKC,SAAS0M,OACd,YAA0B,CACtBgD,SAAU,WAEN,IADA,IAAIpL,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB3O,EAAMiP,iBAAiBH,MAAM9O,EAAO,YAAS5B,KAEjD3C,KAAM,UAGV5B,KAAKC,SAAS6N,SACd,YAA0B,CACtB6B,SAAU,WAEN,IADA,IAAIpL,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB3O,EAAMkP,mBAAmBJ,MAAM9O,EAAO,YAAS5B,KAEnD3C,KAAM,aAQlB4S,EAAYlU,UAAU0U,mBAAqB,SAAUM,GACjD,IAAIzD,EAAa,CACblH,SAAU,UACV4K,KAAM,CACFR,UAAWO,EAAY/Q,KACvBkG,OAAQ,WAEZ5I,MAAO,IAASqM,WAAWoH,EAAYzT,OACvCI,QAAS,YAASqT,EAAY/Q,KAAM,MAExC,GAA0B,WAAtB+Q,EAAYzT,MAAoB,CAChC,IAA4B,IAAxByT,EAAY/Q,KAAK,GAMjB,OALAsN,EAAW5P,QAAU,sBAAwB,YAASqT,EAAY/Q,KAAKe,MAAM,GAAI,MAAQ,kBACzFuM,EAAW0D,KAAKR,UAAYO,EAAY/Q,KAAKe,MAAM,GAO3D,cAAgBsM,cAAcC,EAAY,CACtCjP,MAAO0S,EAAY/Q,KACnB1C,MAAOyT,EAAYzT,SAO3B2S,EAAYlU,UAAU4U,eAAiB,SAAUI,GAC7C,IAAIE,EAEJ,IACIA,EAASF,EAAYxU,MAAM0U,OACrB,YAAiBF,EAAYxU,MAAM0U,QACnC,YAAiBF,EAAYxU,OAEvC,MAAO+D,GACH2Q,EAAS,YAES,IAAlBA,EAAOtR,QAGX,cAAgB0N,cAAc,CAC1BjH,SAAU,MAAQ2K,EAAYhT,KAC9BL,QAASuT,GACV,CACC1U,MAAOwU,EAAYxU,MACnBwB,KAAMgT,EAAYhT,QAO1BkS,EAAYlU,UAAU6U,eAAiB,SAAUG,GAC7C,GAAIA,EAAYG,aAAhB,CAEI,GAAIH,EAAYV,IAAIc,uBAChB,OAEJ,IAAIvL,EAAKmL,EAAYV,IAAIe,gBAAkB,GAAIC,EAASzL,EAAGyL,OAAQvR,EAAM8F,EAAG9F,IAAKwR,EAAc1L,EAAG0L,YAAaC,EAAO3L,EAAG2L,KACzH,cAAgBlE,cAAc,CAC1BjH,SAAU,MACV4K,KAAM,CACFK,OAAQA,EACRvR,IAAKA,EACLwR,YAAaA,GAEjBjU,KAAM,QACP,CACCgT,IAAKU,EAAYV,IACjBhS,MAAOkT,WASnBtB,EAAYlU,UAAU8U,iBAAmB,SAAUE,GAE1CA,EAAYG,eAGbH,EAAYS,UAAU1R,IAAI2R,MAAM,eAAkD,SAAjCV,EAAYS,UAAUH,SAIvEN,EAAYrU,MACZ,cAAgB2Q,cAAc,CAC1BjH,SAAU,QACV4K,KAAMD,EAAYS,UAClBlU,MAAO,IAASC,MAChBF,KAAM,QACP,CACC2T,KAAMD,EAAYrU,MAClB2B,MAAO0S,EAAY/Q,OAIvB,cAAgBqN,cAAc,CAC1BjH,SAAU,QACV4K,KAAM,YAAS,YAAS,GAAID,EAAYS,WAAY,CAAEF,YAAaP,EAAYjL,SAASE,SACxF3I,KAAM,QACP,CACCgB,MAAO0S,EAAY/Q,KACnB8F,SAAUiL,EAAYjL,cAQlCmK,EAAYlU,UAAU+U,mBAAqB,SAAUC,GACjD,IAAI5I,EAAS,cACTuJ,EAAOX,EAAYW,KACnBC,EAAKZ,EAAYY,GACjBC,EAAY,YAASzJ,EAAO0J,SAASC,MACrCC,EAAa,YAASL,GACtBM,EAAW,YAASL,GAEnBI,EAAWE,OACZF,EAAaH,GAIbA,EAAUM,WAAaF,EAASE,UAAYN,EAAUO,OAASH,EAASG,OACxER,EAAKK,EAASI,UAEdR,EAAUM,WAAaH,EAAWG,UAAYN,EAAUO,OAASJ,EAAWI,OAC5ET,EAAOK,EAAWK,UAEtB,cAAgB/E,cAAc,CAC1BjH,SAAU,aACV4K,KAAM,CACFU,KAAMA,EACNC,GAAIA,MAOhB1B,EAAYvM,GAAK,cACVuM,EAzPqB,I,8OCA5B,EAAgC,SAAUzO,GAE1C,SAAS6Q,IACL,OAAkB,OAAX7Q,GAAmBA,EAAOkP,MAAMjV,KAAM+U,YAAc/U,KAgC/D,OAlCA,YAAU4W,EAAgB7Q,GAO1B6Q,EAAetW,UAAUC,mBAAqB,SAAUc,EAAWC,GAC/D,OAAO,YAAmBtB,KAAKC,SAAUoB,EAAWC,IAKxDsV,EAAetW,UAAUI,iBAAmB,SAAUuB,EAASJ,EAAOP,GAElE,YADc,IAAVO,IAAoBA,EAAQ,IAASK,MAClC,YAAiBlC,KAAKC,SAAUgC,EAASJ,EAAOP,IAK3DsV,EAAetW,UAAUD,gBAAkB,WACvC,IAAKL,KAAKC,SAASC,IAEf,OAAO6F,EAAOzF,UAAUD,gBAAgB+F,KAAKpG,MAEjD,IAAI6W,EAAmB,YAAS,YAAS,GAAI7W,KAAKC,SAAS4W,kBAAmB,CAAE3W,IAAKF,KAAKC,SAASC,IAAK4J,UAAW9J,KAAKC,SAAS6J,YACjI,OAAI9J,KAAKC,SAAS6W,UACP,IAAI9W,KAAKC,SAAS6W,UAAUD,GAEnC,OAAAE,EAAA,KACO,IAAI,IAAeF,GAEvB,IAAI,IAAaA,IAErBD,EAnCwB,CAoCjC,K,gCClCE,EAA+B,SAAU7Q,GAOzC,SAASiR,EAAcjX,GAEnB,YADgB,IAAZA,IAAsBA,EAAU,IAC7BgG,EAAOK,KAAKpG,KAAM,EAAgBD,IAAYC,KAqCzD,OA7CA,YAAUgX,EAAejR,GAezBiR,EAAc1W,UAAU2W,iBAAmB,SAAUlX,QACjC,IAAZA,IAAsBA,EAAU,IAErB,cAAkB+M,WAI5B9M,KAAKkX,aAIV,YAAmB,YAAS,YAAS,GAAInX,GAAU,CAAEG,IAAKH,EAAQG,KAAOF,KAAKmX,YAH1E1M,EAAA,EAAOxJ,MAAM,iEAQrB+V,EAAc1W,UAAU8W,cAAgB,SAAUtW,EAAOsO,EAAO9N,GAE5D,OADAR,EAAMuW,SAAWvW,EAAMuW,UAAY,aAC5BtR,EAAOzF,UAAU8W,cAAchR,KAAKpG,KAAMc,EAAOsO,EAAO9N,IAKnE0V,EAAc1W,UAAUgX,WAAa,SAAUxW,GAC3C,IAAIyW,EAAcvX,KAAKwI,eAAe,KAClC+O,GACAA,EAAY1C,oBAAoB/T,GAEpCiF,EAAOzF,UAAUgX,WAAWlR,KAAKpG,KAAMc,IAEpCkW,EA9CuB,CA+ChC,M,yCC3DF,kFASIQ,EAAsB,CACtBC,WAAY,WAAc,OAAO5M,KAAKC,MAAQ,MAwDlD,IAAI4M,EAAsB,cAZ1B,WACI,IAEI,OADgB,YAAeC,EAAQ,cACtBC,YAErB,MAAO5N,GACH,QAMgC6N,GAhDxC,WACI,IAAID,EAAc,cAAkBA,YACpC,GAAKA,GAAgBA,EAAY9M,IAyBjC,MAAO,CACHA,IAAK,WAAc,OAAO8M,EAAY9M,OACtCgN,WAHajN,KAAKC,MAAQ8M,EAAY9M,OAsBiBiN,GAC3DC,OAA0CvW,IAAxBiW,EAChBF,EACA,CACEC,WAAY,WAAc,OAAQC,EAAoBI,WAAaJ,EAAoB5M,OAAS,MAK7FmN,EAAyBT,EAAoBC,WAAWS,KAAKV,GAYxCQ,EAAgBP,WAAWS,KAAKF,GAWtB,WACtC,IAAIJ,EAAc,cAAkBA,YACpC,GAAKA,EAGDA,EAAYE,WACLF,EAAYE,WAQfF,EAAYO,QAAUP,EAAYO,OAAOC,iBAAoBvN,KAAKC,MAdpC,K,qEClG1C,kCAMA,IAAIuN,EAAsB,WACtB,SAASA,IACLrY,KAAKsY,YAAiC,mBAAZC,QAC1BvY,KAAKwY,OAASxY,KAAKsY,YAAc,IAAIC,QAAY,GAyCrD,OAnCAF,EAAK/X,UAAUmY,QAAU,SAAU9S,GAC/B,GAAI3F,KAAKsY,YACL,QAAItY,KAAKwY,OAAOE,IAAI/S,KAGpB3F,KAAKwY,OAAOxP,IAAIrD,IACT,GAGX,IAAK,IAAIZ,EAAI,EAAGA,EAAI/E,KAAKwY,OAAOtU,OAAQa,IAAK,CAEzC,GADY/E,KAAKwY,OAAOzT,KACVY,EACV,OAAO,EAIf,OADA3F,KAAKwY,OAAO/T,KAAKkB,IACV,GAMX0S,EAAK/X,UAAUqY,UAAY,SAAUhT,GACjC,GAAI3F,KAAKsY,YACLtY,KAAKwY,OAAOI,OAAOjT,QAGnB,IAAK,IAAIZ,EAAI,EAAGA,EAAI/E,KAAKwY,OAAOtU,OAAQa,IACpC,GAAI/E,KAAKwY,OAAOzT,KAAOY,EAAK,CACxB3F,KAAKwY,OAAOpP,OAAOrE,EAAG,GACtB,QAKTsT,EA5Cc,I,oTCDrB,EAAyB,WACzB,SAASQ,EAAQhI,GACb7Q,KAAK8Y,OAAS,EACd9Y,KAAK+Y,IAAM,cACX/Y,KAAKgS,UAAYnH,KAAKC,MACtB9K,KAAKgZ,QAAUnO,KAAKC,MACpB9K,KAAKiZ,SAAW,EAChBjZ,KAAKuK,OAAS,IAAc2O,GACxBrI,GACA7Q,KAAK+P,OAAOc,GAkFpB,OA7EAgI,EAAQvY,UAAUyP,OAAS,SAAUc,QACjB,IAAZA,IAAsBA,EAAU,IAChCA,EAAQf,OACJe,EAAQf,KAAKqJ,aACbnZ,KAAKoZ,UAAYvI,EAAQf,KAAKqJ,YAE7BtI,EAAQwI,MACTrZ,KAAKqZ,IAAMxI,EAAQf,KAAK7H,IAAM4I,EAAQf,KAAKwJ,OAASzI,EAAQf,KAAKyJ,WAGzEvZ,KAAKgS,UAAYnB,EAAQmB,WAAanH,KAAKC,MACvC+F,EAAQkI,MAER/Y,KAAK+Y,IAA6B,KAAvBlI,EAAQkI,IAAI7U,OAAgB2M,EAAQkI,IAAM,eAErDlI,EAAQwI,MACRrZ,KAAKqZ,IAAM,GAAKxI,EAAQwI,KAEG,iBAApBxI,EAAQmI,UACfhZ,KAAKgZ,QAAUnI,EAAQmI,SAEK,iBAArBnI,EAAQoI,SACfjZ,KAAKiZ,SAAWpI,EAAQoI,SAGxBjZ,KAAKiZ,SAAWjZ,KAAKgS,UAAYhS,KAAKgZ,QAEtCnI,EAAQ2I,UACRxZ,KAAKwZ,QAAU3I,EAAQ2I,SAEvB3I,EAAQ4I,cACRzZ,KAAKyZ,YAAc5I,EAAQ4I,aAE3B5I,EAAQuI,YACRpZ,KAAKoZ,UAAYvI,EAAQuI,WAEzBvI,EAAQ6I,YACR1Z,KAAK0Z,UAAY7I,EAAQ6I,WAEC,iBAAnB7I,EAAQiI,SACf9Y,KAAK8Y,OAASjI,EAAQiI,QAEtBjI,EAAQtG,SACRvK,KAAKuK,OAASsG,EAAQtG,SAI9BsO,EAAQvY,UAAU2J,MAAQ,SAAUM,GAC5BA,EACAvK,KAAK+P,OAAO,CAAExF,OAAQA,IAEjBvK,KAAKuK,SAAW,IAAc2O,GACnClZ,KAAK+P,OAAO,CAAExF,OAAQ,IAAcoP,SAGpC3Z,KAAK+P,UAIb8I,EAAQvY,UAAUsZ,OAAS,WACvB,OAAO,YAAkB,CACrBb,IAAK,GAAK/Y,KAAK+Y,IACfc,MAAM,EACNb,QAAS,IAAInO,KAAK7K,KAAKgZ,SAASc,cAChC9H,UAAW,IAAInH,KAAK7K,KAAKgS,WAAW8H,cACpCvP,OAAQvK,KAAKuK,OACbuO,OAAQ9Y,KAAK8Y,OACbO,IAAyB,iBAAbrZ,KAAKqZ,KAAwC,iBAAbrZ,KAAKqZ,IAAmB,GAAKrZ,KAAKqZ,SAAM5X,EACpFwX,SAAUjZ,KAAKiZ,SACfc,MAAO,YAAkB,CACrBP,QAASxZ,KAAKwZ,QACdC,YAAazZ,KAAKyZ,YAClBN,WAAYnZ,KAAKoZ,UACjBY,WAAYha,KAAK0Z,eAItBb,EA3FiB,GCqBxB,EAAqB,WASrB,SAASoB,EAAIC,EAAQ9K,EAAO+K,QACV,IAAV/K,IAAoBA,EAAQ,IAAI,UACnB,IAAb+K,IAAuBA,EAzBV,GA0BjBna,KAAKma,SAAWA,EAEhBna,KAAKoa,OAAS,CAAC,IACfpa,KAAKqa,cAAcjL,MAAQA,EAC3BpP,KAAKsa,WAAWJ,GAqUpB,OAhUAD,EAAI3Z,UAAUia,YAAc,SAAUC,GAClC,OAAOxa,KAAKma,SAAWK,GAK3BP,EAAI3Z,UAAUga,WAAa,SAAUJ,GACvBla,KAAKqa,cACXH,OAASA,EACTA,GAAUA,EAAOO,mBACjBP,EAAOO,qBAMfR,EAAI3Z,UAAUoa,UAAY,WAEtB,IAAItL,EAAQ,IAAMD,MAAMnP,KAAK2a,YAK7B,OAJA3a,KAAK4a,WAAWnW,KAAK,CACjByV,OAAQla,KAAK6a,YACbzL,MAAOA,IAEJA,GAKX6K,EAAI3Z,UAAUwa,SAAW,WACrB,QAAI9a,KAAK4a,WAAW1W,QAAU,MAErBlE,KAAK4a,WAAWG,OAK7Bd,EAAI3Z,UAAU0a,UAAY,SAAUrL,GAChC,IAAIP,EAAQpP,KAAK0a,YACjB,IACI/K,EAASP,GAEb,QACIpP,KAAK8a,aAMbb,EAAI3Z,UAAUua,UAAY,WACtB,OAAO7a,KAAKqa,cAAcH,QAG9BD,EAAI3Z,UAAUqa,SAAW,WACrB,OAAO3a,KAAKqa,cAAcjL,OAG9B6K,EAAI3Z,UAAUsa,SAAW,WACrB,OAAO5a,KAAKoa,QAGhBH,EAAI3Z,UAAU+Z,YAAc,WACxB,OAAOra,KAAKoa,OAAOpa,KAAKoa,OAAOlW,OAAS,IAM5C+V,EAAI3Z,UAAU2a,iBAAmB,SAAU5Z,EAAWC,GAClD,IAAI4Z,EAAWlb,KAAKmb,aAAe,cAC/BC,EAAY9Z,EAKhB,IAAKA,EAAM,CACP,IAAIE,OAAqB,EACzB,IACI,MAAM,IAAIM,MAAM,6BAEpB,MAAOT,GACHG,EAAqBH,EAEzB+Z,EAAY,CACR1S,kBAAmBrH,EACnBG,mBAAoBA,GAI5B,OADAxB,KAAKqb,cAAc,mBAAoBha,EAAW,YAAS,YAAS,GAAI+Z,GAAY,CAAErZ,SAAUmZ,KACzFA,GAKXjB,EAAI3Z,UAAUgb,eAAiB,SAAUrZ,EAASJ,EAAOP,GACrD,IAAI4Z,EAAWlb,KAAKmb,aAAe,cAC/BC,EAAY9Z,EAKhB,IAAKA,EAAM,CACP,IAAIE,OAAqB,EACzB,IACI,MAAM,IAAIM,MAAMG,GAEpB,MAAOZ,GACHG,EAAqBH,EAEzB+Z,EAAY,CACR1S,kBAAmBzG,EACnBT,mBAAoBA,GAI5B,OADAxB,KAAKqb,cAAc,iBAAkBpZ,EAASJ,EAAO,YAAS,YAAS,GAAIuZ,GAAY,CAAErZ,SAAUmZ,KAC5FA,GAKXjB,EAAI3Z,UAAUib,aAAe,SAAUza,EAAOQ,GAC1C,IAAI4Z,EAAWlb,KAAKmb,aAAe,cAEnC,OADAnb,KAAKqb,cAAc,eAAgBva,EAAO,YAAS,YAAS,GAAIQ,GAAO,CAAES,SAAUmZ,KAC5EA,GAKXjB,EAAI3Z,UAAUkb,YAAc,WACxB,OAAOxb,KAAKmb,cAKhBlB,EAAI3Z,UAAUsR,cAAgB,SAAUC,EAAYvQ,GAChD,IAAI6I,EAAKnK,KAAKqa,cAAejL,EAAQjF,EAAGiF,MAAO8K,EAAS/P,EAAG+P,OAC3D,GAAK9K,GAAU8K,EAAf,CAGA,IAAIjP,EAAMiP,EAAOuB,YAAcvB,EAAOuB,cAAiB,GAAIrQ,EAAKH,EAAGyQ,iBAAkBA,OAA0B,IAAPtQ,EAAgB,KAAOA,EAAIE,EAAKL,EAAG6G,eAAgBA,OAAwB,IAAPxG,EAxK1J,IAwKgMA,EAClN,KAAIwG,GAAkB,GAAtB,CAEA,IAAIE,EAAY,cACZD,EAAmB,YAAS,CAAEC,UAAWA,GAAaH,GACtD8J,EAAkBD,EAChB,aAAe,WAAc,OAAOA,EAAiB3J,EAAkBzQ,MACvEyQ,EACkB,OAApB4J,GAEJvM,EAAMwC,cAAc+J,EAAiBC,KAAKC,IAAI/J,EA7KhC,SAkLlBmI,EAAI3Z,UAAUuP,QAAU,SAAUC,GAC9B,IAAIV,EAAQpP,KAAK2a,WACbvL,GACAA,EAAMS,QAAQC,IAKtBmK,EAAI3Z,UAAU4P,QAAU,SAAU3N,GAC9B,IAAI6M,EAAQpP,KAAK2a,WACbvL,GACAA,EAAMc,QAAQ3N,IAKtB0X,EAAI3Z,UAAU8P,UAAY,SAAUC,GAChC,IAAIjB,EAAQpP,KAAK2a,WACbvL,GACAA,EAAMgB,UAAUC,IAKxB4J,EAAI3Z,UAAU6P,OAAS,SAAUhI,EAAK5B,GAClC,IAAI6I,EAAQpP,KAAK2a,WACbvL,GACAA,EAAMe,OAAOhI,EAAK5B,IAK1B0T,EAAI3Z,UAAUgQ,SAAW,SAAUnI,EAAKzB,GACpC,IAAI0I,EAAQpP,KAAK2a,WACbvL,GACAA,EAAMkB,SAASnI,EAAKzB,IAM5BuT,EAAI3Z,UAAUsQ,WAAa,SAAUtO,EAAMuO,GACvC,IAAIzB,EAAQpP,KAAK2a,WACbvL,GACAA,EAAMwB,WAAWtO,EAAMuO,IAK/BoJ,EAAI3Z,UAAUwb,eAAiB,SAAUnM,GACrC,IAAIxF,EAAKnK,KAAKqa,cAAejL,EAAQjF,EAAGiF,MAAO8K,EAAS/P,EAAG+P,OACvD9K,GAAS8K,GACTvK,EAASP,IAMjB6K,EAAI3Z,UAAUyb,IAAM,SAAUpM,GAC1B,IAAIqM,EAASC,EAASjc,MACtB,IACI2P,EAAS3P,MAEb,QACIic,EAASD,KAMjB/B,EAAI3Z,UAAUkI,eAAiB,SAAU+O,GACrC,IAAI2C,EAASla,KAAK6a,YAClB,IAAKX,EACD,OAAO,KACX,IACI,OAAOA,EAAO1R,eAAe+O,GAEjC,MAAOxD,GAEH,OADAtJ,EAAA,EAAOtK,KAAK,+BAAiCoX,EAAYtP,GAAK,yBACvD,OAMfgS,EAAI3Z,UAAU4b,UAAY,SAAUrL,GAChC,OAAO7Q,KAAKmc,qBAAqB,YAAatL,IAKlDoJ,EAAI3Z,UAAU8b,iBAAmB,SAAUvL,EAASwL,GAChD,OAAOrc,KAAKmc,qBAAqB,mBAAoBtL,EAASwL,IAKlEpC,EAAI3Z,UAAUgc,aAAe,WACzB,OAAOtc,KAAKmc,qBAAqB,iBAKrClC,EAAI3Z,UAAUic,aAAe,SAAU1L,GAEnC7Q,KAAKwc,aACL,IAAIrS,EAAKnK,KAAKqa,cAAejL,EAAQjF,EAAGiF,MAAO8K,EAAS/P,EAAG+P,OACvDjP,EAAMiP,GAAUA,EAAOuB,cAAiB,GAAIjC,EAAUvO,EAAGuO,QAASC,EAAcxO,EAAGwO,YACnFtY,EAAU,IAAI,EAAQ,YAAS,YAAS,CAAEqY,QAASA,EACnDC,YAAaA,GAAgBrK,GAAS,CAAEU,KAAMV,EAAMa,YAAeY,IAIvE,OAHIzB,GACAA,EAAMiC,WAAWlQ,GAEdA,GAKX8Y,EAAI3Z,UAAUkc,WAAa,WACvB,IAAIrS,EAAKnK,KAAKqa,cAAejL,EAAQjF,EAAGiF,MAAO8K,EAAS/P,EAAG+P,OAC3D,GAAK9K,EAAL,CAEA,IAAIjO,EAAUiO,EAAMkC,YAAclC,EAAMkC,aACpCnQ,IACAA,EAAQ8I,QACJiQ,GAAUA,EAAOuC,gBACjBvC,EAAOuC,eAAetb,GAE1BiO,EAAMiC,gBAUd4I,EAAI3Z,UAAU+a,cAAgB,SAAUzF,GAGpC,IAFA,IAAIzL,EACA5F,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,EAAK,GAAKC,UAAUD,GAE7B,IAAI7J,EAAKjL,KAAKqa,cAAejL,EAAQnE,EAAGmE,MAAO8K,EAASjP,EAAGiP,OACvDA,GAAUA,EAAOtE,KAEhBzL,EAAK+P,GAAQtE,GAAQX,MAAM9K,EAAI,YAAS5F,EAAM,CAAC6K,MAQxD6K,EAAI3Z,UAAU6b,qBAAuB,SAAUvG,GAE3C,IADA,IAAIrR,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,EAAK,GAAKC,UAAUD,GAE7B,IAAI4H,EAAUC,IACVhI,EAAS+H,EAAQzJ,WACrB,GAAI0B,GAAUA,EAAOiI,YAAmD,mBAA9BjI,EAAOiI,WAAWhH,GACxD,OAAOjB,EAAOiI,WAAWhH,GAAQX,MAAMjV,KAAMuE,GAEjDkG,EAAA,EAAOtK,KAAK,oBAAsByV,EAAS,uCAExCqE,EArVa,GAyVjB,SAAS0C,IACZ,IAAID,EAAU,cAKd,OAJAA,EAAQzJ,WAAayJ,EAAQzJ,YAAc,CACvC2J,WAAY,GACZC,SAAKpb,GAEFib,EAOJ,SAAST,EAASY,GACrB,IAAIC,EAAWH,IACXX,EAASe,EAAkBD,GAE/B,OADAE,EAAgBF,EAAUD,GACnBb,EASJ,SAASiB,IAEZ,IAAIH,EAAWH,IAMf,OAJKO,EAAgBJ,KAAaC,EAAkBD,GAAUvC,YArYzC,IAsYjByC,EAAgBF,EAAU,IAAI,GAG9B,cAmBR,SAAgCA,GAC5B,IACI,IAAIK,GATJxI,EAASgI,IAAiB1J,aACb0B,EAAOiI,YAAcjI,EAAOiI,WAAWQ,QAAUzI,EAAOiI,WAAWQ,OAAOC,OAUvF,IAAKF,EACD,OAAOJ,EAAkBD,GAG7B,IAAKI,EAAgBC,IAAiBJ,EAAkBI,GAAc5C,YAparD,GAoa+E,CAC5F,IAAI+C,EAAsBP,EAAkBD,GAAUzC,cACtD2C,EAAgBG,EAAc,IAAI,EAAIG,EAAoBpD,OAAQ,IAAM/K,MAAMmO,EAAoBlO,SAGtG,OAAO2N,EAAkBI,GAE7B,MAAOI,GAEH,OAAOR,EAAkBD,GAzB1B,IACCnI,EAXO6I,CAAuBV,GAG3BC,EAAkBD,GAuC7B,SAASI,EAAgBR,GACrB,SAAUA,GAAWA,EAAQzJ,YAAcyJ,EAAQzJ,WAAW4J,KAQ3D,SAASE,EAAkBL,GAC9B,OAAIA,GAAWA,EAAQzJ,YAAcyJ,EAAQzJ,WAAW4J,MAExDH,EAAQzJ,WAAayJ,EAAQzJ,YAAc,GAC3CyJ,EAAQzJ,WAAW4J,IAAM,IAAI,GAFlBH,EAAQzJ,WAAW4J,IAU3B,SAASG,EAAgBN,EAASG,GACrC,QAAKH,IAELA,EAAQzJ,WAAayJ,EAAQzJ,YAAc,GAC3CyJ,EAAQzJ,WAAW4J,IAAMA,GAClB,K,wCC1dX,sGAGInQ,EAAS,cAET+Q,EAA2B,WAC3B,SAASA,IAILzd,KAAKsC,KAAOmb,EAAUxV,GA4B1B,OAvBAwV,EAAUnd,UAAUgI,UAAY,WAC5B,aAAwB,SAAUxH,GAC9B,IAAIqJ,EAAIc,EAAIG,EACZ,GAAI,cAAgB5C,eAAeiV,GAAY,CAE3C,IAAK/Q,EAAOgR,YAAchR,EAAO0J,WAAa1J,EAAOI,SACjD,OAAOhM,EAGX,IAAIuD,GAAgC,QAAxB8F,EAAKrJ,EAAM6c,eAA4B,IAAPxT,OAAgB,EAASA,EAAG9F,OAAoC,QAA1B4G,EAAKyB,EAAO0J,gBAA6B,IAAPnL,OAAgB,EAASA,EAAGoL,MAC5IuH,GAAYlR,EAAOI,UAAY,IAAI8Q,SACnClE,GAAahN,EAAOgR,WAAa,IAAIhE,UACrCpP,EAAU,YAAS,YAAS,YAAS,GAA6B,QAAxBc,EAAKtK,EAAM6c,eAA4B,IAAPvS,OAAgB,EAASA,EAAGd,SAAWsT,GAAY,CAAEC,QAASD,IAAelE,GAAa,CAAE,aAAcA,IACpLiE,EAAU,YAAS,YAAS,GAAKtZ,GAAO,CAAEA,IAAKA,IAAS,CAAEiG,QAASA,IACvE,OAAO,YAAS,YAAS,GAAIxJ,GAAQ,CAAE6c,QAASA,IAEpD,OAAO7c,MAMf2c,EAAUxV,GAAK,YACRwV,EAjCmB,I,wCCL9B,sCAMIK,EANJ,iBAOA,SAAWA,GAEPA,EAAgB,QAAI,UAEpBA,EAAiB,SAAI,WAErBA,EAAiB,SAAI,WANzB,CAOGA,IAAWA,EAAS,KAKvB,IAAIC,EAA6B,WAC7B,SAASA,EAAYC,GACjB,IAAI7X,EAAQnG,KACZA,KAAKie,OAASH,EAAOI,QACrBle,KAAKme,UAAY,GAEjBne,KAAKoe,SAAW,SAAU7X,GACtBJ,EAAMkY,WAAWP,EAAOQ,SAAU/X,IAGtCvG,KAAKue,QAAU,SAAUvd,GACrBmF,EAAMkY,WAAWP,EAAOU,SAAUxd,IAGtChB,KAAKqe,WAAa,SAAUI,EAAOlY,GAC3BJ,EAAM8X,SAAWH,EAAOI,UAGxB,YAAW3X,GACXA,EAAMxF,KAAKoF,EAAMiY,SAAUjY,EAAMoY,UAGrCpY,EAAM8X,OAASQ,EACftY,EAAMuY,OAASnY,EACfJ,EAAMwY,sBAIV3e,KAAK4e,eAAiB,SAAUC,GAC5B1Y,EAAMgY,UAAYhY,EAAMgY,UAAUnL,OAAO6L,GACzC1Y,EAAMwY,oBAGV3e,KAAK2e,iBAAmB,WACpB,GAAIxY,EAAM8X,SAAWH,EAAOI,QAA5B,CAGA,IAAIY,EAAiB3Y,EAAMgY,UAAU7Y,QACrCa,EAAMgY,UAAY,GAClBW,EAAehM,SAAQ,SAAU+L,GACzBA,EAAQrT,OAGRrF,EAAM8X,SAAWH,EAAOQ,UACpBO,EAAQE,aAERF,EAAQE,YAAY5Y,EAAMuY,QAG9BvY,EAAM8X,SAAWH,EAAOU,UACpBK,EAAQG,YACRH,EAAQG,WAAW7Y,EAAMuY,QAGjCG,EAAQrT,MAAO,QAGvB,IACIwS,EAAShe,KAAKoe,SAAUpe,KAAKue,SAEjC,MAAO1Z,GACH7E,KAAKue,QAAQ1Z,IAoHrB,OAhHAkZ,EAAY/b,QAAU,SAAUuE,GAC5B,OAAO,IAAIwX,GAAY,SAAU/b,GAC7BA,EAAQuE,OAIhBwX,EAAY5U,OAAS,SAAUnI,GAC3B,OAAO,IAAI+c,GAAY,SAAU/T,EAAGb,GAChCA,EAAOnI,OAIf+c,EAAYtU,IAAM,SAAUwV,GACxB,OAAO,IAAIlB,GAAY,SAAU/b,EAASmH,GACtC,GAAKzD,MAAMqN,QAAQkM,GAInB,GAA0B,IAAtBA,EAAW/a,OAAf,CAIA,IAAIgb,EAAUD,EAAW/a,OACrBib,EAAqB,GACzBF,EAAWnM,SAAQ,SAAUsM,EAAMzM,GAC/BoL,EAAY/b,QAAQod,GACfre,MAAK,SAAUwF,GAChB4Y,EAAmBxM,GAASpM,EAEZ,KADhB2Y,GAAW,IAIXld,EAAQmd,MAEPpe,KAAK,KAAMoI,WAfhBnH,EAAQ,SAJRmH,EAAO,IAAIkW,UAAU,gDAwBjCtB,EAAYzd,UAAUS,KAAO,SAAUge,EAAaC,GAChD,IAAI7Y,EAAQnG,KACZ,OAAO,IAAI+d,GAAY,SAAU/b,EAASmH,GACtChD,EAAMyY,eAAe,CACjBpT,MAAM,EACNuT,YAAa,SAAUnS,GACnB,GAAKmS,EAML,IAEI,YADA/c,EAAQ+c,EAAYnS,IAGxB,MAAO/H,GAEH,YADAsE,EAAOtE,QARP7C,EAAQ4K,IAYhBoS,WAAY,SAAUhe,GAClB,GAAKge,EAIL,IAEI,YADAhd,EAAQgd,EAAWhe,IAGvB,MAAO6D,GAEH,YADAsE,EAAOtE,QARPsE,EAAOnI,UAgB3B+c,EAAYzd,UAAUgf,MAAQ,SAAUN,GACpC,OAAOhf,KAAKe,MAAK,SAAUwe,GAAO,OAAOA,IAAQP,IAGrDjB,EAAYzd,UAAUkf,QAAU,SAAUC,GACtC,IAAItZ,EAAQnG,KACZ,OAAO,IAAI+d,GAAY,SAAU/b,EAASmH,GACtC,IAAIoW,EACAG,EACJ,OAAOvZ,EAAMpF,MAAK,SAAUwF,GACxBmZ,GAAa,EACbH,EAAMhZ,EACFkZ,GACAA,OAEL,SAAUze,GACT0e,GAAa,EACbH,EAAMve,EACFye,GACAA,OAEL1e,MAAK,WACA2e,EACAvW,EAAOoW,GAGXvd,EAAQud,UAKpBxB,EAAYzd,UAAUkM,SAAW,WAC7B,MAAO,wBAEJuR,EAjLqB,I,yCCnBhC,kVAEI4B,GAFJ,cAE2B,IAMpB,SAASC,IACZ,OAAQ,cACFlT,EACkB,oBAAXmT,OACHA,OACgB,oBAATtX,KACHA,KACAoX,EAOX,SAASG,IACZ,IAAIpT,EAASkT,IACTG,EAASrT,EAAOqT,QAAUrT,EAAOsT,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,EAAI7T,SAAS,IACd8T,EAAEpc,OAAS,GACdoc,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,IAAIC,EAAqB,GAAhB7E,KAAK8E,SAAiB,EAG/B,OADc,MAANF,EAAYC,EAAS,EAAJA,EAAW,GAC3BjU,SAAS,OAUnB,SAASmU,EAAStc,GACrB,IAAKA,EACD,MAAO,GAEX,IAAI2R,EAAQ3R,EAAI2R,MAAM,gEACtB,IAAKA,EACD,MAAO,GAGX,IAAI4K,EAAQ5K,EAAM,IAAM,GACpB6K,EAAW7K,EAAM,IAAM,GAC3B,MAAO,CACHU,KAAMV,EAAM,GACZQ,KAAMR,EAAM,GACZS,SAAUT,EAAM,GAChBW,SAAUX,EAAM,GAAK4K,EAAQC,GAO9B,SAASC,EAAoBhgB,GAChC,GAAIA,EAAMmB,QACN,OAAOnB,EAAMmB,QAEjB,GAAInB,EAAMO,WAAaP,EAAMO,UAAUoF,QAAU3F,EAAMO,UAAUoF,OAAO,GAAI,CACxE,IAAIpF,EAAYP,EAAMO,UAAUoF,OAAO,GACvC,OAAIpF,EAAUO,MAAQP,EAAUkF,MACrBlF,EAAUO,KAAO,KAAOP,EAAUkF,MAEtClF,EAAUO,MAAQP,EAAUkF,OAASzF,EAAMiB,UAAY,YAElE,OAAOjB,EAAMiB,UAAY,YAGtB,SAASgf,EAAepR,GAC3B,IAAIjD,EAASkT,IAEb,KAAM,YAAalT,GACf,OAAOiD,IAGX,IAAIqR,EAAkBtU,EAAO+H,QACzBwM,EAAgB,GANP,CAAC,QAAS,OAAQ,OAAQ,QAAS,MAAO,UAQhDnO,SAAQ,SAAUjR,GAEjBA,KAAS6K,EAAO+H,SAAWuM,EAAgBnf,GAAOqf,sBAClDD,EAAcpf,GAASmf,EAAgBnf,GACvCmf,EAAgBnf,GAASmf,EAAgBnf,GAAOqf,wBAIxD,IAAItU,EAAS+C,IAKb,OAHAnK,OAAOiM,KAAKwP,GAAenO,SAAQ,SAAUjR,GACzCmf,EAAgBnf,GAASof,EAAcpf,MAEpC+K,EASJ,SAASuU,EAAsBrgB,EAAOyF,EAAO3E,GAChDd,EAAMO,UAAYP,EAAMO,WAAa,GACrCP,EAAMO,UAAUoF,OAAS3F,EAAMO,UAAUoF,QAAU,GACnD3F,EAAMO,UAAUoF,OAAO,GAAK3F,EAAMO,UAAUoF,OAAO,IAAM,GACzD3F,EAAMO,UAAUoF,OAAO,GAAGF,MAAQzF,EAAMO,UAAUoF,OAAO,GAAGF,OAASA,GAAS,GAC9EzF,EAAMO,UAAUoF,OAAO,GAAG7E,KAAOd,EAAMO,UAAUoF,OAAO,GAAG7E,MAAQA,GAAQ,QAQxE,SAASwf,EAAsBtgB,EAAOugB,QACvB,IAAdA,IAAwBA,EAAY,IAExC,IAGIvgB,EAAMO,UAAUoF,OAAO,GAAG4a,UAAYvgB,EAAMO,UAAUoF,OAAO,GAAG4a,WAAa,GAC7E7b,OAAOiM,KAAK4P,GAAWvO,SAAQ,SAAU3K,GAGrCrH,EAAMO,UAAUoF,OAAO,GAAG4a,UAAUlZ,GAAOkZ,EAAUlZ,MAG7D,MAAO4L,KAOJ,SAASuN,IACZ,IACI,OAAOxU,SAASsJ,SAASC,KAE7B,MAAOkL,GACH,MAAO,IA4BR,SAASC,EAAsB1W,EAAK2W,GACvC,IAAKA,EACD,OARgB,IAUpB,IAAI/V,EAAcC,SAAS,GAAK8V,EAAQ,IACxC,IAAK5V,MAAMH,GACP,OAAqB,IAAdA,EAEX,IAAIgW,EAAa7W,KAAK8W,MAAM,GAAKF,GACjC,OAAK5V,MAAM6V,GAfS,IAgBTA,EAAa5W,K,kEC5M5B,sLAQI8W,EAAgC,WAEhC,SAASA,EAAe7hB,GAIpBC,KAAKsC,KAAOsf,EAAe3Z,GAE3BjI,KAAK6hB,0BAA2B,EAEhC7hB,KAAK8hB,uCAAwC,EAC7C9hB,KAAKC,SAAW,YAAS,CAAE8hB,SAAS,EAAMC,sBAAsB,GAAQjiB,GAoL5E,OA/KA6hB,EAAethB,UAAUgI,UAAY,WACjCxG,MAAMmgB,gBAAkB,GACpBjiB,KAAKC,SAAS8hB,UACd,IAAOG,IAAI,oCACXliB,KAAKmiB,gCAELniB,KAAKC,SAAS+hB,uBACd,IAAOE,IAAI,iDACXliB,KAAKoiB,8CAIbR,EAAethB,UAAU6hB,6BAA+B,WACpD,IAAIhc,EAAQnG,KACRA,KAAK6hB,2BAGT,YAA0B,CAEtBlS,SAAU,SAAU4F,GAChB,IAAItU,EAAQsU,EAAKtU,MACbohB,EAAa,cACbC,EAAiBD,EAAW7Z,eAAeoZ,GAC3CW,EAAsBthB,IAA0C,IAAjCA,EAAMyU,uBACzC,GAAK4M,IAAkB,gBAAyBC,EAAhD,CAGA,IAAIrI,EAASmI,EAAWxH,YACpB/Z,EAAQ,YAAYG,GAClBkF,EAAMqc,4BAA4BjN,EAAKkN,IAAKlN,EAAKlR,IAAKkR,EAAKtR,KAAMsR,EAAK/Q,QACtE2B,EAAMuc,8BAA8B,YAAsBzhB,OAAOQ,EAAW,CAC1EC,iBAAkBwY,GAAUA,EAAOuB,aAAa/Z,iBAChDgB,WAAW,IACX6S,EAAKlR,IAAKkR,EAAKtR,KAAMsR,EAAK/Q,QAClC,YAAsB1D,EAAO,CACzBa,SAAS,EACTC,KAAM,YAEVygB,EAAW9G,aAAaza,EAAO,CAC3B4H,kBAAmBzH,MAG3BW,KAAM,UAEV5B,KAAK6hB,0BAA2B,IAGpCD,EAAethB,UAAU8hB,0CAA4C,WACjE,IAAIjc,EAAQnG,KACRA,KAAK8hB,wCAGT,YAA0B,CAEtBnS,SAAU,SAAU9K,GAChB,IAAI5D,EAAQ4D,EAEZ,IAGQ,WAAYA,EACZ5D,EAAQ4D,EAAE7D,OAOL,WAAY6D,GAAK,WAAYA,EAAE8d,SACpC1hB,EAAQ4D,EAAE8d,OAAO3hB,QAGzB,MAAO+S,IAGP,IAAIsO,EAAa,cACbC,EAAiBD,EAAW7Z,eAAeoZ,GAC3CW,EAAsBthB,IAA0C,IAAjCA,EAAMyU,uBACzC,IAAK4M,GAAkB,eAAyBC,EAC5C,OAAO,EAEX,IAAIrI,EAASmI,EAAWxH,YACpB/Z,EAAQ,YAAYG,GAClBkF,EAAMyc,iCAAiC3hB,GACvC,YAAsBA,OAAOQ,EAAW,CACtCC,iBAAkBwY,GAAUA,EAAOuB,aAAa/Z,iBAChDgB,WAAW,IAEnB5B,EAAMe,MAAQ,IAASC,MACvB,YAAsBhB,EAAO,CACzBa,SAAS,EACTC,KAAM,yBAEVygB,EAAW9G,aAAaza,EAAO,CAC3B4H,kBAAmBzH,KAI3BW,KAAM,uBAEV5B,KAAK8hB,uCAAwC,IAMjDF,EAAethB,UAAUkiB,4BAA8B,SAAUC,EAAKpe,EAAKJ,EAAMO,GAC7E,IAGIlC,EADAL,EAAU,YAAawgB,GAAOA,EAAIxgB,QAAUwgB,EAEhD,GAAI,YAASxgB,GAAU,CACnB,IAAI4gB,EAAS5gB,EAAQ+T,MALJ,4GAMb6M,IACAvgB,EAAOugB,EAAO,GACd5gB,EAAU4gB,EAAO,IAGzB,IAAI/hB,EAAQ,CACRO,UAAW,CACPoF,OAAQ,CACJ,CACI7E,KAAMU,GAAQ,QACdiE,MAAOtE,MAKvB,OAAOjC,KAAK0iB,8BAA8B5hB,EAAOuD,EAAKJ,EAAMO,IAQhEod,EAAethB,UAAUsiB,iCAAmC,SAAU5hB,GAClE,MAAO,CACHK,UAAW,CACPoF,OAAQ,CACJ,CACI7E,KAAM,qBAEN2E,MAAO,oDAAsDuc,OAAO9hB,QAQxF4gB,EAAethB,UAAUoiB,8BAAgC,SAAU5hB,EAAOuD,EAAKJ,EAAMO,GACjF1D,EAAMO,UAAYP,EAAMO,WAAa,GACrCP,EAAMO,UAAUoF,OAAS3F,EAAMO,UAAUoF,QAAU,GACnD3F,EAAMO,UAAUoF,OAAO,GAAK3F,EAAMO,UAAUoF,OAAO,IAAM,GACzD3F,EAAMO,UAAUoF,OAAO,GAAG5D,WAAa/B,EAAMO,UAAUoF,OAAO,GAAG5D,YAAc,GAC/E/B,EAAMO,UAAUoF,OAAO,GAAG5D,WAAWG,OAASlC,EAAMO,UAAUoF,OAAO,GAAG5D,WAAWG,QAAU,GAC7F,IAAIkE,EAAQ2E,MAAMF,SAASnH,EAAQ,UAAO/C,EAAY+C,EAClD8C,EAASuE,MAAMF,SAAS1H,EAAM,UAAOxC,EAAYwC,EACjDkD,EAAW,YAAS9C,IAAQA,EAAIH,OAAS,EAAIG,EAAM,cAUvD,OAT2D,IAAvDvD,EAAMO,UAAUoF,OAAO,GAAG5D,WAAWG,OAAOkB,QAC5CpD,EAAMO,UAAUoF,OAAO,GAAG5D,WAAWG,OAAOyB,KAAK,CAC7CyC,MAAOA,EACPC,SAAUA,EACVC,SAAU,IACVC,QAAQ,EACRC,OAAQA,IAGTxG,GAKX8gB,EAAe3Z,GAAK,iBACb2Z,EA/LwB,I,8RCLxBmB,EAAwB,GAuD5B,SAAStI,EAAkB1a,GAC9B,IAAIijB,EAAe,GAKnB,OA3DG,SAAgCjjB,GACnC,IAAIkjB,EAAuBljB,EAAQkjB,qBAAuB,YAASljB,EAAQkjB,sBAAyB,GAChGC,EAAmBnjB,EAAQijB,aAC3BA,EAAe,GACnB,GAAItd,MAAMqN,QAAQmQ,GAAmB,CACjC,IAAIC,EAA0BD,EAAiBlc,KAAI,SAAUjC,GAAK,OAAOA,EAAEzC,QACvE8gB,EAA4B,GAEhCH,EAAoBnQ,SAAQ,SAAUuQ,IACgC,IAA9DF,EAAwBle,QAAQoe,EAAmB/gB,QACa,IAAhE8gB,EAA0Bne,QAAQoe,EAAmB/gB,QACrD0gB,EAAave,KAAK4e,GAClBD,EAA0B3e,KAAK4e,EAAmB/gB,UAI1D4gB,EAAiBpQ,SAAQ,SAAUwQ,IACkC,IAA7DF,EAA0Bne,QAAQqe,EAAgBhhB,QAClD0gB,EAAave,KAAK6e,GAClBF,EAA0B3e,KAAK6e,EAAgBhhB,cAItB,mBAArB4gB,GACZF,EAAeE,EAAiBD,GAChCD,EAAetd,MAAMqN,QAAQiQ,GAAgBA,EAAe,CAACA,IAG7DA,EAAe,YAASC,GAG5B,IAAIM,EAAoBP,EAAahc,KAAI,SAAUjC,GAAK,OAAOA,EAAEzC,QAKjE,OAHoD,IAAhDihB,EAAkBte,QADA,UAElB+d,EAAave,KAAKwQ,MAAM+N,EAAc,YAASA,EAAa5Z,OAAOma,EAAkBte,QAFnE,SAE6F,KAE5G+d,EAmBPQ,CAAuBzjB,GAAS+S,SAAQ,SAAUyE,GAC9CyL,EAAazL,EAAYjV,MAAQiV,EAjBlC,SAA0BA,IAC4B,IAArDwL,EAAsB9d,QAAQsS,EAAYjV,QAG9CiV,EAAYjP,UAAU,IAAyB,KAC/Cya,EAAsBte,KAAK8S,EAAYjV,MACvCmI,EAAA,EAAOyX,IAAI,0BAA4B3K,EAAYjV,OAY/CmhB,CAAiBlM,MAEdyL,EC1BX,IAAI,EAA4B,WAO5B,SAASU,EAAWC,EAAc5jB,GAE9BC,KAAK4jB,cAAgB,GAErB5jB,KAAK6jB,YAAc,EACnB7jB,KAAK8jB,SAAW,IAAIH,EAAa5jB,GACjCC,KAAKC,SAAWF,EACZA,EAAQG,MACRF,KAAK+jB,KAAO,IAAI,IAAIhkB,EAAQG,MAwZpC,OAjZAwjB,EAAWpjB,UAAU2a,iBAAmB,SAAU5Z,EAAWC,EAAM8N,GAC/D,IAAIjJ,EAAQnG,KACRkb,EAAU5Z,GAAQA,EAAKS,SAO3B,OANA/B,KAAKgkB,SAAShkB,KAAKikB,cACd1jB,mBAAmBc,EAAWC,GAC9BP,MAAK,SAAUD,GAAS,OAAOqF,EAAM+d,cAAcpjB,EAAOQ,EAAM8N,MAChErO,MAAK,SAAU6L,GAChBsO,EAAUtO,MAEPsO,GAKXwI,EAAWpjB,UAAUgb,eAAiB,SAAUrZ,EAASJ,EAAOP,EAAM8N,GAClE,IAAIjJ,EAAQnG,KACRkb,EAAU5Z,GAAQA,EAAKS,SACvBoiB,EAAgB,OAAAC,EAAA,GAAYniB,GAC1BjC,KAAKikB,cAAcvjB,iBAAiBoiB,OAAO7gB,GAAUJ,EAAOP,GAC5DtB,KAAKikB,cAAc1jB,mBAAmB0B,EAASX,GAMrD,OALAtB,KAAKgkB,SAASG,EACTpjB,MAAK,SAAUD,GAAS,OAAOqF,EAAM+d,cAAcpjB,EAAOQ,EAAM8N,MAChErO,MAAK,SAAU6L,GAChBsO,EAAUtO,MAEPsO,GAKXwI,EAAWpjB,UAAUib,aAAe,SAAUza,EAAOQ,EAAM8N,GACvD,IAAI8L,EAAU5Z,GAAQA,EAAKS,SAI3B,OAHA/B,KAAKgkB,SAAShkB,KAAKkkB,cAAcpjB,EAAOQ,EAAM8N,GAAOrO,MAAK,SAAU6L,GAChEsO,EAAUtO,MAEPsO,GAKXwI,EAAWpjB,UAAUmc,eAAiB,SAAUtb,GACvCA,EAAQqY,QAITxZ,KAAKqkB,aAAaljB,GAHlBsJ,EAAA,EAAOtK,KAAK,iDASpBujB,EAAWpjB,UAAU6W,OAAS,WAC1B,OAAOnX,KAAK+jB,MAKhBL,EAAWpjB,UAAUmb,WAAa,WAC9B,OAAOzb,KAAKC,UAKhByjB,EAAWpjB,UAAUgkB,MAAQ,SAAUhb,GACnC,IAAInD,EAAQnG,KACZ,OAAOA,KAAKukB,oBAAoBjb,GAASvI,MAAK,SAAUyjB,GACpD,OAAOre,EAAM8d,cACR7iB,eACA6I,MAAMX,GACNvI,MAAK,SAAU0jB,GAAoB,OAAOD,GAASC,SAMhEf,EAAWpjB,UAAU2J,MAAQ,SAAUX,GACnC,IAAInD,EAAQnG,KACZ,OAAOA,KAAKskB,MAAMhb,GAASvI,MAAK,SAAU6L,GAEtC,OADAzG,EAAMsV,aAAaiJ,SAAU,EACtB9X,MAMf8W,EAAWpjB,UAAUma,kBAAoB,WACjCza,KAAKkX,eACLlX,KAAK4jB,cAAgBnJ,EAAkBza,KAAKC,YAMpDyjB,EAAWpjB,UAAUkI,eAAiB,SAAU+O,GAC5C,IACI,OAAOvX,KAAK4jB,cAAcrM,EAAYtP,KAAO,KAEjD,MAAO8L,GAEH,OADAtJ,EAAA,EAAOtK,KAAK,+BAAiCoX,EAAYtP,GAAK,4BACvD,OAIfyb,EAAWpjB,UAAUqkB,wBAA0B,SAAUxjB,EAASL,GAC9D,IAAIiK,EAAKZ,EAGLuP,EAFAkL,GAAU,EACVC,GAAU,EAEVC,EAAahkB,EAAMO,WAAaP,EAAMO,UAAUoF,OACpD,GAAIqe,EAAY,CACZD,GAAU,EACV,IACI,IAAK,IAAIE,EAAe,YAASD,GAAaE,EAAiBD,EAAaxZ,QAASyZ,EAAexZ,KAAMwZ,EAAiBD,EAAaxZ,OAAQ,CAC5I,IACI8V,EADK2D,EAAeze,MACL8a,UACnB,GAAIA,IAAmC,IAAtBA,EAAU1f,QAAmB,CAC1CijB,GAAU,EACV,QAIZ,MAAO1Y,GAASnB,EAAM,CAAE9J,MAAOiL,GAC/B,QACI,IACQ8Y,IAAmBA,EAAexZ,OAASrB,EAAK4a,EAAa9Y,SAAS9B,EAAG/D,KAAK2e,GAEtF,QAAU,GAAIha,EAAK,MAAMA,EAAI9J,QAGrC,IAAI6O,EAAOhP,EAAMgP,KACjB,IAAK3O,EAAQuY,UAAW,CACpB,IAAIpP,EAAUxJ,EAAM6c,QAAU7c,EAAM6c,QAAQrT,QAAU,GACtD,IAAK,IAAInC,KAAOmC,EACZ,GAA0B,eAAtBnC,EAAIkM,cAAgC,CACpCqF,EAAYpP,EAAQnC,GACpB,OAIZhH,EAAQ4O,OAAO,YAAS,YAAS,GAAK6U,GAAW,CAAEra,OAAQ,IAAc0a,UAAa,CAAEnV,KAAMA,EAC1F4J,UAAWA,EAAWZ,OAAQ3X,EAAQ2X,OAASoM,OAAOL,GAAWD,OAGzElB,EAAWpjB,UAAU+jB,aAAe,SAAUljB,GAC1CnB,KAAKikB,cAAc/iB,YAAYC,IAGnCuiB,EAAWpjB,UAAUikB,oBAAsB,SAAUjb,GACjD,IAAInD,EAAQnG,KACZ,OAAO,IAAI,KAAY,SAAUgC,GAC7B,IAAImjB,EAAS,EAETC,EAAWC,aAAY,WACE,GAArBlf,EAAM0d,aACNyB,cAAcF,GACdpjB,GAAQ,KAGRmjB,GAPG,EAQC7b,GAAW6b,GAAU7b,IACrBgc,cAAcF,GACdpjB,GAAQ,OAVT,OAiBnB0hB,EAAWpjB,UAAU2jB,YAAc,WAC/B,OAAOjkB,KAAK8jB,UAGhBJ,EAAWpjB,UAAU4W,WAAa,WAC9B,OAAqC,IAA9BlX,KAAKyb,aAAaiJ,cAAmCjjB,IAAdzB,KAAK+jB,MAgBvDL,EAAWpjB,UAAU8W,cAAgB,SAAUtW,EAAOsO,EAAO9N,GACzD,IAAI6E,EAAQnG,KACRmK,EAAKnK,KAAKyb,aAAa8J,eAAgBA,OAAwB,IAAPpb,EAAgB,EAAIA,EAC5Eqb,EAAW,YAAS,YAAS,GAAI1kB,GAAQ,CAAEiB,SAAUjB,EAAMiB,WAAaT,GAAQA,EAAKS,SAAWT,EAAKS,SAAW,eAAUiQ,UAAWlR,EAAMkR,WAAa,gBAC5JhS,KAAKylB,oBAAoBD,GACzBxlB,KAAK0lB,2BAA2BF,GAGhC,IAAIG,EAAavW,EACb9N,GAAQA,EAAKiQ,iBACboU,EAAa,IAAMxW,MAAMwW,GAAY5V,OAAOzO,EAAKiQ,iBAGrD,IAAI3E,EAAS,IAAY5K,QAAQwjB,GAOjC,OAJIG,IAEA/Y,EAAS+Y,EAAWzT,aAAasT,EAAUlkB,IAExCsL,EAAO7L,MAAK,SAAU6kB,GACzB,MAA8B,iBAAnBL,GAA+BA,EAAiB,EAChDpf,EAAM0f,gBAAgBD,EAAKL,GAE/BK,MAaflC,EAAWpjB,UAAUulB,gBAAkB,SAAU/kB,EAAOglB,GACpD,IAAKhlB,EACD,OAAO,KAEX,IAAIilB,EAAa,YAAS,YAAS,YAAS,YAAS,YAAS,GAAIjlB,GAASA,EAAMyR,aAAe,CAC5FA,YAAazR,EAAMyR,YAAYvL,KAAI,SAAUgf,GAAK,OAAQ,WAAD,CAAU,YAAS,GAAIA,GAAKA,EAAEzQ,MAAQ,CAC3FA,KAAM,YAAUyQ,EAAEzQ,KAAMuQ,UAE1BhlB,EAAMgP,MAAQ,CAChBA,KAAM,YAAUhP,EAAMgP,KAAMgW,KAC1BhlB,EAAM4Q,UAAY,CACpBA,SAAU,YAAU5Q,EAAM4Q,SAAUoU,KAClChlB,EAAM4F,OAAS,CACjBA,MAAO,YAAU5F,EAAM4F,MAAOof,KAalC,OAJIhlB,EAAM4Q,UAAY5Q,EAAM4Q,SAASS,QAEjC4T,EAAWrU,SAASS,MAAQrR,EAAM4Q,SAASS,OAExC4T,GAQXrC,EAAWpjB,UAAUmlB,oBAAsB,SAAU3kB,GACjD,IAAIf,EAAUC,KAAKyb,aACfhC,EAAc1Z,EAAQ0Z,YAAaD,EAAUzZ,EAAQyZ,QAASyM,EAAOlmB,EAAQkmB,KAAM9b,EAAKpK,EAAQmmB,eAAgBA,OAAwB,IAAP/b,EAAgB,IAAMA,EACrJ,gBAAiBrJ,IACnBA,EAAM2Y,YAAc,gBAAiB1Z,EAAU0Z,EAAc,mBAE3ChY,IAAlBX,EAAM0Y,cAAqC/X,IAAZ+X,IAC/B1Y,EAAM0Y,QAAUA,QAED/X,IAAfX,EAAMmlB,WAA+BxkB,IAATwkB,IAC5BnlB,EAAMmlB,KAAOA,GAEbnlB,EAAMmB,UACNnB,EAAMmB,QAAU,YAASnB,EAAMmB,QAASikB,IAE5C,IAAI7kB,EAAYP,EAAMO,WAAaP,EAAMO,UAAUoF,QAAU3F,EAAMO,UAAUoF,OAAO,GAChFpF,GAAaA,EAAUkF,QACvBlF,EAAUkF,MAAQ,YAASlF,EAAUkF,MAAO2f,IAEhD,IAAIvI,EAAU7c,EAAM6c,QAChBA,GAAWA,EAAQtZ,MACnBsZ,EAAQtZ,IAAM,YAASsZ,EAAQtZ,IAAK6hB,KAO5CxC,EAAWpjB,UAAUolB,2BAA6B,SAAU5kB,GACxD,IAAIqlB,EAAUrlB,EAAMslB,IAChBC,EAAoB7gB,OAAOiM,KAAKzR,KAAK4jB,eACrCuC,GAAWE,EAAkBniB,OAAS,IACtCiiB,EAAQnD,aAAeqD,IAO/B3C,EAAWpjB,UAAUgX,WAAa,SAAUxW,GACxCd,KAAKikB,cAAcpjB,UAAUC,IAQjC4iB,EAAWpjB,UAAU4jB,cAAgB,SAAUpjB,EAAOQ,EAAM8N,GACxD,OAAOpP,KAAKsmB,cAAcxlB,EAAOQ,EAAM8N,GAAOrO,MAAK,SAAUwlB,GACzD,OAAOA,EAAWxkB,YACnB,SAAUf,GACTyJ,EAAA,EAAOxJ,MAAMD,OAiBrB0iB,EAAWpjB,UAAUgmB,cAAgB,SAAUxlB,EAAOQ,EAAM8N,GACxD,IAAIjJ,EAAQnG,KAERmK,EAAKnK,KAAKyb,aAAc+K,EAAarc,EAAGqc,WAAYC,EAAatc,EAAGsc,WACxE,IAAKzmB,KAAKkX,aACN,OAAO,IAAY/N,OAAO,IAAI,IAAY,0CAE9C,IAAIud,EAA+B,gBAAf5lB,EAAMc,KAI1B,OAAK8kB,GAAuC,iBAAfD,GAA2B7K,KAAK8E,SAAW+F,EAC7D,IAAYtd,OAAO,IAAI,IAAY,oFAAsFsd,EAAa,MAE1IzmB,KAAKoX,cAActW,EAAOsO,EAAO9N,GACnCP,MAAK,SAAUykB,GAChB,GAAiB,OAAbA,EACA,MAAM,IAAI,IAAY,0DAG1B,GAD0BlkB,GAAQA,EAAKiU,OAAiC,IAAzBjU,EAAKiU,KAAKoR,YAC9BD,IAAkBF,EACzC,OAAOhB,EAEX,IAAIoB,EAAmBJ,EAAWhB,EAAUlkB,GAC5C,QAAgC,IAArBslB,EACP,MAAM,IAAI,IAAY,8DAErB,OAAI,OAAAxC,EAAA,GAAWwC,GACTA,EAAiB7lB,MAAK,SAAUD,GAAS,OAAOA,KAAU,SAAU+D,GACvE,MAAM,IAAI,IAAY,4BAA8BA,MAGrD+hB,KAEN7lB,MAAK,SAAU8lB,GAChB,GAAuB,OAAnBA,EACA,MAAM,IAAI,IAAY,sDAE1B,IAAI1lB,EAAUiO,GAASA,EAAMkC,YAAclC,EAAMkC,aAKjD,OAJKoV,GAAiBvlB,GAClBgF,EAAMwe,wBAAwBxjB,EAAS0lB,GAE3C1gB,EAAMmR,WAAWuP,GACVA,KAEN9lB,KAAK,MAAM,SAAUC,GACtB,GAAIA,aAAkB,IAClB,MAAMA,EAQV,MANAmF,EAAM8U,iBAAiBja,EAAQ,CAC3BuU,KAAM,CACFoR,YAAY,GAEhBje,kBAAmB1H,IAEjB,IAAI,IAAY,8HAAgIA,OAM9J0iB,EAAWpjB,UAAU0jB,SAAW,SAAU8C,GACtC,IAAI3gB,EAAQnG,KACZA,KAAK6jB,aAAe,EACpBiD,EAAQ/lB,MAAK,SAAUwF,GAEnB,OADAJ,EAAM0d,aAAe,EACdtd,KACR,SAAUvF,GAET,OADAmF,EAAM0d,aAAe,EACd7iB,MAGR0iB,EAvaoB,I,wCCtC/B,sDAGIhX,EAAS,cAETqa,EAAS,iBAETC,EAAwB,WAExB,SAASA,IACLhnB,KAAKinB,UAAW,EAiDpB,OA9CAD,EAAO1mB,UAAU4mB,QAAU,WACvBlnB,KAAKinB,UAAW,GAGpBD,EAAO1mB,UAAU6mB,OAAS,WACtBnnB,KAAKinB,UAAW,GAGpBD,EAAO1mB,UAAU4hB,IAAM,WAEnB,IADA,IAAI3d,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEpB9U,KAAKinB,UAGV,aAAe,WACXva,EAAO+H,QAAQyN,IAAI6E,EAAS,UAAYxiB,EAAKuP,KAAK,UAI1DkT,EAAO1mB,UAAUH,KAAO,WAEpB,IADA,IAAIoE,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEpB9U,KAAKinB,UAGV,aAAe,WACXva,EAAO+H,QAAQtU,KAAK4mB,EAAS,WAAaxiB,EAAKuP,KAAK,UAI5DkT,EAAO1mB,UAAUW,MAAQ,WAErB,IADA,IAAIsD,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEpB9U,KAAKinB,UAGV,aAAe,WACXva,EAAO+H,QAAQxT,MAAM8lB,EAAS,YAAcxiB,EAAKuP,KAAK,UAGvDkT,EApDgB,GAuD3Bta,EAAOuG,WAAavG,EAAOuG,YAAc,GACzC,IAAIxI,EAASiC,EAAOuG,WAAWxI,SAAWiC,EAAOuG,WAAWxI,OAAS,IAAIuc,I,wCC/DzE,sFAKII,EAA8B,SAAUrhB,GAExC,SAASqhB,IACL,OAAkB,OAAXrhB,GAAmBA,EAAOkP,MAAMjV,KAAM+U,YAAc/U,KAgD/D,OAlDA,YAAUonB,EAAcrhB,GAOxBqhB,EAAa9mB,UAAUO,UAAY,SAAUC,GACzC,OAAOd,KAAKqnB,aAAa,YAAqBvmB,EAAOd,KAAK6J,MAAO/I,IAKrEsmB,EAAa9mB,UAAUY,YAAc,SAAUC,GAC3C,OAAOnB,KAAKqnB,aAAa,YAAuBlmB,EAASnB,KAAK6J,MAAO1I,IAMzEimB,EAAa9mB,UAAU+mB,aAAe,SAAUC,EAAeC,GAC3D,IAAIphB,EAAQnG,KACZ,OAAIA,KAAK4K,eAAe0c,EAAc1lB,MAC3B4lB,QAAQre,OAAO,CAClBrI,MAAOymB,EACP3lB,KAAM0lB,EAAc1lB,KACpBZ,OAAQ,yBAA2BhB,KAAK0K,eAAe4c,EAAc1lB,MAAQ,6BAC7E2I,OAAQ,MAGTvK,KAAK8I,QAAQE,IAAI,IAAI,KAAY,SAAUhH,EAASmH,GACvD,IAAIwU,EAAU,IAAI8J,eAWlB,IAAK,IAAIhG,KAVT9D,EAAQ+J,mBAAqB,WACzB,GAA2B,IAAvB/J,EAAQgK,WAAkB,CAC1B,IAAIrd,EAAU,CACV,uBAAwBqT,EAAQiK,kBAAkB,wBAClD,cAAejK,EAAQiK,kBAAkB,gBAE7CzhB,EAAM+D,gBAAgB,CAAEE,YAAakd,EAAc1lB,KAAMyI,SAAUsT,EAASrT,QAASA,EAAStI,QAASA,EAASmH,OAAQA,MAGhIwU,EAAQkK,KAAK,OAAQP,EAAcjjB,KAChB8B,EAAMpG,QAAQuK,QACzBnE,EAAMpG,QAAQuK,QAAQxE,eAAe2b,IACrC9D,EAAQmK,iBAAiBrG,EAAQtb,EAAMpG,QAAQuK,QAAQmX,IAG/D9D,EAAQoK,KAAKT,EAAcxR,WAG5BsR,EAnDsB,CALjC,cAyDE,I,sCCzDF,sIAII1a,EAAS,cAETsb,EAAgC,SAAUjiB,GAE1C,SAASiiB,IACL,OAAkB,OAAXjiB,GAAmBA,EAAOkP,MAAMjV,KAAM+U,YAAc/U,KA8D/D,OAhEA,YAAUgoB,EAAgBjiB,GAO1BiiB,EAAe1nB,UAAUO,UAAY,SAAUC,GAC3C,OAAOd,KAAKqnB,aAAa,YAAqBvmB,EAAOd,KAAK6J,MAAO/I,IAKrEknB,EAAe1nB,UAAUY,YAAc,SAAUC,GAC7C,OAAOnB,KAAKqnB,aAAa,YAAuBlmB,EAASnB,KAAK6J,MAAO1I,IAMzE6mB,EAAe1nB,UAAU+mB,aAAe,SAAUC,EAAeC,GAC7D,IAAIphB,EAAQnG,KACZ,GAAIA,KAAK4K,eAAe0c,EAAc1lB,MAClC,OAAO4lB,QAAQre,OAAO,CAClBrI,MAAOymB,EACP3lB,KAAM0lB,EAAc1lB,KACpBZ,OAAQ,yBAA2BhB,KAAK0K,eAAe4c,EAAc1lB,MAAQ,6BAC7E2I,OAAQ,MAGhB,IAAIxK,EAAU,CACV+V,KAAMwR,EAAcxR,KACpBF,OAAQ,OAKRpI,eAAiB,cAA2B,SAAW,IAQ3D,YANqC/L,IAAjCzB,KAAKD,QAAQkoB,iBACbziB,OAAO0iB,OAAOnoB,EAASC,KAAKD,QAAQkoB,sBAEXxmB,IAAzBzB,KAAKD,QAAQuK,UACbvK,EAAQuK,QAAUtK,KAAKD,QAAQuK,SAE5BtK,KAAK8I,QAAQE,IAAI,IAAI,KAAY,SAAUhH,EAASmH,GACvDuD,EACKC,MAAM2a,EAAcjjB,IAAKtE,GACzBgB,MAAK,SAAUsJ,GAChB,IAAIC,EAAU,CACV,uBAAwBD,EAASC,QAAQ6d,IAAI,wBAC7C,cAAe9d,EAASC,QAAQ6d,IAAI,gBAExChiB,EAAM+D,gBAAgB,CAClBE,YAAakd,EAAc1lB,KAC3ByI,SAAUA,EACVC,QAASA,EACTtI,QAASA,EACTmH,OAAQA,OAGXmW,MAAMnW,QAGZ6e,EAjEwB,CAkEjC,M,sCCxEF,wFAEA,SAASI,EAAgCC,GACrC,GAAKA,EAAIC,UAAaD,EAAIC,SAASlC,IAAnC,CAGA,IAAIjc,EAAKke,EAAIC,SAASlC,IACtB,MAAO,CAAE9jB,KADyB6H,EAAG7H,KAChBkY,QADgCrQ,EAAGqQ,UAO5D,SAAS+N,EAAwBznB,EAAOqlB,GACpC,OAAKA,GAGLrlB,EAAMslB,IAAMtlB,EAAMslB,KAAO,CACrB9jB,KAAM6jB,EAAQ7jB,KACdkY,QAAS2L,EAAQ3L,SAErB1Z,EAAMslB,IAAI9jB,KAAOxB,EAAMslB,IAAI9jB,MAAQ6jB,EAAQ7jB,KAC3CxB,EAAMslB,IAAI5L,QAAU1Z,EAAMslB,IAAI5L,SAAW2L,EAAQ3L,QACjD1Z,EAAMslB,IAAIpD,aAAe,YAAUliB,EAAMslB,IAAIpD,cAAgB,GAAMmD,EAAQnD,cAAgB,IAC3FliB,EAAMslB,IAAIoC,SAAW,YAAU1nB,EAAMslB,IAAIoC,UAAY,GAAMrC,EAAQqC,UAAY,IACxE1nB,GAVIA,EAaR,SAAS2nB,EAAuBtnB,EAASknB,GAC5C,IAAIlC,EAAUiC,EAAgCC,GAK9C,MAAO,CACHvS,KALkB4S,KAAKC,UAAU,YAAS,CAAEC,SAAS,IAAI/d,MAAOiP,eAAkBqM,GAAW,CAAEC,IAAKD,KAK5E,KAJVuC,KAAKC,UAAU,CAC7B/mB,KAAM,YAGuC,KAAO8mB,KAAKC,UAAUxnB,GACnES,KAAM,UACNyC,IAAKgkB,EAAIQ,yCAIV,SAASC,EAAqBhoB,EAAOunB,GAExC,IAAIle,EAAKrJ,EAAMyB,MAAQ,GAAIwmB,EAAiB5e,EAAG6e,wBAAyBvC,EAAatc,EAAG8e,oBAAqBC,EAAY,YAAO/e,EAAI,CAAC,0BAA2B,wBAChKrJ,EAAMyB,KAAO2mB,EACb,IAAI/C,EAAUiC,EAAgCC,GAC1Cc,EAAYroB,EAAMc,MAAQ,QAC1BwnB,EAA4B,gBAAdD,EACdE,EAAM,CACNvT,KAAM4S,KAAKC,UAAUxC,EAAUoC,EAAwBznB,EAAOunB,EAAIC,SAASlC,KAAOtlB,GAClFc,KAAMunB,EACN9kB,IAAK+kB,EAAcf,EAAIQ,wCAA0CR,EAAIte,sCAOzE,GAAIqf,EAAa,CACb,IAWIE,EAXkBZ,KAAKC,UAAU,YAAS,CAAE5mB,SAAUjB,EAAMiB,SAAU6mB,SAAS,IAAI/d,MAAOiP,eAAkBqM,GAAW,CAAEC,IAAKD,KAWjG,KAVfuC,KAAKC,UAAU,CAC7B/mB,KAAMd,EAAMc,KAGZ2nB,aAAc,CAAC,CAAEthB,GAAI8gB,EAAgBS,KAAM/C,MAMO,KAAO4C,EAAIvT,KACjEuT,EAAIvT,KAAOwT,EAEf,OAAOD,I,uCCzEX,4TAeO,SAASI,EAAKC,EAAQpnB,EAAMqnB,GAC/B,GAAMrnB,KAAQonB,EAAd,CAGA,IAAIE,EAAWF,EAAOpnB,GAClBunB,EAAUF,EAAmBC,GAGjC,GAAuB,mBAAZC,EACP,IACIA,EAAQvpB,UAAYupB,EAAQvpB,WAAa,GACzCkF,OAAOskB,iBAAiBD,EAAS,CAC7B3I,oBAAqB,CACjB6I,YAAY,EACZxjB,MAAOqjB,KAInB,MAAOrM,IAKXmM,EAAOpnB,GAAQunB,GAQZ,SAASG,EAAUC,GACtB,OAAOzkB,OAAOiM,KAAKwY,GACdjjB,KAAI,SAAUmB,GAAO,OAAO+hB,mBAAmB/hB,GAAO,IAAM+hB,mBAAmBD,EAAO9hB,OACtF2L,KAAK,KAQd,SAASqW,EAAc5jB,GACnB,GAAI,YAAQA,GAAQ,CAChB,IAAItF,EAAQsF,EACR+G,EAAM,CACNrL,QAAShB,EAAMgB,QACfK,KAAMrB,EAAMqB,KACZS,MAAO9B,EAAM8B,OAEjB,IAAK,IAAIgC,KAAK9D,EACNuE,OAAOlF,UAAUwF,eAAeM,KAAKnF,EAAO8D,KAC5CuI,EAAIvI,GAAK9D,EAAM8D,IAGvB,OAAOuI,EAEX,GAAI,YAAQ/G,GAAQ,CAChB,IAAI6jB,EAAU7jB,EACVmjB,EAAS,GACbA,EAAO9nB,KAAOwoB,EAAQxoB,KAEtB,IACI8nB,EAAOlU,OAAS,YAAU4U,EAAQ5U,QAC5B,YAAiB4U,EAAQ5U,QACzBhQ,OAAOlF,UAAUkM,SAASpG,KAAKgkB,EAAQ5U,QAEjD,MAAOzB,GACH2V,EAAOlU,OAAS,YAEpB,IACIkU,EAAOW,cAAgB,YAAUD,EAAQC,eACnC,YAAiBD,EAAQC,eACzB7kB,OAAOlF,UAAUkM,SAASpG,KAAKgkB,EAAQC,eAEjD,MAAOtW,GACH2V,EAAOW,cAAgB,YAK3B,IAAK,IAAItlB,IAHkB,oBAAhBulB,aAA+B,YAAa/jB,EAAO+jB,eAC1DZ,EAAO/G,OAASyH,EAAQzH,QAEdyH,EACN5kB,OAAOlF,UAAUwF,eAAeM,KAAKgkB,EAASrlB,KAC9C2kB,EAAO3kB,GAAKqlB,GAGpB,OAAOV,EAEX,OAAOnjB,EAQX,SAASgkB,EAAShkB,GACd,OANJ,SAAoBA,GAEhB,QAASikB,UAAUjkB,GAAOvC,MAAM,SAASE,OAIlCumB,CAAW/B,KAAKC,UAAUpiB,IAG9B,SAASmkB,EAAgBT,EAEhCnE,EAEA6E,QACkB,IAAV7E,IAAoBA,EAAQ,QAChB,IAAZ6E,IAAsBA,EAAU,QACpC,IAAIC,EAAaC,EAAUZ,EAAQnE,GACnC,OAAIyE,EAASK,GAAcD,EAChBD,EAAgBT,EAAQnE,EAAQ,EAAG6E,GAEvCC,EAmCX,SAASE,EAAevkB,EAAO4B,GAC3B,MAAY,WAARA,GAAoB5B,GAA0B,iBAAVA,GAAsBA,EAAMwkB,QACzD,WAEC,kBAAR5iB,EACO,uBAEW,IAAXuE,GAA0BnG,IAAUmG,EACpC,WAEW,oBAAXmT,QAA0BtZ,IAAUsZ,OACpC,WAEa,oBAAb/S,UAA4BvG,IAAUuG,SACtC,aAGP,YAAiBvG,GACV,mBAEU,iBAAVA,GAAsBA,GAAUA,EAChC,aAEG,IAAVA,EACO,cAEU,mBAAVA,EACA,cAAgB,YAAgBA,GAAS,IAG/B,iBAAVA,EACA,IAAMuc,OAAOvc,GAAS,IAEZ,iBAAVA,EACA,YAAcuc,OAAOvc,GAAS,IAElCA,EAWJ,SAASykB,EAAK7iB,EAAK5B,EAAOuf,EAAOmF,GAIpC,QAHc,IAAVnF,IAAoBA,EAASoF,UACpB,IAATD,IAAmBA,EAAO,IAAI,KAEpB,IAAVnF,EACA,OA5ER,SAAwBvf,GACpB,IAAI3E,EAAO4D,OAAOlF,UAAUkM,SAASpG,KAAKG,GAE1C,GAAqB,iBAAVA,EACP,OAAOA,EAEX,GAAa,oBAAT3E,EACA,MAAO,WAEX,GAAa,mBAATA,EACA,MAAO,UAEX,IAAImkB,EAAa+E,EAAevkB,GAChC,OAAO,YAAYwf,GAAcA,EAAankB,EA+DnCupB,CAAe5kB,GAI1B,GAAIA,SAAiE,mBAAjBA,EAAMqT,OACtD,OAAOrT,EAAMqT,SAIjB,IAAImM,EAAa+E,EAAevkB,EAAO4B,GACvC,GAAI,YAAY4d,GACZ,OAAOA,EAGX,IAAI2D,EAASS,EAAc5jB,GAEvB6kB,EAAM1lB,MAAMqN,QAAQxM,GAAS,GAAK,GAEtC,GAAI0kB,EAAKxS,QAAQlS,GACb,MAAO,eAGX,IAAK,IAAI8kB,KAAY3B,EAEZlkB,OAAOlF,UAAUwF,eAAeM,KAAKsjB,EAAQ2B,KAIlDD,EAAIC,GAAYL,EAAKK,EAAU3B,EAAO2B,GAAWvF,EAAQ,EAAGmF,IAKhE,OAFAA,EAAKtS,UAAUpS,GAER6kB,EAeJ,SAASP,EAAUjoB,EAAOkjB,GAC7B,IACI,OAAO4C,KAAK/G,MAAM+G,KAAKC,UAAU/lB,GAAO,SAAUuF,EAAK5B,GAAS,OAAOykB,EAAK7iB,EAAK5B,EAAOuf,OAE5F,MAAO/R,GACH,MAAO,wBASR,SAASuX,EAA+BjqB,EAAWkqB,QACpC,IAAdA,IAAwBA,EAAY,IACxC,IAAI9Z,EAAOjM,OAAOiM,KAAK0Y,EAAc9oB,IAErC,GADAoQ,EAAK+Z,QACA/Z,EAAKvN,OACN,MAAO,uBAEX,GAAIuN,EAAK,GAAGvN,QAAUqnB,EAClB,OAAO,YAAS9Z,EAAK,GAAI8Z,GAE7B,IAAK,IAAIE,EAAeha,EAAKvN,OAAQunB,EAAe,EAAGA,IAAgB,CACnE,IAAIb,EAAanZ,EAAKnM,MAAM,EAAGmmB,GAAc3X,KAAK,MAClD,KAAI8W,EAAW1mB,OAASqnB,GAGxB,OAAIE,IAAiBha,EAAKvN,OACf0mB,EAEJ,YAASA,EAAYW,GAEhC,MAAO,GAMJ,SAASG,EAAkBnM,GAC9B,IAAIxU,EAAKZ,EACT,GAAI,YAAcoV,GAAM,CACpB,IAAI5Z,EAAM4Z,EACNoM,EAAK,GACT,IACI,IAAK,IAAI1gB,EAAK,YAASzF,OAAOiM,KAAK9L,IAAOyF,EAAKH,EAAGM,QAASH,EAAGI,KAAMJ,EAAKH,EAAGM,OAAQ,CAChF,IAAIpD,EAAMiD,EAAG7E,WACW,IAAbZ,EAAIwC,KACXwjB,EAAGxjB,GAAOujB,EAAkB/lB,EAAIwC,MAI5C,MAAO+D,GAASnB,EAAM,CAAE9J,MAAOiL,GAC/B,QACI,IACQd,IAAOA,EAAGI,OAASrB,EAAKc,EAAGgB,SAAS9B,EAAG/D,KAAK6E,GAEpD,QAAU,GAAIF,EAAK,MAAMA,EAAI9J,OAEjC,OAAO0qB,EAEX,OAAIjmB,MAAMqN,QAAQwM,GACPA,EAAIvY,IAAI0kB,GAEZnM,K,sGCtUPqM,E,4GAEJ,IAAIC,EAAkC,WAClC,SAASA,IAIL7rB,KAAKsC,KAAOupB,EAAiB5jB,GAsBjC,OAjBA4jB,EAAiBvrB,UAAUgI,UAAY,WAEnCsjB,EAA2BE,SAASxrB,UAAUkM,SAE9Csf,SAASxrB,UAAUkM,SAAW,WAE1B,IADA,IAAIjI,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB,IAAIjE,EAAU7Q,KAAKkhB,qBAAuBlhB,KAC1C,OAAO4rB,EAAyB3W,MAAMpE,EAAStM,KAMvDsnB,EAAiB5jB,GAAK,mBACf4jB,EA3B0B,G,gGCGjCE,EAAwB,CAAC,oBAAqB,iDAE9C,EAAgC,WAChC,SAASC,EAAe/rB,QACH,IAAbA,IAAuBA,EAAW,IACtCD,KAAKC,SAAWA,EAIhBD,KAAKsC,KAAO0pB,EAAe/jB,GAyI/B,OApIA+jB,EAAe1rB,UAAUgI,UAAY,WACjC,aAAwB,SAAUxH,GAC9B,IAAI+b,EAAM,cACV,IAAKA,EACD,OAAO/b,EAEX,IAAIyH,EAAOsU,EAAIrU,eAAewjB,GAC9B,GAAIzjB,EAAM,CACN,IAAI2R,EAAS2C,EAAIhC,YACboR,EAAgB/R,EAASA,EAAOuB,aAAe,GAC/C1b,EAAUwI,EAAK2jB,cAAcD,GACjC,GAAI1jB,EAAK4jB,iBAAiBrrB,EAAOf,GAC7B,OAAO,KAGf,OAAOe,MAIfkrB,EAAe1rB,UAAU6rB,iBAAmB,SAAUrrB,EAAOf,GACzD,OAAIC,KAAKosB,eAAetrB,EAAOf,IAC3B0K,EAAA,EAAOtK,KAAK,6DAA+D,YAAoBW,KACxF,GAEPd,KAAKqsB,gBAAgBvrB,EAAOf,IAC5B0K,EAAA,EAAOtK,KAAK,wEAA0E,YAAoBW,KACnG,GAEPd,KAAKssB,aAAaxrB,EAAOf,IACzB0K,EAAA,EAAOtK,KAAK,oEAAsE,YAAoBW,GAAS,WAAad,KAAKusB,mBAAmBzrB,KAC7I,IAENd,KAAKwsB,cAAc1rB,EAAOf,KAC3B0K,EAAA,EAAOtK,KAAK,yEAA2E,YAAoBW,GAAS,WAAad,KAAKusB,mBAAmBzrB,KAClJ,IAKfkrB,EAAe1rB,UAAU8rB,eAAiB,SAAUtrB,EAAOf,GACvD,IAAKA,EAAQ0sB,eACT,OAAO,EAEX,IACI,OAAS3rB,GACLA,EAAMO,WACNP,EAAMO,UAAUoF,QAChB3F,EAAMO,UAAUoF,OAAO,IACY,gBAAnC3F,EAAMO,UAAUoF,OAAO,GAAG7E,OAC1B,EAER,MAAOmS,GACH,OAAO,IAIfiY,EAAe1rB,UAAU+rB,gBAAkB,SAAUvrB,EAAOf,GACxD,SAAKA,EAAQ2sB,eAAiB3sB,EAAQ2sB,aAAaxoB,SAG5ClE,KAAK2sB,0BAA0B7rB,GAAO8rB,MAAK,SAAU3qB,GAExD,OAAOlC,EAAQ2sB,aAAaE,MAAK,SAAUC,GAAW,OAAO,YAAkB5qB,EAAS4qB,UAIhGb,EAAe1rB,UAAUgsB,aAAe,SAAUxrB,EAAOf,GAErD,IAAKA,EAAQ+sB,WAAa/sB,EAAQ+sB,SAAS5oB,OACvC,OAAO,EAEX,IAAIG,EAAMrE,KAAKusB,mBAAmBzrB,GAClC,QAAQuD,GAActE,EAAQ+sB,SAASF,MAAK,SAAUC,GAAW,OAAO,YAAkBxoB,EAAKwoB,OAGnGb,EAAe1rB,UAAUksB,cAAgB,SAAU1rB,EAAOf,GAEtD,IAAKA,EAAQgtB,YAAchtB,EAAQgtB,UAAU7oB,OACzC,OAAO,EAEX,IAAIG,EAAMrE,KAAKusB,mBAAmBzrB,GAClC,OAAQuD,GAAatE,EAAQgtB,UAAUH,MAAK,SAAUC,GAAW,OAAO,YAAkBxoB,EAAKwoB,OAGnGb,EAAe1rB,UAAU4rB,cAAgB,SAAUD,GAE/C,YADsB,IAAlBA,IAA4BA,EAAgB,IACzC,CACHc,UAAW,YAAU/sB,KAAKC,SAAS+sB,eAAiB,GAAMhtB,KAAKC,SAAS8sB,WAAa,GAAMd,EAAce,eAAiB,GAAMf,EAAcc,WAAa,IAC3JD,SAAU,YAAU9sB,KAAKC,SAASgtB,eAAiB,GAAMjtB,KAAKC,SAAS6sB,UAAY,GAAMb,EAAcgB,eAAiB,GAAMhB,EAAca,UAAY,IACxJJ,aAAc,YAAU1sB,KAAKC,SAASysB,cAAgB,GAAMT,EAAcS,cAAgB,GAAKX,GAC/FU,oBAAwD,IAAjCzsB,KAAKC,SAASwsB,gBAAiCzsB,KAAKC,SAASwsB,iBAI5FT,EAAe1rB,UAAUqsB,0BAA4B,SAAU7rB,GAC3D,GAAIA,EAAMmB,QACN,MAAO,CAACnB,EAAMmB,SAElB,GAAInB,EAAMO,UACN,IACI,IAAI8I,EAAMrJ,EAAMO,UAAUoF,QAAU3F,EAAMO,UAAUoF,OAAO,IAAO,GAAIwE,EAAKd,EAAGvI,KAAMA,OAAc,IAAPqJ,EAAgB,GAAKA,EAAIG,EAAKjB,EAAG5D,MAAOA,OAAe,IAAP6E,EAAgB,GAAKA,EAChK,MAAO,CAAC,GAAK7E,EAAO3E,EAAO,KAAO2E,GAEtC,MAAOgb,GAEH,OADA9W,EAAA,EAAOxJ,MAAM,oCAAsC,YAAoBH,IAChE,GAGf,MAAO,IAGXkrB,EAAe1rB,UAAUisB,mBAAqB,SAAUzrB,GACpD,IACI,GAAIA,EAAM+B,WAAY,CAClB,IAAIC,EAAWhC,EAAM+B,WAAWG,OAChC,OAAQF,GAAYA,EAASA,EAASoB,OAAS,GAAGiD,UAAa,KAEnE,GAAIrG,EAAMO,UAAW,CACjB,IAAI6rB,EAAWpsB,EAAMO,UAAUoF,QAAU3F,EAAMO,UAAUoF,OAAO,GAAG5D,YAAc/B,EAAMO,UAAUoF,OAAO,GAAG5D,WAAWG,OACtH,OAAQkqB,GAAYA,EAASA,EAAShpB,OAAS,GAAGiD,UAAa,KAEnE,OAAO,KAEX,MAAOoa,GAEH,OADA9W,EAAA,EAAOxJ,MAAM,gCAAkC,YAAoBH,IAC5D,OAMfkrB,EAAe/jB,GAAK,iBACb+jB,EAhJwB,I,sCCPnC,sEASO,SAASmB,EAAYC,EAAartB,IACf,IAAlBA,EAAQstB,OACR,IAAOlG,SAEX,IAAItK,EAAM,cACN3C,EAAS,IAAIkT,EAAYrtB,GAC7B8c,EAAIvC,WAAWJ,K,sCCfnB,sHAGIoT,EAAuB,CACvB,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,wBAGAC,EAA0B,WAI1B,SAASA,EAASxtB,GAIdC,KAAKsC,KAAOirB,EAAStlB,GACrBjI,KAAKC,SAAW,YAAS,CAAEwnB,gBAAgB,EAAM+F,aAAa,EAAMC,uBAAuB,EAAMpI,aAAa,EAAM7b,YAAY,GAAQzJ,GAsL5I,OAhLAwtB,EAASjtB,UAAUgI,UAAY,WAC3B,IAAIoE,EAAS,eACT1M,KAAKC,SAASuJ,YACd,YAAKkD,EAAQ,aAAc1M,KAAK0tB,kBAAkBxV,KAAKlY,OAEvDA,KAAKC,SAASolB,aACd,YAAK3Y,EAAQ,cAAe1M,KAAK0tB,kBAAkBxV,KAAKlY,OAExDA,KAAKC,SAASwtB,uBACd,YAAK/gB,EAAQ,wBAAyB1M,KAAK2tB,SAASzV,KAAKlY,OAEzDA,KAAKC,SAASwnB,gBAAkB,mBAAoB/a,GACpD,YAAK+a,eAAennB,UAAW,OAAQN,KAAK4tB,SAAS1V,KAAKlY,OAE1DA,KAAKC,SAASutB,eACI9nB,MAAMqN,QAAQ/S,KAAKC,SAASutB,aAAextB,KAAKC,SAASutB,YAAcF,GAC7Exa,QAAQ9S,KAAK6tB,iBAAiB3V,KAAKlY,QAIvDutB,EAASjtB,UAAUotB,kBAAoB,SAAU9D,GAE7C,OAAO,WAEH,IADA,IAAIrlB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB,IAAIgZ,EAAmBvpB,EAAK,GAQ5B,OAPAA,EAAK,GAAK,YAAKupB,EAAkB,CAC7BzM,UAAW,CACP9L,KAAM,CAAEnO,SAAU,YAAgBwiB,IAClCjoB,SAAS,EACTC,KAAM,gBAGPgoB,EAAS3U,MAAMjV,KAAMuE,KAKpCgpB,EAASjtB,UAAUqtB,SAAW,SAAU/D,GAEpC,OAAO,SAAUja,GAEb,OAAOia,EAASxjB,KAAKpG,KAAM,YAAK2P,EAAU,CACtC0R,UAAW,CACP9L,KAAM,CACFnO,SAAU,wBACVyX,QAAS,YAAgB+K,IAE7BjoB,SAAS,EACTC,KAAM,mBAMtB2rB,EAASjtB,UAAUutB,iBAAmB,SAAUrY,GAE5C,IAAI9I,EAAS,cAET9G,EAAQ8G,EAAO8I,IAAW9I,EAAO8I,GAAQlV,UAExCsF,GAAUA,EAAME,gBAAmBF,EAAME,eAAe,sBAG7D,YAAKF,EAAO,oBAAoB,SAAUgkB,GACtC,OAAO,SAAUmE,EAAWC,EAAIjuB,GAC5B,IACkC,mBAAnBiuB,EAAGC,cACVD,EAAGC,YAAc,YAAKD,EAAGC,YAAY/V,KAAK8V,GAAK,CAC3C3M,UAAW,CACP9L,KAAM,CACFnO,SAAU,cACVyX,QAAS,YAAgBmP,GACzBxY,OAAQA,GAEZ7T,SAAS,EACTC,KAAM,iBAKtB,MAAO0L,IAGP,OAAOsc,EAASxjB,KAAKpG,KAAM+tB,EAE3B,YAAKC,EAAI,CACL3M,UAAW,CACP9L,KAAM,CACFnO,SAAU,mBACVyX,QAAS,YAAgBmP,GACzBxY,OAAQA,GAEZ7T,SAAS,EACTC,KAAM,gBAEV7B,OAGZ,YAAK6F,EAAO,uBAAuB,SAAUsoB,GACzC,OAAO,SAAUH,EAAWC,EAAIjuB,GAC5B,IAAIoK,EAkBAgkB,EAAsBH,EAC1B,IACI,IAAII,EAAsD,QAA9BjkB,EAAKgkB,SAAwC,IAAPhkB,OAAgB,EAASA,EAAGkkB,mBAC1FD,GACAF,EAA4B9nB,KAAKpG,KAAM+tB,EAAWK,EAAsBruB,GAGhF,MAAO8E,IAGP,OAAOqpB,EAA4B9nB,KAAKpG,KAAM+tB,EAAWI,EAAqBpuB,SAK1FwtB,EAASjtB,UAAUstB,SAAW,SAAUU,GAEpC,OAAO,WAEH,IADA,IAAI/pB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAGzB,IAAIF,EAAM5U,KACNuuB,EAAsB,CAAC,SAAU,UAAW,aAAc,sBAwB9D,OAvBAA,EAAoBzb,SAAQ,SAAUjN,GAC9BA,KAAQ+O,GAA4B,mBAAdA,EAAI/O,IAE1B,YAAK+O,EAAK/O,GAAM,SAAU+jB,GACtB,IAAI4E,EAAc,CACdnN,UAAW,CACP9L,KAAM,CACFnO,SAAUvB,EACVgZ,QAAS,YAAgB+K,IAE7BjoB,SAAS,EACTC,KAAM,eAQd,OAJIgoB,EAAS1I,sBACTsN,EAAYnN,UAAU9L,KAAKsJ,QAAU,YAAgB+K,EAAS1I,sBAG3D,YAAK0I,EAAU4E,SAI3BF,EAAarZ,MAAMjV,KAAMuE,KAMxCgpB,EAAStlB,GAAK,WACPslB,EA/LkB,I,sCCnC7B,siBAKWtK,EAAsB,CAC7B,IAAI,IAAiB+I,eACrB,IAAI,IAAiBH,iBACrB,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,IACJ,IAAI,KA2DD,SAAShS,EAAK9Z,GAKjB,QAJgB,IAAZA,IAAsBA,EAAU,SACA0B,IAAhC1B,EAAQkjB,sBACRljB,EAAQkjB,oBAAsBA,QAEVxhB,IAApB1B,EAAQyZ,QAAuB,CAC/B,IAAIiV,EAAW,cAEXA,EAASC,gBAAkBD,EAASC,eAAezmB,KACnDlI,EAAQyZ,QAAUiV,EAASC,eAAezmB,SAGdxG,IAAhC1B,EAAQ4uB,sBACR5uB,EAAQ4uB,qBAAsB,GAElC5uB,EAAQ+J,UAAY/J,EAAQ+J,WAAa,GACzC/J,EAAQ+J,UAAUsc,IAAM,CACpB9jB,KAAM,4BACNkmB,SAAU,CACN,CACIlmB,KAAM,sBACNkY,QAAS,MAGjBA,QAAS,KAEb,YAAY,IAAeza,GACvBA,EAAQ4uB,qBAiFhB,WACI,IAAI9O,EAAS,cACT/S,EAAW+S,EAAO/S,SACtB,QAAwB,IAAbA,EAEP,YADA,IAAO3M,KAAK,sFAGhB,IAAI0c,EAAM,cAKN+R,EAAuC,aAAxB9hB,EAAS6a,WACxBkH,GAAc,EACdC,EAAqB,WACjBD,GAAeD,GACf/R,EAAIL,cAGRuS,EAAsB,WACtBH,GAAe,EACfE,IACAjP,EAAOmP,oBAAoB,OAAQD,IAEvClS,EAAIN,eACCqS,GAGD/O,EAAOoP,iBAAiB,OAAQF,GAEpC,IACI,IAAIG,EAAK,IAAIC,qBAAoB,SAAUC,EAAWF,GAClDE,EAAUC,aAAavc,SAAQ,SAAUwc,GAClB,2BAAfA,EAAMhtB,MAAqCgtB,EAAMC,UAAYC,IAC7DN,EAAGO,aACHZ,GAAc,EACdC,WAMRU,EAAiD,WAA7B1iB,EAAS4iB,gBAA+B,EAAIxE,IACpEpe,EAASmiB,iBAAiB,oBAAoB,SAAUnuB,GACpD0uB,EAAoB5T,KAAKC,IAAI2T,EAAmB1uB,EAAM6uB,aACvD,CAAEC,MAAM,IACXV,EAAGW,QAAQ,CACPjuB,KAAM,QACNkuB,UAAU,IAGlB,MAAOjrB,GACHgqB,GAAc,EACdC,IAGJ,YAA0B,CACtBnf,SAAU,WACN,IAAIxF,GAEiB,QADdA,EAAK,cACPwQ,kBAA+B,IAAPxQ,OAAgB,EAASA,EAAGmH,gBACrDuL,EAAIN,eACJM,EAAIL,eAGZ5a,KAAM,YAjJNmuB,GAQD,SAAS9Y,EAAiBlX,QACb,IAAZA,IAAsBA,EAAU,IAC/BA,EAAQmb,UACTnb,EAAQmb,QAAU,cAAgBM,eAEtC,IAAItB,EAAS,cAAgBW,YACzBX,GACAA,EAAOjD,iBAAiBlX,GAQzB,SAASyb,IACZ,OAAO,cAAgBA,cAMpB,SAASwU,KAOT,SAASC,EAAOtgB,GACnBA,IAQG,SAAS2U,EAAMhb,GAClB,IAAI4Q,EAAS,cAAgBW,YAC7B,OAAIX,EACOA,EAAOoK,MAAMhb,GAEjB,IAAYH,QAAO,GAQvB,SAASc,EAAMX,GAClB,IAAI4Q,EAAS,cAAgBW,YAC7B,OAAIX,EACOA,EAAOjQ,MAAMX,GAEjB,IAAYH,QAAO,GAUvB,SAAS+mB,EAAKlC,GACjB,OAAO,YAAaA,EAAb,K,sCC9KX,0LAGImC,EAAgB,EAIb,SAASC,IACZ,OAAOD,EAAgB,EAKpB,SAASE,IAEZF,GAAiB,EACjB3mB,YAAW,WACP2mB,GAAiB,KAWlB,SAASD,EAAKlC,EAAIjuB,EAASuwB,GAE9B,QADgB,IAAZvwB,IAAsBA,EAAU,IAClB,mBAAPiuB,EACP,OAAOA,EAEX,IAEI,GAAIA,EAAGrH,WACH,OAAOqH,EAGX,GAAIA,EAAGK,mBACH,OAAOL,EAAGK,mBAGlB,MAAOxpB,GAIH,OAAOmpB,EAIX,IAAIuC,EAAgB,WAChB,IAAIhsB,EAAOmB,MAAMpF,UAAUgF,MAAMc,KAAK2O,WACtC,IACQub,GAA4B,mBAAXA,GACjBA,EAAOrb,MAAMjV,KAAM+U,WAGvB,IAAIyb,EAAmBjsB,EAAKyC,KAAI,SAAUypB,GAAO,OAAOP,EAAKO,EAAK1wB,MAClE,OAAIiuB,EAAGC,YAMID,EAAGC,YAAYhZ,MAAMjV,KAAMwwB,GAM/BxC,EAAG/Y,MAAMjV,KAAMwwB,GAE1B,MAAOhtB,GAcH,MAbA6sB,IACA,aAAU,SAAUjhB,GAChBA,EAAMQ,mBAAkB,SAAU9O,GAC9B,IAAI+lB,EAAiB,YAAS,GAAI/lB,GAMlC,OALIf,EAAQshB,YACR,YAAsBwF,OAAgBplB,OAAWA,GACjD,YAAsBolB,EAAgB9mB,EAAQshB,YAElDwF,EAAengB,MAAQ,YAAS,YAAS,GAAImgB,EAAengB,OAAQ,CAAEqO,UAAWxQ,IAC1EsiB,KAEX,YAAiBrjB,MAEfA,IAMd,IACI,IAAK,IAAIktB,KAAY1C,EACbxoB,OAAOlF,UAAUwF,eAAeM,KAAK4nB,EAAI0C,KACzCH,EAAcG,GAAY1C,EAAG0C,IAIzC,MAAO3c,IACPia,EAAG1tB,UAAY0tB,EAAG1tB,WAAa,GAC/BiwB,EAAcjwB,UAAY0tB,EAAG1tB,UAC7BkF,OAAOmrB,eAAe3C,EAAI,qBAAsB,CAC5CjE,YAAY,EACZxjB,MAAOgqB,IAIX/qB,OAAOskB,iBAAiByG,EAAe,CACnC5J,WAAY,CACRoD,YAAY,EACZxjB,OAAO,GAEX2a,oBAAqB,CACjB6I,YAAY,EACZxjB,MAAOynB,KAIf,IACqBxoB,OAAOorB,yBAAyBL,EAAe,QACjDM,cACXrrB,OAAOmrB,eAAeJ,EAAe,OAAQ,CACzCpI,IAAK,WACD,OAAO6F,EAAG1rB,QAM1B,MAAOyR,IACP,OAAOwc,EAMJ,SAASO,EAAmB/wB,GAE/B,QADgB,IAAZA,IAAsBA,EAAU,IAC/BA,EAAQmb,QAIb,GAAKnb,EAAQG,IAAb,CAIA,IAAI6wB,EAASjkB,SAASC,cAAc,UACpCgkB,EAAOC,OAAQ,EACfD,EAAOE,IAAM,IAAI,IAAIlxB,EAAQG,KAAKgxB,wBAAwBnxB,GACtDA,EAAQkwB,SAERc,EAAOI,OAASpxB,EAAQkwB,SAE3BnjB,SAASI,MAAQJ,SAASgJ,MAAM3I,YAAY4jB,QAVzC,IAAO9vB,MAAM,oDAJb,IAAOA,MAAM,qD,sCC7IrB,sEAGImwB,EAAY,iEAIZC,EAAqB,WAErB,SAASA,EAAIpb,GACW,iBAATA,EACPjW,KAAKsxB,YAAYrb,GAGjBjW,KAAKuxB,gBAAgBtb,GAEzBjW,KAAKwxB,YAmET,OAxDAH,EAAI/wB,UAAUkM,SAAW,SAAUilB,QACV,IAAjBA,IAA2BA,GAAe,GAC9C,IAAItnB,EAAKnK,KAAM0W,EAAOvM,EAAGuM,KAAMF,EAAOrM,EAAGqM,KAAMkb,EAAOvnB,EAAGunB,KAAMC,EAAOxnB,EAAGwnB,KAAMC,EAAYznB,EAAGynB,UAC9F,OADoHznB,EAAGsM,SACpG,MADqHtM,EAAG2F,MACxG2hB,GAAgBC,EAAO,IAAMA,EAAO,IAClE,IAAMhb,GAAQib,EAAO,IAAMA,EAAO,IAAM,KAAOnb,EAAOA,EAAO,IAAMA,GAAQob,GAGpFP,EAAI/wB,UAAUgxB,YAAc,SAAUO,GAClC,IAAI7b,EAAQob,EAAUhtB,KAAKytB,GAC3B,IAAK7b,EACD,MAAM,IAAI,IAhCF,eAkCZ,IAAI7L,EAAK,YAAO6L,EAAM1Q,MAAM,GAAI,GAAImR,EAAWtM,EAAG,GAAI2F,EAAO3F,EAAG,GAAIc,EAAKd,EAAG,GAAIunB,OAAc,IAAPzmB,EAAgB,GAAKA,EAAIyL,EAAOvM,EAAG,GAAIiB,EAAKjB,EAAG,GAAIwnB,OAAc,IAAPvmB,EAAgB,GAAKA,EAClKoL,EAAO,GACPob,EAFiLznB,EAAG,GAGpLnG,EAAQ4tB,EAAU5tB,MAAM,KAK5B,GAJIA,EAAME,OAAS,IACfsS,EAAOxS,EAAMsB,MAAM,GAAI,GAAGwO,KAAK,KAC/B8d,EAAY5tB,EAAM+W,OAElB6W,EAAW,CACX,IAAIE,EAAeF,EAAU5b,MAAM,QAC/B8b,IACAF,EAAYE,EAAa,IAGjC9xB,KAAKuxB,gBAAgB,CAAE7a,KAAMA,EAAMgb,KAAMA,EAAMlb,KAAMA,EAAMob,UAAWA,EAAWD,KAAMA,EAAMlb,SAAUA,EAAU3G,KAAMA,KAG3HuhB,EAAI/wB,UAAUixB,gBAAkB,SAAUQ,GACtC/xB,KAAKyW,SAAWsb,EAAWtb,SAC3BzW,KAAK8P,KAAOiiB,EAAWjiB,KACvB9P,KAAK0xB,KAAOK,EAAWL,MAAQ,GAC/B1xB,KAAK0W,KAAOqb,EAAWrb,KACvB1W,KAAK2xB,KAAOI,EAAWJ,MAAQ,GAC/B3xB,KAAKwW,KAAOub,EAAWvb,MAAQ,GAC/BxW,KAAK4xB,UAAYG,EAAWH,WAGhCP,EAAI/wB,UAAUkxB,UAAY,WACtB,IAAIrrB,EAAQnG,KAMZ,GALA,CAAC,WAAY,OAAQ,OAAQ,aAAa8S,SAAQ,SAAUkf,GACxD,IAAK7rB,EAAM6rB,GACP,MAAM,IAAI,IAAYC,gBAAuBD,EAAY,gBAG5DhyB,KAAK4xB,UAAU5b,MAAM,SACtB,MAAM,IAAI,IAAYic,kCAAyCjyB,KAAK4xB,WAExE,GAAsB,SAAlB5xB,KAAKyW,UAAyC,UAAlBzW,KAAKyW,SACjC,MAAM,IAAI,IAAYwb,iCAAwCjyB,KAAKyW,UAEvE,GAAIzW,KAAK2xB,MAAQ9lB,MAAMF,SAAS3L,KAAK2xB,KAAM,KACvC,MAAM,IAAI,IAAYM,6BAAoCjyB,KAAK2xB,OAGhEN,EA5Ea,I,s6DCNba,EAAW,4B,gECKlBC,EAAqB,GAErBC,EAAU,cACVA,EAAQC,QAAUD,EAAQC,OAAOC,eACjCH,EAAqBC,EAAQC,OAAOC,cAExC,IAAIC,EAAe,YAAS,YAAS,YAAS,GAAIJ,GAAqB,KAAmB,I,sCCZ1F,sEAOIK,EAAqB,WAErB,SAASA,EAAItyB,EAAKooB,QACG,IAAbA,IAAuBA,EAAW,IACtCtoB,KAAKE,IAAMA,EACXF,KAAKsoB,SAAWA,EAChBtoB,KAAKyyB,WAAa,IAAI,IAAIvyB,GA4G9B,OAzGAsyB,EAAIlyB,UAAU6W,OAAS,WACnB,OAAOnX,KAAKyyB,YAGhBD,EAAIlyB,UAAUoyB,mBAAqB,WAC/B,IAAIxyB,EAAMF,KAAKyyB,WACXhc,EAAWvW,EAAIuW,SAAWvW,EAAIuW,SAAW,IAAM,GAC/Ckb,EAAOzxB,EAAIyxB,KAAO,IAAMzxB,EAAIyxB,KAAO,GACvC,OAAOlb,EAAW,KAAOvW,EAAIwW,KAAOib,GAAQzxB,EAAIsW,KAAO,IAAMtW,EAAIsW,KAAO,IAAM,SAGlFgc,EAAIlyB,UAAUqyB,iBAAmB,WAC7B,OAAO3yB,KAAK4yB,mBAAmB,UAOnCJ,EAAIlyB,UAAUyJ,mCAAqC,WAC/C,OAAO/J,KAAK2yB,mBAAqB,IAAM3yB,KAAK6yB,gBAOhDL,EAAIlyB,UAAUuoB,sCAAwC,WAClD,OAAO7oB,KAAK8yB,uBAAyB,IAAM9yB,KAAK6yB,gBAGpDL,EAAIlyB,UAAUyyB,qBAAuB,WACjC,IAAI7yB,EAAMF,KAAKyyB,WACf,OAAQvyB,EAAIsW,KAAO,IAAMtW,EAAIsW,KAAO,IAAM,QAAUtW,EAAI0xB,UAAY,WAMxEY,EAAIlyB,UAAU0yB,kBAAoB,SAAUC,EAAYC,GAEpD,IAAIhzB,EAAMF,KAAKyyB,WACXhR,EAAS,CAAC,2BAMd,OALAA,EAAOhd,KAAK,iBAAmBwuB,EAAa,IAAMC,GAClDzR,EAAOhd,KAAK,cAAgBvE,EAAI4P,MAC5B5P,EAAIwxB,MACJjQ,EAAOhd,KAAK,iBAAmBvE,EAAIwxB,MAEhC,CACH,eAAgB,mBAChB,gBAAiBjQ,EAAO3N,KAAK,QAIrC0e,EAAIlyB,UAAU4wB,wBAA0B,SAAUiC,QACxB,IAAlBA,IAA4BA,EAAgB,IAChD,IAAIjzB,EAAMF,KAAKyyB,WACXW,EAAWpzB,KAAK0yB,qBAAuB,oBACvCW,EAAiB,GAErB,IAAK,IAAIlrB,KADTkrB,EAAe5uB,KAAK,OAASvE,EAAIsM,YACjB2mB,EACZ,GAAY,QAARhrB,EAGJ,GAAY,SAARA,EAAgB,CAChB,IAAKgrB,EAAcrjB,KACf,SAEAqjB,EAAcrjB,KAAKxN,MACnB+wB,EAAe5uB,KAAK,QAAUylB,mBAAmBiJ,EAAcrjB,KAAKxN,OAEpE6wB,EAAcrjB,KAAKwJ,OACnB+Z,EAAe5uB,KAAK,SAAWylB,mBAAmBiJ,EAAcrjB,KAAKwJ,aAIzE+Z,EAAe5uB,KAAKylB,mBAAmB/hB,GAAO,IAAM+hB,mBAAmBiJ,EAAchrB,KAG7F,OAAIkrB,EAAenvB,OACRkvB,EAAW,IAAMC,EAAevf,KAAK,KAEzCsf,GAGXZ,EAAIlyB,UAAUwyB,qBAAuB,WACjC,OAAO9yB,KAAK4yB,mBAAmB,aAGnCJ,EAAIlyB,UAAUsyB,mBAAqB,SAAUpd,GAGzC,MAAO,GAFIxV,KAAK0yB,qBACN1yB,KAAKyyB,WACQb,UAAY,IAAMpc,EAAS,KAGtDgd,EAAIlyB,UAAUuyB,aAAe,WACzB,IACIS,EAAO,CAGPC,WAJMvzB,KAAKyyB,WAIK3iB,KAChB0jB,eApHa,KAsHjB,OAAO,YAAUF,IAEdd,EAlHa,I,sCCPxB,8dAQA,SAASiB,EAAU7d,GAEf,IADA,IAAIrR,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,EAAK,GAAKC,UAAUD,GAE7B,IAAI+H,EAAM,cACV,GAAIA,GAAOA,EAAIjH,GAEX,OAAOiH,EAAIjH,GAAQX,MAAM4H,EAAK,YAAStY,IAE3C,MAAM,IAAIzC,MAAM,qBAAuB8T,EAAS,wDAS7C,SAASqF,EAAiB5Z,EAAWkQ,GACxC,IAAI/P,EACJ,IACI,MAAM,IAAIM,MAAM,6BAEpB,MAAOT,GACHG,EAAqBH,EAEzB,OAAOoyB,EAAU,mBAAoBpyB,EAAW,CAC5CkQ,eAAgBA,EAChB7I,kBAAmBrH,EACnBG,mBAAoBA,IAUrB,SAAS8Z,EAAerZ,EAASsP,GACpC,IAAI/P,EACJ,IACI,MAAM,IAAIM,MAAMG,GAEpB,MAAOZ,GACHG,EAAqBH,EAIzB,IACIwP,EAAoC,iBAAnBU,EAA8B,CAAEA,eAAgBA,QAAmB9P,EACxF,OAAOgyB,EAAU,iBAAkBxxB,EAFG,iBAAnBsP,EAA8BA,OAAiB9P,EAEf,YAAS,CAAEiH,kBAAmBzG,EAAST,mBAAoBA,GAAsBqP,IAQjI,SAAS0K,EAAaza,GACzB,OAAO2yB,EAAU,eAAgB3yB,GAM9B,SAASgb,EAAenM,GAC3B8jB,EAAU,iBAAkB9jB,GAUzB,SAASiC,EAAcC,GAC1B4hB,EAAU,gBAAiB5hB,GAQxB,SAASjB,EAAWtO,EAAMuO,GAC7B4iB,EAAU,aAAcnxB,EAAMuO,GAM3B,SAAST,EAAUC,GACtBojB,EAAU,YAAapjB,GAMpB,SAASH,EAAQ3N,GACpBkxB,EAAU,UAAWlxB,GAOlB,SAAS+N,EAASnI,EAAKzB,GAC1B+sB,EAAU,WAAYtrB,EAAKzB,GAUxB,SAASyJ,EAAOhI,EAAK5B,GACxBktB,EAAU,SAAUtrB,EAAK5B,GAOtB,SAASsJ,EAAQC,GACpB2jB,EAAU,UAAW3jB,GAelB,SAASkL,EAAUrL,GACtB8jB,EAAU,YAAa9jB,GAqCpB,SAASyM,EAAiBvL,EAASwL,GACtC,OAAOoX,EAAU,mBAAoB,YAAS,GAAI5iB,GAAUwL,K,sCC/LhE,iV,uCCAA,8GAOO,SAASqX,IACZ,MAAwF,qBAAjFluB,OAAOlF,UAAUkM,SAASpG,UAAwB,IAAZutB,EAA0BA,EAAU,GAQ9E,SAASC,EAAeC,EAAKlW,GAEhC,OAAOkW,EAAIC,QAAQnW,M,iFClBvB,sCA6QIoW,EA7QJ,gHAOIrnB,EAAS,cAWTsnB,EAAW,GACXC,EAAe,GAEnB,SAASC,EAAWtyB,GAChB,IAAIqyB,EAAaryB,GAIjB,OADAqyB,EAAaryB,IAAQ,EACbA,GACJ,IAAK,WAgEb,WACI,KAAM,YAAa8K,GACf,OAEJ,CAAC,QAAS,OAAQ,OAAQ,QAAS,MAAO,UAAUoG,SAAQ,SAAUjR,GAC5DA,KAAS6K,EAAO+H,SAGtB,YAAK/H,EAAO+H,QAAS5S,GAAO,SAAUsyB,GAClC,OAAO,WAEH,IADA,IAAI5vB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzBsf,EAAgB,UAAW,CAAE7vB,KAAMA,EAAM1C,MAAOA,IAE5CsyB,GACArI,SAASxrB,UAAU2U,MAAM7O,KAAK+tB,EAAsBznB,EAAO+H,QAASlQ,UAhF5E8vB,GACA,MACJ,IAAK,OAiSb,WACI,KAAM,aAAc3nB,GAChB,OAIJA,EAAOI,SAASmiB,iBAAiB,QAASqF,EAAgB,QAASF,EAAgBlc,KAAK,KAAM,SAAS,GACvGxL,EAAOI,SAASmiB,iBAAiB,WAAYsF,EAAqBH,EAAgBlc,KAAK,KAAM,SAAS,GAEtG,CAAC,cAAe,QAAQpF,SAAQ,SAAU0C,GAEtC,IAAI5P,EAAQ8G,EAAO8I,IAAW9I,EAAO8I,GAAQlV,UAExCsF,GAAUA,EAAME,gBAAmBF,EAAME,eAAe,sBAI7D,YAAKF,EAAO,oBAAoB,SAAUgkB,GACtC,OAAO,SAAUmE,EAAWC,EAAIjuB,GA2B5B,OA1BIiuB,GAAMA,EAAGC,aACS,UAAdF,GACA,YAAKC,EAAI,eAAe,SAAUwG,GAC9B,OAAO,SAAU1zB,GAEb,OADAwzB,EAAgB,QAASF,EAAgBlc,KAAK,KAAM,OAApDoc,CAA4DxzB,GACrD0zB,EAAcpuB,KAAKpG,KAAMc,OAI1B,aAAditB,GACA,YAAKC,EAAI,eAAe,SAAUwG,GAC9B,OAAO,SAAU1zB,GAEb,OADAyzB,EAAqBH,EAAgBlc,KAAK,KAAM,OAAhDqc,CAAwDzzB,GACjD0zB,EAAcpuB,KAAKpG,KAAMc,SAM1B,UAAditB,GACAuG,EAAgB,QAASF,EAAgBlc,KAAK,KAAM,QAAQ,EAA5Doc,CAAkEt0B,MAEpD,aAAd+tB,GACAwG,EAAqBH,EAAgBlc,KAAK,KAAM,OAAhDqc,CAAwDv0B,OAGzD4pB,EAASxjB,KAAKpG,KAAM+tB,EAAWC,EAAIjuB,OAGlD,YAAK6F,EAAO,uBAAuB,SAAUgkB,GACzC,OAAO,SAAUmE,EAAWC,EAAIjuB,GAC5B,IACI6pB,EAASxjB,KAAKpG,KAAM+tB,EAAWC,EAAGK,mBAAoBtuB,GAE1D,MAAO8E,IAGP,OAAO+kB,EAASxjB,KAAKpG,KAAM+tB,EAAWC,EAAIjuB,WAxV9C00B,GACA,MACJ,IAAK,OA4Ib,WACI,KAAM,mBAAoB/nB,GACtB,OAGJ,IAAIgoB,EAAc,GACdC,EAAgB,GAChBC,EAAWnN,eAAennB,UAC9B,YAAKs0B,EAAU,QAAQ,SAAUC,GAC7B,OAAO,WAEH,IADA,IAAItwB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAGzB,IAAIF,EAAM5U,KACNqE,EAAME,EAAK,GACfqQ,EAAIe,eAAiB,CAEjBC,OAAQ,YAASrR,EAAK,IAAMA,EAAK,GAAGuwB,cAAgBvwB,EAAK,GACzDF,IAAKE,EAAK,IAIV,YAASF,IAAsC,SAA9BuQ,EAAIe,eAAeC,QAAqBvR,EAAI2R,MAAM,gBACnEpB,EAAIc,wBAAyB,GAEjC,IAAIqf,EAA4B,WAC5B,GAAuB,IAAnBngB,EAAI+S,WAAkB,CACtB,IAGQ/S,EAAIe,iBACJf,EAAIe,eAAeE,YAAcjB,EAAIrK,QAG7C,MAAO1F,IAGP,IACI,IAAImwB,EAAaN,EAAYzvB,QAAQ2P,GACrC,IAAoB,IAAhBogB,EAAmB,CAEnBN,EAAYtrB,OAAO4rB,GACnB,IAAIC,EAASN,EAAcvrB,OAAO4rB,GAAY,GAC1CpgB,EAAIe,qBAAgClU,IAAdwzB,EAAO,KAC7BrgB,EAAIe,eAAeG,KAAOmf,EAAO,KAI7C,MAAOpwB,IAGPuvB,EAAgB,MAAO,CACnB7vB,KAAMA,EACNkR,aAAc5K,KAAKC,MACnBoqB,eAAgBrqB,KAAKC,MACrB8J,IAAKA,MAmBjB,MAfI,uBAAwBA,GAAyC,mBAA3BA,EAAI8S,mBAC1C,YAAK9S,EAAK,sBAAsB,SAAUgV,GACtC,OAAO,WAEH,IADA,IAAIuL,EAAiB,GACZrgB,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCqgB,EAAergB,GAAMC,UAAUD,GAGnC,OADAigB,IACOnL,EAAS3U,MAAML,EAAKugB,OAKnCvgB,EAAIqa,iBAAiB,mBAAoB8F,GAEtCF,EAAa5f,MAAML,EAAKrQ,OAGvC,YAAKqwB,EAAU,QAAQ,SAAUtG,GAC7B,OAAO,WAEH,IADA,IAAI/pB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GASzB,OAPA4f,EAAYjwB,KAAKzE,MACjB20B,EAAclwB,KAAKF,GACnB6vB,EAAgB,MAAO,CACnB7vB,KAAMA,EACN2wB,eAAgBrqB,KAAKC,MACrB8J,IAAK5U,OAEFsuB,EAAarZ,MAAMjV,KAAMuE,OAvOhC6wB,GACA,MACJ,IAAK,SA+Eb,WACI,IAAK,cACD,OAEJ,YAAK1oB,EAAQ,SAAS,SAAU2oB,GAC5B,OAAO,WAEH,IADA,IAAI9wB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB,IAAIQ,EAAc,CACd/Q,KAAMA,EACNwR,UAAW,CACPH,OAAQ0f,EAAe/wB,GACvBF,IAAKkxB,EAAYhxB,IAErB2wB,eAAgBrqB,KAAKC,OAIzB,OAFAspB,EAAgB,QAAS,YAAS,GAAI9e,IAE/B+f,EAAcpgB,MAAMvI,EAAQnI,GAAMxD,MAAK,SAAUsJ,GAEpD,OADA+pB,EAAgB,QAAS,YAAS,YAAS,GAAI9e,GAAc,CAAEG,aAAc5K,KAAKC,MAAOT,SAAUA,KAC5FA,KACR,SAAUpJ,GAKT,MAJAmzB,EAAgB,QAAS,YAAS,YAAS,GAAI9e,GAAc,CAAEG,aAAc5K,KAAKC,MAAO7J,MAAOA,KAI1FA,SA1GVu0B,GACA,MACJ,IAAK,WAwOb,WACI,IAAK,cACD,OAEJ,IAAIC,EAAgB/oB,EAAOgpB,WAmB3B,SAASC,EAA2BC,GAChC,OAAO,WAEH,IADA,IAAIrxB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB,IAAIzQ,EAAME,EAAKL,OAAS,EAAIK,EAAK,QAAK9C,EACtC,GAAI4C,EAAK,CAEL,IAAI4R,EAAO8d,EACP7d,EAAK4M,OAAOze,GAEhB0vB,EAAW7d,EACXke,EAAgB,UAAW,CACvBne,KAAMA,EACNC,GAAIA,IAGZ,OAAO0f,EAAwB3gB,MAAMjV,KAAMuE,IApCnDmI,EAAOgpB,WAAa,WAEhB,IADA,IAAInxB,EAAO,GACFuQ,EAAK,EAAGA,EAAKC,UAAU7Q,OAAQ4Q,IACpCvQ,EAAKuQ,GAAMC,UAAUD,GAEzB,IAAIoB,EAAKxJ,EAAO0J,SAASC,KAErBJ,EAAO8d,EAMX,GALAA,EAAW7d,EACXke,EAAgB,UAAW,CACvBne,KAAMA,EACNC,GAAIA,IAEJuf,EACA,OAAOA,EAAcxgB,MAAMjV,KAAMuE,IAyBzC,YAAKmI,EAAOoB,QAAS,YAAa6nB,GAClC,YAAKjpB,EAAOoB,QAAS,eAAgB6nB,GApR7BE,GACA,MACJ,IAAK,QAkaTC,EAAqBppB,EAAOqV,QAC5BrV,EAAOqV,QAAU,SAAUU,EAAKpe,EAAKJ,EAAMO,EAAQvD,GAQ/C,OAPAmzB,EAAgB,QAAS,CACrB5vB,OAAQA,EACRvD,MAAOA,EACPgD,KAAMA,EACNwe,IAAKA,EACLpe,IAAKA,MAELyxB,GAEOA,EAAmB7gB,MAAMjV,KAAM+U,YA3atC,MACJ,IAAK,qBAkbTghB,EAAkCrpB,EAAOsV,qBACzCtV,EAAOsV,qBAAuB,SAAUnd,GAEpC,OADAuvB,EAAgB,qBAAsBvvB,IAClCkxB,GAEOA,EAAgC9gB,MAAMjV,KAAM+U,YArbnD,MACJ,QACI,IAAO5U,KAAK,gCAAiCyB,IAQlD,SAASo0B,EAA0BnX,GACjCA,GAAmC,iBAAjBA,EAAQjd,MAAiD,mBAArBid,EAAQlP,WAGnEqkB,EAASnV,EAAQjd,MAAQoyB,EAASnV,EAAQjd,OAAS,GACnDoyB,EAASnV,EAAQjd,MAAM6C,KAAKoa,EAAQlP,UACpCukB,EAAWrV,EAAQjd,OAGvB,SAASwyB,EAAgBxyB,EAAM2T,GAC3B,IAAIxK,EAAKZ,EACT,GAAKvI,GAASoyB,EAASpyB,GAGvB,IACI,IAAK,IAAIqJ,EAAK,YAAS+oB,EAASpyB,IAAS,IAAKwJ,EAAKH,EAAGM,QAASH,EAAGI,KAAMJ,EAAKH,EAAGM,OAAQ,CACpF,IAAIsT,EAAUzT,EAAG7E,MACjB,IACIsY,EAAQtJ,GAEZ,MAAO1Q,GACH,IAAO5D,MAAM,0DAA4DW,EAAO,WAAa,YAAgBid,GAAW,YAAcha,KAIlJ,MAAOqH,GAASnB,EAAM,CAAE9J,MAAOiL,GAC/B,QACI,IACQd,IAAOA,EAAGI,OAASrB,EAAKc,EAAGgB,SAAS9B,EAAG/D,KAAK6E,GAEpD,QAAU,GAAIF,EAAK,MAAMA,EAAI9J,QA+DrC,SAASq0B,EAAeW,GAEpB,YADkB,IAAdA,IAAwBA,EAAY,IACpC,YAAavpB,GAAU,YAAaupB,EAAU,GAAI5pB,UAAY4pB,EAAU,GAAGrgB,OACpEkN,OAAOmT,EAAU,GAAGrgB,QAAQkf,cAEnCmB,EAAU,IAAMA,EAAU,GAAGrgB,OACtBkN,OAAOmT,EAAU,GAAGrgB,QAAQkf,cAEhC,MAGX,SAASS,EAAYU,GAEjB,YADkB,IAAdA,IAAwBA,EAAY,IACZ,iBAAjBA,EAAU,GACVA,EAAU,GAEjB,YAAavpB,GAAU,YAAaupB,EAAU,GAAI5pB,SAC3C4pB,EAAU,GAAG5xB,IAEjBye,OAAOmT,EAAU,IAmN5B,IAEIC,EACAC,EAFAC,EAAgB,EAWpB,SAAS9B,EAAgBhyB,EAAMuc,EAASwX,GAEpC,YADiB,IAAbA,IAAuBA,GAAW,GAC/B,SAAUv1B,GAIbo1B,OAAkBz0B,EAIbX,GAASq1B,IAAsBr1B,IAGpCq1B,EAAoBr1B,EAChBs1B,GACA1sB,aAAa0sB,GAEbC,EACAD,EAAgB5sB,YAAW,WACvBqV,EAAQ,CAAE/d,MAAOA,EAAOwB,KAAMA,OAIlCuc,EAAQ,CAAE/d,MAAOA,EAAOwB,KAAMA,MAU1C,SAASiyB,EAAqB1V,GAI1B,OAAO,SAAU/d,GACb,IAAI0U,EACJ,IACIA,EAAS1U,EAAM0U,OAEnB,MAAO3Q,GAGH,OAEJ,IAAIuP,EAAUoB,GAAUA,EAAOpB,QAI1BA,IAAwB,UAAZA,GAAmC,aAAZA,GAA2BoB,EAAO8gB,qBAKrEJ,GACD5B,EAAgB,QAASzV,EAAzByV,CAAkCxzB,GAEtC4I,aAAawsB,GACbA,EAAkB1sB,YAAW,WACzB0sB,OAAkBz0B,IAzEP,OA6EvB,IAAIq0B,EAAqB,KAmBzB,IAAIC,EAAkC,M,sCC5dtC,kCAAO,IAAIQ,EAAc,S,sCCAzB,kCAIO,SAASC,EAAgBxI,GAC5B,IACI,OAAKA,GAAoB,mBAAPA,GAGXA,EAAG1rB,MATQ,cAWtB,MAAOuC,GAGH,MAdkB,iB,sCCA1B,4JAQO,SAAS4xB,EAAS5E,EAAK6E,GAE1B,YADY,IAARA,IAAkBA,EAAM,GACT,iBAAR7E,GAA4B,IAAR6E,GAGxB7E,EAAI3tB,QAAUwyB,EAFV7E,EAEsBA,EAAI3sB,OAAO,EAAGwxB,GAAO,MAUnD,SAASC,EAAS1yB,EAAMiD,GAC3B,IAAI0vB,EAAU3yB,EACV4yB,EAAKD,EAAQ1yB,OACjB,GAAI2yB,GAAM,IACN,OAAOD,EAEP1vB,EAAQ2vB,IAER3vB,EAAQ2vB,GAEZ,IAAIC,EAAQlb,KAAK8a,IAAIxvB,EAAQ,GAAI,GAC7B4vB,EAAQ,IACRA,EAAQ,GAEZ,IAAIC,EAAMnb,KAAKC,IAAIib,EAAQ,IAAKD,GAchC,OAbIE,EAAMF,EAAK,IACXE,EAAMF,GAENE,IAAQF,IACRC,EAAQlb,KAAK8a,IAAIK,EAAM,IAAK,IAEhCH,EAAUA,EAAQtxB,MAAMwxB,EAAOC,GAC3BD,EAAQ,IACRF,EAAU,WAAaA,GAEvBG,EAAMF,IACND,GAAW,WAERA,EASJ,SAASI,EAASp0B,EAAOq0B,GAC5B,IAAKvxB,MAAMqN,QAAQnQ,GACf,MAAO,GAIX,IAFA,IAAIs0B,EAAS,GAEJnyB,EAAI,EAAGA,EAAInC,EAAMsB,OAAQa,IAAK,CACnC,IAAIwB,EAAQ3D,EAAMmC,GAClB,IACImyB,EAAOzyB,KAAKqe,OAAOvc,IAEvB,MAAO1B,GACHqyB,EAAOzyB,KAAK,iCAGpB,OAAOyyB,EAAOpjB,KAAKmjB,GAOhB,SAASE,EAAkB5wB,EAAOsmB,GACrC,QAAK,YAAStmB,KAGV,YAASsmB,GACFA,EAAQlpB,KAAK4C,GAED,iBAAZsmB,IAC4B,IAA5BtmB,EAAMtB,QAAQ4nB,M,sCC1F7B,oN,sCCSO,SAASuK,EAAQC,GACpB,OAAQ7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,IACnC,IAAK,iBAEL,IAAK,qBAEL,IAAK,wBACD,OAAO,EACX,QACI,OAAOC,EAAaD,EAAKv1B,QAU9B,SAASy1B,EAAaF,GACzB,MAA+C,wBAAxC7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,GASnC,SAASG,EAAWH,GACvB,MAA+C,sBAAxC7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,GASnC,SAASI,EAAeJ,GAC3B,MAA+C,0BAAxC7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,GASnC,SAASK,EAASL,GACrB,MAA+C,oBAAxC7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,GASnC,SAASM,EAAYN,GACxB,OAAe,OAARA,GAAgC,iBAARA,GAAmC,mBAARA,EASvD,SAASO,EAAcP,GAC1B,MAA+C,oBAAxC7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,GASnC,SAASQ,EAAQR,GACpB,MAAwB,oBAAVS,OAAyBR,EAAaD,EAAKS,OAStD,SAASC,EAAUV,GACtB,MAA0B,oBAAZW,SAA2BV,EAAaD,EAAKW,SASxD,SAASC,EAASZ,GACrB,MAA+C,oBAAxC7xB,OAAOlF,UAAUkM,SAASpG,KAAKixB,GAMnC,SAASa,EAAWb,GAEvB,OAAOc,QAAQd,GAAOA,EAAIt2B,MAA4B,mBAAbs2B,EAAIt2B,MAS1C,SAASq3B,EAAiBf,GAC7B,OAAOO,EAAcP,IAAQ,gBAAiBA,GAAO,mBAAoBA,GAAO,oBAAqBA,EAUlG,SAASC,EAAaD,EAAKgB,GAC9B,IACI,OAAOhB,aAAegB,EAE1B,MAAOvsB,GACH,OAAO,GA9If","file":"script/chunks/chunk.vendor-sentry.a88c3a19ca.js","sourcesContent":["import { logger, SentryError } from '@sentry/utils';\nimport { NoopTransport } from './transports/noop';\n/**\n * This is the base implemention of a Backend.\n * @hidden\n */\nvar BaseBackend = /** @class */ (function () {\n    /** Creates a new backend instance. */\n    function BaseBackend(options) {\n        this._options = options;\n        if (!this._options.dsn) {\n            logger.warn('No DSN provided, backend will not do anything.');\n        }\n        this._transport = this._setupTransport();\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseBackend.prototype.eventFromException = function (_exception, _hint) {\n        throw new SentryError('Backend has to implement `eventFromException` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {\n        throw new SentryError('Backend has to implement `eventFromMessage` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendEvent = function (event) {\n        this._transport.sendEvent(event).then(null, function (reason) {\n            logger.error(\"Error while sending event: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.sendSession = function (session) {\n        if (!this._transport.sendSession) {\n            logger.warn(\"Dropping session because custom transport doesn't implement sendSession\");\n            return;\n        }\n        this._transport.sendSession(session).then(null, function (reason) {\n            logger.error(\"Error while sending session: \" + reason);\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseBackend.prototype.getTransport = function () {\n        return this._transport;\n    };\n    /**\n     * Sets up the transport so it can be used later to send requests.\n     */\n    BaseBackend.prototype._setupTransport = function () {\n        return new NoopTransport();\n    };\n    return BaseBackend;\n}());\nexport { BaseBackend };\n//# sourceMappingURL=basebackend.js.map","import { __assign } from \"tslib\";\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, SyncPromise, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nexport function eventFromException(options, exception, hint) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    addExceptionMechanism(event, {\n        handled: true,\n        type: 'generic',\n    });\n    event.level = Severity.Error;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(options, message, level, hint) {\n    if (level === void 0) { level = Severity.Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event;\n    if (isErrorEvent(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        // eslint-disable-next-line no-param-reassign\n        exception = errorEvent.error;\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isDOMError(exception) || isDOMException(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name, code, and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\n        var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n        var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n        event = eventFromString(message, syntheticException, options);\n        addExceptionTypeValue(event, message);\n        if ('code' in domException) {\n            event.tags = __assign(__assign({}, event.tags), { 'DOMException.code': \"\" + domException.code });\n        }\n        return event;\n    }\n    if (isError(exception)) {\n        // we have a real Error object, do nothing\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, options.rejection);\n        addExceptionMechanism(event, {\n            synthetic: true,\n        });\n        return event;\n    }\n    // If none of previous checks were valid, then it means that it's not:\n    // - an instance of DOMError\n    // - an instance of DOMException\n    // - an instance of Event\n    // - an instance of Error\n    // - a valid ErrorEvent (one with an error property)\n    // - a plain Object\n    //\n    // So bail out and capture it as a simple message:\n    event = eventFromString(exception, syntheticException, options);\n    addExceptionTypeValue(event, \"\" + exception, undefined);\n    addExceptionMechanism(event, {\n        synthetic: true,\n    });\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromString(input, syntheticException, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map","/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\nimport { __assign } from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function computeStackTrace(ex) {\n    var stack = null;\n    var popSize = 0;\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            popSize = ex.framesToPop;\n        }\n        else if (reactMinifiedRegexp.test(ex.message)) {\n            popSize = 1;\n        }\n    }\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex) {\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\n                // throw out eval line/column and use top-most line/column number\n                parts[2] = submatch[1]; // url\n                parts[3] = submatch[2]; // line\n                parts[4] = submatch[3]; // column\n            }\n            element = {\n                // working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n                // prefix here seems like the quickest solution for now.\n                url: parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: isNative ? [parts[2]] : [],\n                line: parts[3] ? +parts[3] : null,\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\n                // throw out eval line/column and use top-most line number\n                parts[1] = parts[1] || \"eval\";\n                parts[3] = submatch[1];\n                parts[4] = submatch[2];\n                parts[5] = ''; // no column when eval\n            }\n            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            element = {\n                url: parts[3],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\n    }\n    // Access and store the stacktrace property before doing ANYTHING\n    // else to it because Opera is not very good at providing it\n    // reliably in other circumstances.\n    var stacktrace = ex.stacktrace;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return __assign(__assign({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\n    }\n}\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction extractMessage(ex) {\n    var message = ex && ex.message;\n    if (!message) {\n        return 'No error message';\n    }\n    if (message.error && typeof message.error.message === 'string') {\n        return message.error.message;\n    }\n    return message;\n}\n//# sourceMappingURL=tracekit.js.map","export var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n/**\n * setPrototypeOf polyfill using __proto__\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction setProtoOf(obj, proto) {\n    // @ts-ignore __proto__ does not exist on obj\n    obj.__proto__ = proto;\n    return obj;\n}\n/**\n * setPrototypeOf polyfill using mixin\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction mixinProperties(obj, proto) {\n    for (var prop in proto) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (!obj.hasOwnProperty(prop)) {\n            // @ts-ignore typescript complains about indexing so we remove\n            obj[prop] = proto[prop];\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=polyfill.js.map","import { __extends } from \"tslib\";\nimport { setPrototypeOf } from './polyfill';\n/** An error emitted by Sentry SDKs and related utilities. */\nvar SentryError = /** @class */ (function (_super) {\n    __extends(SentryError, _super);\n    function SentryError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.name = _newTarget.prototype.constructor.name;\n        setPrototypeOf(_this, _newTarget.prototype);\n        return _this;\n    }\n    return SentryError;\n}(Error));\nexport { SentryError };\n//# sourceMappingURL=error.js.map","import { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\nimport { computeStackTrace } from './tracekit';\nvar STACKTRACE_LIMIT = 50;\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nexport function eventFromPlainObject(exception, syntheticException, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\n    // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n    if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n        localStack = localStack.slice(1);\n    }\n    // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n    if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n        localStack = localStack.slice(0, -1);\n    }\n    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .slice(0, STACKTRACE_LIMIT)\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map","/** The status of an event. */\n// eslint-disable-next-line import/export\nexport var Status;\n(function (Status) {\n    /** The status could not be determined. */\n    Status[\"Unknown\"] = \"unknown\";\n    /** The event was skipped due to configuration or callbacks. */\n    Status[\"Skipped\"] = \"skipped\";\n    /** The event was sent to Sentry successfully. */\n    Status[\"Success\"] = \"success\";\n    /** The client is currently rate limited and will try again later. */\n    Status[\"RateLimit\"] = \"rate_limit\";\n    /** The event could not be processed. */\n    Status[\"Invalid\"] = \"invalid\";\n    /** A server-side error ocurred during submission. */\n    Status[\"Failed\"] = \"failed\";\n})(Status || (Status = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Status) {\n    /**\n     * Converts a HTTP status code into a {@link Status}.\n     *\n     * @param code The HTTP response status code.\n     * @returns The send status or {@link Status.Unknown}.\n     */\n    function fromHttpCode(code) {\n        if (code >= 200 && code < 300) {\n            return Status.Success;\n        }\n        if (code === 429) {\n            return Status.RateLimit;\n        }\n        if (code >= 400 && code < 500) {\n            return Status.Invalid;\n        }\n        if (code >= 500) {\n            return Status.Failed;\n        }\n        return Status.Unknown;\n    }\n    Status.fromHttpCode = fromHttpCode;\n})(Status || (Status = {}));\n//# sourceMappingURL=status.js.map","/**\n * Session Status\n */\nexport var SessionStatus;\n(function (SessionStatus) {\n    /** JSDoc */\n    SessionStatus[\"Ok\"] = \"ok\";\n    /** JSDoc */\n    SessionStatus[\"Exited\"] = \"exited\";\n    /** JSDoc */\n    SessionStatus[\"Crashed\"] = \"crashed\";\n    /** JSDoc */\n    SessionStatus[\"Abnormal\"] = \"abnormal\";\n})(SessionStatus || (SessionStatus = {}));\n//# sourceMappingURL=session.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event, hint) {\n            var self = getCurrentHub().getIntegration(LinkedErrors);\n            if (self) {\n                return self._handler(event, hint);\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = __spread(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = computeStackTrace(error[key]);\n        var exception = exceptionFromStacktrace(stacktrace);\n        return this._walkErrorTree(error[key], key, __spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map","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","import { __values } from \"tslib\";\nimport { API } from '@sentry/core';\nimport { Status, } from '@sentry/types';\nimport { logger, parseRetryAfterHeader, PromiseBuffer, SentryError } from '@sentry/utils';\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = new PromiseBuffer(30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._api = new API(options.dsn, options._metadata);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (_) {\n        throw new SentryError('Transport Class has to implement `sendEvent` method');\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    /**\n     * Handle Sentry repsonse for promise-based transports.\n     */\n    BaseTransport.prototype._handleResponse = function (_a) {\n        var requestType = _a.requestType, response = _a.response, headers = _a.headers, resolve = _a.resolve, reject = _a.reject;\n        var status = Status.fromHttpCode(response.status);\n        /**\n         * \"The name is case-insensitive.\"\n         * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n         */\n        var limited = this._handleRateLimit(headers);\n        if (limited)\n            logger.warn(\"Too many requests, backing off until: \" + this._disabledUntil(requestType));\n        if (status === Status.Success) {\n            resolve({ status: status });\n            return;\n        }\n        reject(response);\n    };\n    /**\n     * Gets the time that given category is disabled until for rate limiting\n     */\n    BaseTransport.prototype._disabledUntil = function (category) {\n        return this._rateLimits[category] || this._rateLimits.all;\n    };\n    /**\n     * Checks if a category is rate limited\n     */\n    BaseTransport.prototype._isRateLimited = function (category) {\n        return this._disabledUntil(category) > new Date(Date.now());\n    };\n    /**\n     * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n     */\n    BaseTransport.prototype._handleRateLimit = function (headers) {\n        var e_1, _a, e_2, _b;\n        var now = Date.now();\n        var rlHeader = headers['x-sentry-rate-limits'];\n        var raHeader = headers['retry-after'];\n        if (rlHeader) {\n            try {\n                // rate limit headers are of the form\n                //     <header>,<header>,..\n                // where each <header> is of the form\n                //     <retry_after>: <categories>: <scope>: <reason_code>\n                // where\n                //     <retry_after> is a delay in ms\n                //     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n                //         <category>;<category>;...\n                //     <scope> is what's being limited (org, project, or key) - ignored by SDK\n                //     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n                for (var _c = __values(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {\n                    var limit = _d.value;\n                    var parameters = limit.split(':', 2);\n                    var headerDelay = parseInt(parameters[0], 10);\n                    var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n                    try {\n                        for (var _e = (e_2 = void 0, __values(parameters[1].split(';'))), _f = _e.next(); !_f.done; _f = _e.next()) {\n                            var category = _f.value;\n                            this._rateLimits[category || 'all'] = new Date(now + delay);\n                        }\n                    }\n                    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                    finally {\n                        try {\n                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                        }\n                        finally { if (e_2) throw e_2.error; }\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            return true;\n        }\n        else if (raHeader) {\n            this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));\n            return true;\n        }\n        return false;\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import { logger } from './logger';\nimport { getGlobalObject } from './misc';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent() {\n    try {\n        new ErrorEvent('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError() {\n    try {\n        // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n        // 1 argument required, but only 0 present.\n        // @ts-ignore It really needs 1 argument, not 0.\n        new DOMError('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException() {\n    try {\n        new DOMException('');\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch() {\n    if (!('fetch' in getGlobalObject())) {\n        return false;\n    }\n    try {\n        new Headers();\n        new Request('');\n        new Response();\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFetch(func) {\n    return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch() {\n    if (!supportsFetch()) {\n        return false;\n    }\n    var global = getGlobalObject();\n    // Fast path to avoid DOM I/O\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    if (isNativeFetch(global.fetch)) {\n        return true;\n    }\n    // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n    // so create a \"pure\" iframe to see if that has native fetch\n    var result = false;\n    var doc = global.document;\n    // eslint-disable-next-line deprecation/deprecation\n    if (doc && typeof doc.createElement === \"function\") {\n        try {\n            var sandbox = doc.createElement('iframe');\n            sandbox.hidden = true;\n            doc.head.appendChild(sandbox);\n            if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                // eslint-disable-next-line @typescript-eslint/unbound-method\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n            }\n            doc.head.removeChild(sandbox);\n        }\n        catch (err) {\n            logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n        }\n    }\n    return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver() {\n    return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy() {\n    // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n    // https://caniuse.com/#feat=referrer-policy\n    // It doesn't. And it throw exception instead of ignoring this parameter...\n    // REF: https://github.com/getsentry/raven-js/issues/1233\n    if (!supportsFetch()) {\n        return false;\n    }\n    try {\n        new Request('_', {\n            referrerPolicy: 'origin',\n        });\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory() {\n    // NOTE: in Chrome App environment, touching history.pushState, *even inside\n    //       a try/catch block*, will cause Chrome to output an error to console.error\n    // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n    var global = getGlobalObject();\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var chrome = global.chrome;\n    var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n    return !isChromePackagedApp && hasHistoryApi;\n}\n//# sourceMappingURL=supports.js.map","/** JSDoc */\n// eslint-disable-next-line import/export\nexport var Severity;\n(function (Severity) {\n    /** JSDoc */\n    Severity[\"Fatal\"] = \"fatal\";\n    /** JSDoc */\n    Severity[\"Error\"] = \"error\";\n    /** JSDoc */\n    Severity[\"Warning\"] = \"warning\";\n    /** JSDoc */\n    Severity[\"Log\"] = \"log\";\n    /** JSDoc */\n    Severity[\"Info\"] = \"info\";\n    /** JSDoc */\n    Severity[\"Debug\"] = \"debug\";\n    /** JSDoc */\n    Severity[\"Critical\"] = \"critical\";\n})(Severity || (Severity = {}));\n// eslint-disable-next-line @typescript-eslint/no-namespace, import/export\n(function (Severity) {\n    /**\n     * Converts a string-based level into a {@link Severity}.\n     *\n     * @param level string representation of Severity\n     * @returns Severity\n     */\n    function fromString(level) {\n        switch (level) {\n            case 'debug':\n                return Severity.Debug;\n            case 'info':\n                return Severity.Info;\n            case 'warn':\n            case 'warning':\n                return Severity.Warning;\n            case 'error':\n                return Severity.Error;\n            case 'fatal':\n                return Severity.Fatal;\n            case 'critical':\n                return Severity.Critical;\n            case 'log':\n            default:\n                return Severity.Log;\n        }\n    }\n    Severity.fromString = fromString;\n})(Severity || (Severity = {}));\n//# sourceMappingURL=severity.js.map","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 { __assign, __read, __spread } from \"tslib\";\nimport { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = __spread(scope._breadcrumbs);\n            newScope._tags = __assign({}, scope._tags);\n            newScope._extra = __assign({}, scope._extra);\n            newScope._contexts = __assign({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._session = scope._session;\n            newScope._transactionName = scope._transactionName;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = __spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = __assign(__assign({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = __assign(__assign({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = __assign(__assign({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = __assign(__assign({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        var _a, _b, _c, _d;\n        // often, this span will be a transaction, but it's not guaranteed to be\n        var span = this.getSpan();\n        // try it the new way first\n        if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {\n            return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;\n        }\n        // fallback to the old way (known bug: this only finds transactions with sampled = true)\n        if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {\n            return span.spanRecorder.spans[0];\n        }\n        // neither way found a transaction\n        return undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = __assign(__assign({}, this._tags), captureContext._tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext._extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext._contexts);\n            if (captureContext._user && Object.keys(captureContext._user).length) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n        }\n        else if (isPlainObject(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = __assign(__assign({}, this._tags), captureContext.tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext.extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transactionName = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._session = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : __spread(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        var _a;\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = __assign(__assign({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = __assign(__assign({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = __assign(__assign({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = __assign(__assign({}, this._contexts), event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transactionName) {\n            event.transaction = this._transactionName;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relys on that.\n        if (this._span) {\n            event.contexts = __assign({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;\n            if (transactionName) {\n                event.tags = __assign({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        // We need this check for this._notifyingListeners to be able to work on scope during updates\n        // If this check is not here we'll produce endless recursion when something is done with the scope\n        // during the callback.\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            this._scopeListeners.forEach(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\n        }\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","import { isString } from './is';\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(elem) {\n    // try/catch both:\n    // - accessing event.target (see getsentry/raven-js#838, #768)\n    // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n    // - can throw an exception in some circumstances.\n    try {\n        var currentElem = elem;\n        var MAX_TRAVERSE_HEIGHT = 5;\n        var MAX_OUTPUT_LEN = 80;\n        var out = [];\n        var height = 0;\n        var len = 0;\n        var separator = ' > ';\n        var sepLength = separator.length;\n        var nextStr = void 0;\n        // eslint-disable-next-line no-plusplus\n        while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n            nextStr = _htmlElementAsString(currentElem);\n            // bail out if\n            // - nextStr is the 'html' element\n            // - the length of the string that would be created exceeds MAX_OUTPUT_LEN\n            //   (ignore this limit if we are on the first iteration)\n            if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\n                break;\n            }\n            out.push(nextStr);\n            len += nextStr.length;\n            currentElem = currentElem.parentNode;\n        }\n        return out.reverse().join(separator);\n    }\n    catch (_oO) {\n        return '<unknown>';\n    }\n}\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el) {\n    var elem = el;\n    var out = [];\n    var className;\n    var classes;\n    var key;\n    var attr;\n    var i;\n    if (!elem || !elem.tagName) {\n        return '';\n    }\n    out.push(elem.tagName.toLowerCase());\n    if (elem.id) {\n        out.push(\"#\" + elem.id);\n    }\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n        classes = className.split(/\\s+/);\n        for (i = 0; i < classes.length; i++) {\n            out.push(\".\" + classes[i]);\n        }\n    }\n    var allowedAttrs = ['type', 'name', 'title', 'alt'];\n    for (i = 0; i < allowedAttrs.length; i++) {\n        key = allowedAttrs[i];\n        attr = elem.getAttribute(key);\n        if (attr) {\n            out.push(\"[\" + key + \"=\\\"\" + attr + \"\\\"]\");\n        }\n    }\n    return out.join('');\n}\n//# sourceMappingURL=browser.js.map","import { __assign, __read, __spread } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, parseUrl, safeJoin, } from '@sentry/utils';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = __assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Create a breadcrumb of `sentry` from the events themselves\n     */\n    Breadcrumbs.prototype.addSentryBreadcrumb = function (event) {\n        if (!this._options.sentry) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"sentry.\" + (event.type === 'transaction' ? 'transaction' : 'event'),\n            event_id: event.event_id,\n            level: event.level,\n            message: getEventDescription(event),\n        }, {\n            event: event,\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    Breadcrumbs.prototype.setupOnce = function () {\n        var _this = this;\n        if (this._options.console) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console',\n            },\n            level: Severity.fromString(handlerData.level),\n            message: safeJoin(handlerData.args, ' '),\n        };\n        if (handlerData.level === 'assert') {\n            if (handlerData.args[0] === false) {\n                breadcrumb.message = \"Assertion failed: \" + (safeJoin(handlerData.args.slice(1), ' ') || 'console.assert');\n                breadcrumb.data.arguments = handlerData.args.slice(1);\n            }\n            else {\n                // Don't capture a breadcrumb for passed assertions\n                return;\n            }\n        }\n        getCurrentHub().addBreadcrumb(breadcrumb, {\n            input: handlerData.args,\n            level: handlerData.level,\n        });\n    };\n    /**\n     * Creates breadcrumbs from DOM API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? htmlTreeAsString(handlerData.event.target)\n                : htmlTreeAsString(handlerData.event);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: handlerData.event,\n            name: handlerData.name,\n        });\n    };\n    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._xhrBreadcrumb = function (handlerData) {\n        if (handlerData.endTimestamp) {\n            // We only capture complete, non-sentry requests\n            if (handlerData.xhr.__sentry_own_request__) {\n                return;\n            }\n            var _a = handlerData.xhr.__sentry_xhr__ || {}, method = _a.method, url = _a.url, status_code = _a.status_code, body = _a.body;\n            getCurrentHub().addBreadcrumb({\n                category: 'xhr',\n                data: {\n                    method: method,\n                    url: url,\n                    status_code: status_code,\n                },\n                type: 'http',\n            }, {\n                xhr: handlerData.xhr,\n                input: body,\n            });\n            return;\n        }\n    };\n    /**\n     * Creates breadcrumbs from fetch API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._fetchBreadcrumb = function (handlerData) {\n        // We only capture complete fetch requests\n        if (!handlerData.endTimestamp) {\n            return;\n        }\n        if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n            // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n            return;\n        }\n        if (handlerData.error) {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: handlerData.fetchData,\n                level: Severity.Error,\n                type: 'http',\n            }, {\n                data: handlerData.error,\n                input: handlerData.args,\n            });\n        }\n        else {\n            getCurrentHub().addBreadcrumb({\n                category: 'fetch',\n                data: __assign(__assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),\n                type: 'http',\n            }, {\n                input: handlerData.args,\n                response: handlerData.response,\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from history API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._historyBreadcrumb = function (handlerData) {\n        var global = getGlobalObject();\n        var from = handlerData.from;\n        var to = handlerData.to;\n        var parsedLoc = parseUrl(global.location.href);\n        var parsedFrom = parseUrl(from);\n        var parsedTo = parseUrl(to);\n        // Initial pushState doesn't provide `from` information\n        if (!parsedFrom.path) {\n            parsedFrom = parsedLoc;\n        }\n        // Use only the path component of the URL if the URL matches the current\n        // document (almost all the time when using pushState)\n        if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n            to = parsedTo.relative;\n        }\n        if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n            from = parsedFrom.relative;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: 'navigation',\n            data: {\n                from: from,\n                to: to,\n            },\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseBackend } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    __extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        return eventFromException(this._options, exception, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        return eventFromMessage(this._options, message, level, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, _metadata: this._options._metadata });\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            return new FetchTransport(transportOptions);\n        }\n        return new XHRTransport(transportOptions);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseClient } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { injectReportDialog } from './helpers';\nimport { Breadcrumbs } from './integrations';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    __extends(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        return _super.call(this, BrowserBackend, options) || this;\n    }\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = getGlobalObject().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            logger.error('Trying to call showReportDialog with Sentry Client disabled');\n            return;\n        }\n        injectReportDialog(__assign(__assign({}, options), { dsn: options.dsn || this.getDsn() }));\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._sendEvent = function (event) {\n        var integration = this.getIntegration(Breadcrumbs);\n        if (integration) {\n            integration.addSentryBreadcrumb(event);\n        }\n        _super.prototype._sendEvent.call(this, event);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map","import { getGlobalObject } from './misc';\nimport { dynamicRequire, isNodeEnv } from './node';\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n    nowSeconds: function () { return Date.now() / 1000; },\n};\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n    var performance = getGlobalObject().performance;\n    if (!performance || !performance.now) {\n        return undefined;\n    }\n    // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n    //\n    // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n    // performance.now() gives a date arbitrarily in the past.\n    //\n    // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n    // undefined.\n    //\n    // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n    // interact with data coming out of performance entries.\n    //\n    // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n    // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n    // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n    // observed skews that can be as long as days, weeks or months.\n    //\n    // See https://github.com/getsentry/sentry-javascript/issues/2590.\n    //\n    // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n    // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n    // transactions of long-lived web pages.\n    var timeOrigin = Date.now() - performance.now();\n    return {\n        now: function () { return performance.now(); },\n        timeOrigin: timeOrigin,\n    };\n}\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n    try {\n        var perfHooks = dynamicRequire(module, 'perf_hooks');\n        return perfHooks.performance;\n    }\n    catch (_) {\n        return undefined;\n    }\n}\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\nvar timestampSource = platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },\n    };\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n// Re-exported with an old name for backwards-compatibility.\nexport var timestampWithMs = timestampInSeconds;\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nexport var usingPerformanceAPI = platformPerformance !== undefined;\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport var browserPerformanceTimeOrigin = (function () {\n    var performance = getGlobalObject().performance;\n    if (!performance) {\n        return undefined;\n    }\n    if (performance.timeOrigin) {\n        return performance.timeOrigin;\n    }\n    // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n    // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n    // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n    // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n    // Date API.\n    // eslint-disable-next-line deprecation/deprecation\n    return (performance.timing && performance.timing.navigationStart) || Date.now();\n})();\n//# sourceMappingURL=time.js.map","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.\n */\nvar Memo = /** @class */ (function () {\n    function Memo() {\n        this._hasWeakSet = typeof WeakSet === 'function';\n        this._inner = this._hasWeakSet ? new WeakSet() : [];\n    }\n    /**\n     * Sets obj to remember.\n     * @param obj Object to remember\n     */\n    Memo.prototype.memoize = function (obj) {\n        if (this._hasWeakSet) {\n            if (this._inner.has(obj)) {\n                return true;\n            }\n            this._inner.add(obj);\n            return false;\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\n        for (var i = 0; i < this._inner.length; i++) {\n            var value = this._inner[i];\n            if (value === obj) {\n                return true;\n            }\n        }\n        this._inner.push(obj);\n        return false;\n    };\n    /**\n     * Removes object from internal storage.\n     * @param obj Object to forget\n     */\n    Memo.prototype.unmemoize = function (obj) {\n        if (this._hasWeakSet) {\n            this._inner.delete(obj);\n        }\n        else {\n            for (var i = 0; i < this._inner.length; i++) {\n                if (this._inner[i] === obj) {\n                    this._inner.splice(i, 1);\n                    break;\n                }\n            }\n        }\n    };\n    return Memo;\n}());\nexport { Memo };\n//# sourceMappingURL=memo.js.map","import { SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, uuid4 } from '@sentry/utils';\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = uuid4();\n        this.timestamp = Date.now();\n        this.started = Date.now();\n        this.duration = 0;\n        this.status = SessionStatus.Ok;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || Date.now();\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : uuid4();\n        }\n        if (context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            this.duration = this.timestamp - this.started;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === SessionStatus.Ok) {\n            this.update({ status: SessionStatus.Exited });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return dropUndefinedKeys({\n            sid: \"\" + this.sid,\n            init: true,\n            started: new Date(this.started).toISOString(),\n            timestamp: new Date(this.timestamp).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: dropUndefinedKeys({\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            }),\n        });\n    };\n    return Session;\n}());\nexport { Session };\n//# sourceMappingURL=session.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, isNodeEnv, logger, uuid4 } from '@sentry/utils';\nimport { Scope } from './scope';\nimport { Session } from './session';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        this.bindClient(client);\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var scope = Scope.clone(this.getScope());\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = dateTimestampInSeconds();\n        var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        // End existing session if there's one\n        this.endSession();\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        var session = new Session(__assign(__assign({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), context));\n        if (scope) {\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            session.close();\n            if (client && client.captureSession) {\n                client.captureSession(session);\n            }\n            scope.setSession();\n        }\n    };\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, __spread(args, [scope]));\n        }\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/** Returns the global shim registry. */\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Returns the active domain, if one exists\n *\n * @returns The domain, or undefined if there is no active domain\n */\nexport function getActiveDomain() {\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n}\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var activeDomain = getActiveDomain();\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or it's an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)\n        return carrier.__SENTRY__.hub;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { __assign } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var _a, _b, _c;\n            if (getCurrentHub().getIntegration(UserAgent)) {\n                // if none of the information we want exists, don't bother\n                if (!global.navigator && !global.location && !global.document) {\n                    return event;\n                }\n                // grab as much info as exists and add it to the event\n                var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global.location) === null || _b === void 0 ? void 0 : _b.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = __assign(__assign(__assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));\n                var request = __assign(__assign({}, (url && { url: url })), { headers: headers });\n                return __assign(__assign({}, event), { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\nexport { UserAgent };\n//# sourceMappingURL=useragent.js.map","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n/** SyncPromise internal states */\nvar States;\n(function (States) {\n    /** Pending */\n    States[\"PENDING\"] = \"PENDING\";\n    /** Resolved / OK */\n    States[\"RESOLVED\"] = \"RESOLVED\";\n    /** Rejected / Error */\n    States[\"REJECTED\"] = \"REJECTED\";\n})(States || (States = {}));\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nvar SyncPromise = /** @class */ (function () {\n    function SyncPromise(executor) {\n        var _this = this;\n        this._state = States.PENDING;\n        this._handlers = [];\n        /** JSDoc */\n        this._resolve = function (value) {\n            _this._setResult(States.RESOLVED, value);\n        };\n        /** JSDoc */\n        this._reject = function (reason) {\n            _this._setResult(States.REJECTED, reason);\n        };\n        /** JSDoc */\n        this._setResult = function (state, value) {\n            if (_this._state !== States.PENDING) {\n                return;\n            }\n            if (isThenable(value)) {\n                value.then(_this._resolve, _this._reject);\n                return;\n            }\n            _this._state = state;\n            _this._value = value;\n            _this._executeHandlers();\n        };\n        // TODO: FIXME\n        /** JSDoc */\n        this._attachHandler = function (handler) {\n            _this._handlers = _this._handlers.concat(handler);\n            _this._executeHandlers();\n        };\n        /** JSDoc */\n        this._executeHandlers = function () {\n            if (_this._state === States.PENDING) {\n                return;\n            }\n            var cachedHandlers = _this._handlers.slice();\n            _this._handlers = [];\n            cachedHandlers.forEach(function (handler) {\n                if (handler.done) {\n                    return;\n                }\n                if (_this._state === States.RESOLVED) {\n                    if (handler.onfulfilled) {\n                        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                        handler.onfulfilled(_this._value);\n                    }\n                }\n                if (_this._state === States.REJECTED) {\n                    if (handler.onrejected) {\n                        handler.onrejected(_this._value);\n                    }\n                }\n                handler.done = true;\n            });\n        };\n        try {\n            executor(this._resolve, this._reject);\n        }\n        catch (e) {\n            this._reject(e);\n        }\n    }\n    /** JSDoc */\n    SyncPromise.resolve = function (value) {\n        return new SyncPromise(function (resolve) {\n            resolve(value);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.reject = function (reason) {\n        return new SyncPromise(function (_, reject) {\n            reject(reason);\n        });\n    };\n    /** JSDoc */\n    SyncPromise.all = function (collection) {\n        return new SyncPromise(function (resolve, reject) {\n            if (!Array.isArray(collection)) {\n                reject(new TypeError(\"Promise.all requires an array as input.\"));\n                return;\n            }\n            if (collection.length === 0) {\n                resolve([]);\n                return;\n            }\n            var counter = collection.length;\n            var resolvedCollection = [];\n            collection.forEach(function (item, index) {\n                SyncPromise.resolve(item)\n                    .then(function (value) {\n                    resolvedCollection[index] = value;\n                    counter -= 1;\n                    if (counter !== 0) {\n                        return;\n                    }\n                    resolve(resolvedCollection);\n                })\n                    .then(null, reject);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.then = function (onfulfilled, onrejected) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            _this._attachHandler({\n                done: false,\n                onfulfilled: function (result) {\n                    if (!onfulfilled) {\n                        // TODO: ¯\\_(ツ)_/¯\n                        // TODO: FIXME\n                        resolve(result);\n                        return;\n                    }\n                    try {\n                        resolve(onfulfilled(result));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n                onrejected: function (reason) {\n                    if (!onrejected) {\n                        reject(reason);\n                        return;\n                    }\n                    try {\n                        resolve(onrejected(reason));\n                        return;\n                    }\n                    catch (e) {\n                        reject(e);\n                        return;\n                    }\n                },\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.catch = function (onrejected) {\n        return this.then(function (val) { return val; }, onrejected);\n    };\n    /** JSDoc */\n    SyncPromise.prototype.finally = function (onfinally) {\n        var _this = this;\n        return new SyncPromise(function (resolve, reject) {\n            var val;\n            var isRejected;\n            return _this.then(function (value) {\n                isRejected = false;\n                val = value;\n                if (onfinally) {\n                    onfinally();\n                }\n            }, function (reason) {\n                isRejected = true;\n                val = reason;\n                if (onfinally) {\n                    onfinally();\n                }\n            }).then(function () {\n                if (isRejected) {\n                    reject(val);\n                    return;\n                }\n                resolve(val);\n            });\n        });\n    };\n    /** JSDoc */\n    SyncPromise.prototype.toString = function () {\n        return '[object SyncPromise]';\n    };\n    return SyncPromise;\n}());\nexport { SyncPromise };\n//# sourceMappingURL=syncpromise.js.map","import { isNodeEnv } from './node';\nimport { snipLine } from './string';\nvar fallbackGlobalObject = {};\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nexport function getGlobalObject() {\n    return (isNodeEnv()\n        ? global\n        : typeof window !== 'undefined'\n            ? window\n            : typeof self !== 'undefined'\n                ? self\n                : fallbackGlobalObject);\n}\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4() {\n    var global = getGlobalObject();\n    var crypto = global.crypto || global.msCrypto;\n    if (!(crypto === void 0) && crypto.getRandomValues) {\n        // Use window.crypto API if available\n        var arr = new Uint16Array(8);\n        crypto.getRandomValues(arr);\n        // set 4 in byte 7\n        // eslint-disable-next-line no-bitwise\n        arr[3] = (arr[3] & 0xfff) | 0x4000;\n        // set 2 most significant bits of byte 9 to '10'\n        // eslint-disable-next-line no-bitwise\n        arr[4] = (arr[4] & 0x3fff) | 0x8000;\n        var pad = function (num) {\n            var v = num.toString(16);\n            while (v.length < 4) {\n                v = \"0\" + v;\n            }\n            return v;\n        };\n        return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));\n    }\n    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n        // eslint-disable-next-line no-bitwise\n        var r = (Math.random() * 16) | 0;\n        // eslint-disable-next-line no-bitwise\n        var v = c === 'x' ? r : (r & 0x3) | 0x8;\n        return v.toString(16);\n    });\n}\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url) {\n    if (!url) {\n        return {};\n    }\n    var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n    if (!match) {\n        return {};\n    }\n    // coerce to undefined values to empty string so we don't get 'undefined'\n    var query = match[6] || '';\n    var fragment = match[8] || '';\n    return {\n        host: match[4],\n        path: match[5],\n        protocol: match[2],\n        relative: match[5] + query + fragment,\n    };\n}\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event) {\n    if (event.message) {\n        return event.message;\n    }\n    if (event.exception && event.exception.values && event.exception.values[0]) {\n        var exception = event.exception.values[0];\n        if (exception.type && exception.value) {\n            return exception.type + \": \" + exception.value;\n        }\n        return exception.type || exception.value || event.event_id || '<unknown>';\n    }\n    return event.event_id || '<unknown>';\n}\n/** JSDoc */\nexport function consoleSandbox(callback) {\n    var global = getGlobalObject();\n    var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];\n    if (!('console' in global)) {\n        return callback();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var originalConsole = global.console;\n    var wrappedLevels = {};\n    // Restore all wrapped console methods\n    levels.forEach(function (level) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (level in global.console && originalConsole[level].__sentry_original__) {\n            wrappedLevels[level] = originalConsole[level];\n            originalConsole[level] = originalConsole[level].__sentry_original__;\n        }\n    });\n    // Perform callback manipulations\n    var result = callback();\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(function (level) {\n        originalConsole[level] = wrappedLevels[level];\n    });\n    return result;\n}\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event, value, type) {\n    event.exception = event.exception || {};\n    event.exception.values = event.exception.values || [];\n    event.exception.values[0] = event.exception.values[0] || {};\n    event.exception.values[0].value = event.exception.values[0].value || value || '';\n    event.exception.values[0].type = event.exception.values[0].type || type || 'Error';\n}\n/**\n * Adds exception mechanism to a given event.\n * @param event The event to modify.\n * @param mechanism Mechanism of the mechanism.\n * @hidden\n */\nexport function addExceptionMechanism(event, mechanism) {\n    if (mechanism === void 0) { mechanism = {}; }\n    // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?\n    try {\n        // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};\n        Object.keys(mechanism).forEach(function (key) {\n            // @ts-ignore Mechanism has no index signature\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            event.exception.values[0].mechanism[key] = mechanism[key];\n        });\n    }\n    catch (_oO) {\n        // no-empty\n    }\n}\n/**\n * A safe form of location.href\n */\nexport function getLocationHref() {\n    try {\n        return document.location.href;\n    }\n    catch (oO) {\n        return '';\n    }\n}\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input) {\n    var match = input.match(SEMVER_REGEXP) || [];\n    var major = parseInt(match[1], 10);\n    var minor = parseInt(match[2], 10);\n    var patch = parseInt(match[3], 10);\n    return {\n        buildmetadata: match[5],\n        major: isNaN(major) ? undefined : major,\n        minor: isNaN(minor) ? undefined : minor,\n        patch: isNaN(patch) ? undefined : patch,\n        prerelease: match[4],\n    };\n}\nvar defaultRetryAfter = 60 * 1000; // 60 seconds\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param now current unix timestamp\n * @param header string representation of 'Retry-After' header\n */\nexport function parseRetryAfterHeader(now, header) {\n    if (!header) {\n        return defaultRetryAfter;\n    }\n    var headerDelay = parseInt(\"\" + header, 10);\n    if (!isNaN(headerDelay)) {\n        return headerDelay * 1000;\n    }\n    var headerDate = Date.parse(\"\" + header);\n    if (!isNaN(headerDate)) {\n        return headerDate - now;\n    }\n    return defaultRetryAfter;\n}\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines, frame, linesOfContext) {\n    if (linesOfContext === void 0) { linesOfContext = 5; }\n    var lineno = frame.lineno || 0;\n    var maxLines = lines.length;\n    var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n    frame.pre_context = lines\n        .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n        .map(function (line) { return snipLine(line, 0); });\n    frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n    frame.post_context = lines\n        .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n        .map(function (line) { return snipLine(line, 0); });\n}\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath) {\n    // eslint-disable-next-line no-useless-escape\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n//# sourceMappingURL=misc.js.map","import { __assign } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addInstrumentationHandler, getLocationHref, isErrorEvent, isPrimitive, isString, logger, } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = __assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        var _this = this;\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (data) {\n                var error = data.error;\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n                    : _this._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: false,\n                    }), data.url, data.line, data.column);\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onerror',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n            },\n            type: 'error',\n        });\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        var _this = this;\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (e) {\n                var error = e;\n                // dig the object of the rejection out of known event types\n                try {\n                    // PromiseRejectionEvents store the object of the rejection under 'reason'\n                    // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n                    if ('reason' in e) {\n                        error = e.reason;\n                    }\n                    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n                    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n                    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n                    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n                    // https://github.com/getsentry/sentry-javascript/issues/2380\n                    else if ('detail' in e && 'reason' in e.detail) {\n                        error = e.detail.reason;\n                    }\n                }\n                catch (_oO) {\n                    // no-empty\n                }\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return true;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromRejectionWithPrimitive(error)\n                    : eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: true,\n                    });\n                event.level = Severity.Error;\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onunhandledrejection',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n                return;\n            },\n            type: 'unhandledrejection',\n        });\n        this._onUnhandledRejectionHandlerInstalled = true;\n    };\n    /**\n     * This function creates a stack from an old, error-less onerror handler.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (msg, url, line, column) {\n        var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n        // If 'message' is ErrorEvent, get real message from inside\n        var message = isErrorEvent(msg) ? msg.message : msg;\n        var name;\n        if (isString(message)) {\n            var groups = message.match(ERROR_TYPES_RE);\n            if (groups) {\n                name = groups[1];\n                message = groups[2];\n            }\n        }\n        var event = {\n            exception: {\n                values: [\n                    {\n                        type: name || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\n    };\n    /**\n     * Create an event from a promise rejection where the `reason` is a primitive.\n     *\n     * @param reason: The `reason` property of the promise rejection\n     * @returns An Event object with an appropriate `exception` value\n     */\n    GlobalHandlers.prototype._eventFromRejectionWithPrimitive = function (reason) {\n        return {\n            exception: {\n                values: [\n                    {\n                        type: 'UnhandledRejection',\n                        // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n                        value: \"Non-Error promise rejection captured with value: \" + String(reason),\n                    },\n                ],\n            },\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];\n        var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n        var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n        var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\nexport var installedIntegrations = [];\n/** Gets integration to install */\nexport function getIntegrationsToSetup(options) {\n    var defaultIntegrations = (options.defaultIntegrations && __spread(options.defaultIntegrations)) || [];\n    var userIntegrations = options.integrations;\n    var integrations = [];\n    if (Array.isArray(userIntegrations)) {\n        var userIntegrationsNames_1 = userIntegrations.map(function (i) { return i.name; });\n        var pickedIntegrationsNames_1 = [];\n        // Leave only unique default integrations, that were not overridden with provided user integrations\n        defaultIntegrations.forEach(function (defaultIntegration) {\n            if (userIntegrationsNames_1.indexOf(defaultIntegration.name) === -1 &&\n                pickedIntegrationsNames_1.indexOf(defaultIntegration.name) === -1) {\n                integrations.push(defaultIntegration);\n                pickedIntegrationsNames_1.push(defaultIntegration.name);\n            }\n        });\n        // Don't add same user integration twice\n        userIntegrations.forEach(function (userIntegration) {\n            if (pickedIntegrationsNames_1.indexOf(userIntegration.name) === -1) {\n                integrations.push(userIntegration);\n                pickedIntegrationsNames_1.push(userIntegration.name);\n            }\n        });\n    }\n    else if (typeof userIntegrations === 'function') {\n        integrations = userIntegrations(defaultIntegrations);\n        integrations = Array.isArray(integrations) ? integrations : [integrations];\n    }\n    else {\n        integrations = __spread(defaultIntegrations);\n    }\n    // Make sure that if present, `Debug` integration will always run last\n    var integrationsNames = integrations.map(function (i) { return i.name; });\n    var alwaysLastToRun = 'Debug';\n    if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n        integrations.push.apply(integrations, __spread(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));\n    }\n    return integrations;\n}\n/** Setup given integration */\nexport function setupIntegration(integration) {\n    if (installedIntegrations.indexOf(integration.name) !== -1) {\n        return;\n    }\n    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n    installedIntegrations.push(integration.name);\n    logger.log(\"Integration installed: \" + integration.name);\n}\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(options) {\n    var integrations = {};\n    getIntegrationsToSetup(options).forEach(function (integration) {\n        integrations[integration.name] = integration;\n        setupIntegration(integration);\n    });\n    return integrations;\n}\n//# sourceMappingURL=integration.js.map","import { __assign, __values } from \"tslib\";\n/* eslint-disable max-lines */\nimport { Scope } from '@sentry/hub';\nimport { SessionStatus, } from '@sentry/types';\nimport { dateTimestampInSeconds, Dsn, isPrimitive, isThenable, logger, normalize, SentryError, SyncPromise, truncate, uuid4, } from '@sentry/utils';\nimport { setupIntegrations } from './integration';\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding backend constructor and options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}. Also, the Backend instance is available via\n * {@link Client.getBackend}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event via the backend, it is passed through\n * {@link BaseClient.prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeBackend, NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(NodeBackend, options);\n *   }\n *\n *   // ...\n * }\n */\nvar BaseClient = /** @class */ (function () {\n    /**\n     * Initializes this client instance.\n     *\n     * @param backendClass A constructor function to create the backend.\n     * @param options Options for the client.\n     */\n    function BaseClient(backendClass, options) {\n        /** Array of used integrations. */\n        this._integrations = {};\n        /** Number of call being processed */\n        this._processing = 0;\n        this._backend = new backendClass(options);\n        this._options = options;\n        if (options.dsn) {\n            this._dsn = new Dsn(options.dsn);\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    BaseClient.prototype.captureException = function (exception, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        this._process(this._getBackend()\n            .eventFromException(exception, hint)\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureMessage = function (message, level, hint, scope) {\n        var _this = this;\n        var eventId = hint && hint.event_id;\n        var promisedEvent = isPrimitive(message)\n            ? this._getBackend().eventFromMessage(String(message), level, hint)\n            : this._getBackend().eventFromException(message, hint);\n        this._process(promisedEvent\n            .then(function (event) { return _this._captureEvent(event, hint, scope); })\n            .then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureEvent = function (event, hint, scope) {\n        var eventId = hint && hint.event_id;\n        this._process(this._captureEvent(event, hint, scope).then(function (result) {\n            eventId = result;\n        }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.captureSession = function (session) {\n        if (!session.release) {\n            logger.warn('Discarded session because of missing release');\n        }\n        else {\n            this._sendSession(session);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getDsn = function () {\n        return this._dsn;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getOptions = function () {\n        return this._options;\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.flush = function (timeout) {\n        var _this = this;\n        return this._isClientProcessing(timeout).then(function (ready) {\n            return _this._getBackend()\n                .getTransport()\n                .close(timeout)\n                .then(function (transportFlushed) { return ready && transportFlushed; });\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.close = function (timeout) {\n        var _this = this;\n        return this.flush(timeout).then(function (result) {\n            _this.getOptions().enabled = false;\n            return result;\n        });\n    };\n    /**\n     * Sets up the integrations\n     */\n    BaseClient.prototype.setupIntegrations = function () {\n        if (this._isEnabled()) {\n            this._integrations = setupIntegrations(this._options);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseClient.prototype.getIntegration = function (integration) {\n        try {\n            return this._integrations[integration.id] || null;\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Client\");\n            return null;\n        }\n    };\n    /** Updates existing session based on the provided event */\n    BaseClient.prototype._updateSessionFromEvent = function (session, event) {\n        var e_1, _a;\n        var crashed = false;\n        var errored = false;\n        var userAgent;\n        var exceptions = event.exception && event.exception.values;\n        if (exceptions) {\n            errored = true;\n            try {\n                for (var exceptions_1 = __values(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {\n                    var ex = exceptions_1_1.value;\n                    var mechanism = ex.mechanism;\n                    if (mechanism && mechanism.handled === false) {\n                        crashed = true;\n                        break;\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n        }\n        var user = event.user;\n        if (!session.userAgent) {\n            var headers = event.request ? event.request.headers : {};\n            for (var key in headers) {\n                if (key.toLowerCase() === 'user-agent') {\n                    userAgent = headers[key];\n                    break;\n                }\n            }\n        }\n        session.update(__assign(__assign({}, (crashed && { status: SessionStatus.Crashed })), { user: user,\n            userAgent: userAgent, errors: session.errors + Number(errored || crashed) }));\n    };\n    /** Deliver captured session to Sentry */\n    BaseClient.prototype._sendSession = function (session) {\n        this._getBackend().sendSession(session);\n    };\n    /** Waits for the client to be done with processing. */\n    BaseClient.prototype._isClientProcessing = function (timeout) {\n        var _this = this;\n        return new SyncPromise(function (resolve) {\n            var ticked = 0;\n            var tick = 1;\n            var interval = setInterval(function () {\n                if (_this._processing == 0) {\n                    clearInterval(interval);\n                    resolve(true);\n                }\n                else {\n                    ticked += tick;\n                    if (timeout && ticked >= timeout) {\n                        clearInterval(interval);\n                        resolve(false);\n                    }\n                }\n            }, tick);\n        });\n    };\n    /** Returns the current backend. */\n    BaseClient.prototype._getBackend = function () {\n        return this._backend;\n    };\n    /** Determines whether this SDK is enabled and a valid Dsn is present. */\n    BaseClient.prototype._isEnabled = function () {\n        return this.getOptions().enabled !== false && this._dsn !== undefined;\n    };\n    /**\n     * Adds common information to events.\n     *\n     * The information includes release and environment from `options`,\n     * breadcrumbs and context (extra, tags and user) from the scope.\n     *\n     * Information that is already present in the event is never overwritten. For\n     * nested objects, such as the context, keys are merged.\n     *\n     * @param event The original event.\n     * @param hint May contain additional information about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A new event with more information.\n     */\n    BaseClient.prototype._prepareEvent = function (event, scope, hint) {\n        var _this = this;\n        var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;\n        var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });\n        this._applyClientOptions(prepared);\n        this._applyIntegrationsMetadata(prepared);\n        // If we have scope given to us, use it as the base for further modifications.\n        // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n        var finalScope = scope;\n        if (hint && hint.captureContext) {\n            finalScope = Scope.clone(finalScope).update(hint.captureContext);\n        }\n        // We prepare the result here with a resolved Event.\n        var result = SyncPromise.resolve(prepared);\n        // This should be the last thing called, since we want that\n        // {@link Hub.addEventProcessor} gets the finished prepared event.\n        if (finalScope) {\n            // In case we have a hub we reassign it.\n            result = finalScope.applyToEvent(prepared, hint);\n        }\n        return result.then(function (evt) {\n            if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n                return _this._normalizeEvent(evt, normalizeDepth);\n            }\n            return evt;\n        });\n    };\n    /**\n     * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n     * Normalized keys:\n     * - `breadcrumbs.data`\n     * - `user`\n     * - `contexts`\n     * - `extra`\n     * @param event Event\n     * @returns Normalized event\n     */\n    BaseClient.prototype._normalizeEvent = function (event, depth) {\n        if (!event) {\n            return null;\n        }\n        var normalized = __assign(__assign(__assign(__assign(__assign({}, event), (event.breadcrumbs && {\n            breadcrumbs: event.breadcrumbs.map(function (b) { return (__assign(__assign({}, b), (b.data && {\n                data: normalize(b.data, depth),\n            }))); }),\n        })), (event.user && {\n            user: normalize(event.user, depth),\n        })), (event.contexts && {\n            contexts: normalize(event.contexts, depth),\n        })), (event.extra && {\n            extra: normalize(event.extra, depth),\n        }));\n        // event.contexts.trace stores information about a Transaction. Similarly,\n        // event.spans[] stores information about child Spans. Given that a\n        // Transaction is conceptually a Span, normalization should apply to both\n        // Transactions and Spans consistently.\n        // For now the decision is to skip normalization of Transactions and Spans,\n        // so this block overwrites the normalized event to add back the original\n        // Transaction information prior to normalization.\n        if (event.contexts && event.contexts.trace) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            normalized.contexts.trace = event.contexts.trace;\n        }\n        return normalized;\n    };\n    /**\n     *  Enhances event using the client configuration.\n     *  It takes care of all \"static\" values like environment, release and `dist`,\n     *  as well as truncating overly long values.\n     * @param event event instance to be enhanced\n     */\n    BaseClient.prototype._applyClientOptions = function (event) {\n        var options = this.getOptions();\n        var environment = options.environment, release = options.release, dist = options.dist, _a = options.maxValueLength, maxValueLength = _a === void 0 ? 250 : _a;\n        if (!('environment' in event)) {\n            event.environment = 'environment' in options ? environment : 'production';\n        }\n        if (event.release === undefined && release !== undefined) {\n            event.release = release;\n        }\n        if (event.dist === undefined && dist !== undefined) {\n            event.dist = dist;\n        }\n        if (event.message) {\n            event.message = truncate(event.message, maxValueLength);\n        }\n        var exception = event.exception && event.exception.values && event.exception.values[0];\n        if (exception && exception.value) {\n            exception.value = truncate(exception.value, maxValueLength);\n        }\n        var request = event.request;\n        if (request && request.url) {\n            request.url = truncate(request.url, maxValueLength);\n        }\n    };\n    /**\n     * This function adds all used integrations to the SDK info in the event.\n     * @param sdkInfo The sdkInfo of the event that will be filled with all integrations.\n     */\n    BaseClient.prototype._applyIntegrationsMetadata = function (event) {\n        var sdkInfo = event.sdk;\n        var integrationsArray = Object.keys(this._integrations);\n        if (sdkInfo && integrationsArray.length > 0) {\n            sdkInfo.integrations = integrationsArray;\n        }\n    };\n    /**\n     * Tells the backend to send this event\n     * @param event The Sentry event to send\n     */\n    BaseClient.prototype._sendEvent = function (event) {\n        this._getBackend().sendEvent(event);\n    };\n    /**\n     * Processes the event and logs an error in case of rejection\n     * @param event\n     * @param hint\n     * @param scope\n     */\n    BaseClient.prototype._captureEvent = function (event, hint, scope) {\n        return this._processEvent(event, hint, scope).then(function (finalEvent) {\n            return finalEvent.event_id;\n        }, function (reason) {\n            logger.error(reason);\n            return undefined;\n        });\n    };\n    /**\n     * Processes an event (either error or message) and sends it to Sentry.\n     *\n     * This also adds breadcrumbs and context information to the event. However,\n     * platform specific meta data (such as the User's IP address) must be added\n     * by the SDK implementor.\n     *\n     *\n     * @param event The event to send to Sentry.\n     * @param hint May contain additional information about the original exception.\n     * @param scope A scope containing event metadata.\n     * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n     */\n    BaseClient.prototype._processEvent = function (event, hint, scope) {\n        var _this = this;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;\n        if (!this._isEnabled()) {\n            return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));\n        }\n        var isTransaction = event.type === 'transaction';\n        // 1.0 === 100% events are sent\n        // 0.0 === 0% events are sent\n        // Sampling for transaction happens somewhere else\n        if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n            return SyncPromise.reject(new SentryError(\"Discarding event because it's not included in the random sample (sampling rate = \" + sampleRate + \")\"));\n        }\n        return this._prepareEvent(event, scope, hint)\n            .then(function (prepared) {\n            if (prepared === null) {\n                throw new SentryError('An event processor returned null, will not send event.');\n            }\n            var isInternalException = hint && hint.data && hint.data.__sentry__ === true;\n            if (isInternalException || isTransaction || !beforeSend) {\n                return prepared;\n            }\n            var beforeSendResult = beforeSend(prepared, hint);\n            if (typeof beforeSendResult === 'undefined') {\n                throw new SentryError('`beforeSend` method has to return `null` or a valid event.');\n            }\n            else if (isThenable(beforeSendResult)) {\n                return beforeSendResult.then(function (event) { return event; }, function (e) {\n                    throw new SentryError(\"beforeSend rejected with \" + e);\n                });\n            }\n            return beforeSendResult;\n        })\n            .then(function (processedEvent) {\n            if (processedEvent === null) {\n                throw new SentryError('`beforeSend` returned `null`, will not send event.');\n            }\n            var session = scope && scope.getSession && scope.getSession();\n            if (!isTransaction && session) {\n                _this._updateSessionFromEvent(session, processedEvent);\n            }\n            _this._sendEvent(processedEvent);\n            return processedEvent;\n        })\n            .then(null, function (reason) {\n            if (reason instanceof SentryError) {\n                throw reason;\n            }\n            _this.captureException(reason, {\n                data: {\n                    __sentry__: true,\n                },\n                originalException: reason,\n            });\n            throw new SentryError(\"Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: \" + reason);\n        });\n    };\n    /**\n     * Occupies the client with processing and event\n     */\n    BaseClient.prototype._process = function (promise) {\n        var _this = this;\n        this._processing += 1;\n        promise.then(function (value) {\n            _this._processing -= 1;\n            return value;\n        }, function (reason) {\n            _this._processing -= 1;\n            return reason;\n        });\n    };\n    return BaseClient;\n}());\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { consoleSandbox, getGlobalObject } from './misc';\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n/** JSDoc */\nvar Logger = /** @class */ (function () {\n    /** JSDoc */\n    function Logger() {\n        this._enabled = false;\n    }\n    /** JSDoc */\n    Logger.prototype.disable = function () {\n        this._enabled = false;\n    };\n    /** JSDoc */\n    Logger.prototype.enable = function () {\n        this._enabled = true;\n    };\n    /** JSDoc */\n    Logger.prototype.log = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.log(PREFIX + \"[Log]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.warn(PREFIX + \"[Warn]: \" + args.join(' '));\n        });\n    };\n    /** JSDoc */\n    Logger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (!this._enabled) {\n            return;\n        }\n        consoleSandbox(function () {\n            global.console.error(PREFIX + \"[Error]: \" + args.join(' '));\n        });\n    };\n    return Logger;\n}());\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nglobal.__SENTRY__ = global.__SENTRY__ || {};\nvar logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());\nexport { logger };\n//# sourceMappingURL=logger.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    __extends(XHRTransport, _super);\n    function XHRTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            var request = new XMLHttpRequest();\n            request.onreadystatechange = function () {\n                if (request.readyState === 4) {\n                    var headers = {\n                        'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                        'retry-after': request.getResponseHeader('Retry-After'),\n                    };\n                    _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });\n                }\n            };\n            request.open('POST', sentryRequest.url);\n            for (var header in _this.options.headers) {\n                if (_this.options.headers.hasOwnProperty(header)) {\n                    request.setRequestHeader(header, _this.options.headers[header]);\n                }\n            }\n            request.send(sentryRequest.body);\n        }));\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { getGlobalObject, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nvar global = getGlobalObject();\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    __extends(FetchTransport, _super);\n    function FetchTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        if (this._isRateLimited(sentryRequest.type)) {\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                reason: \"Transport locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var options = {\n            body: sentryRequest.body,\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default\n            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),\n        };\n        if (this.options.fetchParameters !== undefined) {\n            Object.assign(options, this.options.fetchParameters);\n        }\n        if (this.options.headers !== undefined) {\n            options.headers = this.options.headers;\n        }\n        return this._buffer.add(new SyncPromise(function (resolve, reject) {\n            global\n                .fetch(sentryRequest.url, options)\n                .then(function (response) {\n                var headers = {\n                    'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                    'retry-after': response.headers.get('Retry-After'),\n                };\n                _this._handleResponse({\n                    requestType: sentryRequest.type,\n                    response: response,\n                    headers: headers,\n                    resolve: resolve,\n                    reject: reject,\n                });\n            })\n                .catch(reject);\n        }));\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map","import { __assign, __read, __rest, __spread } from \"tslib\";\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(api) {\n    if (!api.metadata || !api.metadata.sdk) {\n        return;\n    }\n    var _a = api.metadata.sdk, name = _a.name, version = _a.version;\n    return { name: name, version: version };\n}\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n    if (!sdkInfo) {\n        return event;\n    }\n    event.sdk = event.sdk || {\n        name: sdkInfo.name,\n        version: sdkInfo.version,\n    };\n    event.sdk.name = event.sdk.name || sdkInfo.name;\n    event.sdk.version = event.sdk.version || sdkInfo.version;\n    event.sdk.integrations = __spread((event.sdk.integrations || []), (sdkInfo.integrations || []));\n    event.sdk.packages = __spread((event.sdk.packages || []), (sdkInfo.packages || []));\n    return event;\n}\n/** Creates a SentryRequest from an event. */\nexport function sessionToSentryRequest(session, api) {\n    var sdkInfo = getSdkMetadataForEnvelopeHeader(api);\n    var envelopeHeaders = JSON.stringify(__assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));\n    var itemHeaders = JSON.stringify({\n        type: 'session',\n    });\n    return {\n        body: envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + JSON.stringify(session),\n        type: 'session',\n        url: api.getEnvelopeEndpointWithUrlEncodedAuth(),\n    };\n}\n/** Creates a SentryRequest from an event. */\nexport function eventToSentryRequest(event, api) {\n    // since JS has no Object.prototype.pop()\n    var _a = event.tags || {}, samplingMethod = _a.__sentry_samplingMethod, sampleRate = _a.__sentry_sampleRate, otherTags = __rest(_a, [\"__sentry_samplingMethod\", \"__sentry_sampleRate\"]);\n    event.tags = otherTags;\n    var sdkInfo = getSdkMetadataForEnvelopeHeader(api);\n    var eventType = event.type || 'event';\n    var useEnvelope = eventType === 'transaction';\n    var req = {\n        body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),\n        type: eventType,\n        url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),\n    };\n    // https://develop.sentry.dev/sdk/envelopes/\n    // Since we don't need to manipulate envelopes nor store them, there is no\n    // exported concept of an Envelope with operations including serialization and\n    // deserialization. Instead, we only implement a minimal subset of the spec to\n    // serialize events inline here.\n    if (useEnvelope) {\n        var envelopeHeaders = JSON.stringify(__assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));\n        var itemHeaders = JSON.stringify({\n            type: event.type,\n            // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and\n            // explicitly-set sampling decisions). Are we good with that?\n            sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n        });\n        // The trailing newline is optional. We intentionally don't send it to avoid\n        // sending unnecessary bytes.\n        //\n        // const envelope = `${envelopeHeaders}\\n${itemHeaders}\\n${req.body}\\n`;\n        var envelope = envelopeHeaders + \"\\n\" + itemHeaders + \"\\n\" + req.body;\n        req.body = envelope;\n    }\n    return req;\n}\n//# sourceMappingURL=request.js.map","import { __values } from \"tslib\";\nimport { htmlTreeAsString } from './browser';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive, isSyntheticEvent } from './is';\nimport { Memo } from './memo';\nimport { getFunctionName } from './stacktrace';\nimport { truncate } from './string';\n/**\n * Wrap a given object method with a higher-order function\n *\n * @param source An object that contains a method to be wrapped.\n * @param name A name of method to be wrapped.\n * @param replacementFactory A function that should be used to wrap a given method, returning the wrapped method which\n * will be substituted in for `source[name]`.\n * @returns void\n */\nexport function fill(source, name, replacementFactory) {\n    if (!(name in source)) {\n        return;\n    }\n    var original = source[name];\n    var wrapped = replacementFactory(original);\n    // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n    // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n    if (typeof wrapped === 'function') {\n        try {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __sentry_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        catch (_Oo) {\n            // This can throw if multiple fill happens on a global object like XMLHttpRequest\n            // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n        }\n    }\n    source[name] = wrapped;\n}\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object) {\n    return Object.keys(object)\n        .map(function (key) { return encodeURIComponent(key) + \"=\" + encodeURIComponent(object[key]); })\n        .join('&');\n}\n/**\n * Transforms any object into an object literal with all its attributes\n * attached to it.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n */\nfunction getWalkSource(value) {\n    if (isError(value)) {\n        var error = value;\n        var err = {\n            message: error.message,\n            name: error.name,\n            stack: error.stack,\n        };\n        for (var i in error) {\n            if (Object.prototype.hasOwnProperty.call(error, i)) {\n                err[i] = error[i];\n            }\n        }\n        return err;\n    }\n    if (isEvent(value)) {\n        var event_1 = value;\n        var source = {};\n        source.type = event_1.type;\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            source.target = isElement(event_1.target)\n                ? htmlTreeAsString(event_1.target)\n                : Object.prototype.toString.call(event_1.target);\n        }\n        catch (_oO) {\n            source.target = '<unknown>';\n        }\n        try {\n            source.currentTarget = isElement(event_1.currentTarget)\n                ? htmlTreeAsString(event_1.currentTarget)\n                : Object.prototype.toString.call(event_1.currentTarget);\n        }\n        catch (_oO) {\n            source.currentTarget = '<unknown>';\n        }\n        if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n            source.detail = event_1.detail;\n        }\n        for (var i in event_1) {\n            if (Object.prototype.hasOwnProperty.call(event_1, i)) {\n                source[i] = event_1;\n            }\n        }\n        return source;\n    }\n    return value;\n}\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    // eslint-disable-next-line no-bitwise\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n    return utf8Length(JSON.stringify(value));\n}\n/** JSDoc */\nexport function normalizeToSize(object, \n// Default Node.js REPL depth\ndepth, \n// 100kB, as 200kB is max payload size, so half sounds reasonable\nmaxSize) {\n    if (depth === void 0) { depth = 3; }\n    if (maxSize === void 0) { maxSize = 100 * 1024; }\n    var serialized = normalize(object, depth);\n    if (jsonSize(serialized) > maxSize) {\n        return normalizeToSize(object, depth - 1, maxSize);\n    }\n    return serialized;\n}\n/**\n * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,\n * booleans, null, and undefined.\n *\n * @param value The value to stringify\n * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or\n *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,\n *  unchanged.\n */\nfunction serializeValue(value) {\n    var type = Object.prototype.toString.call(value);\n    // Node.js REPL notation\n    if (typeof value === 'string') {\n        return value;\n    }\n    if (type === '[object Object]') {\n        return '[Object]';\n    }\n    if (type === '[object Array]') {\n        return '[Array]';\n    }\n    var normalized = normalizeValue(value);\n    return isPrimitive(normalized) ? normalized : type;\n}\n/**\n * normalizeValue()\n *\n * Takes unserializable input and make it serializable friendly\n *\n * - translates undefined/NaN values to \"[undefined]\"/\"[NaN]\" respectively,\n * - serializes Error objects\n * - filter global objects\n */\nfunction normalizeValue(value, key) {\n    if (key === 'domain' && value && typeof value === 'object' && value._events) {\n        return '[Domain]';\n    }\n    if (key === 'domainEmitter') {\n        return '[DomainEmitter]';\n    }\n    if (typeof global !== 'undefined' && value === global) {\n        return '[Global]';\n    }\n    if (typeof window !== 'undefined' && value === window) {\n        return '[Window]';\n    }\n    if (typeof document !== 'undefined' && value === document) {\n        return '[Document]';\n    }\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n        return '[SyntheticEvent]';\n    }\n    if (typeof value === 'number' && value !== value) {\n        return '[NaN]';\n    }\n    if (value === void 0) {\n        return '[undefined]';\n    }\n    if (typeof value === 'function') {\n        return \"[Function: \" + getFunctionName(value) + \"]\";\n    }\n    // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable\n    if (typeof value === 'symbol') {\n        return \"[\" + String(value) + \"]\";\n    }\n    if (typeof value === 'bigint') {\n        return \"[BigInt: \" + String(value) + \"]\";\n    }\n    return value;\n}\n/**\n * Walks an object to perform a normalization on it\n *\n * @param key of object that's walked in current iteration\n * @param value object to be walked\n * @param depth Optional number indicating how deep should walking be performed\n * @param memo Optional Memo class handling decycling\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function walk(key, value, depth, memo) {\n    if (depth === void 0) { depth = +Infinity; }\n    if (memo === void 0) { memo = new Memo(); }\n    // If we reach the maximum depth, serialize whatever has left\n    if (depth === 0) {\n        return serializeValue(value);\n    }\n    /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n    // If value implements `toJSON` method, call it and return early\n    if (value !== null && value !== undefined && typeof value.toJSON === 'function') {\n        return value.toJSON();\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n    // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further\n    var normalized = normalizeValue(value, key);\n    if (isPrimitive(normalized)) {\n        return normalized;\n    }\n    // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself\n    var source = getWalkSource(value);\n    // Create an accumulator that will act as a parent for all future itterations of that branch\n    var acc = Array.isArray(value) ? [] : {};\n    // If we already walked that branch, bail out, as it's circular reference\n    if (memo.memoize(value)) {\n        return '[Circular ~]';\n    }\n    // Walk all keys of the source\n    for (var innerKey in source) {\n        // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n        if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {\n            continue;\n        }\n        // Recursively walk through all the child nodes\n        acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);\n    }\n    // Once walked through all the branches, remove the parent from memo storage\n    memo.unmemoize(value);\n    // Return accumulated values\n    return acc;\n}\n/**\n * normalize()\n *\n * - Creates a copy to prevent original input mutation\n * - Skip non-enumerablers\n * - Calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format\n * - Translates known global objects/Classes to a string representations\n * - Takes care of Error objects serialization\n * - Optionally limit depth of final output\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function normalize(input, depth) {\n    try {\n        return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));\n    }\n    catch (_oO) {\n        return '**non-serializable**';\n    }\n}\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function extractExceptionKeysForMessage(exception, maxLength) {\n    if (maxLength === void 0) { maxLength = 40; }\n    var keys = Object.keys(getWalkSource(exception));\n    keys.sort();\n    if (!keys.length) {\n        return '[object has no keys]';\n    }\n    if (keys[0].length >= maxLength) {\n        return truncate(keys[0], maxLength);\n    }\n    for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n        var serialized = keys.slice(0, includedKeys).join(', ');\n        if (serialized.length > maxLength) {\n            continue;\n        }\n        if (includedKeys === keys.length) {\n            return serialized;\n        }\n        return truncate(serialized, maxLength);\n    }\n    return '';\n}\n/**\n * Given any object, return the new object with removed keys that value was `undefined`.\n * Works recursively on objects and arrays.\n */\nexport function dropUndefinedKeys(val) {\n    var e_1, _a;\n    if (isPlainObject(val)) {\n        var obj = val;\n        var rv = {};\n        try {\n            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var key = _c.value;\n                if (typeof obj[key] !== 'undefined') {\n                    rv[key] = dropUndefinedKeys(obj[key]);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return rv;\n    }\n    if (Array.isArray(val)) {\n        return val.map(dropUndefinedKeys);\n    }\n    return val;\n}\n//# sourceMappingURL=object.js.map","var originalFunctionToString;\n/** Patch toString calls to return proper name for wrapped functions */\nvar FunctionToString = /** @class */ (function () {\n    function FunctionToString() {\n        /**\n         * @inheritDoc\n         */\n        this.name = FunctionToString.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.prototype.setupOnce = function () {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        originalFunctionToString = Function.prototype.toString;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        Function.prototype.toString = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var context = this.__sentry_original__ || this;\n            return originalFunctionToString.apply(context, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    FunctionToString.id = 'FunctionToString';\n    return FunctionToString;\n}());\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils';\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n/** Inbound filters configurable by the user */\nvar InboundFilters = /** @class */ (function () {\n    function InboundFilters(_options) {\n        if (_options === void 0) { _options = {}; }\n        this._options = _options;\n        /**\n         * @inheritDoc\n         */\n        this.name = InboundFilters.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            var hub = getCurrentHub();\n            if (!hub) {\n                return event;\n            }\n            var self = hub.getIntegration(InboundFilters);\n            if (self) {\n                var client = hub.getClient();\n                var clientOptions = client ? client.getOptions() : {};\n                var options = self._mergeOptions(clientOptions);\n                if (self._shouldDropEvent(event, options)) {\n                    return null;\n                }\n            }\n            return event;\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._shouldDropEvent = function (event, options) {\n        if (this._isSentryError(event, options)) {\n            logger.warn(\"Event dropped due to being internal Sentry Error.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isIgnoredError(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `ignoreErrors` option.\\nEvent: \" + getEventDescription(event));\n            return true;\n        }\n        if (this._isDeniedUrl(event, options)) {\n            logger.warn(\"Event dropped due to being matched by `denyUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        if (!this._isAllowedUrl(event, options)) {\n            logger.warn(\"Event dropped due to not being matched by `allowUrls` option.\\nEvent: \" + getEventDescription(event) + \".\\nUrl: \" + this._getEventFilterUrl(event));\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isSentryError = function (event, options) {\n        if (!options.ignoreInternal) {\n            return false;\n        }\n        try {\n            return ((event &&\n                event.exception &&\n                event.exception.values &&\n                event.exception.values[0] &&\n                event.exception.values[0].type === 'SentryError') ||\n                false);\n        }\n        catch (_oO) {\n            return false;\n        }\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isIgnoredError = function (event, options) {\n        if (!options.ignoreErrors || !options.ignoreErrors.length) {\n            return false;\n        }\n        return this._getPossibleEventMessages(event).some(function (message) {\n            // Not sure why TypeScript complains here...\n            return options.ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });\n        });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isDeniedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.denyUrls || !options.denyUrls.length) {\n            return false;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? false : options.denyUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._isAllowedUrl = function (event, options) {\n        // TODO: Use Glob instead?\n        if (!options.allowUrls || !options.allowUrls.length) {\n            return true;\n        }\n        var url = this._getEventFilterUrl(event);\n        return !url ? true : options.allowUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });\n    };\n    /** JSDoc */\n    InboundFilters.prototype._mergeOptions = function (clientOptions) {\n        if (clientOptions === void 0) { clientOptions = {}; }\n        return {\n            allowUrls: __spread((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),\n            denyUrls: __spread((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),\n            ignoreErrors: __spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),\n            ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,\n        };\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getPossibleEventMessages = function (event) {\n        if (event.message) {\n            return [event.message];\n        }\n        if (event.exception) {\n            try {\n                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;\n                return [\"\" + value, type + \": \" + value];\n            }\n            catch (oO) {\n                logger.error(\"Cannot extract message for event \" + getEventDescription(event));\n                return [];\n            }\n        }\n        return [];\n    };\n    /** JSDoc */\n    InboundFilters.prototype._getEventFilterUrl = function (event) {\n        try {\n            if (event.stacktrace) {\n                var frames_1 = event.stacktrace.frames;\n                return (frames_1 && frames_1[frames_1.length - 1].filename) || null;\n            }\n            if (event.exception) {\n                var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;\n                return (frames_2 && frames_2[frames_2.length - 1].filename) || null;\n            }\n            return null;\n        }\n        catch (oO) {\n            logger.error(\"Cannot extract url for event \" + getEventDescription(event));\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    InboundFilters.id = 'InboundFilters';\n    return InboundFilters;\n}());\nexport { InboundFilters };\n//# sourceMappingURL=inboundfilters.js.map","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind(clientClass, options) {\n    if (options.debug === true) {\n        logger.enable();\n    }\n    var hub = getCurrentHub();\n    var client = new clientClass(options);\n    hub.bindClient(client);\n}\n//# sourceMappingURL=sdk.js.map","import { __assign } from \"tslib\";\nimport { fill, getFunctionName, getGlobalObject } from '@sentry/utils';\nimport { wrap } from '../helpers';\nvar DEFAULT_EVENT_TARGET = [\n    'EventTarget',\n    'Window',\n    'Node',\n    'ApplicationCache',\n    'AudioTrackList',\n    'ChannelMergerNode',\n    'CryptoOperation',\n    'EventSource',\n    'FileReader',\n    'HTMLUnknownElement',\n    'IDBDatabase',\n    'IDBRequest',\n    'IDBTransaction',\n    'KeyOperation',\n    'MediaController',\n    'MessagePort',\n    'ModalWindow',\n    'Notification',\n    'SVGElementInstance',\n    'Screen',\n    'TextTrack',\n    'TextTrackCue',\n    'TextTrackList',\n    'WebSocket',\n    'WebSocketWorker',\n    'Worker',\n    'XMLHttpRequest',\n    'XMLHttpRequestEventTarget',\n    'XMLHttpRequestUpload',\n];\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function TryCatch(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n        this._options = __assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        var global = getGlobalObject();\n        if (this._options.setTimeout) {\n            fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.setInterval) {\n            fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.requestAnimationFrame) {\n            fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        if (this._options.eventTarget) {\n            var eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(this._wrapEventTarget.bind(this));\n        }\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var originalCallback = args[0];\n            args[0] = wrap(originalCallback, {\n                mechanism: {\n                    data: { function: getFunctionName(original) },\n                    handled: true,\n                    type: 'instrument',\n                },\n            });\n            return original.apply(this, args);\n        };\n    };\n    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TryCatch.prototype._wrapRAF = function (original) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function (callback) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return original.call(this, wrap(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: getFunctionName(original),\n                    },\n                    handled: true,\n                    type: 'instrument',\n                },\n            }));\n        };\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (target) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        var global = getGlobalObject();\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    if (typeof fn.handleEvent === 'function') {\n                        fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n                            mechanism: {\n                                data: {\n                                    function: 'handleEvent',\n                                    handler: getFunctionName(fn),\n                                    target: target,\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        });\n                    }\n                }\n                catch (err) {\n                    // can sometimes get 'Permission denied to access property \"handle Event'\n                }\n                return original.call(this, eventName, \n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                wrap(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: getFunctionName(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }), options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (eventName, fn, options) {\n                var _a;\n                /**\n                 * There are 2 possible scenarios here:\n                 *\n                 * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n                 * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n                 * as a pass-through, and call original `removeEventListener` with it.\n                 *\n                 * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n                 * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n                 * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n                 * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n                 * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n                 *\n                 * When someone adds a handler prior to initialization, and then do it again, but after,\n                 * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n                 * to get rid of the initial handler and it'd stick there forever.\n                 */\n                var wrappedEventHandler = fn;\n                try {\n                    var originalEventHandler = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__sentry_wrapped__;\n                    if (originalEventHandler) {\n                        originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n                    }\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n            };\n        });\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (originalSend) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n            xmlHttpRequestProps.forEach(function (prop) {\n                if (prop in xhr && typeof xhr[prop] === 'function') {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    fill(xhr, prop, function (original) {\n                        var wrapOptions = {\n                            mechanism: {\n                                data: {\n                                    function: prop,\n                                    handler: getFunctionName(original),\n                                },\n                                handled: true,\n                                type: 'instrument',\n                            },\n                        };\n                        // If Instrument integration has been called before TryCatch, get the name of original function\n                        if (original.__sentry_original__) {\n                            wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\n                        }\n                        // Otherwise wrap directly\n                        return wrap(original, wrapOptions);\n                    });\n                }\n            });\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map","import { getCurrentHub, initAndBind, Integrations as CoreIntegrations, SDK_VERSION } from '@sentry/core';\nimport { addInstrumentationHandler, getGlobalObject, logger, SyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [\n    new CoreIntegrations.InboundFilters(),\n    new CoreIntegrations.FunctionToString(),\n    new TryCatch(),\n    new Breadcrumbs(),\n    new GlobalHandlers(),\n    new LinkedErrors(),\n    new UserAgent(),\n];\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    if (options.autoSessionTracking === undefined) {\n        options.autoSessionTracking = true;\n    }\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = {\n        name: 'sentry.javascript.browser',\n        packages: [\n            {\n                name: 'npm:@sentry/browser',\n                version: SDK_VERSION,\n            },\n        ],\n        version: SDK_VERSION,\n    };\n    initAndBind(BrowserClient, options);\n    if (options.autoSessionTracking) {\n        startSessionTracking();\n    }\n}\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        options.eventId = getCurrentHub().lastEventId();\n    }\n    var client = getCurrentHub().getClient();\n    if (client) {\n        client.showReportDialog(options);\n    }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId() {\n    return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad() {\n    // Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback) {\n    callback();\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function flush(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * A promise that resolves when all current events have been sent.\n * If you provide a timeout and the queue takes longer to drain the promise returns false.\n *\n * @param timeout Maximum time in ms the client should wait.\n */\nexport function close(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    return SyncPromise.reject(false);\n}\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn) {\n    return internalWrap(fn)();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n    var window = getGlobalObject();\n    var document = window.document;\n    if (typeof document === 'undefined') {\n        logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n        return;\n    }\n    var hub = getCurrentHub();\n    /**\n     * We should be using `Promise.all([windowLoaded, firstContentfulPaint])` here,\n     * but, as always, it's not available in the IE10-11. Thanks IE.\n     */\n    var loadResolved = document.readyState === 'complete';\n    var fcpResolved = false;\n    var possiblyEndSession = function () {\n        if (fcpResolved && loadResolved) {\n            hub.endSession();\n        }\n    };\n    var resolveWindowLoaded = function () {\n        loadResolved = true;\n        possiblyEndSession();\n        window.removeEventListener('load', resolveWindowLoaded);\n    };\n    hub.startSession();\n    if (!loadResolved) {\n        // IE doesn't support `{ once: true }` for event listeners, so we have to manually\n        // attach and then detach it once completed.\n        window.addEventListener('load', resolveWindowLoaded);\n    }\n    try {\n        var po = new PerformanceObserver(function (entryList, po) {\n            entryList.getEntries().forEach(function (entry) {\n                if (entry.name === 'first-contentful-paint' && entry.startTime < firstHiddenTime_1) {\n                    po.disconnect();\n                    fcpResolved = true;\n                    possiblyEndSession();\n                }\n            });\n        });\n        // There's no need to even attach this listener if `PerformanceObserver` constructor will fail,\n        // so we do it below here.\n        var firstHiddenTime_1 = document.visibilityState === 'hidden' ? 0 : Infinity;\n        document.addEventListener('visibilitychange', function (event) {\n            firstHiddenTime_1 = Math.min(firstHiddenTime_1, event.timeStamp);\n        }, { once: true });\n        po.observe({\n            type: 'paint',\n            buffered: true,\n        });\n    }\n    catch (e) {\n        fcpResolved = true;\n        possiblyEndSession();\n    }\n    // We want to create a session for every navigation as well\n    addInstrumentationHandler({\n        callback: function () {\n            var _a;\n            if (!((_a = getCurrentHub()\n                .getScope()) === null || _a === void 0 ? void 0 : _a.getSession())) {\n                hub.startSession();\n                hub.endSession();\n            }\n        },\n        type: 'history',\n    });\n}\n//# sourceMappingURL=sdk.js.map","import { __assign } from \"tslib\";\nimport { API, captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, logger } from '@sentry/utils';\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nexport function ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\n    });\n}\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(fn, options, before) {\n    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\n        }\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        // Bail on wrapping and return the function as-is (defers to window.onerror).\n        return fn;\n    }\n    /* eslint-disable prefer-rest-params */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        try {\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            if (fn.handleEvent) {\n                // Attempt to invoke user-land function\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n                //       means the sentry.javascript SDK caught an error invoking your application code. This\n                //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                return fn.handleEvent.apply(this, wrappedArguments);\n            }\n            // Attempt to invoke user-land function\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n            //       means the sentry.javascript SDK caught an error invoking your application code. This\n            //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n            return fn.apply(this, wrappedArguments);\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    var processedEvent = __assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = __assign(__assign({}, processedEvent.extra), { arguments: args });\n                    return processedEvent;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    /* eslint-enable prefer-rest-params */\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // eslint-disable-line no-empty\n    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\n    });\n    // Restore original function name (not all browsers allow that)\n    try {\n        var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n        if (descriptor.configurable) {\n            Object.defineProperty(sentryWrapped, 'name', {\n                get: function () {\n                    return fn.name;\n                },\n            });\n        }\n        // eslint-disable-next-line no-empty\n    }\n    catch (_oO) { }\n    return sentryWrapped;\n}\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!options.eventId) {\n        logger.error(\"Missing eventId option in showReportDialog call\");\n        return;\n    }\n    if (!options.dsn) {\n        logger.error(\"Missing dsn option in showReportDialog call\");\n        return;\n    }\n    var script = document.createElement('script');\n    script.async = true;\n    script.src = new API(options.dsn).getReportDialogEndpoint(options);\n    if (options.onLoad) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        script.onload = options.onLoad;\n    }\n    (document.head || document.body).appendChild(script);\n}\n//# sourceMappingURL=helpers.js.map","import { __read } from \"tslib\";\nimport { SentryError } from './error';\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n/** Error message */\nvar ERROR_MESSAGE = 'Invalid Dsn';\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nvar Dsn = /** @class */ (function () {\n    /** Creates a new Dsn component */\n    function Dsn(from) {\n        if (typeof from === 'string') {\n            this._fromString(from);\n        }\n        else {\n            this._fromComponents(from);\n        }\n        this._validate();\n    }\n    /**\n     * Renders the string representation of this Dsn.\n     *\n     * By default, this will render the public representation without the password\n     * component. To get the deprecated private representation, set `withPassword`\n     * to true.\n     *\n     * @param withPassword When set to true, the password will be included.\n     */\n    Dsn.prototype.toString = function (withPassword) {\n        if (withPassword === void 0) { withPassword = false; }\n        var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, user = _a.user;\n        return (protocol + \"://\" + user + (withPassword && pass ? \":\" + pass : '') +\n            (\"@\" + host + (port ? \":\" + port : '') + \"/\" + (path ? path + \"/\" : path) + projectId));\n    };\n    /** Parses a string into this Dsn. */\n    Dsn.prototype._fromString = function (str) {\n        var match = DSN_REGEX.exec(str);\n        if (!match) {\n            throw new SentryError(ERROR_MESSAGE);\n        }\n        var _a = __read(match.slice(1), 6), protocol = _a[0], user = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];\n        var path = '';\n        var projectId = lastPath;\n        var split = projectId.split('/');\n        if (split.length > 1) {\n            path = split.slice(0, -1).join('/');\n            projectId = split.pop();\n        }\n        if (projectId) {\n            var projectMatch = projectId.match(/^\\d+/);\n            if (projectMatch) {\n                projectId = projectMatch[0];\n            }\n        }\n        this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, user: user });\n    };\n    /** Maps Dsn components into this instance. */\n    Dsn.prototype._fromComponents = function (components) {\n        this.protocol = components.protocol;\n        this.user = components.user;\n        this.pass = components.pass || '';\n        this.host = components.host;\n        this.port = components.port || '';\n        this.path = components.path || '';\n        this.projectId = components.projectId;\n    };\n    /** Validates this Dsn and throws on error. */\n    Dsn.prototype._validate = function () {\n        var _this = this;\n        ['protocol', 'user', 'host', 'projectId'].forEach(function (component) {\n            if (!_this[component]) {\n                throw new SentryError(ERROR_MESSAGE + \": \" + component + \" missing\");\n            }\n        });\n        if (!this.projectId.match(/^\\d+$/)) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid projectId \" + this.projectId);\n        }\n        if (this.protocol !== 'http' && this.protocol !== 'https') {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid protocol \" + this.protocol);\n        }\n        if (this.port && isNaN(parseInt(this.port, 10))) {\n            throw new SentryError(ERROR_MESSAGE + \": Invalid port \" + this.port);\n        }\n    };\n    return Dsn;\n}());\nexport { Dsn };\n//# sourceMappingURL=dsn.js.map","// TODO: Remove in the next major release and rely only on @sentry/core SDK_VERSION and SdkInfo metadata\nexport var SDK_NAME = 'sentry.javascript.browser';\n//# sourceMappingURL=version.js.map","import { __assign } from \"tslib\";\nexport * from './exports';\nimport { Integrations as CoreIntegrations } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nimport * as BrowserIntegrations from './integrations';\nimport * as Transports from './transports';\nvar windowIntegrations = {};\n// This block is needed to add compatibility with the integrations packages when used with a CDN\nvar _window = getGlobalObject();\nif (_window.Sentry && _window.Sentry.Integrations) {\n    windowIntegrations = _window.Sentry.Integrations;\n}\nvar INTEGRATIONS = __assign(__assign(__assign({}, windowIntegrations), CoreIntegrations), BrowserIntegrations);\nexport { INTEGRATIONS as Integrations, Transports };\n//# sourceMappingURL=index.js.map","import { Dsn, urlEncode } from '@sentry/utils';\nvar SENTRY_API_VERSION = '7';\n/**\n * Helper class to provide urls, headers and metadata that can be used to form\n * different types of requests to Sentry endpoints.\n * Supports both envelopes and regular event requests.\n **/\nvar API = /** @class */ (function () {\n    /** Create a new instance of API */\n    function API(dsn, metadata) {\n        if (metadata === void 0) { metadata = {}; }\n        this.dsn = dsn;\n        this.metadata = metadata;\n        this._dsnObject = new Dsn(dsn);\n    }\n    /** Returns the Dsn object. */\n    API.prototype.getDsn = function () {\n        return this._dsnObject;\n    };\n    /** Returns the prefix to construct Sentry ingestion API endpoints. */\n    API.prototype.getBaseApiEndpoint = function () {\n        var dsn = this._dsnObject;\n        var protocol = dsn.protocol ? dsn.protocol + \":\" : '';\n        var port = dsn.port ? \":\" + dsn.port : '';\n        return protocol + \"//\" + dsn.host + port + (dsn.path ? \"/\" + dsn.path : '') + \"/api/\";\n    };\n    /** Returns the store endpoint URL. */\n    API.prototype.getStoreEndpoint = function () {\n        return this._getIngestEndpoint('store');\n    };\n    /**\n     * Returns the store endpoint URL with auth in the query string.\n     *\n     * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n     */\n    API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {\n        return this.getStoreEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /**\n     * Returns the envelope endpoint URL with auth in the query string.\n     *\n     * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n     */\n    API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {\n        return this._getEnvelopeEndpoint() + \"?\" + this._encodedAuth();\n    };\n    /** Returns only the path component for the store endpoint. */\n    API.prototype.getStoreEndpointPath = function () {\n        var dsn = this._dsnObject;\n        return (dsn.path ? \"/\" + dsn.path : '') + \"/api/\" + dsn.projectId + \"/store/\";\n    };\n    /**\n     * Returns an object that can be used in request headers.\n     * This is needed for node and the old /store endpoint in sentry\n     */\n    API.prototype.getRequestHeaders = function (clientName, clientVersion) {\n        // CHANGE THIS to use metadata but keep clientName and clientVersion compatible\n        var dsn = this._dsnObject;\n        var header = [\"Sentry sentry_version=\" + SENTRY_API_VERSION];\n        header.push(\"sentry_client=\" + clientName + \"/\" + clientVersion);\n        header.push(\"sentry_key=\" + dsn.user);\n        if (dsn.pass) {\n            header.push(\"sentry_secret=\" + dsn.pass);\n        }\n        return {\n            'Content-Type': 'application/json',\n            'X-Sentry-Auth': header.join(', '),\n        };\n    };\n    /** Returns the url to the report dialog endpoint. */\n    API.prototype.getReportDialogEndpoint = function (dialogOptions) {\n        if (dialogOptions === void 0) { dialogOptions = {}; }\n        var dsn = this._dsnObject;\n        var endpoint = this.getBaseApiEndpoint() + \"embed/error-page/\";\n        var encodedOptions = [];\n        encodedOptions.push(\"dsn=\" + dsn.toString());\n        for (var key in dialogOptions) {\n            if (key === 'dsn') {\n                continue;\n            }\n            if (key === 'user') {\n                if (!dialogOptions.user) {\n                    continue;\n                }\n                if (dialogOptions.user.name) {\n                    encodedOptions.push(\"name=\" + encodeURIComponent(dialogOptions.user.name));\n                }\n                if (dialogOptions.user.email) {\n                    encodedOptions.push(\"email=\" + encodeURIComponent(dialogOptions.user.email));\n                }\n            }\n            else {\n                encodedOptions.push(encodeURIComponent(key) + \"=\" + encodeURIComponent(dialogOptions[key]));\n            }\n        }\n        if (encodedOptions.length) {\n            return endpoint + \"?\" + encodedOptions.join('&');\n        }\n        return endpoint;\n    };\n    /** Returns the envelope endpoint URL. */\n    API.prototype._getEnvelopeEndpoint = function () {\n        return this._getIngestEndpoint('envelope');\n    };\n    /** Returns the ingest API endpoint for target. */\n    API.prototype._getIngestEndpoint = function (target) {\n        var base = this.getBaseApiEndpoint();\n        var dsn = this._dsnObject;\n        return \"\" + base + dsn.projectId + \"/\" + target + \"/\";\n    };\n    /** Returns a URL-encoded string with auth config suitable for a query string. */\n    API.prototype._encodedAuth = function () {\n        var dsn = this._dsnObject;\n        var auth = {\n            // We send only the minimum set of required information. See\n            // https://github.com/getsentry/sentry-javascript/issues/2572.\n            sentry_key: dsn.user,\n            sentry_version: SENTRY_API_VERSION,\n        };\n        return urlEncode(auth);\n    };\n    return API;\n}());\nexport { API };\n//# sourceMappingURL=api.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { getCurrentHub } from '@sentry/hub';\n/**\n * This calls a function on the current hub.\n * @param method function to call on hub.\n * @param args to pass to function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction callOnHub(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var hub = getCurrentHub();\n    if (hub && hub[method]) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return hub[method].apply(hub, __spread(args));\n    }\n    throw new Error(\"No hub defined or \" + method + \" was not found on the hub, please open a bug report.\");\n}\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error('Sentry syntheticException');\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    return callOnHub('captureException', exception, {\n        captureContext: captureContext,\n        originalException: exception,\n        syntheticException: syntheticException,\n    });\n}\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param level Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(message, captureContext) {\n    var syntheticException;\n    try {\n        throw new Error(message);\n    }\n    catch (exception) {\n        syntheticException = exception;\n    }\n    // This is necessary to provide explicit scopes upgrade, without changing the original\n    // arity of the `captureMessage(message, level)` method.\n    var level = typeof captureContext === 'string' ? captureContext : undefined;\n    var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;\n    return callOnHub('captureMessage', message, level, __assign({ originalException: message, syntheticException: syntheticException }, context));\n}\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event) {\n    return callOnHub('captureEvent', event);\n}\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback) {\n    callOnHub('configureScope', callback);\n}\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb) {\n    callOnHub('addBreadcrumb', breadcrumb);\n}\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name, context) {\n    callOnHub('setContext', name, context);\n}\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras) {\n    callOnHub('setExtras', extras);\n}\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags) {\n    callOnHub('setTags', tags);\n}\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key, extra) {\n    callOnHub('setExtra', key, extra);\n}\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key, value) {\n    callOnHub('setTag', key, value);\n}\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user) {\n    callOnHub('setUser', user);\n}\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback) {\n    callOnHub('withScope', callback);\n}\n/**\n * Calls a function on the latest client. Use this with caution, it's meant as\n * in \"internal\" helper so we don't need to expose every possible function in\n * the shim. It is not guaranteed that the client actually implements the\n * function.\n *\n * @param method The method to call on the client/client.\n * @param args Arguments to pass to the client/fontend.\n * @hidden\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function _callOnClient(method) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    callOnHub.apply(void 0, __spread(['_invokeClient', method], args));\n}\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(context, customSamplingContext) {\n    return callOnHub('startTransaction', __assign({}, context), customSamplingContext);\n}\n//# sourceMappingURL=index.js.map","export { GlobalHandlers } from './globalhandlers';\nexport { TryCatch } from './trycatch';\nexport { Breadcrumbs } from './breadcrumbs';\nexport { LinkedErrors } from './linkederrors';\nexport { UserAgent } from './useragent';\n//# sourceMappingURL=index.js.map","import { isString } from './is';\nimport { normalize } from './object';\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv() {\n    return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\n}\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nexport function dynamicRequire(mod, request) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return mod.require(request);\n}\n/** Default request keys that'll be used to extract data from the request */\nvar DEFAULT_REQUEST_KEYS = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];\n/**\n * Normalizes data from the request object, accounting for framework differences.\n *\n * @param req The request object from which to extract data\n * @param keys An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_KEYS if not\n * provided.\n * @returns An object containing normalized request data\n */\nexport function extractNodeRequestData(req, keys) {\n    if (keys === void 0) { keys = DEFAULT_REQUEST_KEYS; }\n    // make sure we can safely use dynamicRequire below\n    if (!isNodeEnv()) {\n        throw new Error(\"Can't get node request data outside of a node environment\");\n    }\n    var requestData = {};\n    // headers:\n    //   node, express: req.headers\n    //   koa: req.header\n    var headers = (req.headers || req.header || {});\n    // method:\n    //   node, express, koa: req.method\n    var method = req.method;\n    // host:\n    //   express: req.hostname in > 4 and req.host in < 4\n    //   koa: req.host\n    //   node: req.headers.host\n    var host = req.hostname || req.host || headers.host || '<no host>';\n    // protocol:\n    //   node: <n/a>\n    //   express, koa: req.protocol\n    var protocol = req.protocol === 'https' || req.secure || (req.socket || {}).encrypted\n        ? 'https'\n        : 'http';\n    // url (including path and query string):\n    //   node, express: req.originalUrl\n    //   koa: req.url\n    var originalUrl = (req.originalUrl || req.url || '');\n    // absolute url\n    var absoluteUrl = protocol + \"://\" + host + originalUrl;\n    keys.forEach(function (key) {\n        switch (key) {\n            case 'headers':\n                requestData.headers = headers;\n                break;\n            case 'method':\n                requestData.method = method;\n                break;\n            case 'url':\n                requestData.url = absoluteUrl;\n                break;\n            case 'cookies':\n                // cookies:\n                //   node, express, koa: req.headers.cookie\n                //   vercel, sails.js, express (w/ cookie middleware): req.cookies\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.cookies = req.cookies || dynamicRequire(module, 'cookie').parse(headers.cookie || '');\n                break;\n            case 'query_string':\n                // query string:\n                //   node: req.url (raw)\n                //   express, koa: req.query\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                requestData.query_string = dynamicRequire(module, 'url').parse(originalUrl || '', false).query;\n                break;\n            case 'data':\n                if (method === 'GET' || method === 'HEAD') {\n                    break;\n                }\n                // body data:\n                //   node, express, koa: req.body\n                if (req.body !== undefined) {\n                    requestData.data = isString(req.body) ? req.body : JSON.stringify(normalize(req.body));\n                }\n                break;\n            default:\n                if ({}.hasOwnProperty.call(req, key)) {\n                    requestData[key] = req[key];\n                }\n        }\n    });\n    return requestData;\n}\n//# sourceMappingURL=node.js.map","import { __assign, __values } from \"tslib\";\nimport { isInstanceOf, isString } from './is';\nimport { logger } from './logger';\nimport { getGlobalObject } from './misc';\nimport { fill } from './object';\nimport { getFunctionName } from './stacktrace';\nimport { supportsHistory, supportsNativeFetch } from './supports';\nvar global = getGlobalObject();\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\nvar handlers = {};\nvar instrumented = {};\n/** Instruments given API */\nfunction instrument(type) {\n    if (instrumented[type]) {\n        return;\n    }\n    instrumented[type] = true;\n    switch (type) {\n        case 'console':\n            instrumentConsole();\n            break;\n        case 'dom':\n            instrumentDOM();\n            break;\n        case 'xhr':\n            instrumentXHR();\n            break;\n        case 'fetch':\n            instrumentFetch();\n            break;\n        case 'history':\n            instrumentHistory();\n            break;\n        case 'error':\n            instrumentError();\n            break;\n        case 'unhandledrejection':\n            instrumentUnhandledRejection();\n            break;\n        default:\n            logger.warn('unknown instrumentation type:', type);\n    }\n}\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addInstrumentationHandler(handler) {\n    if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {\n        return;\n    }\n    handlers[handler.type] = handlers[handler.type] || [];\n    handlers[handler.type].push(handler.callback);\n    instrument(handler.type);\n}\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n    var e_1, _a;\n    if (!type || !handlers[type]) {\n        return;\n    }\n    try {\n        for (var _b = __values(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {\n            var handler = _c.value;\n            try {\n                handler(data);\n            }\n            catch (e) {\n                logger.error(\"Error while triggering instrumentation handler.\\nType: \" + type + \"\\nName: \" + getFunctionName(handler) + \"\\nError: \" + e);\n            }\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n}\n/** JSDoc */\nfunction instrumentConsole() {\n    if (!('console' in global)) {\n        return;\n    }\n    ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {\n        if (!(level in global.console)) {\n            return;\n        }\n        fill(global.console, level, function (originalConsoleLevel) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                triggerHandlers('console', { args: args, level: level });\n                // this fails for some browsers. :(\n                if (originalConsoleLevel) {\n                    Function.prototype.apply.call(originalConsoleLevel, global.console, args);\n                }\n            };\n        });\n    });\n}\n/** JSDoc */\nfunction instrumentFetch() {\n    if (!supportsNativeFetch()) {\n        return;\n    }\n    fill(global, 'fetch', function (originalFetch) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var handlerData = {\n                args: args,\n                fetchData: {\n                    method: getFetchMethod(args),\n                    url: getFetchUrl(args),\n                },\n                startTimestamp: Date.now(),\n            };\n            triggerHandlers('fetch', __assign({}, handlerData));\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            return originalFetch.apply(global, args).then(function (response) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));\n                return response;\n            }, function (error) {\n                triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), error: error }));\n                // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n                //       it means the sentry.javascript SDK caught an error invoking your application code.\n                //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n                throw error;\n            });\n        };\n    });\n}\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n        return String(fetchArgs[0].method).toUpperCase();\n    }\n    if (fetchArgs[1] && fetchArgs[1].method) {\n        return String(fetchArgs[1].method).toUpperCase();\n    }\n    return 'GET';\n}\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs) {\n    if (fetchArgs === void 0) { fetchArgs = []; }\n    if (typeof fetchArgs[0] === 'string') {\n        return fetchArgs[0];\n    }\n    if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n        return fetchArgs[0].url;\n    }\n    return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n/** JSDoc */\nfunction instrumentXHR() {\n    if (!('XMLHttpRequest' in global)) {\n        return;\n    }\n    // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.\n    var requestKeys = [];\n    var requestValues = [];\n    var xhrproto = XMLHttpRequest.prototype;\n    fill(xhrproto, 'open', function (originalOpen) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            var xhr = this;\n            var url = args[1];\n            xhr.__sentry_xhr__ = {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n                url: args[1],\n            };\n            // if Sentry key appears in URL, don't capture it as a request\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n            if (isString(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {\n                xhr.__sentry_own_request__ = true;\n            }\n            var onreadystatechangeHandler = function () {\n                if (xhr.readyState === 4) {\n                    try {\n                        // touching statusCode in some platforms throws\n                        // an exception\n                        if (xhr.__sentry_xhr__) {\n                            xhr.__sentry_xhr__.status_code = xhr.status;\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    try {\n                        var requestPos = requestKeys.indexOf(xhr);\n                        if (requestPos !== -1) {\n                            // Make sure to pop both key and value to keep it in sync.\n                            requestKeys.splice(requestPos);\n                            var args_1 = requestValues.splice(requestPos)[0];\n                            if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {\n                                xhr.__sentry_xhr__.body = args_1[0];\n                            }\n                        }\n                    }\n                    catch (e) {\n                        /* do nothing */\n                    }\n                    triggerHandlers('xhr', {\n                        args: args,\n                        endTimestamp: Date.now(),\n                        startTimestamp: Date.now(),\n                        xhr: xhr,\n                    });\n                }\n            };\n            if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n                fill(xhr, 'onreadystatechange', function (original) {\n                    return function () {\n                        var readyStateArgs = [];\n                        for (var _i = 0; _i < arguments.length; _i++) {\n                            readyStateArgs[_i] = arguments[_i];\n                        }\n                        onreadystatechangeHandler();\n                        return original.apply(xhr, readyStateArgs);\n                    };\n                });\n            }\n            else {\n                xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n            }\n            return originalOpen.apply(xhr, args);\n        };\n    });\n    fill(xhrproto, 'send', function (originalSend) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            requestKeys.push(this);\n            requestValues.push(args);\n            triggerHandlers('xhr', {\n                args: args,\n                startTimestamp: Date.now(),\n                xhr: this,\n            });\n            return originalSend.apply(this, args);\n        };\n    });\n}\nvar lastHref;\n/** JSDoc */\nfunction instrumentHistory() {\n    if (!supportsHistory()) {\n        return;\n    }\n    var oldOnPopState = global.onpopstate;\n    global.onpopstate = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var to = global.location.href;\n        // keep track of the current URL state, as we always receive only the updated state\n        var from = lastHref;\n        lastHref = to;\n        triggerHandlers('history', {\n            from: from,\n            to: to,\n        });\n        if (oldOnPopState) {\n            return oldOnPopState.apply(this, args);\n        }\n    };\n    /** @hidden */\n    function historyReplacementFunction(originalHistoryFunction) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var url = args.length > 2 ? args[2] : undefined;\n            if (url) {\n                // coerce to string (this is what pushState does)\n                var from = lastHref;\n                var to = String(url);\n                // keep track of the current URL state, as we always receive only the updated state\n                lastHref = to;\n                triggerHandlers('history', {\n                    from: from,\n                    to: to,\n                });\n            }\n            return originalHistoryFunction.apply(this, args);\n        };\n    }\n    fill(global.history, 'pushState', historyReplacementFunction);\n    fill(global.history, 'replaceState', historyReplacementFunction);\n}\n/** JSDoc */\nfunction instrumentDOM() {\n    if (!('document' in global)) {\n        return;\n    }\n    // Capture breadcrumbs from any click that is unhandled / bubbled up all the way\n    // to the document. Do this before we instrument addEventListener.\n    global.document.addEventListener('click', domEventHandler('click', triggerHandlers.bind(null, 'dom')), false);\n    global.document.addEventListener('keypress', keypressEventHandler(triggerHandlers.bind(null, 'dom')), false);\n    // After hooking into document bubbled up click and keypresses events, we also hook into user handled click & keypresses.\n    ['EventTarget', 'Node'].forEach(function (target) {\n        /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n        var proto = global[target] && global[target].prototype;\n        // eslint-disable-next-line no-prototype-builtins\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n            return;\n        }\n        /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n        fill(proto, 'addEventListener', function (original) {\n            return function (eventName, fn, options) {\n                if (fn && fn.handleEvent) {\n                    if (eventName === 'click') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                domEventHandler('click', triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                    if (eventName === 'keypress') {\n                        fill(fn, 'handleEvent', function (innerOriginal) {\n                            return function (event) {\n                                keypressEventHandler(triggerHandlers.bind(null, 'dom'))(event);\n                                return innerOriginal.call(this, event);\n                            };\n                        });\n                    }\n                }\n                else {\n                    if (eventName === 'click') {\n                        domEventHandler('click', triggerHandlers.bind(null, 'dom'), true)(this);\n                    }\n                    if (eventName === 'keypress') {\n                        keypressEventHandler(triggerHandlers.bind(null, 'dom'))(this);\n                    }\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (original) {\n            return function (eventName, fn, options) {\n                try {\n                    original.call(this, eventName, fn.__sentry_wrapped__, options);\n                }\n                catch (e) {\n                    // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n                }\n                return original.call(this, eventName, fn, options);\n            };\n        });\n    });\n}\nvar debounceDuration = 1000;\nvar debounceTimer = 0;\nvar keypressTimeout;\nvar lastCapturedEvent;\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param name the event name (e.g. \"click\")\n * @param handler function that will be triggered\n * @param debounce decides whether it should wait till another event loop\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction domEventHandler(name, handler, debounce) {\n    if (debounce === void 0) { debounce = false; }\n    return function (event) {\n        // reset keypress timeout; e.g. triggering a 'click' after\n        // a 'keypress' will reset the keypress debounce so that a new\n        // set of keypresses can be recorded\n        keypressTimeout = undefined;\n        // It's possible this handler might trigger multiple times for the same\n        // event (e.g. event propagation through node ancestors). Ignore if we've\n        // already captured the event.\n        if (!event || lastCapturedEvent === event) {\n            return;\n        }\n        lastCapturedEvent = event;\n        if (debounceTimer) {\n            clearTimeout(debounceTimer);\n        }\n        if (debounce) {\n            debounceTimer = setTimeout(function () {\n                handler({ event: event, name: name });\n            });\n        }\n        else {\n            handler({ event: event, name: name });\n        }\n    };\n}\n/**\n * Wraps addEventListener to capture keypress UI events\n * @param handler function that will be triggered\n * @returns wrapped keypress events handler\n * @hidden\n */\nfunction keypressEventHandler(handler) {\n    // TODO: if somehow user switches keypress target before\n    //       debounce timeout is triggered, we will only capture\n    //       a single breadcrumb from the FIRST target (acceptable?)\n    return function (event) {\n        var target;\n        try {\n            target = event.target;\n        }\n        catch (e) {\n            // just accessing event properties can throw an exception in some rare circumstances\n            // see: https://github.com/getsentry/raven-js/issues/838\n            return;\n        }\n        var tagName = target && target.tagName;\n        // only consider keypress events on actual input elements\n        // this will disregard keypresses targeting body (e.g. tabbing\n        // through elements, hotkeys, etc)\n        if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {\n            return;\n        }\n        // record first keypress in a series, but ignore subsequent\n        // keypresses until debounce clears\n        if (!keypressTimeout) {\n            domEventHandler('input', handler)(event);\n        }\n        clearTimeout(keypressTimeout);\n        keypressTimeout = setTimeout(function () {\n            keypressTimeout = undefined;\n        }, debounceDuration);\n    };\n}\nvar _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n    _oldOnErrorHandler = global.onerror;\n    global.onerror = function (msg, url, line, column, error) {\n        triggerHandlers('error', {\n            column: column,\n            error: error,\n            line: line,\n            msg: msg,\n            url: url,\n        });\n        if (_oldOnErrorHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnErrorHandler.apply(this, arguments);\n        }\n        return false;\n    };\n}\nvar _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n    _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n    global.onunhandledrejection = function (e) {\n        triggerHandlers('unhandledrejection', e);\n        if (_oldOnUnhandledRejectionHandler) {\n            // eslint-disable-next-line prefer-rest-params\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n        }\n        return true;\n    };\n}\n//# sourceMappingURL=instrument.js.map","export var SDK_VERSION = '6.0.2';\n//# sourceMappingURL=version.js.map","var defaultFunctionName = '<anonymous>';\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn) {\n    try {\n        if (!fn || typeof fn !== 'function') {\n            return defaultFunctionName;\n        }\n        return fn.name || defaultFunctionName;\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        return defaultFunctionName;\n    }\n}\n//# sourceMappingURL=stacktrace.js.map","import { isRegExp, isString } from './is';\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str, max) {\n    if (max === void 0) { max = 0; }\n    if (typeof str !== 'string' || max === 0) {\n        return str;\n    }\n    return str.length <= max ? str : str.substr(0, max) + \"...\";\n}\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line, colno) {\n    var newLine = line;\n    var ll = newLine.length;\n    if (ll <= 150) {\n        return newLine;\n    }\n    if (colno > ll) {\n        // eslint-disable-next-line no-param-reassign\n        colno = ll;\n    }\n    var start = Math.max(colno - 60, 0);\n    if (start < 5) {\n        start = 0;\n    }\n    var end = Math.min(start + 140, ll);\n    if (end > ll - 5) {\n        end = ll;\n    }\n    if (end === ll) {\n        start = Math.max(end - 140, 0);\n    }\n    newLine = newLine.slice(start, end);\n    if (start > 0) {\n        newLine = \"'{snip} \" + newLine;\n    }\n    if (end < ll) {\n        newLine += ' {snip}';\n    }\n    return newLine;\n}\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input, delimiter) {\n    if (!Array.isArray(input)) {\n        return '';\n    }\n    var output = [];\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < input.length; i++) {\n        var value = input[i];\n        try {\n            output.push(String(value));\n        }\n        catch (e) {\n            output.push('[value cannot be serialized]');\n        }\n    }\n    return output.join(delimiter);\n}\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nexport function isMatchingPattern(value, pattern) {\n    if (!isString(value)) {\n        return false;\n    }\n    if (isRegExp(pattern)) {\n        return pattern.test(value);\n    }\n    if (typeof pattern === 'string') {\n        return value.indexOf(pattern) !== -1;\n    }\n    return false;\n}\n//# sourceMappingURL=string.js.map","export { BaseTransport } from './base';\nexport { FetchTransport } from './fetch';\nexport { XHRTransport } from './xhr';\n//# sourceMappingURL=index.js.map","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat) {\n    switch (Object.prototype.toString.call(wat)) {\n        case '[object Error]':\n            return true;\n        case '[object Exception]':\n            return true;\n        case '[object DOMException]':\n            return true;\n        default:\n            return isInstanceOf(wat, Error);\n    }\n}\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat) {\n    return Object.prototype.toString.call(wat) === '[object ErrorEvent]';\n}\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMError]';\n}\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat) {\n    return Object.prototype.toString.call(wat) === '[object DOMException]';\n}\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat) {\n    return Object.prototype.toString.call(wat) === '[object String]';\n}\n/**\n * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat) {\n    return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat) {\n    return Object.prototype.toString.call(wat) === '[object Object]';\n}\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat) {\n    return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat) {\n    return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat) {\n    return Object.prototype.toString.call(wat) === '[object RegExp]';\n}\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat) {\n    return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat, base) {\n    try {\n        return wat instanceof base;\n    }\n    catch (_e) {\n        return false;\n    }\n}\n//# sourceMappingURL=is.js.map"],"sourceRoot":""}