{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/byteUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/serialisation/heavyCustomerDataWarning.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/valueHistory.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/browser/pageExitObservable.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack:///./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/stringUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/flushController.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/sendWithRetryStrategy.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack:///./node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/numberUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/getGlobalObject.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/typeUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/tracekit/computeStackTrace.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/display.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/serialisation/contextManager.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack:///./node_modules/@datadog/browser-core/esm/boot/init.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/user/user.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/eventRateLimiter/createEventRateLimiter.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack:///./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack:///./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/configuration.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logger.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsSessionManager.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsCollection/logger/loggerCollection.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/assembly.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsCollection/console/consoleCollection.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsCollection/report/reportCollection.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsCollection/networkError/networkErrorCollection.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/lifeCycle.js","webpack:///./node_modules/@datadog/browser-logs/esm/entries/main.js","webpack:///./node_modules/@datadog/browser-logs/esm/boot/logsPublicApi.js","webpack:///./node_modules/@datadog/browser-logs/esm/boot/startLogs.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsCollection/runtimeError/runtimeErrorCollection.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/internalContext.js","webpack:///./node_modules/@datadog/browser-logs/esm/transport/startLogsBridge.js","webpack:///./node_modules/@datadog/browser-logs/esm/transport/startLogsBatch.js","webpack:///./app/javascript/packs/datadog-log.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/tracekit/tracekit.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionStoreStrategy.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionState.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInCookie.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/timer.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","navigationStart","ONE_SECOND","ONE_MINUTE","ONE_HOUR","ONE_YEAR","relativeToClocks","relative","timeStamp","getCorrectedTimeStamp","relativeTime","correctedOrigin","dateNow","performance","now","getNavigationStart","Math","round","addDuration","getTimeStamp","currentDrift","toServerDuration","duration","Date","getTime","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","a","b","getRelativeTime","timestamp","looksLikeRelativeTime","time","undefined","timing","Observable","onFirstSubscribe","this","observers","subscribe","f","_this","length","onLastUnsubscribe","push","unsubscribe","filter","other","notify","data","forEach","observer","mergeObservables","observables","_i","arguments","globalObservable","subscriptions","map","observable","subscription","ONE_KIBI_BYTE","ONE_MEBI_BYTE","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","candidate","test","window","TextEncoder","encode","Blob","size","concatBuffers","buffers","reduce","total","buffer","result","Uint8Array","offset","buffers_1","set","isIE","Boolean","document","documentMode","isChromium","chrome","navigator","userAgent","CUSTOMER_DATA_BYTES_LIMIT","warnIfCustomerDataLimitReached","bytesCount","customerDataType","warn","concat","END_OF_TIMES","Infinity","CLEAR_OLD_VALUES_INTERVAL","ValueHistory","expireDelay","maxEntries","entries","clearOldValuesInterval","clearOldValues","add","startTime","entry","endTime","remove","index","indexOf","splice","close","pop","unshift","find","_a","closeActive","latestEntry","findAll","reset","stop","oldTimeThreshold","sendToExtension","type","payload","callback","__ddBrowserSdkExtensionCallback","isServerError","status","tryToClone","response","clone","e","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","createPageExitObservable","configuration","pagehideEnabled","stopListeners","event","reason","visibilityState","capture","stopBeforeUnloadListener","isPageExitReason","throttle","fn","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","apply","cancel","noop","_typeof","iterator","constructor","jsonStringify","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","Array","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","objectToJson","toJSON","getCurrentSiteCache","setCookie","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","cookie","getCookie","deleteCookie","areCookiesAuthorized","testCookieName","testCookieValue","isCookieCorrectlySet","error","getCurrentSite","domainLevels","location","hostname","split","candidateDomain","generateUUID","placeholder","parseInt","random","toString","replace","findCommaSeparatedValue","rawString","matches","RegExp","exec","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","slice","Batch","request","flushController","messageBytesLimit","pushOnlyBuffer","upsertBuffer","flushObservable","flush","message","addOrUpdate","upsert","messages","join","flushReason","sendOnExit","send","process","processedMessage","messageBytesCount","hasMessageFor","separatorBytesCount","messagesCount","notifyBeforeAddMessage","notifyAfterAddMessage","removedMessage","notifyAfterRemoveMessage","createFlushController","messagesLimit","bytesLimit","durationLimit","pageExitObservable","sessionExpireObservable","durationLimitTimeoutId","currentBytesCount","currentMessagesCount","cancelDurationLimitTimeout","MAX_ONGOING_BYTES_COUNT","MAX_ONGOING_REQUESTS","MAX_QUEUE_BYTES_COUNT","MAX_BACKOFF_TIME","INITIAL_BACKOFF_TIME","sendWithRetryStrategy","state","sendStrategy","endpointType","reportError","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","first","dequeue","currentBackoffTime","min","onLine","shouldRetryRequest","ongoingRequestCount","retry","count","lastFailureStatus","isFull","queueFullReported","source","AGENT","startClocks","previousQueue","newPayloadQueue","queue","shift","createHttpRequest","endpointBuilder","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","canUseKeepAlive","Request","isKeepAliveSupported","fetchUrl","build","fetch","method","body","keepalive","then","monitor","xhrUrl","sendXHR","fetchKeepAliveStrategy","canUseBeacon","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","sendBeaconStrategy","url","XMLHttpRequest","open","addEventListener","once","eventTarget","eventName","listener","addEventListeners","_","eventNames","_b","passive","wrappedListener","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","stackTrace","originalError","handlingStack","nonErrorPrefix","handling","isErrorInstance","Error","computeMessage","stack","hasUsableStack","toStackTraceString","causes","parentSource","currentError","cause","flattenErrorCauses","fingerprint","tryToGetFingerprint","String","dd_fingerprint","formatErrorMessage","frame","func","args","line","column","getFileFromStackTraceString","createHandlingStack","formattedStack","ExperimentalFeature","enabledExperimentalFeatures","Set","addExperimentalFeatures","enabledFeatures","flag","isExperimentalFeatureEnabled","featureName","has","getExperimentalFeatures","includes","search","arrayFrom","arrayLike","from","array","item","predicate","findLast","list","objectValues","keys","objectEntries","startsWith","endsWith","elementMatches","element","selector","msMatchesSelector","cssEscape","str","CSS","escape","ch","asCodePoint","assign","target","toAssign","performDraw","threshold","num","decimals","toFixed","isPercentage","isNumber","getGlobalObject","globalThis","configurable","globalObject","_dd_temp_","self","instrumentMethod","instrumentationFactory","original","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","after","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SANITIZE_DEFAULT_MAX_CHARACTER_COUNT","JSON_PATH_ROOT_ELEMENT","KEY_DECORATION_LENGTH","sanitize","maxCharacterCount","containerQueue","visitedObjectsWithPath","WeakMap","sanitizedData","sanitizeProcessor","accumulatedCharacterCount","containerToProcess","separatorLength","isArray","targetData","path","warnOverCharacterLimit","parentPath","sourceToSanitize","tryToApplyToJSON","description","sanitizePrimitivesAndFunctions","sanitizedSource","Event","isTrusted","match","sanitizeObjects","sourceAsObject","currentPath","changeType","getZoneJsOriginalValue","browserWindow","Zone","__symbol__","INTAKE_SITE_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_AP1","INTAKE_SITE_US1_FED","getType","normalizeUrl","buildUrl","getLinkElementOrigin","href","isValidUrl","getOrigin","getPathName","pathname","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","URL","origin","sanitizedHost","host","protocol","UNKNOWN_FUNCTION","computeStackTrace","ex","stackProperty","tryToGetString","exString","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","fileUrl","filePosition","ConsoleApiName","log","debug","info","display","api","globalConsole","console","shallowClone","objectHasValue","some","isEmptyObject","mapValues","newObject","ErrorSource","CONSOLE","CUSTOM","LOGGER","NETWORK","SOURCE","REPORT","onMonitorErrorCollected","__spreadArray","to","pack","ar","debugMode","startMonitorErrorCollection","newOnMonitorErrorCollected","setDebugMode","newDebugMode","monitored","__","descriptor","originalMethod","callMonitored","context","displayIfDebugEnabled","RawReportType","intervention","deprecation","cspViolation","initReportObservable","apis","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","id","types","buffered","observe","disconnect","createReportObservable","BYTES_COMPUTATION_THROTTLING_DELAY","createContextManager","computeBytesCountImpl","bytesCountCache","alreadyWarned","computeBytesCountThrottled","contextManager","getBytesCount","newContext","getContext","setContext","clearContext","setContextProperty","removeContextProperty","BoundedBuffer","drain","makePublicApi","stub","publicApi","version","onReady","defineGlobal","global","existingGlobalVariable","q","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","eventType","canUseEventBridge","currentHost","bridge","allowedHost","sanitizeUser","newUser","user","checkUser","isValid","VISIBILITY_CHECK_DELAY","SESSION_CONTEXT_TIMEOUT_DELAY","stopCallbacks","startSessionManager","productKey","computeSessionState","sessionStore","sessionStoreStrategyType","sessionContextHistory","buildSessionContext","getSession","trackingType","renewObservable","expireObservable","expandOrRenewSession","trackActivity","expandSession","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","expire","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","SYNTHETICS_TEST_ID_COOKIE_NAME","SYNTHETICS_RESULT_ID_COOKIE_NAME","SYNTHETICS_INJECTS_RUM_COOKIE_NAME","willSyntheticsInjectRum","_DATADOG_SYNTHETICS_INJECTS_RUM","getSyntheticsTestId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsResultId","_DATADOG_SYNTHETICS_RESULT_ID","consoleObservablesByApi","initConsoleObservable","consoleObservables","originalConsoleApi","params","param","formatConsoleParameters","firstErrorParam","buildConsoleLog","createConsoleObservable","xhrObservable","xhrContexts","initXhrObservable","stopInstrumentingStart","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","startContext","isAborted","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","readyState","DONE","onEnd","unsubscribeLoadEndListener","completeContext","fetchObservable","initFetchObservable","originalFetch","input","init","responsePromise","beforeSend","afterSend","reportFetch","DOMException","code","ABORT_ERR","responseType","readBytesFromStream","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","collectStreamBody","completeBuffer_1","offset_1","chunk","readMore","read","done","AbstractLifeCycle","callbacks","eventCallbacks","DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT","validateAndBuildForwardOption","option","allowedValues","label","every","__decorate","decorators","desc","Reflect","decorate","StatusType","HandlerType","STATUSES","Logger","handleLogStrategy","handlerType","level","loggerContext","logger","messageContext","errorContext","rawError","kind","sanitizedMessageContext","addContext","removeContext","setHandler","handler","getHandler","setLevel","getLevel","startBatchWithReplica","endpoint","replicaEndpoint","replicaBatch","primaryBatch","createBatch","batchBytesLimit","batchMessagesLimit","flushTimeout","replicated","startLogsSessionManager","sessionManager","rawTrackingType","rawSessionType","hasValidLoggerSession","computeTrackingType","isTracked","findTrackedSession","session","sessionSampleRate","STATUS_PRIORITIES","isAuthorized","loggerHandler","sanitizedHandlerType","logsSentBeforeRumInjectionTelemetryAdded","getRUMInternalContext","getInternalContextFromRumGlobal","DD_RUM_SYNTHETICS","testId","resultId","DD_RUM","rumGlobal","getInternalContext","LogStatusForApi","LogStatusForReport","startNetworkErrorCollection","lifeCycle","forwardErrorsToLogs","xhrSubscription","handleResponse","fetchSubscription","onResponseDataAvailable","responseData","rawLogsEvent","format","http","status_code","isIntakeUrl","isRejected","truncateResponseText","computeXhrResponseData","clonedResponse","TextDecoder","responseText","decode","truncateResponseStream","requestErrorResponseLengthLimit","text","computeFetchResponseText","computeFetchErrorText","substring","LifeCycle","datadogLogs","startLogsImpl","isAlreadyInitialized","globalContextManager","userContextManager","customLoggers","getInternalContextStrategy","beforeInitLoggerLog","_handleLogStrategy","logsMessage","savedCommonContext","buildCommonContext","getInitConfigurationStrategy","mainLogger","view","referrer","initConfiguration","clientToken","overrideInitConfigurationForBridge","silentMultipleInit","canInitLogs","baseConfiguration","forwardConsoleLogs","forwardReports","validateAndBuildLogsConfiguration","handleLog","getLoggerGlobalContext","getGlobalContext","setLoggerGlobalContext","setGlobalContext","addLoggerGlobalContext","setGlobalContextProperty","removeLoggerGlobalContext","removeGlobalContextProperty","clearGlobalContext","createLogger","conf","getLogger","getInitConfiguration","setUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","clearUser","makeLogsPublicApi","startLogsSessionManagerStub","telemetry","bridge_1","telemetryBatch_1","rumEndpointBuilder","replica","startLogsTelemetry","setContextProvider","_c","_d","_e","_f","application","application_id","action","user_action","rawErrorObservable","stopRuntimeErrorTracking","trackRuntimeError","rawErrorSubscription","startRuntimeErrorCollection","consoleSubscription","startConsoleCollection","reportSubscription","startReportCollection","savedDate","startLoggerCollection","statusWithCustom","logRateLimiters","eventRateLimiterThreshold","_g","commonContext","service","session_id","usr","startLogsAssembly","serverLogsEvent","startLogsBridge","batch","logsEndpointBuilder","startLogsBatch","baseSerializedInitConfiguration","forward_errors_to_logs","forward_console_logs","forward_reports","serializeLogsConfiguration","trackedSession","ENV","querySelector","site","env","getAttribute","useSecureSessionCookie","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","createEndpointBuilder","configurationTags","buildUrlWithParameters","proxy","proxyUrl","normalizedProxyUrl_1","encodeURIComponent","internalAnalyticsSubdomain","domainParts","extension","subdomain","buildEndpointHost","normalizedProxyUrl_2","createEndpointUrlWithParametersBuilder","tags","COLLECT_FLUSH_REASON","reverse","buildEndpointParameters","urlPrefix","TAG_SIZE_LIMIT","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","computeTransportConfiguration","datacenter","buildTags","endpointBuilders","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeUrlPrefixes","builder","replicaConfiguration","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","intakeEndpoint","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","sampleRate","telemetrySampleRate","telemetryConfigurationSampleRate","enableExperimentalFeatures","catchUserErrors","maxTelemetryEventsPerPage","serializeConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","use_before_send","use_cross_site_session_cookie","useCrossSiteSessionCookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","trackSessionAcrossSubdomains","track_resources","trackResources","track_long_task","trackLongTasks","allow_fallback_to_local_storage","allowFallbackToLocalStorage","ERROR_TYPES_RE","startUnhandledErrorCollection","stopInstrumentingOnError","messageObj","errorObj","tryToParseMessage","instrumentOnError","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","errorObservable","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryConfiguration","maxEventsPerPage","sentEventCount","telemetryEnabled","telemetryConfigurationEnabled","startTelemetry","telemetryService","contextProvider","rawEvent","event_1","_dd","format_version","experimental_features","toTelemetryEvent","addTelemetryError","provider","enabled","isTelemetryReplicationAllowed","addTelemetryDebug","addTelemetry","scrubCustomerFrames","formatError","addTelemetryConfiguration","allowedFrameUrl","errorMsg","err","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","createCircularReferenceChecker","flags","ignoreCase","multiline","sticky","unicode","merged_1","merged","deepClone","combine","sources","sources_1","SESSION_STORE_KEY","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","isSessionInExpiredState","expandSessionState","toSessionString","toSessionState","sessionString","isValidSessionString","OLD_SESSION_COOKIE_NAME","OLD_RUM_COOKIE_NAME","OLD_LOGS_COOKIE_NAME","RUM_SESSION_KEY","LOGS_SESSION_KEY","selectCookieStrategy","cookieOptions","buildCookieOptions","initCookieStrategy","cookieStore","persistSession","retrieveSession","retrieveSessionCookie","clearSession","deleteSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","LOCAL_STORAGE_TEST_KEY","persistInLocalStorage","sessionState","localStorage","setItem","retrieveSessionFromLocalStorage","getItem","clearSessionFromLocalStorage","removeItem","ongoingOperations","LOCK_RETRY_DELAY","LOCK_MAX_TRIES","bufferedOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","lockEnabled","next","currentLock","currentSession","lock","retryLater","processedSession","currentNumberOfRetries","nextOperations","STORAGE_POLL_DELAY","selectSessionStoreStrategyType","testKey","retrievedId","selectLocalStorageStrategy","startSessionStore","watchSessionTimeoutId","isActiveSession","synchronizeSession","sessionCache","retrieveActiveSession","hasSessionInCache","isSessionInCacheOutdated","created","Number","synchronizedSession","expandOrRenewSessionState","renewSessionInCache","setTimeout","delay","clearTimeout","timeoutId","setInterval","clearInterval"],"mappings":"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","file":"js/datadog-log-a7394f417f56deba862c.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 632);\n","import { isNumber, round } from './numberUtils';\nexport var ONE_SECOND = 1000;\nexport var ONE_MINUTE = 60 * ONE_SECOND;\nexport var ONE_HOUR = 60 * ONE_MINUTE;\nexport var ONE_DAY = 24 * ONE_HOUR;\nexport var ONE_YEAR = 365 * ONE_DAY;\nexport function relativeToClocks(relative) {\n  return {\n    relative: relative,\n    timeStamp: getCorrectedTimeStamp(relative)\n  };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n  var correctedOrigin = dateNow() - performance.now();\n  // apply correction only for positive drift\n  if (correctedOrigin > getNavigationStart()) {\n    return Math.round(addDuration(correctedOrigin, relativeTime));\n  }\n  return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n  return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now()));\n}\nexport function toServerDuration(duration) {\n  if (!isNumber(duration)) {\n    return duration;\n  }\n  return round(duration * 1e6, 0);\n}\nexport function dateNow() {\n  // Do not use `Date.now` because sometimes websites are wrongly \"polyfilling\" it. For example, we\n  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date\n  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this\n  // case ourselves.\n  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16\n  return new Date().getTime();\n}\nexport function timeStampNow() {\n  return dateNow();\n}\nexport function relativeNow() {\n  return performance.now();\n}\nexport function clocksNow() {\n  return {\n    relative: relativeNow(),\n    timeStamp: timeStampNow()\n  };\n}\nexport function clocksOrigin() {\n  return {\n    relative: 0,\n    timeStamp: getNavigationStart()\n  };\n}\nexport function elapsed(start, end) {\n  return end - start;\n}\nexport function addDuration(a, b) {\n  return a + b;\n}\n/**\n * Get the time since the navigation was started.\n *\n * Note: this does not use `performance.timeOrigin` because it doesn't seem to reflect the actual\n * time on which the navigation has started: it may be much farther in the past, at least in Firefox 71.\n * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926\n */\nexport function getRelativeTime(timestamp) {\n  return timestamp - getNavigationStart();\n}\nexport function getTimeStamp(relativeTime) {\n  return Math.round(addDuration(getNavigationStart(), relativeTime));\n}\nexport function looksLikeRelativeTime(time) {\n  return time < ONE_YEAR;\n}\n/**\n * Navigation start slightly change on some rare cases\n */\nvar navigationStart;\nfunction getNavigationStart() {\n  if (navigationStart === undefined) {\n    navigationStart = performance.timing.navigationStart;\n  }\n  return navigationStart;\n}\nexport function resetNavigationStart() {\n  navigationStart = undefined;\n}","var Observable = /** @class */function () {\n  function Observable(onFirstSubscribe) {\n    this.onFirstSubscribe = onFirstSubscribe;\n    this.observers = [];\n  }\n  Observable.prototype.subscribe = function (f) {\n    var _this = this;\n    if (!this.observers.length && this.onFirstSubscribe) {\n      this.onLastUnsubscribe = this.onFirstSubscribe() || undefined;\n    }\n    this.observers.push(f);\n    return {\n      unsubscribe: function unsubscribe() {\n        _this.observers = _this.observers.filter(function (other) {\n          return f !== other;\n        });\n        if (!_this.observers.length && _this.onLastUnsubscribe) {\n          _this.onLastUnsubscribe();\n        }\n      }\n    };\n  };\n  Observable.prototype.notify = function (data) {\n    this.observers.forEach(function (observer) {\n      return observer(data);\n    });\n  };\n  return Observable;\n}();\nexport { Observable };\nexport function mergeObservables() {\n  var observables = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    observables[_i] = arguments[_i];\n  }\n  var globalObservable = new Observable(function () {\n    var subscriptions = observables.map(function (observable) {\n      return observable.subscribe(function (data) {\n        return globalObservable.notify(data);\n      });\n    });\n    return function () {\n      return subscriptions.forEach(function (subscription) {\n        return subscription.unsubscribe();\n      });\n    };\n  });\n  return globalObservable;\n}","export var ONE_KIBI_BYTE = 1024;\nexport var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\n// eslint-disable-next-line no-control-regex\nvar HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nexport function computeBytesCount(candidate) {\n  // Accurate bytes count computations can degrade performances when there is a lot of events to process\n  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n    return candidate.length;\n  }\n  if (window.TextEncoder !== undefined) {\n    return new TextEncoder().encode(candidate).length;\n  }\n  return new Blob([candidate]).size;\n}\nexport function concatBuffers(buffers) {\n  var length = buffers.reduce(function (total, buffer) {\n    return total + buffer.length;\n  }, 0);\n  var result = new Uint8Array(length);\n  var offset = 0;\n  for (var _i = 0, buffers_1 = buffers; _i < buffers_1.length; _i++) {\n    var buffer = buffers_1[_i];\n    result.set(buffer, offset);\n    offset += buffer.length;\n  }\n  return result;\n}","export function isIE() {\n  return Boolean(document.documentMode);\n}\nexport function isChromium() {\n  return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent);\n}","import { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { display } from '../display';\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n    display.warn(\"The \".concat(customerDataType, \" data exceeds the recommended \").concat(CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE, \"KiB threshold. More details: https://docs.datadoghq.com/real_user_monitoring/browser/troubleshooting/#customer-data-exceeds-the-recommended-3kib-warning\"));\n    return true;\n  }\n  return false;\n}","import { setInterval, clearInterval } from './timer';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\n/**\n * Store and keep track of values spans. This whole class assumes that values are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nvar ValueHistory = /** @class */function () {\n  function ValueHistory(expireDelay, maxEntries) {\n    var _this = this;\n    this.expireDelay = expireDelay;\n    this.maxEntries = maxEntries;\n    this.entries = [];\n    this.clearOldValuesInterval = setInterval(function () {\n      return _this.clearOldValues();\n    }, CLEAR_OLD_VALUES_INTERVAL);\n  }\n  /**\n   * Add a value to the history associated with a start time. Returns a reference to this newly\n   * added entry that can be removed or closed.\n   */\n  ValueHistory.prototype.add = function (value, startTime) {\n    var _this = this;\n    var entry = {\n      value: value,\n      startTime: startTime,\n      endTime: END_OF_TIMES,\n      remove: function remove() {\n        var index = _this.entries.indexOf(entry);\n        if (index >= 0) {\n          _this.entries.splice(index, 1);\n        }\n      },\n      close: function close(endTime) {\n        entry.endTime = endTime;\n      }\n    };\n    if (this.maxEntries && this.entries.length >= this.maxEntries) {\n      this.entries.pop();\n    }\n    this.entries.unshift(entry);\n    return entry;\n  };\n  /**\n   * Return the latest value that was active during `startTime`, or the currently active value\n   * if no `startTime` is provided. This method assumes that entries are not overlapping.\n   */\n  ValueHistory.prototype.find = function (startTime) {\n    if (startTime === void 0) {\n      startTime = END_OF_TIMES;\n    }\n    for (var _i = 0, _a = this.entries; _i < _a.length; _i++) {\n      var entry = _a[_i];\n      if (entry.startTime <= startTime) {\n        if (startTime <= entry.endTime) {\n          return entry.value;\n        }\n        break;\n      }\n    }\n  };\n  /**\n   * Helper function to close the currently active value, if any. This method assumes that entries\n   * are not overlapping.\n   */\n  ValueHistory.prototype.closeActive = function (endTime) {\n    var latestEntry = this.entries[0];\n    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n      latestEntry.close(endTime);\n    }\n  };\n  /**\n   * Return all values with an active period overlapping with the duration,\n   * or all values that were active during `startTime` if no duration is provided,\n   * or all currently active values if no `startTime` is provided.\n   */\n  ValueHistory.prototype.findAll = function (startTime, duration) {\n    if (startTime === void 0) {\n      startTime = END_OF_TIMES;\n    }\n    if (duration === void 0) {\n      duration = 0;\n    }\n    var endTime = addDuration(startTime, duration);\n    return this.entries.filter(function (entry) {\n      return entry.startTime <= endTime && startTime <= entry.endTime;\n    }).map(function (entry) {\n      return entry.value;\n    });\n  };\n  /**\n   * Remove all entries from this collection.\n   */\n  ValueHistory.prototype.reset = function () {\n    this.entries = [];\n  };\n  /**\n   * Stop internal garbage collection of past entries.\n   */\n  ValueHistory.prototype.stop = function () {\n    clearInterval(this.clearOldValuesInterval);\n  };\n  ValueHistory.prototype.clearOldValues = function () {\n    var oldTimeThreshold = relativeNow() - this.expireDelay;\n    while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {\n      this.entries.pop();\n    }\n  };\n  return ValueHistory;\n}();\nexport { ValueHistory };","export function sendToExtension(type, payload) {\n  var callback = window.__ddBrowserSdkExtensionCallback;\n  if (callback) {\n    callback({\n      type: type,\n      payload: payload\n    });\n  }\n}","export function isServerError(status) {\n  return status >= 500;\n}\nexport function tryToClone(response) {\n  try {\n    return response.clone();\n  } catch (e) {\n    // clone can throw if the response has already been used by another instrumentation or is disturbed\n    return;\n  }\n}","import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../tools/experimentalFeatures';\nimport { Observable } from '../tools/observable';\nimport { objectValues, includes } from '../tools/utils/polyfills';\nimport { noop } from '../tools/utils/functionUtils';\nimport { addEventListeners, addEventListener } from './addEventListener';\nexport var PageExitReason = {\n  HIDDEN: 'visibility_hidden',\n  UNLOADING: 'before_unload',\n  PAGEHIDE: 'page_hide',\n  FROZEN: 'page_frozen'\n};\nexport function createPageExitObservable(configuration) {\n  var observable = new Observable(function () {\n    var pagehideEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGEHIDE);\n    var stopListeners = addEventListeners(configuration, window, [\"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, \"freeze\" /* DOM_EVENT.FREEZE */, \"pagehide\" /* DOM_EVENT.PAGE_HIDE */], function (event) {\n      if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */ && pagehideEnabled) {\n        /**\n         * Only event that detect page unload events while being compatible with the back/forward cache (bfcache)\n         */\n        observable.notify({\n          reason: PageExitReason.PAGEHIDE\n        });\n      } else if (event.type === \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */ && document.visibilityState === 'hidden') {\n        /**\n         * Only event that guarantee to fire on mobile devices when the page transitions to background state\n         * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n         */\n        observable.notify({\n          reason: PageExitReason.HIDDEN\n        });\n      } else if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n        /**\n         * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)\n         * Allow to collect events happening between hidden and frozen state.\n         */\n        observable.notify({\n          reason: PageExitReason.FROZEN\n        });\n      }\n    }, {\n      capture: true\n    }).stop;\n    var stopBeforeUnloadListener = noop;\n    if (!pagehideEnabled) {\n      stopBeforeUnloadListener = addEventListener(configuration, window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, function () {\n        observable.notify({\n          reason: PageExitReason.UNLOADING\n        });\n      }).stop;\n    }\n    return function () {\n      stopListeners();\n      stopBeforeUnloadListener();\n    };\n  });\n  return observable;\n}\nexport function isPageExitReason(reason) {\n  return includes(objectValues(PageExitReason), reason);\n}","import { setTimeout, clearTimeout } from '../timer';\n// use lodash API\nexport function throttle(fn, wait, options) {\n  var needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n  var needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n  var inWaitPeriod = false;\n  var pendingExecutionWithParameters;\n  var pendingTimeoutId;\n  return {\n    throttled: function throttled() {\n      var parameters = [];\n      for (var _i = 0; _i < arguments.length; _i++) {\n        parameters[_i] = arguments[_i];\n      }\n      if (inWaitPeriod) {\n        pendingExecutionWithParameters = parameters;\n        return;\n      }\n      if (needLeadingExecution) {\n        fn.apply(void 0, parameters);\n      } else {\n        pendingExecutionWithParameters = parameters;\n      }\n      inWaitPeriod = true;\n      pendingTimeoutId = setTimeout(function () {\n        if (needTrailingExecution && pendingExecutionWithParameters) {\n          fn.apply(void 0, pendingExecutionWithParameters);\n        }\n        inWaitPeriod = false;\n        pendingExecutionWithParameters = undefined;\n      }, wait);\n    },\n    cancel: function cancel() {\n      clearTimeout(pendingTimeoutId);\n      inWaitPeriod = false;\n      pendingExecutionWithParameters = undefined;\n    }\n  };\n}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() {}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nimport { noop } from '../utils/functionUtils';\n/**\n * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(value, replacer, space) {\n  if (_typeof(value) !== 'object' || value === null) {\n    return JSON.stringify(value);\n  }\n  // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n  // subclasses.\n  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n  var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n  var restoreValueToJson = detachToJsonMethod(value);\n  try {\n    return JSON.stringify(value, replacer, space);\n  } catch (_a) {\n    return '<error: unable to serialize object>';\n  } finally {\n    restoreObjectPrototypeToJson();\n    restoreArrayPrototypeToJson();\n    restoreValuePrototypeToJson();\n    restoreValueToJson();\n  }\n}\nexport function detachToJsonMethod(value) {\n  var object = value;\n  var objectToJson = object.toJSON;\n  if (objectToJson) {\n    delete object.toJSON;\n    return function () {\n      object.toJSON = objectToJson;\n    };\n  }\n  return noop;\n}","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findCommaSeparatedValue, generateUUID } from '../tools/utils/stringUtils';\nexport function setCookie(name, value, expireDelay, options) {\n  var date = new Date();\n  date.setTime(date.getTime() + expireDelay);\n  var expires = \"expires=\".concat(date.toUTCString());\n  var sameSite = options && options.crossSite ? 'none' : 'strict';\n  var domain = options && options.domain ? \";domain=\".concat(options.domain) : '';\n  var secure = options && options.secure ? ';secure' : '';\n  document.cookie = \"\".concat(name, \"=\").concat(value, \";\").concat(expires, \";path=/;samesite=\").concat(sameSite).concat(domain).concat(secure);\n}\nexport function getCookie(name) {\n  return findCommaSeparatedValue(document.cookie, name);\n}\nexport function deleteCookie(name, options) {\n  setCookie(name, '', 0, options);\n}\nexport function areCookiesAuthorized(options) {\n  if (document.cookie === undefined || document.cookie === null) {\n    return false;\n  }\n  try {\n    // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n    // the test cookie lifetime\n    var testCookieName = \"dd_cookie_test_\".concat(generateUUID());\n    var testCookieValue = 'test';\n    setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);\n    var isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;\n    deleteCookie(testCookieName, options);\n    return isCookieCorrectlySet;\n  } catch (error) {\n    display.error(error);\n    return false;\n  }\n}\n/**\n * No API to retrieve it, number of levels for subdomain and suffix are unknown\n * strategy: find the minimal domain on which cookies are allowed to be set\n * https://web.dev/same-site-same-origin/#site\n */\nvar getCurrentSiteCache;\nexport function getCurrentSite() {\n  if (getCurrentSiteCache === undefined) {\n    // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n    // the test cookie lifetime\n    var testCookieName = \"dd_site_test_\".concat(generateUUID());\n    var testCookieValue = 'test';\n    var domainLevels = window.location.hostname.split('.');\n    var candidateDomain = domainLevels.pop();\n    while (domainLevels.length && !getCookie(testCookieName)) {\n      candidateDomain = \"\".concat(domainLevels.pop(), \".\").concat(candidateDomain);\n      setCookie(testCookieName, testCookieValue, ONE_SECOND, {\n        domain: candidateDomain\n      });\n    }\n    deleteCookie(testCookieName, {\n      domain: candidateDomain\n    });\n    getCurrentSiteCache = candidateDomain;\n  }\n  return getCurrentSiteCache;\n}","/**\n * UUID v4\n * from https://gist.github.com/jed/982883\n */\nexport function generateUUID(placeholder) {\n  return placeholder ?\n  // eslint-disable-next-line  no-bitwise\n  (parseInt(placeholder, 10) ^ Math.random() * 16 >> parseInt(placeholder, 10) / 4).toString(16) : \"\".concat(1e7, \"-\").concat(1e3, \"-\").concat(4e3, \"-\").concat(8e3, \"-\").concat(1e11).replace(/[018]/g, generateUUID);\n}\nexport function findCommaSeparatedValue(rawString, name) {\n  var regex = new RegExp(\"(?:^|;)\\\\s*\".concat(name, \"\\\\s*=\\\\s*([^;]+)\"));\n  var matches = regex.exec(rawString);\n  return matches ? matches[1] : undefined;\n}\nexport function safeTruncate(candidate, length, suffix) {\n  if (suffix === void 0) {\n    suffix = '';\n  }\n  var lastChar = candidate.charCodeAt(length - 1);\n  var isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n  var correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n  if (candidate.length <= correctedLength) {\n    return candidate;\n  }\n  return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}","import { display } from '../tools/display';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isPageExitReason } from '../browser/pageExitObservable';\nimport { computeBytesCount } from '../tools/utils/byteUtils';\nimport { jsonStringify } from '../tools/serialisation/jsonStringify';\nvar Batch = /** @class */function () {\n  function Batch(request, flushController, messageBytesLimit) {\n    var _this = this;\n    this.request = request;\n    this.flushController = flushController;\n    this.messageBytesLimit = messageBytesLimit;\n    this.pushOnlyBuffer = [];\n    this.upsertBuffer = {};\n    this.flushController.flushObservable.subscribe(function (event) {\n      return _this.flush(event);\n    });\n  }\n  Batch.prototype.add = function (message) {\n    this.addOrUpdate(message);\n  };\n  Batch.prototype.upsert = function (message, key) {\n    this.addOrUpdate(message, key);\n  };\n  Batch.prototype.flush = function (event) {\n    var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n    this.pushOnlyBuffer = [];\n    this.upsertBuffer = {};\n    var payload = {\n      data: messages.join('\\n'),\n      bytesCount: event.bytesCount,\n      flushReason: event.reason\n    };\n    if (isPageExitReason(event.reason)) {\n      this.request.sendOnExit(payload);\n    } else {\n      this.request.send(payload);\n    }\n  };\n  Batch.prototype.addOrUpdate = function (message, key) {\n    var _a = this.process(message),\n      processedMessage = _a.processedMessage,\n      messageBytesCount = _a.messageBytesCount;\n    if (messageBytesCount >= this.messageBytesLimit) {\n      display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.messageBytesLimit, \"KB.\"));\n      return;\n    }\n    if (this.hasMessageFor(key)) {\n      this.remove(key);\n    }\n    this.push(processedMessage, messageBytesCount, key);\n  };\n  Batch.prototype.process = function (message) {\n    var processedMessage = jsonStringify(message);\n    var messageBytesCount = computeBytesCount(processedMessage);\n    return {\n      processedMessage: processedMessage,\n      messageBytesCount: messageBytesCount\n    };\n  };\n  Batch.prototype.push = function (processedMessage, messageBytesCount, key) {\n    // If there are other messages, a '\\n' will be added at serialization\n    var separatorBytesCount = this.flushController.messagesCount > 0 ? 1 : 0;\n    this.flushController.notifyBeforeAddMessage(messageBytesCount + separatorBytesCount);\n    if (key !== undefined) {\n      this.upsertBuffer[key] = processedMessage;\n    } else {\n      this.pushOnlyBuffer.push(processedMessage);\n    }\n    this.flushController.notifyAfterAddMessage();\n  };\n  Batch.prototype.remove = function (key) {\n    var removedMessage = this.upsertBuffer[key];\n    delete this.upsertBuffer[key];\n    var messageBytesCount = computeBytesCount(removedMessage);\n    // If there are other messages, a '\\n' will be added at serialization\n    var separatorBytesCount = this.flushController.messagesCount > 1 ? 1 : 0;\n    this.flushController.notifyAfterRemoveMessage(messageBytesCount + separatorBytesCount);\n  };\n  Batch.prototype.hasMessageFor = function (key) {\n    return key !== undefined && this.upsertBuffer[key] !== undefined;\n  };\n  return Batch;\n}();\nexport { Batch };","import { Observable } from '../tools/observable';\nimport { clearTimeout, setTimeout } from '../tools/timer';\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController(_a) {\n  var messagesLimit = _a.messagesLimit,\n    bytesLimit = _a.bytesLimit,\n    durationLimit = _a.durationLimit,\n    pageExitObservable = _a.pageExitObservable,\n    sessionExpireObservable = _a.sessionExpireObservable;\n  var flushObservable = new Observable();\n  pageExitObservable.subscribe(function (event) {\n    return flush(event.reason);\n  });\n  sessionExpireObservable.subscribe(function () {\n    return flush('session_expire');\n  });\n  var currentBytesCount = 0;\n  var currentMessagesCount = 0;\n  function flush(flushReason) {\n    if (currentMessagesCount === 0) {\n      return;\n    }\n    var messagesCount = currentMessagesCount;\n    var bytesCount = currentBytesCount;\n    currentMessagesCount = 0;\n    currentBytesCount = 0;\n    cancelDurationLimitTimeout();\n    flushObservable.notify({\n      reason: flushReason,\n      messagesCount: messagesCount,\n      bytesCount: bytesCount\n    });\n  }\n  var durationLimitTimeoutId;\n  function scheduleDurationLimitTimeout() {\n    if (durationLimitTimeoutId === undefined) {\n      durationLimitTimeoutId = setTimeout(function () {\n        flush('duration_limit');\n      }, durationLimit);\n    }\n  }\n  function cancelDurationLimitTimeout() {\n    clearTimeout(durationLimitTimeoutId);\n    durationLimitTimeoutId = undefined;\n  }\n  return {\n    flushObservable: flushObservable,\n    get messagesCount() {\n      return currentMessagesCount;\n    },\n    /**\n     * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n     *\n     * This function needs to be called synchronously, right before adding the message, so no flush\n     * event can happen after `notifyBeforeAddMessage` and before adding the message.\n     */\n    notifyBeforeAddMessage: function notifyBeforeAddMessage(messageBytesCount) {\n      if (currentBytesCount + messageBytesCount >= bytesLimit) {\n        flush('bytes_limit');\n      }\n      // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n      // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n      // to notify when a flush is needed (for example on page exit).\n      currentMessagesCount += 1;\n      currentBytesCount += messageBytesCount;\n      scheduleDurationLimitTimeout();\n    },\n    /**\n     * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n     *\n     * This function can be called asynchronously after the message was added, but in this case it\n     * should not be called if a flush event occurred in between.\n     */\n    notifyAfterAddMessage: function notifyAfterAddMessage() {\n      if (currentMessagesCount >= messagesLimit) {\n        flush('messages_limit');\n      } else if (currentBytesCount >= bytesLimit) {\n        flush('bytes_limit');\n      }\n    },\n    /**\n     * Notifies that a message was removed from a pool of pending messages waiting to be flushed.\n     *\n     * This function needs to be called synchronously, right after removing the message, so no flush\n     * event can happen after removing the message and before `notifyAfterRemoveMessage`.\n     */\n    notifyAfterRemoveMessage: function notifyAfterRemoveMessage(messageBytesCount) {\n      currentBytesCount -= messageBytesCount;\n      currentMessagesCount -= 1;\n      if (currentMessagesCount === 0) {\n        cancelDurationLimitTimeout();\n      }\n    }\n  };\n}","import { setTimeout } from '../tools/timer';\nimport { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nimport { isServerError } from '../tools/utils/responseUtils';\nimport { ErrorSource } from '../domain/error/error.types';\nexport var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;\nexport var MAX_ONGOING_REQUESTS = 32;\nexport var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;\nexport var MAX_BACKOFF_TIME = ONE_MINUTE;\nexport var INITIAL_BACKOFF_TIME = ONE_SECOND;\nexport function sendWithRetryStrategy(payload, state, sendStrategy, endpointType, reportError) {\n  if (state.transportStatus === 0 /* TransportStatus.UP */ && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) {\n    send(payload, state, sendStrategy, {\n      onSuccess: function onSuccess() {\n        return retryQueuedPayloads(0 /* RetryReason.AFTER_SUCCESS */, state, sendStrategy, endpointType, reportError);\n      },\n      onFailure: function onFailure() {\n        state.queuedPayloads.enqueue(payload);\n        scheduleRetry(state, sendStrategy, endpointType, reportError);\n      }\n    });\n  } else {\n    state.queuedPayloads.enqueue(payload);\n  }\n}\nfunction scheduleRetry(state, sendStrategy, endpointType, reportError) {\n  if (state.transportStatus !== 2 /* TransportStatus.DOWN */) {\n    return;\n  }\n  setTimeout(function () {\n    var payload = state.queuedPayloads.first();\n    send(payload, state, sendStrategy, {\n      onSuccess: function onSuccess() {\n        state.queuedPayloads.dequeue();\n        state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n        retryQueuedPayloads(1 /* RetryReason.AFTER_RESUME */, state, sendStrategy, endpointType, reportError);\n      },\n      onFailure: function onFailure() {\n        state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n        scheduleRetry(state, sendStrategy, endpointType, reportError);\n      }\n    });\n  }, state.currentBackoffTime);\n}\nfunction send(payload, state, sendStrategy, _a) {\n  var onSuccess = _a.onSuccess,\n    onFailure = _a.onFailure;\n  state.bandwidthMonitor.add(payload);\n  sendStrategy(payload, function (response) {\n    state.bandwidthMonitor.remove(payload);\n    if (!shouldRetryRequest(response)) {\n      state.transportStatus = 0 /* TransportStatus.UP */;\n      onSuccess();\n    } else {\n      // do not consider transport down if another ongoing request could succeed\n      state.transportStatus = state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 /* TransportStatus.FAILURE_DETECTED */ : 2 /* TransportStatus.DOWN */;\n      payload.retry = {\n        count: payload.retry ? payload.retry.count + 1 : 1,\n        lastFailureStatus: response.status\n      };\n      onFailure();\n    }\n  });\n}\nfunction retryQueuedPayloads(reason, state, sendStrategy, endpointType, reportError) {\n  if (reason === 0 /* RetryReason.AFTER_SUCCESS */ && state.queuedPayloads.isFull() && !state.queueFullReported) {\n    reportError({\n      message: \"Reached max \".concat(endpointType, \" events size queued for upload: \").concat(MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE, \"MiB\"),\n      source: ErrorSource.AGENT,\n      startClocks: clocksNow()\n    });\n    state.queueFullReported = true;\n  }\n  var previousQueue = state.queuedPayloads;\n  state.queuedPayloads = newPayloadQueue();\n  while (previousQueue.size() > 0) {\n    sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, endpointType, reportError);\n  }\n}\nfunction shouldRetryRequest(response) {\n  return response.type !== 'opaque' && (response.status === 0 && !navigator.onLine || response.status === 408 || response.status === 429 || isServerError(response.status));\n}\nexport function newRetryState() {\n  return {\n    transportStatus: 0 /* TransportStatus.UP */,\n    currentBackoffTime: INITIAL_BACKOFF_TIME,\n    bandwidthMonitor: newBandwidthMonitor(),\n    queuedPayloads: newPayloadQueue(),\n    queueFullReported: false\n  };\n}\nfunction newPayloadQueue() {\n  var queue = [];\n  return {\n    bytesCount: 0,\n    enqueue: function enqueue(payload) {\n      if (this.isFull()) {\n        return;\n      }\n      queue.push(payload);\n      this.bytesCount += payload.bytesCount;\n    },\n    first: function first() {\n      return queue[0];\n    },\n    dequeue: function dequeue() {\n      var payload = queue.shift();\n      if (payload) {\n        this.bytesCount -= payload.bytesCount;\n      }\n      return payload;\n    },\n    size: function size() {\n      return queue.length;\n    },\n    isFull: function isFull() {\n      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;\n    }\n  };\n}\nfunction newBandwidthMonitor() {\n  return {\n    ongoingRequestCount: 0,\n    ongoingByteCount: 0,\n    canHandle: function canHandle(payload) {\n      return this.ongoingRequestCount === 0 || this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT && this.ongoingRequestCount < MAX_ONGOING_REQUESTS;\n    },\n    add: function add(payload) {\n      this.ongoingRequestCount += 1;\n      this.ongoingByteCount += payload.bytesCount;\n    },\n    remove: function remove(payload) {\n      this.ongoingRequestCount -= 1;\n      this.ongoingByteCount -= payload.bytesCount;\n    }\n  };\n}","import { addTelemetryError } from '../domain/telemetry';\nimport { monitor } from '../tools/monitor';\nimport { addEventListener } from '../browser/addEventListener';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(configuration, endpointBuilder, bytesLimit, reportError) {\n  var retryState = newRetryState();\n  var sendStrategyForRetry = function sendStrategyForRetry(payload, onResponse) {\n    return fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse);\n  };\n  return {\n    send: function send(payload) {\n      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.endpointType, reportError);\n    },\n    /**\n     * Since fetch keepalive behaves like regular fetch on Firefox,\n     * keep using sendBeaconStrategy on exit\n     */\n    sendOnExit: function sendOnExit(payload) {\n      sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload);\n    }\n  };\n}\nfunction sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, _a) {\n  var data = _a.data,\n    bytesCount = _a.bytesCount,\n    flushReason = _a.flushReason;\n  var canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit;\n  if (canUseBeacon) {\n    try {\n      var beaconUrl = endpointBuilder.build('beacon', flushReason);\n      var isQueued = navigator.sendBeacon(beaconUrl, data);\n      if (isQueued) {\n        return;\n      }\n    } catch (e) {\n      reportBeaconError(e);\n    }\n  }\n  var xhrUrl = endpointBuilder.build('xhr', flushReason);\n  sendXHR(configuration, xhrUrl, data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n  if (!hasReportedBeaconError) {\n    hasReportedBeaconError = true;\n    addTelemetryError(e);\n  }\n}\nexport function fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, _a, onResponse) {\n  var data = _a.data,\n    bytesCount = _a.bytesCount,\n    flushReason = _a.flushReason,\n    retry = _a.retry;\n  var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit;\n  if (canUseKeepAlive) {\n    var fetchUrl = endpointBuilder.build('fetch', flushReason, retry);\n    fetch(fetchUrl, {\n      method: 'POST',\n      body: data,\n      keepalive: true,\n      mode: 'cors'\n    }).then(monitor(function (response) {\n      return onResponse === null || onResponse === void 0 ? void 0 : onResponse({\n        status: response.status,\n        type: response.type\n      });\n    }), monitor(function () {\n      var xhrUrl = endpointBuilder.build('xhr', flushReason, retry);\n      // failed to queue the request\n      sendXHR(configuration, xhrUrl, data, onResponse);\n    }));\n  } else {\n    var xhrUrl = endpointBuilder.build('xhr', flushReason, retry);\n    sendXHR(configuration, xhrUrl, data, onResponse);\n  }\n}\nfunction isKeepAliveSupported() {\n  // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors\n  try {\n    return window.Request && 'keepalive' in new Request('http://a');\n  } catch (_a) {\n    return false;\n  }\n}\nexport function sendXHR(configuration, url, data, onResponse) {\n  var request = new XMLHttpRequest();\n  request.open('POST', url, true);\n  addEventListener(configuration, request, 'loadend', function () {\n    onResponse === null || onResponse === void 0 ? void 0 : onResponse({\n      status: request.status\n    });\n  }, {\n    // prevent multiple onResponse callbacks\n    // if the xhr instance is reused by a third party\n    once: true\n  });\n  request.send(data);\n}","import { monitor } from '../tools/monitor';\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue';\n/**\n * Add an event listener to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n */\nexport function addEventListener(configuration, eventTarget, eventName, listener, options) {\n  return addEventListeners(configuration, eventTarget, [eventName], listener, options);\n}\n/**\n * Add event listeners to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n *\n * * with `once: true`, the listener will be called at most once, even if different events are listened\n */\nexport function addEventListeners(_, eventTarget, eventNames, listener, _a) {\n  var _b = _a === void 0 ? {} : _a,\n    once = _b.once,\n    capture = _b.capture,\n    passive = _b.passive;\n  var wrappedListener = monitor(once ? function (event) {\n    stop();\n    listener(event);\n  } : listener);\n  var options = passive ? {\n    capture: capture,\n    passive: passive\n  } : capture;\n  var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');\n  eventNames.forEach(function (eventName) {\n    return add.call(eventTarget, eventName, wrappedListener, options);\n  });\n  function stop() {\n    var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');\n    eventNames.forEach(function (eventName) {\n      return remove.call(eventTarget, eventName, wrappedListener, options);\n    });\n  }\n  return {\n    stop: stop\n  };\n}","import { computeStackTrace } from '../tracekit';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { noop } from '../../tools/utils/functionUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nexport var NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nexport function computeRawError(_a) {\n  var stackTrace = _a.stackTrace,\n    originalError = _a.originalError,\n    handlingStack = _a.handlingStack,\n    startClocks = _a.startClocks,\n    nonErrorPrefix = _a.nonErrorPrefix,\n    source = _a.source,\n    handling = _a.handling;\n  var isErrorInstance = originalError instanceof Error;\n  var message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError);\n  var stack = hasUsableStack(isErrorInstance, stackTrace) ? toStackTraceString(stackTrace) : NO_ERROR_STACK_PRESENT_MESSAGE;\n  var causes = isErrorInstance ? flattenErrorCauses(originalError, source) : undefined;\n  var type = stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name;\n  var fingerprint = tryToGetFingerprint(originalError);\n  return {\n    startClocks: startClocks,\n    source: source,\n    handling: handling,\n    handlingStack: handlingStack,\n    originalError: originalError,\n    type: type,\n    message: message,\n    stack: stack,\n    causes: causes,\n    fingerprint: fingerprint\n  };\n}\nfunction computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError) {\n  // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)\n  // TODO rework tracekit integration to avoid scattering error building logic\n  return (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.message) && (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name) ? stackTrace.message : !isErrorInstance ? \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(sanitize(originalError))) : 'Empty message';\n}\nfunction hasUsableStack(isErrorInstance, stackTrace) {\n  if (stackTrace === undefined) {\n    return false;\n  }\n  if (isErrorInstance) {\n    return true;\n  }\n  // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]\n  // TODO rework tracekit integration to avoid generating those unusable stack\n  return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined);\n}\nexport function tryToGetFingerprint(originalError) {\n  return originalError instanceof Error && 'dd_fingerprint' in originalError ? String(originalError.dd_fingerprint) : undefined;\n}\nexport function toStackTraceString(stack) {\n  var result = formatErrorMessage(stack);\n  stack.stack.forEach(function (frame) {\n    var func = frame.func === '?' ? '<anonymous>' : frame.func;\n    var args = frame.args && frame.args.length > 0 ? \"(\".concat(frame.args.join(', '), \")\") : '';\n    var line = frame.line ? \":\".concat(frame.line) : '';\n    var column = frame.line && frame.column ? \":\".concat(frame.column) : '';\n    result += \"\\n  at \".concat(func).concat(args, \" @ \").concat(frame.url).concat(line).concat(column);\n  });\n  return result;\n}\nexport function getFileFromStackTraceString(stack) {\n  var _a;\n  return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function formatErrorMessage(stack) {\n  return \"\".concat(stack.name || 'Error', \": \").concat(stack.message);\n}\n/**\n Creates a stacktrace without SDK internal frames.\n \n Constraints:\n - Has to be called at the utmost position of the call stack.\n - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack() {\n  /**\n   * Skip the two internal frames:\n   * - SDK API (console.error, ...)\n   * - this function\n   * in order to keep only the user calls\n   */\n  var internalFramesToSkip = 2;\n  var error = new Error();\n  var formattedStack;\n  // IE needs to throw the error to fill in the stack trace\n  if (!error.stack) {\n    try {\n      throw error;\n    } catch (e) {\n      noop();\n    }\n  }\n  callMonitored(function () {\n    var stackTrace = computeStackTrace(error);\n    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n    formattedStack = toStackTraceString(stackTrace);\n  });\n  return formattedStack;\n}\nexport function flattenErrorCauses(error, parentSource) {\n  var currentError = error;\n  var causes = [];\n  while ((currentError === null || currentError === void 0 ? void 0 : currentError.cause) instanceof Error && causes.length < 10) {\n    var stackTrace = computeStackTrace(currentError.cause);\n    causes.push({\n      message: currentError.cause.message,\n      source: parentSource,\n      type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,\n      stack: stackTrace && toStackTraceString(stackTrace)\n    });\n    currentError = currentError.cause;\n  }\n  return causes.length ? causes : undefined;\n}","/**\n * LIMITATION:\n * For NPM setup, this feature flag singleton is shared between RUM and Logs product.\n * This means that an experimental flag set on the RUM product will be set on the Logs product.\n * So keep in mind that in certain configurations, your experimental feature flag may affect other products.\n *\n * FORMAT:\n * All feature flags should be snake_cased\n */\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected feature flag\n// eslint-disable-next-line no-restricted-syntax\nexport var ExperimentalFeature;\n(function (ExperimentalFeature) {\n  ExperimentalFeature[\"PAGEHIDE\"] = \"pagehide\";\n  ExperimentalFeature[\"FEATURE_FLAGS\"] = \"feature_flags\";\n  ExperimentalFeature[\"RESOURCE_PAGE_STATES\"] = \"resource_page_states\";\n  ExperimentalFeature[\"PAGE_STATES\"] = \"page_states\";\n  ExperimentalFeature[\"COLLECT_FLUSH_REASON\"] = \"collect_flush_reason\";\n  ExperimentalFeature[\"NO_RESOURCE_DURATION_FROZEN_STATE\"] = \"no_resource_duration_frozen_state\";\n  ExperimentalFeature[\"SCROLLMAP\"] = \"scrollmap\";\n  ExperimentalFeature[\"DISABLE_REPLAY_INLINE_CSS\"] = \"disable_replay_inline_css\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nvar enabledExperimentalFeatures = new Set();\nexport function addExperimentalFeatures(enabledFeatures) {\n  enabledFeatures.forEach(function (flag) {\n    enabledExperimentalFeatures.add(flag);\n  });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n  return enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n  enabledExperimentalFeatures.clear();\n}\nexport function getExperimentalFeatures() {\n  return enabledExperimentalFeatures;\n}","export function includes(candidate, search) {\n  return candidate.indexOf(search) !== -1;\n}\nexport function arrayFrom(arrayLike) {\n  if (Array.from) {\n    return Array.from(arrayLike);\n  }\n  var array = [];\n  if (arrayLike instanceof Set) {\n    arrayLike.forEach(function (item) {\n      return array.push(item);\n    });\n  } else {\n    for (var i = 0; i < arrayLike.length; i++) {\n      array.push(arrayLike[i]);\n    }\n  }\n  return array;\n}\nexport function find(array, predicate) {\n  for (var i = 0; i < array.length; i += 1) {\n    var item = array[i];\n    if (predicate(item, i)) {\n      return item;\n    }\n  }\n  return undefined;\n}\nexport function findLast(array, predicate) {\n  for (var i = array.length - 1; i >= 0; i -= 1) {\n    var item = array[i];\n    if (predicate(item, i, array)) {\n      return item;\n    }\n  }\n  return undefined;\n}\nexport function forEach(list, callback) {\n  Array.prototype.forEach.call(list, callback);\n}\nexport function objectValues(object) {\n  return Object.keys(object).map(function (key) {\n    return object[key];\n  });\n}\nexport function objectEntries(object) {\n  return Object.keys(object).map(function (key) {\n    return [key, object[key]];\n  });\n}\nexport function startsWith(candidate, search) {\n  return candidate.slice(0, search.length) === search;\n}\nexport function endsWith(candidate, search) {\n  return candidate.slice(-search.length) === search;\n}\nexport function elementMatches(element, selector) {\n  if (element.matches) {\n    return element.matches(selector);\n  }\n  // IE11 support\n  if (element.msMatchesSelector) {\n    return element.msMatchesSelector(selector);\n  }\n  return false;\n}\n// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js\nexport function cssEscape(str) {\n  if (window.CSS && window.CSS.escape) {\n    return window.CSS.escape(str);\n  }\n  // eslint-disable-next-line no-control-regex\n  return str.replace(/([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g, function (ch, asCodePoint) {\n    if (asCodePoint) {\n      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n      if (ch === '\\0') {\n        return \"\\uFFFD\";\n      }\n      // Control characters and (dependent upon position) numbers get escaped as code points\n      return \"\".concat(ch.slice(0, -1), \"\\\\\").concat(ch.charCodeAt(ch.length - 1).toString(16), \" \");\n    }\n    // Other potentially-special ASCII characters get backslash-escaped\n    return \"\\\\\".concat(ch);\n  });\n}\nexport function assign(target) {\n  var toAssign = [];\n  for (var _i = 1; _i < arguments.length; _i++) {\n    toAssign[_i - 1] = arguments[_i];\n  }\n  toAssign.forEach(function (source) {\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  });\n  return target;\n}","/**\n * Return true if the draw is successful\n * @param threshold between 0 and 100\n */\nexport function performDraw(threshold) {\n  return threshold !== 0 && Math.random() * 100 <= threshold;\n}\nexport function round(num, decimals) {\n  return +num.toFixed(decimals);\n}\nexport function isPercentage(value) {\n  return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n  return typeof value === 'number';\n}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\n/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\nexport function getGlobalObject() {\n  if ((typeof globalThis === \"undefined\" ? \"undefined\" : _typeof(globalThis)) === 'object') {\n    return globalThis;\n  }\n  Object.defineProperty(Object.prototype, '_dd_temp_', {\n    get: function get() {\n      return this;\n    },\n    configurable: true\n  });\n  // @ts-ignore _dd_temp is defined using defineProperty\n  var globalObject = _dd_temp_;\n  // @ts-ignore _dd_temp is defined using defineProperty\n  delete Object.prototype._dd_temp_;\n  if (_typeof(globalObject) !== 'object') {\n    // on safari _dd_temp_ is available on window but not globally\n    // fallback on other browser globals check\n    if ((typeof self === \"undefined\" ? \"undefined\" : _typeof(self)) === 'object') {\n      globalObject = self;\n    } else if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === 'object') {\n      globalObject = window;\n    } else {\n      globalObject = {};\n    }\n  }\n  return globalObject;\n}","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nexport function instrumentMethod(object, method, instrumentationFactory) {\n  var original = object[method];\n  var instrumentation = instrumentationFactory(original);\n  var instrumentationWrapper = function instrumentationWrapper() {\n    if (typeof instrumentation !== 'function') {\n      return undefined;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return instrumentation.apply(this, arguments);\n  };\n  object[method] = instrumentationWrapper;\n  return {\n    stop: function stop() {\n      if (object[method] === instrumentationWrapper) {\n        object[method] = original;\n      } else {\n        instrumentation = original;\n      }\n    }\n  };\n}\nexport function instrumentMethodAndCallOriginal(object, method, _a) {\n  var before = _a.before,\n    after = _a.after;\n  return instrumentMethod(object, method, function (original) {\n    return function () {\n      var args = arguments;\n      var result;\n      if (before) {\n        callMonitored(before, this, args);\n      }\n      if (typeof original === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        result = original.apply(this, args);\n      }\n      if (after) {\n        callMonitored(after, this, args);\n      }\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      return result;\n    };\n  });\n}\nexport function instrumentSetter(object, property, after) {\n  var originalDescriptor = Object.getOwnPropertyDescriptor(object, property);\n  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n    return {\n      stop: noop\n    };\n  }\n  var instrumentation = function instrumentation(thisObject, value) {\n    // put hooked setter into event loop to avoid of set latency\n    setTimeout(function () {\n      after(thisObject, value);\n    }, 0);\n  };\n  var instrumentationWrapper = function instrumentationWrapper(value) {\n    originalDescriptor.set.call(this, value);\n    instrumentation(this, value);\n  };\n  Object.defineProperty(object, property, {\n    set: instrumentationWrapper\n  });\n  return {\n    stop: function stop() {\n      var _a;\n      if (((_a = Object.getOwnPropertyDescriptor(object, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {\n        Object.defineProperty(object, property, originalDescriptor);\n      } else {\n        instrumentation = noop;\n      }\n    }\n  };\n}","import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils/timeUtils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nimport { display } from '../display';\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { detachToJsonMethod } from './jsonStringify';\n// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data\n// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...\nvar SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;\n// Symbol for the root element of the JSONPath used for visited objects\nvar JSON_PATH_ROOT_ELEMENT = '$';\n// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as \"key\".\n// With the separator (:), we need to add 3 characters to the count.\nvar KEY_DECORATION_LENGTH = 3;\nexport function sanitize(source, maxCharacterCount) {\n  var _a;\n  if (maxCharacterCount === void 0) {\n    maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT;\n  }\n  // Unbind any toJSON function we may have on [] or {} prototypes\n  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n  // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n  var containerQueue = [];\n  var visitedObjectsWithPath = new WeakMap();\n  var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);\n  var accumulatedCharacterCount = ((_a = JSON.stringify(sanitizedData)) === null || _a === void 0 ? void 0 : _a.length) || 0;\n  if (accumulatedCharacterCount > maxCharacterCount) {\n    warnOverCharacterLimit(maxCharacterCount, 'discarded', source);\n    return undefined;\n  }\n  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n    var containerToProcess = containerQueue.shift();\n    var separatorLength = 0; // 0 for the first element, 1 for subsequent elements\n    // Arrays and Objects have to be handled distinctly to ensure\n    // we do not pick up non-numerical properties from Arrays\n    if (Array.isArray(containerToProcess.source)) {\n      for (var key = 0; key < containerToProcess.source.length; key++) {\n        var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n        if (targetData !== undefined) {\n          accumulatedCharacterCount += JSON.stringify(targetData).length;\n        } else {\n          // When an element of an Array (targetData) is undefined, it is serialized as null:\n          // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters\n          accumulatedCharacterCount += 4;\n        }\n        accumulatedCharacterCount += separatorLength;\n        separatorLength = 1;\n        if (accumulatedCharacterCount > maxCharacterCount) {\n          warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n          break;\n        }\n        ;\n        containerToProcess.target[key] = targetData;\n      }\n    } else {\n      for (var key in containerToProcess.source) {\n        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n          var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n          // When a property of an object has an undefined value, it will be dropped during serialization:\n          // JSON.stringify({a:undefined}) => '{}'\n          if (targetData !== undefined) {\n            accumulatedCharacterCount += JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;\n            separatorLength = 1;\n          }\n          if (accumulatedCharacterCount > maxCharacterCount) {\n            warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n            break;\n          }\n          ;\n          containerToProcess.target[key] = targetData;\n        }\n      }\n    }\n  }\n  // Rebind detached toJSON functions\n  restoreObjectPrototypeToJson();\n  restoreArrayPrototypeToJson();\n  return sanitizedData;\n}\n/**\n * Internal function to factorize the process common to the\n * initial call to sanitize, and iterations for Arrays and Objects\n *\n */\nfunction sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {\n  // Start by handling toJSON, as we want to sanitize its output\n  var sourceToSanitize = tryToApplyToJSON(source);\n  if (!sourceToSanitize || _typeof(sourceToSanitize) !== 'object') {\n    return sanitizePrimitivesAndFunctions(sourceToSanitize);\n  }\n  var sanitizedSource = sanitizeObjects(sourceToSanitize);\n  if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n    return sanitizedSource;\n  }\n  // Handle potential cyclic references\n  // We need to use source as sourceToSanitize could be a reference to a new object\n  // At this stage, we know the source is an object type\n  var sourceAsObject = source;\n  if (visitedObjectsWithPath.has(sourceAsObject)) {\n    return \"[Reference seen at \".concat(visitedObjectsWithPath.get(sourceAsObject), \"]\");\n  }\n  // Add processed source to queue\n  var currentPath = key !== undefined ? \"\".concat(parentPath, \".\").concat(key) : parentPath;\n  var target = Array.isArray(sourceToSanitize) ? [] : {};\n  visitedObjectsWithPath.set(sourceAsObject, currentPath);\n  queue.push({\n    source: sourceToSanitize,\n    target: target,\n    path: currentPath\n  });\n  return target;\n}\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value) {\n  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n  if (typeof value === 'bigint') {\n    return \"[BigInt] \".concat(value.toString());\n  }\n  // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted\n  // so it won't prevent stringify from serializing later\n  if (typeof value === 'function') {\n    return \"[Function] \".concat(value.name || 'unknown');\n  }\n  // JSON.stringify() does not serialize symbols.\n  if (_typeof(value) === 'symbol') {\n    return \"[Symbol] \".concat(value.description || value.toString());\n  }\n  return value;\n}\n/**\n * Handles sanitization of object types\n *\n * LIMITATIONS\n * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.\n * To avoid this, a toJSON method can be defined.\n * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their\n * properties enumerated if any.\n *\n */\nfunction sanitizeObjects(value) {\n  try {\n    // Handle events - Keep a simple implementation to avoid breaking changes\n    if (value instanceof Event) {\n      return {\n        isTrusted: value.isTrusted\n      };\n    }\n    // Handle all remaining object types in a generic way\n    var result = Object.prototype.toString.call(value);\n    var match = result.match(/\\[object (.*)\\]/);\n    if (match && match[1]) {\n      return \"[\".concat(match[1], \"]\");\n    }\n  } catch (_a) {\n    // If the previous serialization attempts failed, and we cannot convert using\n    // Object.prototype.toString, declare the value unserializable\n  }\n  return '[Unserializable]';\n}\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value) {\n  var object = value;\n  if (object && typeof object.toJSON === 'function') {\n    try {\n      return object.toJSON();\n    } catch (_a) {\n      // If toJSON fails, we continue by trying to serialize the value manually\n    }\n  }\n  return value;\n}\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount, changeType, source) {\n  display.warn(\"The data provided has been \".concat(changeType, \" as it is over the limit of \").concat(maxCharacterCount, \" characters:\"), source);\n}","import { getGlobalObject } from './getGlobalObject';\n/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue(target, name) {\n  var browserWindow = getGlobalObject();\n  var original;\n  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n    original = target[browserWindow.Zone.__symbol__(name)];\n  }\n  if (!original) {\n    original = target[name];\n  }\n  return original;\n}","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport var INTAKE_SITE_AP1 = 'ap1.datadoghq.com';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\n/**\n * Similar to `typeof`, but distinguish plain objects from `null` and arrays\n */\nexport function getType(value) {\n  if (value === null) {\n    return 'null';\n  }\n  if (Array.isArray(value)) {\n    return 'array';\n  }\n  return _typeof(value);\n}","import { jsonStringify } from '../serialisation/jsonStringify';\nexport function normalizeUrl(url) {\n  return buildUrl(url, getLocationOrigin()).href;\n}\nexport function isValidUrl(url) {\n  try {\n    return !!buildUrl(url);\n  } catch (_a) {\n    return false;\n  }\n}\nexport function getOrigin(url) {\n  return getLinkElementOrigin(buildUrl(url));\n}\nexport function getPathName(url) {\n  var pathname = buildUrl(url).pathname;\n  return pathname[0] === '/' ? pathname : \"/\".concat(pathname);\n}\nexport function getSearch(url) {\n  return buildUrl(url).search;\n}\nexport function getHash(url) {\n  return buildUrl(url).hash;\n}\nexport function buildUrl(url, base) {\n  var supportedURL = getSupportedUrl();\n  if (supportedURL) {\n    try {\n      return base !== undefined ? new supportedURL(url, base) : new supportedURL(url);\n    } catch (error) {\n      throw new Error(\"Failed to construct URL: \".concat(String(error), \" \").concat(jsonStringify({\n        url: url,\n        base: base\n      })));\n    }\n  }\n  if (base === undefined && !/:/.test(url)) {\n    throw new Error(\"Invalid URL: '\".concat(url, \"'\"));\n  }\n  var doc = document;\n  var anchorElement = doc.createElement('a');\n  if (base !== undefined) {\n    doc = document.implementation.createHTMLDocument('');\n    var baseElement = doc.createElement('base');\n    baseElement.href = base;\n    doc.head.appendChild(baseElement);\n    doc.body.appendChild(anchorElement);\n  }\n  anchorElement.href = url;\n  return anchorElement;\n}\nvar originalURL = URL;\nvar isURLSupported;\nfunction getSupportedUrl() {\n  if (isURLSupported === undefined) {\n    try {\n      var url = new originalURL('http://test/path');\n      isURLSupported = url.href === 'http://test/path';\n    } catch (_a) {\n      isURLSupported = false;\n    }\n  }\n  return isURLSupported ? originalURL : undefined;\n}\nexport function getLocationOrigin() {\n  return getLinkElementOrigin(window.location);\n}\n/**\n * Fallback\n * On IE HTMLAnchorElement origin is not supported: https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin\n * On Firefox window.location.origin is \"null\" for file: URIs: https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n */\nexport function getLinkElementOrigin(element) {\n  if (element.origin && element.origin !== 'null') {\n    return element.origin;\n  }\n  var sanitizedHost = element.host.replace(/(:80|:443)$/, '');\n  return \"\".concat(element.protocol, \"//\").concat(sanitizedHost);\n}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nimport { startsWith } from '../../tools/utils/polyfills';\nvar UNKNOWN_FUNCTION = '?';\n/**\n * Computes a stack trace for an exception.\n */\nexport function computeStackTrace(ex) {\n  var stack = [];\n  var stackProperty = tryToGetString(ex, 'stack');\n  var exString = String(ex);\n  if (stackProperty && startsWith(stackProperty, exString)) {\n    stackProperty = stackProperty.slice(exString.length);\n  }\n  if (stackProperty) {\n    stackProperty.split('\\n').forEach(function (line) {\n      var stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line);\n      if (stackFrame) {\n        if (!stackFrame.func && stackFrame.line) {\n          stackFrame.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(stackFrame);\n      }\n    });\n  }\n  return {\n    message: tryToGetString(ex, 'message'),\n    name: tryToGetString(ex, 'name'),\n    stack: stack\n  };\n}\nvar fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nvar filePosition = '(?::(\\\\d+))';\nvar CHROME_LINE_RE = new RegExp(\"^\\\\s*at (.*?) ?\\\\(\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"?\\\\)?\\\\s*$\"), 'i');\nvar CHROME_EVAL_RE = new RegExp(\"\\\\((\\\\S*)\".concat(filePosition).concat(filePosition, \"\\\\)\"));\nfunction parseChromeLine(line) {\n  var parts = CHROME_LINE_RE.exec(line);\n  if (!parts) {\n    return;\n  }\n  var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n  var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n  var submatch = CHROME_EVAL_RE.exec(parts[2]);\n  if (isEval && submatch) {\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  return {\n    args: isNative ? [parts[2]] : [],\n    column: parts[4] ? +parts[4] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: parts[3] ? +parts[3] : undefined,\n    url: !isNative ? parts[2] : undefined\n  };\n}\nvar CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(\"^\\\\s*at ?\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"??\\\\s*$\"), 'i');\nfunction parseChromeAnonymousLine(line) {\n  var parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);\n  if (!parts) {\n    return;\n  }\n  return {\n    args: [],\n    column: parts[3] ? +parts[3] : undefined,\n    func: UNKNOWN_FUNCTION,\n    line: parts[2] ? +parts[2] : undefined,\n    url: parts[1]\n  };\n}\nvar WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n  var parts = WINJS_LINE_RE.exec(line);\n  if (!parts) {\n    return;\n  }\n  return {\n    args: [],\n    column: parts[4] ? +parts[4] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: +parts[3],\n    url: parts[2]\n  };\n}\nvar GECKO_LINE_RE = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n  var parts = GECKO_LINE_RE.exec(line);\n  if (!parts) {\n    return;\n  }\n  var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n  var submatch = GECKO_EVAL_RE.exec(parts[3]);\n  if (isEval && submatch) {\n    // throw out eval line/column and use top-most line number\n    parts[3] = submatch[1];\n    parts[4] = submatch[2];\n    parts[5] = undefined; // no column when eval\n  }\n  return {\n    args: parts[2] ? parts[2].split(',') : [],\n    column: parts[5] ? +parts[5] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: parts[4] ? +parts[4] : undefined,\n    url: parts[3]\n  };\n}\nfunction tryToGetString(candidate, property) {\n  if (_typeof(candidate) !== 'object' || !candidate || !(property in candidate)) {\n    return undefined;\n  }\n  var value = candidate[property];\n  return typeof value === 'string' ? value : undefined;\n}","/* eslint-disable local-rules/disallow-side-effects */\n/**\n * Keep references on console methods to avoid triggering patched behaviors\n *\n * NB: in some setup, console could already be patched by another SDK.\n * In this case, some display messages can be sent by the other SDK\n * but we should be safe from infinite loop nonetheless.\n */\nexport var ConsoleApiName = {\n  log: 'log',\n  debug: 'debug',\n  info: 'info',\n  warn: 'warn',\n  error: 'error'\n};\nexport var display = function display(api) {\n  var args = [];\n  for (var _i = 1; _i < arguments.length; _i++) {\n    args[_i - 1] = arguments[_i];\n  }\n  if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {\n    api = ConsoleApiName.log;\n  }\n  display[api].apply(display, args);\n};\n/**\n * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove\n * \"console.*\" references. This causes some issue as we expect `console.*` to be defined.\n * As a workaround, let's use a variable alias, so those expressions won't be taken into account by\n * simple static analysis.\n *\n * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/\n * [2]: https://github.com/terser/terser#compress-options (look for drop_console)\n */\nexport var globalConsole = console;\ndisplay.debug = globalConsole.debug.bind(globalConsole);\ndisplay.log = globalConsole.log.bind(globalConsole);\ndisplay.info = globalConsole.info.bind(globalConsole);\ndisplay.warn = globalConsole.warn.bind(globalConsole);\ndisplay.error = globalConsole.error.bind(globalConsole);","import { assign } from './polyfills';\nexport function shallowClone(object) {\n  return assign({}, object);\n}\nexport function objectHasValue(object, value) {\n  return Object.keys(object).some(function (key) {\n    return object[key] === value;\n  });\n}\nexport function isEmptyObject(object) {\n  return Object.keys(object).length === 0;\n}\nexport function mapValues(object, fn) {\n  var newObject = {};\n  for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {\n    var key = _a[_i];\n    newObject[key] = fn(object[key]);\n  }\n  return newObject;\n}","export var ErrorSource = {\n  AGENT: 'agent',\n  CONSOLE: 'console',\n  CUSTOM: 'custom',\n  LOGGER: 'logger',\n  NETWORK: 'network',\n  SOURCE: 'source',\n  REPORT: 'report'\n};","var __spreadArray = this && this.__spreadArray || function (to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { ConsoleApiName, display } from './display';\nvar onMonitorErrorCollected;\nvar debugMode = false;\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected) {\n  onMonitorErrorCollected = newOnMonitorErrorCollected;\n}\nexport function setDebugMode(newDebugMode) {\n  debugMode = newDebugMode;\n}\nexport function resetMonitor() {\n  onMonitorErrorCollected = undefined;\n  debugMode = false;\n}\nexport function monitored(_, __, descriptor) {\n  var originalMethod = descriptor.value;\n  descriptor.value = function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    var decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod;\n    return decorated.apply(this, args);\n  };\n}\nexport function monitor(fn) {\n  return function () {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return callMonitored(fn, this, arguments);\n  }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return fn.apply(context, args);\n  } catch (e) {\n    displayIfDebugEnabled(ConsoleApiName.error, e);\n    if (onMonitorErrorCollected) {\n      try {\n        onMonitorErrorCollected(e);\n      } catch (e) {\n        displayIfDebugEnabled(ConsoleApiName.error, e);\n      }\n    }\n  }\n}\nexport function displayIfDebugEnabled(api) {\n  var args = [];\n  for (var _i = 1; _i < arguments.length; _i++) {\n    args[_i - 1] = arguments[_i];\n  }\n  if (debugMode) {\n    display.apply(void 0, __spreadArray([api, '[MONITOR]'], args, false));\n  }\n}","import { toStackTraceString } from '../error/error';\nimport { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { addEventListener } from '../../browser/addEventListener';\nimport { includes } from '../../tools/utils/polyfills';\nimport { safeTruncate } from '../../tools/utils/stringUtils';\nexport var RawReportType = {\n  intervention: 'intervention',\n  deprecation: 'deprecation',\n  cspViolation: 'csp_violation'\n};\nexport function initReportObservable(configuration, apis) {\n  var observables = [];\n  if (includes(apis, RawReportType.cspViolation)) {\n    observables.push(createCspViolationReportObservable(configuration));\n  }\n  var reportTypes = apis.filter(function (api) {\n    return api !== RawReportType.cspViolation;\n  });\n  if (reportTypes.length) {\n    observables.push(createReportObservable(reportTypes));\n  }\n  return mergeObservables.apply(void 0, observables);\n}\nfunction createReportObservable(reportTypes) {\n  var observable = new Observable(function () {\n    if (!window.ReportingObserver) {\n      return;\n    }\n    var handleReports = monitor(function (reports, _) {\n      return reports.forEach(function (report) {\n        observable.notify(buildRawReportFromReport(report));\n      });\n    });\n    var observer = new window.ReportingObserver(handleReports, {\n      types: reportTypes,\n      buffered: true\n    });\n    observer.observe();\n    return function () {\n      observer.disconnect();\n    };\n  });\n  return observable;\n}\nfunction createCspViolationReportObservable(configuration) {\n  var observable = new Observable(function () {\n    var stop = addEventListener(configuration, document, \"securitypolicyviolation\" /* DOM_EVENT.SECURITY_POLICY_VIOLATION */, function (event) {\n      observable.notify(buildRawReportFromCspViolation(event));\n    }).stop;\n    return stop;\n  });\n  return observable;\n}\nfunction buildRawReportFromReport(_a) {\n  var type = _a.type,\n    body = _a.body;\n  return {\n    type: type,\n    subtype: body.id,\n    message: \"\".concat(type, \": \").concat(body.message),\n    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber)\n  };\n}\nfunction buildRawReportFromCspViolation(event) {\n  var type = RawReportType.cspViolation;\n  var message = \"'\".concat(event.blockedURI, \"' blocked by '\").concat(event.effectiveDirective, \"' directive\");\n  return {\n    type: RawReportType.cspViolation,\n    subtype: event.effectiveDirective,\n    message: \"\".concat(type, \": \").concat(message),\n    stack: buildStack(event.effectiveDirective, event.originalPolicy ? \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\") : 'no policy', event.sourceFile, event.lineNumber, event.columnNumber)\n  };\n}\nfunction buildStack(name, message, sourceFile, lineNumber, columnNumber) {\n  return sourceFile ? toStackTraceString({\n    name: name,\n    message: message,\n    stack: [{\n      func: '?',\n      url: sourceFile,\n      line: lineNumber !== null && lineNumber !== void 0 ? lineNumber : undefined,\n      column: columnNumber !== null && columnNumber !== void 0 ? columnNumber : undefined\n    }]\n  }) : undefined;\n}","import { computeBytesCount } from '../utils/byteUtils';\nimport { throttle } from '../utils/functionUtils';\nimport { deepClone } from '../mergeInto';\nimport { getType } from '../utils/typeUtils';\nimport { jsonStringify } from './jsonStringify';\nimport { sanitize } from './sanitize';\nimport { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning';\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\nexport function createContextManager(customerDataType, computeBytesCountImpl) {\n  if (computeBytesCountImpl === void 0) {\n    computeBytesCountImpl = computeBytesCount;\n  }\n  var context = {};\n  var bytesCountCache;\n  var alreadyWarned = false;\n  // Throttle the bytes computation to minimize the impact on performance.\n  // Especially useful if the user call context APIs synchronously multiple times in a row\n  var computeBytesCountThrottled = throttle(function (context) {\n    bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n    if (!alreadyWarned) {\n      alreadyWarned = warnIfCustomerDataLimitReached(bytesCountCache, customerDataType);\n    }\n  }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled;\n  var contextManager = {\n    getBytesCount: function getBytesCount() {\n      return bytesCountCache;\n    },\n    /** @deprecated use getContext instead */\n    get: function get() {\n      return context;\n    },\n    /** @deprecated use setContextProperty instead */\n    add: function add(key, value) {\n      context[key] = value;\n      computeBytesCountThrottled(context);\n    },\n    /** @deprecated renamed to removeContextProperty */\n    remove: function remove(key) {\n      delete context[key];\n      computeBytesCountThrottled(context);\n    },\n    /** @deprecated use setContext instead */\n    set: function set(newContext) {\n      context = newContext;\n      computeBytesCountThrottled(context);\n    },\n    getContext: function getContext() {\n      return deepClone(context);\n    },\n    setContext: function setContext(newContext) {\n      if (getType(newContext) === 'object') {\n        context = sanitize(newContext);\n        computeBytesCountThrottled(context);\n      } else {\n        contextManager.clearContext();\n      }\n    },\n    setContextProperty: function setContextProperty(key, property) {\n      context[key] = sanitize(property);\n      computeBytesCountThrottled(context);\n    },\n    removeContextProperty: function removeContextProperty(key) {\n      delete context[key];\n      computeBytesCountThrottled(context);\n    },\n    clearContext: function clearContext() {\n      context = {};\n      bytesCountCache = 0;\n    }\n  };\n  return contextManager;\n}","var BUFFER_LIMIT = 500;\nvar BoundedBuffer = /** @class */function () {\n  function BoundedBuffer() {\n    this.buffer = [];\n  }\n  BoundedBuffer.prototype.add = function (callback) {\n    var length = this.buffer.push(callback);\n    if (length > BUFFER_LIMIT) {\n      this.buffer.splice(0, 1);\n    }\n  };\n  BoundedBuffer.prototype.drain = function () {\n    this.buffer.forEach(function (callback) {\n      return callback();\n    });\n    this.buffer.length = 0;\n  };\n  return BoundedBuffer;\n}();\nexport { BoundedBuffer };","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { assign } from '../tools/utils/polyfills';\nexport function makePublicApi(stub) {\n  var publicApi = assign({\n    version: \"4.47.0\",\n    // This API method is intentionally not monitored, since the only thing executed is the\n    // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and\n    // we don't want to interfere with the user uncaught exceptions.\n    onReady: function onReady(callback) {\n      callback();\n    }\n  }, stub);\n  // Add a \"hidden\" property to set debug mode. We define it that way to hide it\n  // as much as possible but of course it's not a real protection.\n  Object.defineProperty(publicApi, '_setDebug', {\n    get: function get() {\n      return setDebugMode;\n    },\n    enumerable: false\n  });\n  return publicApi;\n}\nexport function defineGlobal(global, name, api) {\n  var existingGlobalVariable = global[name];\n  global[name] = api;\n  if (existingGlobalVariable && existingGlobalVariable.q) {\n    existingGlobalVariable.q.forEach(function (fn) {\n      return catchUserErrors(fn, 'onReady callback threw an error:')();\n    });\n  }\n}","import { endsWith } from '../tools/utils/polyfills';\nimport { getGlobalObject } from '../tools/getGlobalObject';\nexport function getEventBridge() {\n  var eventBridgeGlobal = getEventBridgeGlobal();\n  if (!eventBridgeGlobal) {\n    return;\n  }\n  return {\n    getAllowedWebViewHosts: function getAllowedWebViewHosts() {\n      return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n    },\n    send: function send(eventType, event) {\n      eventBridgeGlobal.send(JSON.stringify({\n        eventType: eventType,\n        event: event\n      }));\n    }\n  };\n}\nexport function canUseEventBridge(currentHost) {\n  var _a;\n  if (currentHost === void 0) {\n    currentHost = (_a = getGlobalObject().location) === null || _a === void 0 ? void 0 : _a.hostname;\n  }\n  var bridge = getEventBridge();\n  return !!bridge && bridge.getAllowedWebViewHosts().some(function (allowedHost) {\n    return currentHost === allowedHost || endsWith(currentHost, \".\".concat(allowedHost));\n  });\n}\nfunction getEventBridgeGlobal() {\n  return getGlobalObject().DatadogEventBridge;\n}","import { display } from '../../tools/display';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { assign } from '../../tools/utils/polyfills';\n/**\n * Clone input data and ensure known user properties (id, name, email)\n * are strings, as defined here:\n * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n */\nexport function sanitizeUser(newUser) {\n  // We shallow clone only to prevent mutation of user data.\n  var user = assign({}, newUser);\n  var keys = ['id', 'name', 'email'];\n  keys.forEach(function (key) {\n    if (key in user) {\n      user[key] = String(user[key]);\n    }\n  });\n  return user;\n}\n/**\n * Simple check to ensure user is valid\n */\nexport function checkUser(newUser) {\n  var isValid = getType(newUser) === 'object';\n  if (!isValid) {\n    display.error('Unsupported user:', newUser);\n  }\n  return isValid;\n}","import { ValueHistory } from '../../tools/valueHistory';\nimport { relativeNow, clocksOrigin, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { addEventListener, addEventListeners } from '../../browser/addEventListener';\nimport { clearInterval, setInterval } from '../../tools/timer';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { startSessionStore } from './sessionStore';\nexport var VISIBILITY_CHECK_DELAY = ONE_MINUTE;\nvar SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nvar stopCallbacks = [];\nexport function startSessionManager(configuration, productKey, computeSessionState) {\n  // TODO - Improve configuration type and remove assertion\n  var sessionStore = startSessionStore(configuration.sessionStoreStrategyType, productKey, computeSessionState);\n  stopCallbacks.push(function () {\n    return sessionStore.stop();\n  });\n  var sessionContextHistory = new ValueHistory(SESSION_CONTEXT_TIMEOUT_DELAY);\n  stopCallbacks.push(function () {\n    return sessionContextHistory.stop();\n  });\n  sessionStore.renewObservable.subscribe(function () {\n    sessionContextHistory.add(buildSessionContext(), relativeNow());\n  });\n  sessionStore.expireObservable.subscribe(function () {\n    sessionContextHistory.closeActive(relativeNow());\n  });\n  sessionStore.expandOrRenewSession();\n  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);\n  trackActivity(configuration, function () {\n    return sessionStore.expandOrRenewSession();\n  });\n  trackVisibility(configuration, function () {\n    return sessionStore.expandSession();\n  });\n  function buildSessionContext() {\n    return {\n      id: sessionStore.getSession().id,\n      trackingType: sessionStore.getSession()[productKey]\n    };\n  }\n  return {\n    findActiveSession: function findActiveSession(startTime) {\n      return sessionContextHistory.find(startTime);\n    },\n    renewObservable: sessionStore.renewObservable,\n    expireObservable: sessionStore.expireObservable,\n    expire: sessionStore.expire\n  };\n}\nexport function stopSessionManager() {\n  stopCallbacks.forEach(function (e) {\n    return e();\n  });\n  stopCallbacks = [];\n}\nfunction trackActivity(configuration, expandOrRenewSession) {\n  var stop = addEventListeners(configuration, window, [\"click\" /* DOM_EVENT.CLICK */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"scroll\" /* DOM_EVENT.SCROLL */], expandOrRenewSession, {\n    capture: true,\n    passive: true\n  }).stop;\n  stopCallbacks.push(stop);\n}\nfunction trackVisibility(configuration, expandSession) {\n  var expandSessionWhenVisible = function expandSessionWhenVisible() {\n    if (document.visibilityState === 'visible') {\n      expandSession();\n    }\n  };\n  var stop = addEventListener(configuration, document, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, expandSessionWhenVisible).stop;\n  stopCallbacks.push(stop);\n  var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);\n  stopCallbacks.push(function () {\n    clearInterval(visibilityCheckInterval);\n  });\n}","import { setTimeout } from '../../tools/timer';\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { ErrorSource } from '../error/error.types';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n  var eventCount = 0;\n  var allowNextEvent = false;\n  return {\n    isLimitReached: function isLimitReached() {\n      if (eventCount === 0) {\n        setTimeout(function () {\n          eventCount = 0;\n        }, ONE_MINUTE);\n      }\n      eventCount += 1;\n      if (eventCount <= limit || allowNextEvent) {\n        allowNextEvent = false;\n        return false;\n      }\n      if (eventCount === limit + 1) {\n        allowNextEvent = true;\n        try {\n          onLimitReached({\n            message: \"Reached max number of \".concat(eventType, \"s by minute: \").concat(limit),\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow()\n          });\n        } finally {\n          allowNextEvent = false;\n        }\n      }\n      return true;\n    }\n  };\n}","import { getCookie } from '../../browser/cookie';\nexport var SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum';\nexport function willSyntheticsInjectRum() {\n  return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n  var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n  return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n  var value = window._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n  return typeof value === 'string' ? value : undefined;\n}","import { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString, tryToGetFingerprint } from '../error/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { ConsoleApiName, globalConsole } from '../../tools/display';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { find } from '../../tools/utils/polyfills';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nvar consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n  var consoleObservables = apis.map(function (api) {\n    if (!consoleObservablesByApi[api]) {\n      consoleObservablesByApi[api] = createConsoleObservable(api);\n    }\n    return consoleObservablesByApi[api];\n  });\n  return mergeObservables.apply(void 0, consoleObservables);\n}\nexport function resetConsoleObservable() {\n  consoleObservablesByApi = {};\n}\nfunction createConsoleObservable(api) {\n  var observable = new Observable(function () {\n    var originalConsoleApi = globalConsole[api];\n    globalConsole[api] = function () {\n      var params = [];\n      for (var _i = 0; _i < arguments.length; _i++) {\n        params[_i] = arguments[_i];\n      }\n      originalConsoleApi.apply(console, params);\n      var handlingStack = createHandlingStack();\n      callMonitored(function () {\n        observable.notify(buildConsoleLog(params, api, handlingStack));\n      });\n    };\n    return function () {\n      globalConsole[api] = originalConsoleApi;\n    };\n  });\n  return observable;\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n  // Todo: remove console error prefix in the next major version\n  var message = params.map(function (param) {\n    return formatConsoleParameters(param);\n  }).join(' ');\n  var stack;\n  var fingerprint;\n  if (api === ConsoleApiName.error) {\n    var firstErrorParam = find(params, function (param) {\n      return param instanceof Error;\n    });\n    stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;\n    fingerprint = tryToGetFingerprint(firstErrorParam);\n    message = \"console error: \".concat(message);\n  }\n  return {\n    api: api,\n    message: message,\n    stack: stack,\n    handlingStack: handlingStack,\n    fingerprint: fingerprint\n  };\n}\nfunction formatConsoleParameters(param) {\n  if (typeof param === 'string') {\n    return sanitize(param);\n  }\n  if (param instanceof Error) {\n    return formatErrorMessage(computeStackTrace(param));\n  }\n  return jsonStringify(sanitize(param), undefined, 2);\n}","import { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nimport { shallowClone } from '../tools/utils/objectUtils';\nimport { addEventListener } from './addEventListener';\nvar xhrObservable;\nvar xhrContexts = new WeakMap();\nexport function initXhrObservable(configuration) {\n  if (!xhrObservable) {\n    xhrObservable = createXhrObservable(configuration);\n  }\n  return xhrObservable;\n}\nfunction createXhrObservable(configuration) {\n  var observable = new Observable(function () {\n    var stopInstrumentingStart = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {\n      before: openXhr\n    }).stop;\n    var stopInstrumentingSend = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {\n      before: function before() {\n        sendXhr.call(this, configuration, observable);\n      }\n    }).stop;\n    var stopInstrumentingAbort = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {\n      before: abortXhr\n    }).stop;\n    return function () {\n      stopInstrumentingStart();\n      stopInstrumentingSend();\n      stopInstrumentingAbort();\n    };\n  });\n  return observable;\n}\nfunction openXhr(method, url) {\n  xhrContexts.set(this, {\n    state: 'open',\n    method: method,\n    url: normalizeUrl(String(url))\n  });\n}\nfunction sendXhr(configuration, observable) {\n  var _this = this;\n  var context = xhrContexts.get(this);\n  if (!context) {\n    return;\n  }\n  var startContext = context;\n  startContext.state = 'start';\n  startContext.startTime = relativeNow();\n  startContext.startClocks = clocksNow();\n  startContext.isAborted = false;\n  startContext.xhr = this;\n  var hasBeenReported = false;\n  var stopInstrumentingOnReadyStateChange = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {\n    before: function before() {\n      if (this.readyState === XMLHttpRequest.DONE) {\n        // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n        // application during a future event. For example, Angular is calling .abort() on\n        // completed requests during a onreadystatechange event, so the status becomes '0'\n        // before the request is collected.\n        onEnd();\n      }\n    }\n  }).stop;\n  var onEnd = function onEnd() {\n    unsubscribeLoadEndListener();\n    stopInstrumentingOnReadyStateChange();\n    if (hasBeenReported) {\n      return;\n    }\n    hasBeenReported = true;\n    var completeContext = context;\n    completeContext.state = 'complete';\n    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\n    completeContext.status = _this.status;\n    observable.notify(shallowClone(completeContext));\n  };\n  var unsubscribeLoadEndListener = addEventListener(configuration, this, 'loadend', onEnd).stop;\n  observable.notify(startContext);\n}\nfunction abortXhr() {\n  var context = xhrContexts.get(this);\n  if (context) {\n    context.isAborted = true;\n  }\n}","import { instrumentMethod } from '../tools/instrumentMethod';\nimport { callMonitored, monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { clocksNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nvar fetchObservable;\nexport function initFetchObservable() {\n  if (!fetchObservable) {\n    fetchObservable = createFetchObservable();\n  }\n  return fetchObservable;\n}\nfunction createFetchObservable() {\n  var observable = new Observable(function () {\n    if (!window.fetch) {\n      return;\n    }\n    var stop = instrumentMethod(window, 'fetch', function (originalFetch) {\n      return function (input, init) {\n        var responsePromise;\n        var context = callMonitored(beforeSend, null, [observable, input, init]);\n        if (context) {\n          responsePromise = originalFetch.call(this, context.input, context.init);\n          callMonitored(afterSend, null, [observable, responsePromise, context]);\n        } else {\n          responsePromise = originalFetch.call(this, input, init);\n        }\n        return responsePromise;\n      };\n    }).stop;\n    return stop;\n  });\n  return observable;\n}\nfunction beforeSend(observable, input, init) {\n  var method = init && init.method || input instanceof Request && input.method || 'GET';\n  var url = input instanceof Request ? input.url : normalizeUrl(String(input));\n  var startClocks = clocksNow();\n  var context = {\n    state: 'start',\n    init: init,\n    input: input,\n    method: method,\n    startClocks: startClocks,\n    url: url\n  };\n  observable.notify(context);\n  return context;\n}\nfunction afterSend(observable, responsePromise, startContext) {\n  var reportFetch = function reportFetch(response) {\n    var context = startContext;\n    context.state = 'resolve';\n    if ('stack' in response || response instanceof Error) {\n      context.status = 0;\n      context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR;\n      context.error = response;\n    } else if ('status' in response) {\n      context.response = response;\n      context.responseType = response.type;\n      context.status = response.status;\n      context.isAborted = false;\n    }\n    observable.notify(context);\n  };\n  responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}","import { monitor } from './monitor';\nimport { noop } from './utils/functionUtils';\n/**\n * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of\n * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit\n * has been exceeded if more bytes were available.\n */\nexport function readBytesFromStream(stream, callback, options) {\n  var reader = stream.getReader();\n  var chunks = [];\n  var readBytesCount = 0;\n  readMore();\n  function readMore() {\n    reader.read().then(monitor(function (result) {\n      if (result.done) {\n        onDone();\n        return;\n      }\n      if (options.collectStreamBody) {\n        chunks.push(result.value);\n      }\n      readBytesCount += result.value.length;\n      if (readBytesCount > options.bytesLimit) {\n        onDone();\n      } else {\n        readMore();\n      }\n    }), monitor(function (error) {\n      return callback(error);\n    }));\n  }\n  function onDone() {\n    reader.cancel()[\"catch\"](\n    // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n    // as an unhandled rejection\n    noop);\n    var bytes;\n    var limitExceeded;\n    if (options.collectStreamBody) {\n      var completeBuffer_1;\n      if (chunks.length === 1) {\n        // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just\n        // use it directly.\n        completeBuffer_1 = chunks[0];\n      } else {\n        // else, we need to copy buffers into a larger buffer to concatenate them.\n        completeBuffer_1 = new Uint8Array(readBytesCount);\n        var offset_1 = 0;\n        chunks.forEach(function (chunk) {\n          completeBuffer_1.set(chunk, offset_1);\n          offset_1 += chunk.length;\n        });\n      }\n      bytes = completeBuffer_1.slice(0, options.bytesLimit);\n      limitExceeded = completeBuffer_1.length > options.bytesLimit;\n    }\n    callback(undefined, bytes, limitExceeded);\n  }\n}","var AbstractLifeCycle = /** @class */function () {\n  function AbstractLifeCycle() {\n    this.callbacks = {};\n  }\n  AbstractLifeCycle.prototype.notify = function (eventType, data) {\n    var eventCallbacks = this.callbacks[eventType];\n    if (eventCallbacks) {\n      eventCallbacks.forEach(function (callback) {\n        return callback(data);\n      });\n    }\n  };\n  AbstractLifeCycle.prototype.subscribe = function (eventType, callback) {\n    var _this = this;\n    if (!this.callbacks[eventType]) {\n      this.callbacks[eventType] = [];\n    }\n    this.callbacks[eventType].push(callback);\n    return {\n      unsubscribe: function unsubscribe() {\n        _this.callbacks[eventType] = _this.callbacks[eventType].filter(function (other) {\n          return callback !== other;\n        });\n      }\n    };\n  };\n  return AbstractLifeCycle;\n}();\nexport { AbstractLifeCycle };","import { serializeConfiguration, assign, ONE_KIBI_BYTE, validateAndBuildConfiguration, display, removeDuplicates, ConsoleApiName, RawReportType, includes, objectValues } from '@datadog/browser-core';\n/**\n * arbitrary value, byte precision not needed\n */\nexport var DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE;\nexport function validateAndBuildLogsConfiguration(initConfiguration) {\n  var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n  var forwardConsoleLogs = validateAndBuildForwardOption(initConfiguration.forwardConsoleLogs, objectValues(ConsoleApiName), 'Forward Console Logs');\n  var forwardReports = validateAndBuildForwardOption(initConfiguration.forwardReports, objectValues(RawReportType), 'Forward Reports');\n  if (!baseConfiguration || !forwardConsoleLogs || !forwardReports) {\n    return;\n  }\n  if (initConfiguration.forwardErrorsToLogs && !includes(forwardConsoleLogs, ConsoleApiName.error)) {\n    forwardConsoleLogs.push(ConsoleApiName.error);\n  }\n  return assign({\n    forwardErrorsToLogs: initConfiguration.forwardErrorsToLogs !== false,\n    forwardConsoleLogs: forwardConsoleLogs,\n    forwardReports: forwardReports,\n    requestErrorResponseLengthLimit: DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT\n  }, baseConfiguration);\n}\nexport function validateAndBuildForwardOption(option, allowedValues, label) {\n  if (option === undefined) {\n    return [];\n  }\n  if (!(option === 'all' || Array.isArray(option) && option.every(function (api) {\n    return includes(allowedValues, api);\n  }))) {\n    display.error(\"\".concat(label, \" should be \\\"all\\\" or an array with allowed values \\\"\").concat(allowedValues.join('\", \"'), \"\\\"\"));\n    return;\n  }\n  return option === 'all' ? allowedValues : removeDuplicates(option);\n}\nexport function serializeLogsConfiguration(configuration) {\n  var baseSerializedInitConfiguration = serializeConfiguration(configuration);\n  return assign({\n    forward_errors_to_logs: configuration.forwardErrorsToLogs,\n    forward_console_logs: configuration.forwardConsoleLogs,\n    forward_reports: configuration.forwardReports\n  }, baseSerializedInitConfiguration);\n}","import { arrayFrom } from './polyfills';\nexport function removeDuplicates(array) {\n  var set = new Set();\n  array.forEach(function (item) {\n    return set.add(item);\n  });\n  return arrayFrom(set);\n}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nvar __decorate = this && this.__decorate || function (decorators, target, key, desc) {\n  var c = arguments.length,\n    r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,\n    d;\n  if ((typeof Reflect === \"undefined\" ? \"undefined\" : _typeof(Reflect)) === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { clocksNow, computeRawError, computeStackTrace, assign, combine, createContextManager, ErrorSource, monitored, sanitize } from '@datadog/browser-core';\nexport var StatusType = {\n  debug: 'debug',\n  error: 'error',\n  info: 'info',\n  warn: 'warn'\n};\nexport var HandlerType = {\n  console: 'console',\n  http: 'http',\n  silent: 'silent'\n};\nexport var STATUSES = Object.keys(StatusType);\nexport var Logger = /** @class */function () {\n  function Logger(handleLogStrategy, name, handlerType, level, loggerContext) {\n    if (handlerType === void 0) {\n      handlerType = HandlerType.http;\n    }\n    if (level === void 0) {\n      level = StatusType.debug;\n    }\n    if (loggerContext === void 0) {\n      loggerContext = {};\n    }\n    this.handleLogStrategy = handleLogStrategy;\n    this.handlerType = handlerType;\n    this.level = level;\n    this.contextManager = createContextManager(\"logger context\" /* CustomerDataType.LoggerContext */);\n    this.contextManager.set(assign({}, loggerContext, name ? {\n      logger: {\n        name: name\n      }\n    } : undefined));\n  }\n  Logger.prototype.log = function (message, messageContext, status, error) {\n    if (status === void 0) {\n      status = StatusType.info;\n    }\n    var errorContext;\n    if (status === StatusType.error) {\n      // Always add origin if status is error (backward compatibility - Remove in next major)\n      errorContext = {\n        origin: ErrorSource.LOGGER\n      };\n    }\n    if (error !== undefined && error !== null) {\n      var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n      var rawError = computeRawError({\n        stackTrace: stackTrace,\n        originalError: error,\n        nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n        source: ErrorSource.LOGGER,\n        handling: \"handled\" /* ErrorHandling.HANDLED */,\n        startClocks: clocksNow()\n      });\n      errorContext = {\n        origin: ErrorSource.LOGGER,\n        stack: rawError.stack,\n        kind: rawError.type,\n        message: rawError.message\n      };\n    }\n    var sanitizedMessageContext = sanitize(messageContext);\n    var context = errorContext ? combine({\n      error: errorContext\n    }, sanitizedMessageContext) : sanitizedMessageContext;\n    this.handleLogStrategy({\n      message: sanitize(message),\n      context: context,\n      status: status\n    }, this);\n  };\n  Logger.prototype.debug = function (message, messageContext, error) {\n    this.log(message, messageContext, StatusType.debug, error);\n  };\n  Logger.prototype.info = function (message, messageContext, error) {\n    this.log(message, messageContext, StatusType.info, error);\n  };\n  Logger.prototype.warn = function (message, messageContext, error) {\n    this.log(message, messageContext, StatusType.warn, error);\n  };\n  Logger.prototype.error = function (message, messageContext, error) {\n    this.log(message, messageContext, StatusType.error, error);\n  };\n  Logger.prototype.setContext = function (context) {\n    this.contextManager.set(context);\n  };\n  Logger.prototype.getContext = function () {\n    return this.contextManager.get();\n  };\n  Logger.prototype.addContext = function (key, value) {\n    this.contextManager.add(key, value);\n  };\n  Logger.prototype.removeContext = function (key) {\n    this.contextManager.remove(key);\n  };\n  Logger.prototype.setHandler = function (handler) {\n    this.handlerType = handler;\n  };\n  Logger.prototype.getHandler = function () {\n    return this.handlerType;\n  };\n  Logger.prototype.setLevel = function (level) {\n    this.level = level;\n  };\n  Logger.prototype.getLevel = function () {\n    return this.level;\n  };\n  __decorate([monitored], Logger.prototype, \"log\", null);\n  return Logger;\n}();","import { Batch } from './batch';\nimport { createHttpRequest } from './httpRequest';\nimport { createFlushController } from './flushController';\nexport function startBatchWithReplica(configuration, endpoint, reportError, pageExitObservable, sessionExpireObservable, replicaEndpoint) {\n  var primaryBatch = createBatch(configuration, endpoint);\n  var replicaBatch;\n  if (replicaEndpoint) {\n    replicaBatch = createBatch(configuration, replicaEndpoint);\n  }\n  function createBatch(configuration, endpointBuilder) {\n    return new Batch(createHttpRequest(configuration, endpointBuilder, configuration.batchBytesLimit, reportError), createFlushController({\n      messagesLimit: configuration.batchMessagesLimit,\n      bytesLimit: configuration.batchBytesLimit,\n      durationLimit: configuration.flushTimeout,\n      pageExitObservable: pageExitObservable,\n      sessionExpireObservable: sessionExpireObservable\n    }), configuration.messageBytesLimit);\n  }\n  return {\n    add: function add(message, replicated) {\n      if (replicated === void 0) {\n        replicated = true;\n      }\n      primaryBatch.add(message);\n      if (replicaBatch && replicated) {\n        replicaBatch.add(message);\n      }\n    }\n  };\n}","import { Observable, performDraw, startSessionManager } from '@datadog/browser-core';\nexport var LOGS_SESSION_KEY = 'logs';\nexport function startLogsSessionManager(configuration) {\n  var sessionManager = startSessionManager(configuration, LOGS_SESSION_KEY, function (rawTrackingType) {\n    return computeSessionState(configuration, rawTrackingType);\n  });\n  return {\n    findTrackedSession: function findTrackedSession(startTime) {\n      var session = sessionManager.findActiveSession(startTime);\n      return session && session.trackingType === \"1\" /* LoggerTrackingType.TRACKED */ ? {\n        id: session.id\n      } : undefined;\n    },\n    expireObservable: sessionManager.expireObservable\n  };\n}\nexport function startLogsSessionManagerStub(configuration) {\n  var isTracked = computeTrackingType(configuration) === \"1\" /* LoggerTrackingType.TRACKED */;\n  var session = isTracked ? {} : undefined;\n  return {\n    findTrackedSession: function findTrackedSession() {\n      return session;\n    },\n    expireObservable: new Observable()\n  };\n}\nfunction computeTrackingType(configuration) {\n  if (!performDraw(configuration.sessionSampleRate)) {\n    return \"0\" /* LoggerTrackingType.NOT_TRACKED */;\n  }\n  return \"1\" /* LoggerTrackingType.TRACKED */;\n}\nfunction computeSessionState(configuration, rawSessionType) {\n  var trackingType = hasValidLoggerSession(rawSessionType) ? rawSessionType : computeTrackingType(configuration);\n  return {\n    trackingType: trackingType,\n    isTracked: trackingType === \"1\" /* LoggerTrackingType.TRACKED */\n  };\n}\nfunction hasValidLoggerSession(trackingType) {\n  return trackingType === \"0\" /* LoggerTrackingType.NOT_TRACKED */ || trackingType === \"1\" /* LoggerTrackingType.TRACKED */;\n}","var _a;\nimport { includes, display, combine, ErrorSource, timeStampNow } from '@datadog/browser-core';\nimport { StatusType, HandlerType } from '../../logger';\nexport var STATUS_PRIORITIES = (_a = {}, _a[StatusType.debug] = 0, _a[StatusType.info] = 1, _a[StatusType.warn] = 2, _a[StatusType.error] = 3, _a);\nexport function startLoggerCollection(lifeCycle) {\n  function handleLog(logsMessage, logger, savedCommonContext, savedDate) {\n    var messageContext = logsMessage.context;\n    if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {\n      display(logsMessage.status, logsMessage.message, combine(logger.getContext(), messageContext));\n    }\n    lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n      rawLogsEvent: {\n        date: savedDate || timeStampNow(),\n        message: logsMessage.message,\n        status: logsMessage.status,\n        origin: ErrorSource.LOGGER\n      },\n      messageContext: messageContext,\n      savedCommonContext: savedCommonContext,\n      logger: logger\n    });\n  }\n  return {\n    handleLog: handleLog\n  };\n}\nexport function isAuthorized(status, handlerType, logger) {\n  var loggerHandler = logger.getHandler();\n  var sanitizedHandlerType = Array.isArray(loggerHandler) ? loggerHandler : [loggerHandler];\n  return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && includes(sanitizedHandlerType, handlerType);\n}","import { getSyntheticsResultId, getSyntheticsTestId, addTelemetryDebug, willSyntheticsInjectRum, ErrorSource, combine, createEventRateLimiter, getRelativeTime, isEmptyObject } from '@datadog/browser-core';\nimport { STATUSES, HandlerType } from './logger';\nimport { isAuthorized } from './logsCollection/logger/loggerCollection';\nexport function startLogsAssembly(sessionManager, configuration, lifeCycle, buildCommonContext, mainLogger,\n// Todo: [RUMF-1230] Remove this parameter in the next major release\nreportError) {\n  var statusWithCustom = STATUSES.concat(['custom']);\n  var logRateLimiters = {};\n  statusWithCustom.forEach(function (status) {\n    logRateLimiters[status] = createEventRateLimiter(status, configuration.eventRateLimiterThreshold, reportError);\n  });\n  lifeCycle.subscribe(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, function (_a) {\n    var _b, _c, _d;\n    var rawLogsEvent = _a.rawLogsEvent,\n      _e = _a.messageContext,\n      messageContext = _e === void 0 ? undefined : _e,\n      _f = _a.savedCommonContext,\n      savedCommonContext = _f === void 0 ? undefined : _f,\n      _g = _a.logger,\n      logger = _g === void 0 ? mainLogger : _g;\n    var startTime = getRelativeTime(rawLogsEvent.date);\n    var session = sessionManager.findTrackedSession(startTime);\n    if (!session) {\n      return;\n    }\n    var commonContext = savedCommonContext || buildCommonContext();\n    var log = combine({\n      service: configuration.service,\n      session_id: session.id,\n      // Insert user first to allow overrides from global context\n      usr: !isEmptyObject(commonContext.user) ? commonContext.user : undefined,\n      view: commonContext.view\n    }, commonContext.context, getRUMInternalContext(startTime), rawLogsEvent, logger.getContext(), messageContext);\n    if (\n    // Todo: [RUMF-1230] Move this check to the logger collection in the next major release\n    !isAuthorized(rawLogsEvent.status, HandlerType.http, logger) || ((_b = configuration.beforeSend) === null || _b === void 0 ? void 0 : _b.call(configuration, log)) === false || ((_c = log.error) === null || _c === void 0 ? void 0 : _c.origin) !== ErrorSource.AGENT && ((_d = logRateLimiters[log.status]) !== null && _d !== void 0 ? _d : logRateLimiters['custom']).isLimitReached()) {\n      return;\n    }\n    lifeCycle.notify(1 /* LifeCycleEventType.LOG_COLLECTED */, log);\n  });\n}\nvar logsSentBeforeRumInjectionTelemetryAdded = false;\nexport function getRUMInternalContext(startTime) {\n  var browserWindow = window;\n  if (willSyntheticsInjectRum()) {\n    var context = getInternalContextFromRumGlobal(browserWindow.DD_RUM_SYNTHETICS);\n    if (!context && !logsSentBeforeRumInjectionTelemetryAdded) {\n      logsSentBeforeRumInjectionTelemetryAdded = true;\n      addTelemetryDebug('Logs sent before RUM is injected by the synthetics worker', {\n        testId: getSyntheticsTestId(),\n        resultId: getSyntheticsResultId()\n      });\n    }\n    return context;\n  }\n  return getInternalContextFromRumGlobal(browserWindow.DD_RUM);\n  function getInternalContextFromRumGlobal(rumGlobal) {\n    if (rumGlobal && rumGlobal.getInternalContext) {\n      return rumGlobal.getInternalContext(startTime);\n    }\n  }\n}\nexport function resetRUMInternalContext() {\n  logsSentBeforeRumInjectionTelemetryAdded = false;\n}","var _a;\nimport { timeStampNow, ConsoleApiName, ErrorSource, initConsoleObservable } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nvar LogStatusForApi = (_a = {}, _a[ConsoleApiName.log] = StatusType.info, _a[ConsoleApiName.debug] = StatusType.debug, _a[ConsoleApiName.info] = StatusType.info, _a[ConsoleApiName.warn] = StatusType.warn, _a[ConsoleApiName.error] = StatusType.error, _a);\nexport function startConsoleCollection(configuration, lifeCycle) {\n  var consoleSubscription = initConsoleObservable(configuration.forwardConsoleLogs).subscribe(function (log) {\n    lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n      rawLogsEvent: {\n        date: timeStampNow(),\n        message: log.message,\n        origin: ErrorSource.CONSOLE,\n        error: log.api === ConsoleApiName.error ? {\n          origin: ErrorSource.CONSOLE,\n          stack: log.stack,\n          fingerprint: log.fingerprint\n        } : undefined,\n        status: LogStatusForApi[log.api]\n      }\n    });\n  });\n  return {\n    stop: function stop() {\n      consoleSubscription.unsubscribe();\n    }\n  };\n}","var _a;\nimport { timeStampNow, ErrorSource, RawReportType, getFileFromStackTraceString, initReportObservable } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nvar LogStatusForReport = (_a = {}, _a[RawReportType.cspViolation] = StatusType.error, _a[RawReportType.intervention] = StatusType.error, _a[RawReportType.deprecation] = StatusType.warn, _a);\nexport function startReportCollection(configuration, lifeCycle) {\n  var reportSubscription = initReportObservable(configuration, configuration.forwardReports).subscribe(function (report) {\n    var message = report.message;\n    var status = LogStatusForReport[report.type];\n    var error;\n    if (status === StatusType.error) {\n      error = {\n        kind: report.subtype,\n        origin: ErrorSource.REPORT,\n        stack: report.stack\n      };\n    } else if (report.stack) {\n      message += \" Found in \".concat(getFileFromStackTraceString(report.stack));\n    }\n    lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n      rawLogsEvent: {\n        date: timeStampNow(),\n        message: message,\n        origin: ErrorSource.REPORT,\n        error: error,\n        status: status\n      }\n    });\n  });\n  return {\n    stop: function stop() {\n      reportSubscription.unsubscribe();\n    }\n  };\n}","import { ErrorSource, initXhrObservable, initFetchObservable, computeStackTrace, toStackTraceString, monitor, noop, readBytesFromStream, tryToClone, isServerError } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nexport function startNetworkErrorCollection(configuration, lifeCycle) {\n  if (!configuration.forwardErrorsToLogs) {\n    return {\n      stop: noop\n    };\n  }\n  var xhrSubscription = initXhrObservable(configuration).subscribe(function (context) {\n    if (context.state === 'complete') {\n      handleResponse(\"xhr\" /* RequestType.XHR */, context);\n    }\n  });\n  var fetchSubscription = initFetchObservable().subscribe(function (context) {\n    if (context.state === 'resolve') {\n      handleResponse(\"fetch\" /* RequestType.FETCH */, context);\n    }\n  });\n  function handleResponse(type, request) {\n    if (!configuration.isIntakeUrl(request.url) && (isRejected(request) || isServerError(request.status))) {\n      if ('xhr' in request) {\n        computeXhrResponseData(request.xhr, configuration, onResponseDataAvailable);\n      } else if (request.response) {\n        computeFetchResponseText(request.response, configuration, onResponseDataAvailable);\n      } else if (request.error) {\n        computeFetchErrorText(request.error, configuration, onResponseDataAvailable);\n      }\n    }\n    function onResponseDataAvailable(responseData) {\n      lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n        rawLogsEvent: {\n          message: \"\".concat(format(type), \" error \").concat(request.method, \" \").concat(request.url),\n          date: request.startClocks.timeStamp,\n          error: {\n            origin: ErrorSource.NETWORK,\n            stack: responseData || 'Failed to load'\n          },\n          http: {\n            method: request.method,\n            status_code: request.status,\n            url: request.url\n          },\n          status: StatusType.error,\n          origin: ErrorSource.NETWORK\n        }\n      });\n    }\n  }\n  return {\n    stop: function stop() {\n      xhrSubscription.unsubscribe();\n      fetchSubscription.unsubscribe();\n    }\n  };\n}\n// TODO: ideally, computeXhrResponseData should always call the callback with a string instead of\n// `unknown`. But to keep backward compatibility, in the case of XHR with a `responseType` different\n// than \"text\", the response data should be whatever `xhr.response` is. This is a bit confusing as\n// Logs event 'stack' is expected to be a string. This should be changed in a future major version\n// as it could be a breaking change.\nexport function computeXhrResponseData(xhr, configuration, callback) {\n  if (typeof xhr.response === 'string') {\n    callback(truncateResponseText(xhr.response, configuration));\n  } else {\n    callback(xhr.response);\n  }\n}\nexport function computeFetchErrorText(error, configuration, callback) {\n  callback(truncateResponseText(toStackTraceString(computeStackTrace(error)), configuration));\n}\nexport function computeFetchResponseText(response, configuration, callback) {\n  var clonedResponse = tryToClone(response);\n  if (!clonedResponse || !clonedResponse.body) {\n    // if the clone failed or if the body is null, let's not try to read it.\n    callback();\n  } else if (!window.TextDecoder) {\n    // If the browser doesn't support TextDecoder, let's read the whole response then truncate it.\n    //\n    // This should only be the case on early versions of Edge (before they migrated to Chromium).\n    // Even if it could be possible to implement a workaround for the missing TextDecoder API (using\n    // a Blob and FileReader), we found another issue preventing us from reading only the first\n    // bytes from the response: contrary to other browsers, when reading from the cloned response,\n    // if the original response gets canceled, the cloned response is also canceled and we can't\n    // know about it.  In the following illustration, the promise returned by `reader.read()` may\n    // never be fulfilled:\n    //\n    // fetch('/').then((response) => {\n    //   const reader = response.clone().body.getReader()\n    //   readMore()\n    //   function readMore() {\n    //     reader.read().then(\n    //       (result) => {\n    //         if (result.done) {\n    //           console.log('done')\n    //         } else {\n    //           readMore()\n    //         }\n    //       },\n    //       () => console.log('error')\n    //     )\n    //   }\n    //   response.body.getReader().cancel()\n    // })\n    clonedResponse.text().then(monitor(function (text) {\n      return callback(truncateResponseText(text, configuration));\n    }), monitor(function (error) {\n      return callback(\"Unable to retrieve response: \".concat(error));\n    }));\n  } else {\n    truncateResponseStream(clonedResponse.body, configuration.requestErrorResponseLengthLimit, function (error, responseText) {\n      if (error) {\n        callback(\"Unable to retrieve response: \".concat(error));\n      } else {\n        callback(responseText);\n      }\n    });\n  }\n}\nfunction isRejected(request) {\n  return request.status === 0 && request.responseType !== 'opaque';\n}\nfunction truncateResponseText(responseText, configuration) {\n  if (responseText.length > configuration.requestErrorResponseLengthLimit) {\n    return \"\".concat(responseText.substring(0, configuration.requestErrorResponseLengthLimit), \"...\");\n  }\n  return responseText;\n}\nfunction format(type) {\n  if (\"xhr\" /* RequestType.XHR */ === type) {\n    return 'XHR';\n  }\n  return 'Fetch';\n}\nfunction truncateResponseStream(stream, bytesLimit, callback) {\n  readBytesFromStream(stream, function (error, bytes, limitExceeded) {\n    if (error) {\n      callback(error);\n    } else {\n      var responseText = new TextDecoder().decode(bytes);\n      if (limitExceeded) {\n        responseText += '...';\n      }\n      callback(undefined, responseText);\n    }\n  }, {\n    bytesLimit: bytesLimit,\n    collectStreamBody: true\n  });\n}","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = AbstractLifeCycle;","import { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeLogsPublicApi } from '../boot/logsPublicApi';\nimport { startLogs } from '../boot/startLogs';\nexport { Logger, StatusType, HandlerType } from '../domain/logger';\nexport var datadogLogs = makeLogsPublicApi(startLogs);\ndefineGlobal(getGlobalObject(), 'DD_LOGS', datadogLogs);","import { assign, BoundedBuffer, createContextManager, makePublicApi, monitor, display, deepClone, canUseEventBridge, timeStampNow, checkUser, sanitizeUser, sanitize } from '@datadog/browser-core';\nimport { validateAndBuildLogsConfiguration } from '../domain/configuration';\nimport { Logger } from '../domain/logger';\nexport function makeLogsPublicApi(startLogsImpl) {\n  var isAlreadyInitialized = false;\n  var globalContextManager = createContextManager(\"global context\" /* CustomerDataType.GlobalContext */);\n  var userContextManager = createContextManager(\"user\" /* CustomerDataType.User */);\n  var customLoggers = {};\n  var getInternalContextStrategy = function getInternalContextStrategy() {\n    return undefined;\n  };\n  var beforeInitLoggerLog = new BoundedBuffer();\n  var _handleLogStrategy = function handleLogStrategy(logsMessage, logger, savedCommonContext, date) {\n    if (savedCommonContext === void 0) {\n      savedCommonContext = deepClone(buildCommonContext());\n    }\n    if (date === void 0) {\n      date = timeStampNow();\n    }\n    beforeInitLoggerLog.add(function () {\n      return _handleLogStrategy(logsMessage, logger, savedCommonContext, date);\n    });\n  };\n  var getInitConfigurationStrategy = function getInitConfigurationStrategy() {\n    return undefined;\n  };\n  var mainLogger = new Logger(function () {\n    var params = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      params[_i] = arguments[_i];\n    }\n    return _handleLogStrategy.apply(void 0, params);\n  });\n  function buildCommonContext() {\n    return {\n      view: {\n        referrer: document.referrer,\n        url: window.location.href\n      },\n      context: globalContextManager.getContext(),\n      user: userContextManager.getContext()\n    };\n  }\n  return makePublicApi({\n    logger: mainLogger,\n    init: monitor(function (initConfiguration) {\n      var _a;\n      // This function should be available, regardless of initialization success.\n      getInitConfigurationStrategy = function getInitConfigurationStrategy() {\n        return deepClone(initConfiguration);\n      };\n      if (canUseEventBridge()) {\n        initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n      }\n      if (!canInitLogs(initConfiguration)) {\n        return;\n      }\n      var configuration = validateAndBuildLogsConfiguration(initConfiguration);\n      if (!configuration) {\n        return;\n      }\n      ;\n      _a = startLogsImpl(initConfiguration, configuration, buildCommonContext, mainLogger), _handleLogStrategy = _a.handleLog, getInternalContextStrategy = _a.getInternalContext;\n      beforeInitLoggerLog.drain();\n      isAlreadyInitialized = true;\n    }),\n    /** @deprecated: use getGlobalContext instead */\n    getLoggerGlobalContext: monitor(globalContextManager.get),\n    getGlobalContext: monitor(globalContextManager.getContext),\n    /** @deprecated: use setGlobalContext instead */\n    setLoggerGlobalContext: monitor(globalContextManager.set),\n    setGlobalContext: monitor(globalContextManager.setContext),\n    /** @deprecated: use setGlobalContextProperty instead */\n    addLoggerGlobalContext: monitor(globalContextManager.add),\n    setGlobalContextProperty: monitor(globalContextManager.setContextProperty),\n    /** @deprecated: use removeGlobalContextProperty instead */\n    removeLoggerGlobalContext: monitor(globalContextManager.remove),\n    removeGlobalContextProperty: monitor(globalContextManager.removeContextProperty),\n    clearGlobalContext: monitor(globalContextManager.clearContext),\n    createLogger: monitor(function (name, conf) {\n      if (conf === void 0) {\n        conf = {};\n      }\n      customLoggers[name] = new Logger(function () {\n        var params = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n          params[_i] = arguments[_i];\n        }\n        return _handleLogStrategy.apply(void 0, params);\n      }, sanitize(name), conf.handler, conf.level, sanitize(conf.context));\n      return customLoggers[name];\n    }),\n    getLogger: monitor(function (name) {\n      return customLoggers[name];\n    }),\n    getInitConfiguration: monitor(function () {\n      return getInitConfigurationStrategy();\n    }),\n    getInternalContext: monitor(function (startTime) {\n      return getInternalContextStrategy(startTime);\n    }),\n    setUser: monitor(function (newUser) {\n      if (checkUser(newUser)) {\n        userContextManager.setContext(sanitizeUser(newUser));\n      }\n    }),\n    getUser: monitor(userContextManager.getContext),\n    setUserProperty: monitor(function (key, property) {\n      var _a;\n      var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n      userContextManager.setContextProperty(key, sanitizedProperty);\n    }),\n    removeUserProperty: monitor(userContextManager.removeContextProperty),\n    clearUser: monitor(userContextManager.clearContext)\n  });\n  function overrideInitConfigurationForBridge(initConfiguration) {\n    return assign({}, initConfiguration, {\n      clientToken: 'empty'\n    });\n  }\n  function canInitLogs(initConfiguration) {\n    if (isAlreadyInitialized) {\n      if (!initConfiguration.silentMultipleInit) {\n        display.error('DD_LOGS is already initialized.');\n      }\n      return false;\n    }\n    return true;\n  }\n}","import { sendToExtension, createPageExitObservable, willSyntheticsInjectRum, canUseEventBridge, getEventBridge, startTelemetry, startBatchWithReplica, isTelemetryReplicationAllowed, ErrorSource, addTelemetryConfiguration, addTelemetryDebug } from '@datadog/browser-core';\nimport { startLogsSessionManager, startLogsSessionManagerStub } from '../domain/logsSessionManager';\nimport { serializeLogsConfiguration } from '../domain/configuration';\nimport { startLogsAssembly, getRUMInternalContext } from '../domain/assembly';\nimport { startConsoleCollection } from '../domain/logsCollection/console/consoleCollection';\nimport { startReportCollection } from '../domain/logsCollection/report/reportCollection';\nimport { startNetworkErrorCollection } from '../domain/logsCollection/networkError/networkErrorCollection';\nimport { startRuntimeErrorCollection } from '../domain/logsCollection/runtimeError/runtimeErrorCollection';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startLoggerCollection } from '../domain/logsCollection/logger/loggerCollection';\nimport { startLogsBatch } from '../transport/startLogsBatch';\nimport { startLogsBridge } from '../transport/startLogsBridge';\nimport { StatusType } from '../domain/logger';\nimport { startInternalContext } from '../domain/internalContext';\nexport function startLogs(initConfiguration, configuration, buildCommonContext, mainLogger) {\n  var lifeCycle = new LifeCycle();\n  lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (log) {\n    return sendToExtension('logs', log);\n  });\n  var reportError = function reportError(error) {\n    lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n      rawLogsEvent: {\n        message: error.message,\n        date: error.startClocks.timeStamp,\n        error: {\n          origin: ErrorSource.AGENT // Todo: Remove in the next major release\n        },\n        origin: ErrorSource.AGENT,\n        status: StatusType.error\n      }\n    });\n    addTelemetryDebug('Error reported to customer', {\n      'error.message': error.message\n    });\n  };\n  var pageExitObservable = createPageExitObservable(configuration);\n  var session = configuration.sessionStoreStrategyType && !canUseEventBridge() && !willSyntheticsInjectRum() ? startLogsSessionManager(configuration) : startLogsSessionManagerStub(configuration);\n  var telemetry = startLogsTelemetry(configuration, reportError, pageExitObservable, session.expireObservable);\n  telemetry.setContextProvider(function () {\n    var _a, _b, _c, _d, _e, _f;\n    return {\n      application: {\n        id: (_a = getRUMInternalContext()) === null || _a === void 0 ? void 0 : _a.application_id\n      },\n      session: {\n        id: (_b = session.findTrackedSession()) === null || _b === void 0 ? void 0 : _b.id\n      },\n      view: {\n        id: (_d = (_c = getRUMInternalContext()) === null || _c === void 0 ? void 0 : _c.view) === null || _d === void 0 ? void 0 : _d.id\n      },\n      action: {\n        id: (_f = (_e = getRUMInternalContext()) === null || _e === void 0 ? void 0 : _e.user_action) === null || _f === void 0 ? void 0 : _f.id\n      }\n    };\n  });\n  startNetworkErrorCollection(configuration, lifeCycle);\n  startRuntimeErrorCollection(configuration, lifeCycle);\n  startConsoleCollection(configuration, lifeCycle);\n  startReportCollection(configuration, lifeCycle);\n  var handleLog = startLoggerCollection(lifeCycle).handleLog;\n  startLogsAssembly(session, configuration, lifeCycle, buildCommonContext, mainLogger, reportError);\n  if (!canUseEventBridge()) {\n    startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, session.expireObservable);\n  } else {\n    startLogsBridge(lifeCycle);\n  }\n  addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration));\n  var internalContext = startInternalContext(session);\n  return {\n    handleLog: handleLog,\n    getInternalContext: internalContext.get\n  };\n}\nfunction startLogsTelemetry(configuration, reportError, pageExitObservable, sessionExpireObservable) {\n  var _a;\n  var telemetry = startTelemetry(\"browser-logs-sdk\" /* TelemetryService.LOGS */, configuration);\n  if (canUseEventBridge()) {\n    var bridge_1 = getEventBridge();\n    telemetry.observable.subscribe(function (event) {\n      return bridge_1.send('internal_telemetry', event);\n    });\n  } else {\n    var telemetryBatch_1 = startBatchWithReplica(configuration, configuration.rumEndpointBuilder, reportError, pageExitObservable, sessionExpireObservable, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.rumEndpointBuilder);\n    telemetry.observable.subscribe(function (event) {\n      return telemetryBatch_1.add(event, isTelemetryReplicationAllowed(configuration));\n    });\n  }\n  return telemetry;\n}","import { noop, ErrorSource, trackRuntimeError, Observable } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nexport function startRuntimeErrorCollection(configuration, lifeCycle) {\n  if (!configuration.forwardErrorsToLogs) {\n    return {\n      stop: noop\n    };\n  }\n  var rawErrorObservable = new Observable();\n  var stopRuntimeErrorTracking = trackRuntimeError(rawErrorObservable).stop;\n  var rawErrorSubscription = rawErrorObservable.subscribe(function (rawError) {\n    lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n      rawLogsEvent: {\n        message: rawError.message,\n        date: rawError.startClocks.timeStamp,\n        error: {\n          kind: rawError.type,\n          origin: ErrorSource.SOURCE,\n          stack: rawError.stack\n        },\n        origin: ErrorSource.SOURCE,\n        status: StatusType.error\n      }\n    });\n  });\n  return {\n    stop: function stop() {\n      stopRuntimeErrorTracking();\n      rawErrorSubscription.unsubscribe();\n    }\n  };\n}","export function startInternalContext(sessionManager) {\n  return {\n    get: function get(startTime) {\n      var trackedSession = sessionManager.findTrackedSession(startTime);\n      if (trackedSession) {\n        return {\n          session_id: trackedSession.id\n        };\n      }\n    }\n  };\n}","import { getEventBridge } from '@datadog/browser-core';\nexport function startLogsBridge(lifeCycle) {\n  var bridge = getEventBridge();\n  lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (serverLogsEvent) {\n    bridge.send('log', serverLogsEvent);\n  });\n}","import { startBatchWithReplica } from '@datadog/browser-core';\nexport function startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, sessionExpireObservable) {\n  var _a;\n  var batch = startBatchWithReplica(configuration, configuration.logsEndpointBuilder, reportError, pageExitObservable, sessionExpireObservable, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.logsEndpointBuilder);\n  lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (serverLogsEvent) {\n    batch.add(serverLogsEvent);\n  });\n}","import { datadogLogs } from '@datadog/browser-logs'\n\nlet ENV = document.querySelector(\"meta[name='env']\");\n\nif(ENV != null) {\n  datadogLogs.init({\n    clientToken: 'pub99913b544a78550a3ab06ba93cf1f287',\n    site: 'datadoghq.com',\n    service: 'titan',\n    env: ENV.getAttribute('content'),\n    forwardErrorsToLogs: true,\n    sessionSampleRate: 100,\n    useSecureSessionCookie: true\n  })\n}\n","import { timeStampNow } from '../../tools/utils/timeUtils';\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill';\nimport { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites';\nexport var ENDPOINTS = {\n  logs: 'logs',\n  rum: 'rum',\n  sessionReplay: 'session-replay'\n};\nvar INTAKE_TRACKS = {\n  logs: 'logs',\n  rum: 'rum',\n  sessionReplay: 'replay'\n};\nexport function createEndpointBuilder(initConfiguration, endpointType, configurationTags) {\n  var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, endpointType);\n  return {\n    build: function build(api, flushReason, retry) {\n      var parameters = buildEndpointParameters(initConfiguration, endpointType, configurationTags, api, flushReason, retry);\n      return buildUrlWithParameters(parameters);\n    },\n    urlPrefix: buildUrlWithParameters(''),\n    endpointType: endpointType\n  };\n}\n/**\n * Create a function used to build a full endpoint url from provided parameters. The goal of this\n * function is to pre-compute some parts of the URL to avoid re-computing everything on every\n * request, as only parameters are changing.\n */\nfunction createEndpointUrlWithParametersBuilder(initConfiguration, endpointType) {\n  var path = \"/api/v2/\".concat(INTAKE_TRACKS[endpointType]);\n  var proxy = initConfiguration.proxy,\n    proxyUrl = initConfiguration.proxyUrl;\n  if (proxy) {\n    var normalizedProxyUrl_1 = normalizeUrl(proxy);\n    return function (parameters) {\n      return \"\".concat(normalizedProxyUrl_1, \"?ddforward=\").concat(encodeURIComponent(\"\".concat(path, \"?\").concat(parameters)));\n    };\n  }\n  var host = buildEndpointHost(initConfiguration, endpointType);\n  if (proxy === undefined && proxyUrl) {\n    // TODO: remove this in a future major.\n    var normalizedProxyUrl_2 = normalizeUrl(proxyUrl);\n    return function (parameters) {\n      return \"\".concat(normalizedProxyUrl_2, \"?ddforward=\").concat(encodeURIComponent(\"https://\".concat(host).concat(path, \"?\").concat(parameters)));\n    };\n  }\n  return function (parameters) {\n    return \"https://\".concat(host).concat(path, \"?\").concat(parameters);\n  };\n}\nfunction buildEndpointHost(initConfiguration, endpointType) {\n  var _a = initConfiguration.site,\n    site = _a === void 0 ? INTAKE_SITE_US1 : _a,\n    internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;\n  if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n    return \"\".concat(internalAnalyticsSubdomain, \".\").concat(INTAKE_SITE_US1);\n  }\n  var domainParts = site.split('.');\n  var extension = domainParts.pop();\n  var subdomain = site !== INTAKE_SITE_AP1 ? \"\".concat(ENDPOINTS[endpointType], \".\") : '';\n  return \"\".concat(subdomain, \"browser-intake-\").concat(domainParts.join('-'), \".\").concat(extension);\n}\n/**\n * Build parameters to be used for an intake request. Parameters should be re-built for each\n * request, as they change randomly.\n */\nfunction buildEndpointParameters(_a, endpointType, configurationTags, api, flushReason, retry) {\n  var clientToken = _a.clientToken,\n    internalAnalyticsSubdomain = _a.internalAnalyticsSubdomain;\n  var tags = [\"sdk_version:\".concat(\"4.47.0\"), \"api:\".concat(api)].concat(configurationTags);\n  if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {\n    tags.push(\"flush_reason:\".concat(flushReason));\n  }\n  if (retry) {\n    tags.push(\"retry_count:\".concat(retry.count), \"retry_after:\".concat(retry.lastFailureStatus));\n  }\n  var parameters = ['ddsource=browser', \"ddtags=\".concat(encodeURIComponent(tags.join(','))), \"dd-api-key=\".concat(clientToken), \"dd-evp-origin-version=\".concat(encodeURIComponent(\"4.47.0\")), 'dd-evp-origin=browser', \"dd-request-id=\".concat(generateUUID())];\n  if (endpointType === 'rum') {\n    parameters.push(\"batch_time=\".concat(timeStampNow()));\n  }\n  if (internalAnalyticsSubdomain) {\n    parameters.reverse();\n  }\n  return parameters.join('&');\n}","import { display } from '../../tools/display';\nexport var TAG_SIZE_LIMIT = 200;\nexport function buildTags(configuration) {\n  var env = configuration.env,\n    service = configuration.service,\n    version = configuration.version,\n    datacenter = configuration.datacenter;\n  var tags = [];\n  if (env) {\n    tags.push(buildTag('env', env));\n  }\n  if (service) {\n    tags.push(buildTag('service', service));\n  }\n  if (version) {\n    tags.push(buildTag('version', version));\n  }\n  if (datacenter) {\n    tags.push(buildTag('datacenter', datacenter));\n  }\n  return tags;\n}\nvar FORBIDDEN_CHARACTERS = /[^a-z0-9_:./-]/;\nexport function buildTag(key, rawValue) {\n  // See https://docs.datadoghq.com/getting_started/tagging/#defining-tags for tags syntax. Note\n  // that the backend may not follow the exact same rules, so we only want to display an informal\n  // warning.\n  var valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1;\n  if (rawValue.length > valueSizeLimit || FORBIDDEN_CHARACTERS.test(rawValue)) {\n    display.warn(\"\".concat(key, \" value doesn't meet tag requirements and will be sanitized\"));\n  }\n  // Let the backend do most of the sanitization, but still make sure multiple tags can't be crafted\n  // by forging a value containing commas.\n  var sanitizedValue = rawValue.replace(/,/g, '_');\n  return \"\".concat(key, \":\").concat(sanitizedValue);\n}","import { objectValues, assign } from '../../tools/utils/polyfills';\nimport { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1 } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n  var tags = buildTags(initConfiguration);\n  var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n  var intakeUrlPrefixes = objectValues(endpointBuilders).map(function (builder) {\n    return builder.urlPrefix;\n  });\n  var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags);\n  return assign({\n    isIntakeUrl: function isIntakeUrl(url) {\n      return intakeUrlPrefixes.some(function (intakeEndpoint) {\n        return url.indexOf(intakeEndpoint) === 0;\n      });\n    },\n    replica: replicaConfiguration,\n    site: initConfiguration.site || INTAKE_SITE_US1\n  }, endpointBuilders);\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n  return {\n    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags)\n  };\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags) {\n  if (!initConfiguration.replica) {\n    return;\n  }\n  var replicaConfiguration = assign({}, initConfiguration, {\n    site: INTAKE_SITE_US1,\n    clientToken: initConfiguration.replica.clientToken\n  });\n  var replicaEndpointBuilders = {\n    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags)\n  };\n  intakeUrlPrefixes.push.apply(intakeUrlPrefixes, objectValues(replicaEndpointBuilders).map(function (builder) {\n    return builder.urlPrefix;\n  }));\n  return assign({\n    applicationId: initConfiguration.replica.applicationId\n  }, replicaEndpointBuilders);\n}","import { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { ExperimentalFeature, addExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { ONE_SECOND } from '../../tools/utils/timeUtils';\nimport { isPercentage } from '../../tools/utils/numberUtils';\nimport { ONE_KIBI_BYTE } from '../../tools/utils/byteUtils';\nimport { objectHasValue } from '../../tools/utils/objectUtils';\nimport { assign } from '../../tools/utils/polyfills';\nimport { selectSessionStoreStrategyType } from '../session/sessionStore';\nimport { computeTransportConfiguration } from './transportConfiguration';\nexport var DefaultPrivacyLevel = {\n  ALLOW: 'allow',\n  MASK: 'mask',\n  MASK_USER_INPUT: 'mask-user-input'\n};\nexport function validateAndBuildConfiguration(initConfiguration) {\n  var _a, _b, _c;\n  if (!initConfiguration || !initConfiguration.clientToken) {\n    display.error('Client Token is not configured, we will not send any data.');\n    return;\n  }\n  var sessionSampleRate = (_a = initConfiguration.sessionSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.sampleRate;\n  if (sessionSampleRate !== undefined && !isPercentage(sessionSampleRate)) {\n    display.error('Session Sample Rate should be a number between 0 and 100');\n    return;\n  }\n  if (initConfiguration.telemetrySampleRate !== undefined && !isPercentage(initConfiguration.telemetrySampleRate)) {\n    display.error('Telemetry Sample Rate should be a number between 0 and 100');\n    return;\n  }\n  if (initConfiguration.telemetryConfigurationSampleRate !== undefined && !isPercentage(initConfiguration.telemetryConfigurationSampleRate)) {\n    display.error('Telemetry Configuration Sample Rate should be a number between 0 and 100');\n    return;\n  }\n  // Set the experimental feature flags as early as possible, so we can use them in most places\n  if (Array.isArray(initConfiguration.enableExperimentalFeatures)) {\n    addExperimentalFeatures(initConfiguration.enableExperimentalFeatures.filter(function (flag) {\n      return objectHasValue(ExperimentalFeature, flag);\n    }));\n  }\n  return assign({\n    beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n    sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),\n    sessionSampleRate: sessionSampleRate !== null && sessionSampleRate !== void 0 ? sessionSampleRate : 100,\n    telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n    telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,\n    service: initConfiguration.service,\n    silentMultipleInit: !!initConfiguration.silentMultipleInit,\n    /**\n     * beacon payload max queue size implementation is 64kb\n     * ensure that we leave room for logs, rum and potential other users\n     */\n    batchBytesLimit: 16 * ONE_KIBI_BYTE,\n    eventRateLimiterThreshold: 3000,\n    maxTelemetryEventsPerPage: 15,\n    /**\n     * flush automatically, aim to be lower than ALB connection timeout\n     * to maximize connection reuse.\n     */\n    flushTimeout: 30 * ONE_SECOND,\n    /**\n     * Logs intake limit\n     */\n    batchMessagesLimit: 50,\n    messageBytesLimit: 256 * ONE_KIBI_BYTE\n  }, computeTransportConfiguration(initConfiguration));\n}\nexport function serializeConfiguration(initConfiguration) {\n  var _a, _b;\n  var proxy = (_a = initConfiguration.proxy) !== null && _a !== void 0 ? _a : initConfiguration.proxyUrl;\n  return {\n    session_sample_rate: (_b = initConfiguration.sessionSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.sampleRate,\n    telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n    telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n    use_before_send: !!initConfiguration.beforeSend,\n    use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,\n    use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n    use_proxy: proxy !== undefined ? !!proxy : undefined,\n    silent_multiple_init: initConfiguration.silentMultipleInit,\n    track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n    track_resources: initConfiguration.trackResources,\n    track_long_task: initConfiguration.trackLongTasks,\n    allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage\n  };\n}","import { instrumentMethodAndCallOriginal } from '../../tools/instrumentMethod';\nimport { computeStackTrace } from './computeStackTrace';\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\\s\\S]*)$/;\n/**\n * Cross-browser collection of unhandled errors\n *\n * Supports:\n * - Firefox: full stack trace with line numbers, plus column number\n * on top frame; column number is not guaranteed\n * - Opera: full stack trace with line and column numbers\n * - Chrome: full stack trace with line and column numbers\n * - Safari: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n * - IE: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n * - IE5.5+ (only 8.0 tested)\n * - Firefox 0.9+ (only 3.5+ tested)\n * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n * Exceptions Have Stacktrace to be enabled in opera:config)\n * - Safari 3+ (only 4+ tested)\n * - Chrome 1+ (only 5+ tested)\n * - Konqueror 3.5+ (untested)\n *\n * Tries to catch all unhandled errors and report them to the\n * callback.\n *\n * Callbacks receive a StackTrace object as described in the\n * computeStackTrace docs.\n *\n * @memberof TraceKit\n * @namespace\n */\nexport function startUnhandledErrorCollection(callback) {\n  var stopInstrumentingOnError = instrumentOnError(callback).stop;\n  var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(callback).stop;\n  return {\n    stop: function stop() {\n      stopInstrumentingOnError();\n      stopInstrumentingOnUnhandledRejection();\n    }\n  };\n}\n/**\n * Install a global onerror handler\n */\nfunction instrumentOnError(callback) {\n  return instrumentMethodAndCallOriginal(window, 'onerror', {\n    before: function before(messageObj, url, line, column, errorObj) {\n      var stackTrace;\n      if (errorObj instanceof Error) {\n        stackTrace = computeStackTrace(errorObj);\n      } else {\n        var stack = [{\n          url: url,\n          column: column,\n          line: line\n        }];\n        var _a = tryToParseMessage(messageObj),\n          name_1 = _a.name,\n          message = _a.message;\n        stackTrace = {\n          name: name_1,\n          message: message,\n          stack: stack\n        };\n      }\n      callback(stackTrace, errorObj !== null && errorObj !== void 0 ? errorObj : messageObj);\n    }\n  });\n}\nfunction tryToParseMessage(messageObj) {\n  var _a;\n  var name;\n  var message;\n  if ({}.toString.call(messageObj) === '[object String]') {\n    ;\n    _a = ERROR_TYPES_RE.exec(messageObj), name = _a[1], message = _a[2];\n  }\n  return {\n    name: name,\n    message: message\n  };\n}\n/**\n * Install a global onunhandledrejection handler\n */\nfunction instrumentUnhandledRejection(callback) {\n  return instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {\n    before: function before(e) {\n      var reason = e.reason || 'Empty reason';\n      var stack = computeStackTrace(reason);\n      callback(stack, reason);\n    }\n  });\n}","import { clocksNow } from '../../tools/utils/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\nimport { computeRawError } from './error';\nimport { ErrorSource } from './error.types';\nexport function trackRuntimeError(errorObservable) {\n  return startUnhandledErrorCollection(function (stackTrace, originalError) {\n    errorObservable.notify(computeRawError({\n      stackTrace: stackTrace,\n      originalError: originalError,\n      startClocks: clocksNow(),\n      nonErrorPrefix: \"Uncaught\" /* NonErrorPrefix.UNCAUGHT */,\n      source: ErrorSource.SOURCE,\n      handling: \"unhandled\" /* ErrorHandling.UNHANDLED */\n    }));\n  });\n}","import { ConsoleApiName } from '../../tools/display';\nimport { toStackTraceString, NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/error';\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { computeStackTrace } from '../tracekit';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/utils/timeUtils';\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor';\nimport { sendToExtension } from '../../tools/sendToExtension';\nimport { startsWith, arrayFrom, includes, assign } from '../../tools/utils/polyfills';\nimport { performDraw } from '../../tools/utils/numberUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { combine } from '../../tools/mergeInto';\nimport { TelemetryType } from './rawTelemetryEvent.types';\nvar ALLOWED_FRAME_URLS = ['https://www.datadoghq-browser-agent.com', 'https://www.datad0g-browser-agent.com', 'https://d3uc069fcn7uxw.cloudfront.net', 'https://d20xtzwzcl0ceb.cloudfront.net', 'http://localhost', '<anonymous>'];\nvar TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\nvar telemetryConfiguration = {\n  maxEventsPerPage: 0,\n  sentEventCount: 0,\n  telemetryEnabled: false,\n  telemetryConfigurationEnabled: false\n};\nvar onRawTelemetryEventCollected;\nexport function startTelemetry(telemetryService, configuration) {\n  var contextProvider;\n  var observable = new Observable();\n  telemetryConfiguration.telemetryEnabled = !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);\n  telemetryConfiguration.telemetryConfigurationEnabled = telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate);\n  onRawTelemetryEventCollected = function onRawTelemetryEventCollected(rawEvent) {\n    if (telemetryConfiguration.telemetryEnabled) {\n      var event_1 = toTelemetryEvent(telemetryService, rawEvent);\n      observable.notify(event_1);\n      sendToExtension('telemetry', event_1);\n    }\n  };\n  startMonitorErrorCollection(addTelemetryError);\n  assign(telemetryConfiguration, {\n    maxEventsPerPage: configuration.maxTelemetryEventsPerPage,\n    sentEventCount: 0\n  });\n  function toTelemetryEvent(telemetryService, event) {\n    return combine({\n      type: 'telemetry',\n      date: timeStampNow(),\n      service: telemetryService,\n      version: \"4.47.0\",\n      source: 'browser',\n      _dd: {\n        format_version: 2\n      },\n      telemetry: event,\n      experimental_features: arrayFrom(getExperimentalFeatures())\n    }, contextProvider !== undefined ? contextProvider() : {});\n  }\n  return {\n    setContextProvider: function setContextProvider(provider) {\n      contextProvider = provider;\n    },\n    observable: observable,\n    enabled: telemetryConfiguration.telemetryEnabled\n  };\n}\nexport function startFakeTelemetry() {\n  var events = [];\n  assign(telemetryConfiguration, {\n    maxEventsPerPage: Infinity,\n    sentEventCount: 0\n  });\n  onRawTelemetryEventCollected = function onRawTelemetryEventCollected(event) {\n    events.push(event);\n  };\n  return events;\n}\nexport function resetTelemetry() {\n  onRawTelemetryEventCollected = undefined;\n}\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nexport function isTelemetryReplicationAllowed(configuration) {\n  return configuration.site === INTAKE_SITE_STAGING;\n}\nexport function addTelemetryDebug(message, context) {\n  displayIfDebugEnabled(ConsoleApiName.debug, message, context);\n  addTelemetry(assign({\n    type: TelemetryType.log,\n    message: message,\n    status: \"debug\" /* StatusType.debug */\n  }, context));\n}\nexport function addTelemetryError(e, context) {\n  addTelemetry(assign({\n    type: TelemetryType.log,\n    status: \"error\" /* StatusType.error */\n  }, formatError(e), context));\n}\nexport function addTelemetryConfiguration(configuration) {\n  if (telemetryConfiguration.telemetryConfigurationEnabled) {\n    addTelemetry({\n      type: TelemetryType.configuration,\n      configuration: configuration\n    });\n  }\n}\nfunction addTelemetry(event) {\n  if (onRawTelemetryEventCollected && telemetryConfiguration.sentEventCount < telemetryConfiguration.maxEventsPerPage) {\n    telemetryConfiguration.sentEventCount += 1;\n    onRawTelemetryEventCollected(event);\n  }\n}\nexport function formatError(e) {\n  if (e instanceof Error) {\n    var stackTrace = computeStackTrace(e);\n    return {\n      error: {\n        kind: stackTrace.name,\n        stack: toStackTraceString(scrubCustomerFrames(stackTrace))\n      },\n      message: stackTrace.message\n    };\n  }\n  return {\n    error: {\n      stack: NO_ERROR_STACK_PRESENT_MESSAGE\n    },\n    message: \"\".concat(\"Uncaught\" /* NonErrorPrefix.UNCAUGHT */, \" \").concat(jsonStringify(e))\n  };\n}\nexport function scrubCustomerFrames(stackTrace) {\n  stackTrace.stack = stackTrace.stack.filter(function (frame) {\n    return !frame.url || ALLOWED_FRAME_URLS.some(function (allowedFrameUrl) {\n      return startsWith(frame.url, allowedFrameUrl);\n    });\n  });\n  return stackTrace;\n}","export var TelemetryType = {\n  log: 'log',\n  configuration: 'configuration'\n};","import { display } from './display';\nexport function catchUserErrors(fn, errorMsg) {\n  return function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n    try {\n      return fn.apply(void 0, args);\n    } catch (err) {\n      display.error(errorMsg, err);\n    }\n  };\n}","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nimport { getType } from './utils/typeUtils';\n/**\n * Iterate over source and affect its sub values into destination, recursively.\n * If the source and destination can't be merged, return source.\n */\nexport function mergeInto(destination, source, circularReferenceChecker) {\n  if (circularReferenceChecker === void 0) {\n    circularReferenceChecker = createCircularReferenceChecker();\n  }\n  // ignore the source if it is undefined\n  if (source === undefined) {\n    return destination;\n  }\n  if (_typeof(source) !== 'object' || source === null) {\n    // primitive values - just return source\n    return source;\n  } else if (source instanceof Date) {\n    return new Date(source.getTime());\n  } else if (source instanceof RegExp) {\n    var flags = source.flags ||\n    // old browsers compatibility\n    [source.global ? 'g' : '', source.ignoreCase ? 'i' : '', source.multiline ? 'm' : '', source.sticky ? 'y' : '', source.unicode ? 'u' : ''].join('');\n    return new RegExp(source.source, flags);\n  }\n  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n    // remove circular references\n    return undefined;\n  } else if (Array.isArray(source)) {\n    var merged_1 = Array.isArray(destination) ? destination : [];\n    for (var i = 0; i < source.length; ++i) {\n      merged_1[i] = mergeInto(merged_1[i], source[i], circularReferenceChecker);\n    }\n    return merged_1;\n  }\n  var merged = getType(destination) === 'object' ? destination : {};\n  for (var key in source) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);\n    }\n  }\n  return merged;\n}\n/**\n * A simplistic implementation of a deep clone algorithm.\n * Caveats:\n * - It doesn't maintain prototype chains - don't use with instances of custom classes.\n * - It doesn't handle Map and Set\n */\nexport function deepClone(value) {\n  return mergeInto(undefined, value);\n}\nexport function combine() {\n  var sources = [];\n  for (var _i = 0; _i < arguments.length; _i++) {\n    sources[_i] = arguments[_i];\n  }\n  var destination;\n  for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {\n    var source = sources_1[_a];\n    // Ignore any undefined or null sources.\n    if (source === undefined || source === null) {\n      continue;\n    }\n    destination = mergeInto(destination, source);\n  }\n  return destination;\n}\nfunction createCircularReferenceChecker() {\n  if (typeof WeakSet !== 'undefined') {\n    var set_1 = new WeakSet();\n    return {\n      hasAlreadyBeenSeen: function hasAlreadyBeenSeen(value) {\n        var has = set_1.has(value);\n        if (!has) {\n          set_1.add(value);\n        }\n        return has;\n      }\n    };\n  }\n  var array = [];\n  return {\n    hasAlreadyBeenSeen: function hasAlreadyBeenSeen(value) {\n      var has = array.indexOf(value) >= 0;\n      if (!has) {\n        array.push(value);\n      }\n      return has;\n    }\n  };\n}","export var SESSION_STORE_KEY = '_dd_s';","import { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants';\nvar SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;\nvar SESSION_ENTRY_SEPARATOR = '&';\nexport function isSessionInExpiredState(session) {\n  return isEmptyObject(session);\n}\nexport function expandSessionState(session) {\n  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n}\nexport function toSessionString(session) {\n  return objectEntries(session).map(function (_a) {\n    var key = _a[0],\n      value = _a[1];\n    return \"\".concat(key, \"=\").concat(value);\n  }).join(SESSION_ENTRY_SEPARATOR);\n}\nexport function toSessionState(sessionString) {\n  var session = {};\n  if (isValidSessionString(sessionString)) {\n    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {\n      var matches = SESSION_ENTRY_REGEXP.exec(entry);\n      if (matches !== null) {\n        var key = matches[1],\n          value = matches[2];\n        session[key] = value;\n      }\n    });\n  }\n  return session;\n}\nfunction isValidSessionString(sessionString) {\n  return !!sessionString && (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));\n}","import { getCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport var OLD_SESSION_COOKIE_NAME = '_dd';\nexport var OLD_RUM_COOKIE_NAME = '_dd_r';\nexport var OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport var RUM_SESSION_KEY = 'rum';\nexport var LOGS_SESSION_KEY = 'logs';\n/**\n * This migration should remain in the codebase as long as older versions are available/live\n * to allow older sdk versions to be upgraded to newer versions without compatibility issues.\n */\nexport function tryOldCookiesMigration(cookieStoreStrategy) {\n  var sessionString = getCookie(SESSION_STORE_KEY);\n  if (!sessionString) {\n    var oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME);\n    var oldRumType = getCookie(OLD_RUM_COOKIE_NAME);\n    var oldLogsType = getCookie(OLD_LOGS_COOKIE_NAME);\n    var session = {};\n    if (oldSessionId) {\n      session.id = oldSessionId;\n    }\n    if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n      session[LOGS_SESSION_KEY] = oldLogsType;\n    }\n    if (oldRumType && /^[012]$/.test(oldRumType)) {\n      session[RUM_SESSION_KEY] = oldRumType;\n    }\n    if (!isSessionInExpiredState(session)) {\n      expandSessionState(session);\n      cookieStoreStrategy.persistSession(session);\n    }\n  }\n}","import { getCurrentSite, areCookiesAuthorized, deleteCookie, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_EXPIRATION_DELAY } from '../sessionConstants';\nimport { toSessionString, toSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nexport function selectCookieStrategy(initConfiguration) {\n  var cookieOptions = buildCookieOptions(initConfiguration);\n  return areCookiesAuthorized(cookieOptions) ? {\n    type: 'Cookie',\n    cookieOptions: cookieOptions\n  } : undefined;\n}\nexport function initCookieStrategy(cookieOptions) {\n  var cookieStore = {\n    persistSession: persistSessionCookie(cookieOptions),\n    retrieveSession: retrieveSessionCookie,\n    clearSession: deleteSessionCookie(cookieOptions)\n  };\n  tryOldCookiesMigration(cookieStore);\n  return cookieStore;\n}\nfunction persistSessionCookie(options) {\n  return function (session) {\n    setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n  };\n}\nfunction retrieveSessionCookie() {\n  var sessionString = getCookie(SESSION_STORE_KEY);\n  return toSessionState(sessionString);\n}\nfunction deleteSessionCookie(options) {\n  return function () {\n    deleteCookie(SESSION_STORE_KEY, options);\n  };\n}\nexport function buildCookieOptions(initConfiguration) {\n  var cookieOptions = {};\n  cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;\n  if (initConfiguration.trackSessionAcrossSubdomains) {\n    cookieOptions.domain = getCurrentSite();\n  }\n  return cookieOptions;\n}","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { toSessionString, toSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nvar LOCAL_STORAGE_TEST_KEY = '_dd_test_';\nexport function selectLocalStorageStrategy() {\n  try {\n    var id = generateUUID();\n    var testKey = \"\".concat(LOCAL_STORAGE_TEST_KEY).concat(id);\n    localStorage.setItem(testKey, id);\n    var retrievedId = localStorage.getItem(testKey);\n    localStorage.removeItem(testKey);\n    return id === retrievedId ? {\n      type: 'LocalStorage'\n    } : undefined;\n  } catch (e) {\n    return undefined;\n  }\n}\nexport function initLocalStorageStrategy() {\n  return {\n    persistSession: persistInLocalStorage,\n    retrieveSession: retrieveSessionFromLocalStorage,\n    clearSession: clearSessionFromLocalStorage\n  };\n}\nfunction persistInLocalStorage(sessionState) {\n  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));\n}\nfunction retrieveSessionFromLocalStorage() {\n  var sessionString = localStorage.getItem(SESSION_STORE_KEY);\n  return toSessionState(sessionString);\n}\nfunction clearSessionFromLocalStorage() {\n  localStorage.removeItem(SESSION_STORE_KEY);\n}","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { isChromium } from '../../tools/utils/browserDetection';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport var LOCK_RETRY_DELAY = 10;\nexport var LOCK_MAX_TRIES = 100;\nvar bufferedOperations = [];\nvar ongoingOperations;\nexport function processSessionStoreOperations(operations, sessionStoreStrategy, numberOfRetries) {\n  var _a;\n  if (numberOfRetries === void 0) {\n    numberOfRetries = 0;\n  }\n  var retrieveSession = sessionStoreStrategy.retrieveSession,\n    persistSession = sessionStoreStrategy.persistSession,\n    clearSession = sessionStoreStrategy.clearSession;\n  var lockEnabled = isLockEnabled();\n  if (!ongoingOperations) {\n    ongoingOperations = operations;\n  }\n  if (operations !== ongoingOperations) {\n    bufferedOperations.push(operations);\n    return;\n  }\n  if (lockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {\n    next(sessionStoreStrategy);\n    return;\n  }\n  var currentLock;\n  var currentSession = retrieveSession();\n  if (lockEnabled) {\n    // if someone has lock, retry later\n    if (currentSession.lock) {\n      retryLater(operations, sessionStoreStrategy, numberOfRetries);\n      return;\n    }\n    // acquire lock\n    currentLock = generateUUID();\n    currentSession.lock = currentLock;\n    persistSession(currentSession);\n    // if lock is not acquired, retry later\n    currentSession = retrieveSession();\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, sessionStoreStrategy, numberOfRetries);\n      return;\n    }\n  }\n  var processedSession = operations.process(currentSession);\n  if (lockEnabled) {\n    // if lock corrupted after process, retry later\n    currentSession = retrieveSession();\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, sessionStoreStrategy, numberOfRetries);\n      return;\n    }\n  }\n  if (processedSession) {\n    if (isSessionInExpiredState(processedSession)) {\n      clearSession();\n    } else {\n      expandSessionState(processedSession);\n      persistSession(processedSession);\n    }\n  }\n  if (lockEnabled) {\n    // correctly handle lock around expiration would require to handle this case properly at several levels\n    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n    if (!(processedSession && isSessionInExpiredState(processedSession))) {\n      // if lock corrupted after persist, retry later\n      currentSession = retrieveSession();\n      if (currentSession.lock !== currentLock) {\n        retryLater(operations, sessionStoreStrategy, numberOfRetries);\n        return;\n      }\n      delete currentSession.lock;\n      persistSession(currentSession);\n      processedSession = currentSession;\n    }\n  }\n  // call after even if session is not persisted in order to perform operations on\n  // up-to-date session state value => the value could have been modified by another tab\n  (_a = operations.after) === null || _a === void 0 ? void 0 : _a.call(operations, processedSession || currentSession);\n  next(sessionStoreStrategy);\n}\n/**\n * Lock strategy allows mitigating issues due to concurrent access to cookie.\n * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.\n */\nexport var isLockEnabled = function isLockEnabled() {\n  return isChromium();\n};\nfunction retryLater(operations, sessionStore, currentNumberOfRetries) {\n  setTimeout(function () {\n    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1);\n  }, LOCK_RETRY_DELAY);\n}\nfunction next(sessionStore) {\n  ongoingOperations = undefined;\n  var nextOperations = bufferedOperations.shift();\n  if (nextOperations) {\n    processSessionStoreOperations(nextOperations, sessionStore);\n  }\n}","import { clearInterval, setInterval } from '../../tools/timer';\nimport { Observable } from '../../tools/observable';\nimport { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage';\nimport { processSessionStoreOperations } from './sessionStoreOperations';\n/**\n * Every second, the storage will be polled to check for any change that can occur\n * to the session state in another browser tab, or another window.\n * This value has been determined from our previous cookie-only implementation.\n */\nexport var STORAGE_POLL_DELAY = ONE_SECOND;\n/**\n * Checks if cookies are available as the preferred storage\n * Else, checks if LocalStorage is allowed and available\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n  var sessionStoreStrategyType = selectCookieStrategy(initConfiguration);\n  if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n    sessionStoreStrategyType = selectLocalStorageStrategy();\n  }\n  return sessionStoreStrategyType;\n}\n/**\n * Different session concepts:\n * - tracked, the session has an id and is updated along the user navigation\n * - not tracked, the session does not have an id but it is updated along the user navigation\n * - inactive, no session in store or session expired, waiting for a renew session\n */\nexport function startSessionStore(sessionStoreStrategyType, productKey, computeSessionState) {\n  var renewObservable = new Observable();\n  var expireObservable = new Observable();\n  var sessionStoreStrategy = sessionStoreStrategyType.type === 'Cookie' ? initCookieStrategy(sessionStoreStrategyType.cookieOptions) : initLocalStorageStrategy();\n  var clearSession = sessionStoreStrategy.clearSession,\n    retrieveSession = sessionStoreStrategy.retrieveSession;\n  var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);\n  var sessionCache = retrieveActiveSession();\n  function expandOrRenewSession() {\n    var isTracked;\n    processSessionStoreOperations({\n      process: function process(sessionState) {\n        var synchronizedSession = synchronizeSession(sessionState);\n        isTracked = expandOrRenewSessionState(synchronizedSession);\n        return synchronizedSession;\n      },\n      after: function after(sessionState) {\n        if (isTracked && !hasSessionInCache()) {\n          renewSessionInCache(sessionState);\n        }\n        sessionCache = sessionState;\n      }\n    }, sessionStoreStrategy);\n  }\n  function expandSession() {\n    processSessionStoreOperations({\n      process: function process(sessionState) {\n        return hasSessionInCache() ? synchronizeSession(sessionState) : undefined;\n      }\n    }, sessionStoreStrategy);\n  }\n  /**\n   * allows two behaviors:\n   * - if the session is active, synchronize the session cache without updating the session store\n   * - if the session is not active, clear the session store and expire the session cache\n   */\n  function watchSession() {\n    processSessionStoreOperations({\n      process: function process(sessionState) {\n        return !isActiveSession(sessionState) ? {} : undefined;\n      },\n      after: synchronizeSession\n    }, sessionStoreStrategy);\n  }\n  function synchronizeSession(sessionState) {\n    if (!isActiveSession(sessionState)) {\n      sessionState = {};\n    }\n    if (hasSessionInCache()) {\n      if (isSessionInCacheOutdated(sessionState)) {\n        expireSessionInCache();\n      } else {\n        sessionCache = sessionState;\n      }\n    }\n    return sessionState;\n  }\n  function expandOrRenewSessionState(sessionState) {\n    var _a = computeSessionState(sessionState[productKey]),\n      trackingType = _a.trackingType,\n      isTracked = _a.isTracked;\n    sessionState[productKey] = trackingType;\n    if (isTracked && !sessionState.id) {\n      sessionState.id = generateUUID();\n      sessionState.created = String(dateNow());\n    }\n    return isTracked;\n  }\n  function hasSessionInCache() {\n    return sessionCache[productKey] !== undefined;\n  }\n  function isSessionInCacheOutdated(sessionState) {\n    return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey];\n  }\n  function expireSessionInCache() {\n    sessionCache = {};\n    expireObservable.notify();\n  }\n  function renewSessionInCache(sessionState) {\n    sessionCache = sessionState;\n    renewObservable.notify();\n  }\n  function retrieveActiveSession() {\n    var session = retrieveSession();\n    if (isActiveSession(session)) {\n      return session;\n    }\n    return {};\n  }\n  function isActiveSession(sessionState) {\n    // created and expire can be undefined for versions which was not storing them\n    // these checks could be removed when older versions will not be available/live anymore\n    return (sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) && (sessionState.expire === undefined || dateNow() < Number(sessionState.expire));\n  }\n  return {\n    expandOrRenewSession: throttle(expandOrRenewSession, STORAGE_POLL_DELAY).throttled,\n    expandSession: expandSession,\n    getSession: function getSession() {\n      return sessionCache;\n    },\n    renewObservable: renewObservable,\n    expireObservable: expireObservable,\n    expire: function expire() {\n      clearSession();\n      synchronizeSession({});\n    },\n    stop: function stop() {\n      clearInterval(watchSessionTimeoutId);\n    }\n  };\n}","import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';\nimport { monitor } from './monitor';\nimport { getGlobalObject } from './getGlobalObject';\nexport function setTimeout(callback, delay) {\n  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay);\n}\nexport function clearTimeout(timeoutId) {\n  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId);\n}\nexport function setInterval(callback, delay) {\n  return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay);\n}\nexport function clearInterval(timeoutId) {\n  getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId);\n}"],"sourceRoot":""}