{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/@datadog/browser-core/esm/tools/display.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/utils.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/contextManager.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/timeUtils.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/browser/cookie.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/experimentalFeatures.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/urlPolyfill.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.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/computeStackTrace.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/error.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/configuration.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logger.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack:///./node_modules/@datadog/browser-core/esm/transport/batch.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/transport/startBatchWithReplica.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/contextHistory.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionCookieStore.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/browserDetection.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.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-core/esm/tools/createEventRateLimiter.js","webpack:///./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.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-core/esm/browser/xhrObservable.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack:///./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack:///./node_modules/@datadog/browser-logs/esm/domain/logsCollection/networkError/networkErrorCollection.js","webpack:///./node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.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-logs/esm/domain/lifeCycle.js","webpack:///./node_modules/@datadog/browser-logs/esm/entries/main.js","webpack:///./node_modules/@datadog/browser-core/esm/boot/init.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-core/esm/browser/pageExitObservable.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_logs_init.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","ConsoleApiName","log","debug","info","warn","error","display","api","args","_i","arguments","length","apply","catchUserErrors","fn","errorMsg","err","console","onMonitorErrorCollected","__spreadArray","to","from","pack","ar","Array","slice","concat","debugMode","setDebugMode","newDebugMode","monitored","_","__","descriptor","originalMethod","decorated","monitor","this","callMonitored","context","e","displayIfDebugEnabled","_typeof","obj","iterator","constructor","ONE_SECOND","ONE_MINUTE","throttle","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","undefined","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","setTimeout","cancel","clearTimeout","target","toAssign","forEach","source","generateUUID","placeholder","parseInt","Math","random","toString","replace","performDraw","threshold","noop","jsonStringify","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","_a","objectToJson","toJSON","includes","candidate","search","indexOf","arrayFrom","arrayLike","array","Set","item","push","isPercentage","isNumber","objectValues","keys","map","isEmptyObject","startsWith","getGlobalObject","globalThis","configurable","globalObject","_dd_temp_","self","window","getLinkElementOrigin","element","origin","sanitizedHost","host","protocol","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","addEventListener","emitter","event","listener","addEventListeners","events","_b","once","capture","passive","wrappedListener","stop","removeEventListener","getType","isArray","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","has","add","createCircularReferenceChecker","Date","getTime","RegExp","flags","global","ignoreCase","multiline","sticky","unicode","join","merged_1","merged","deepClone","combine","sources","sources_1","createContextManager","remove","set","newContext","getContext","setContext","setContextProperty","removeContextProperty","clearContext","navigationStart","BoundedBuffer","buffer","callback","splice","drain","dateNow","timeStampNow","relativeNow","performance","now","clocksNow","relative","timeStamp","elapsed","start","end","getNavigationStart","timing","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","canUseEventBridge","currentHost","location","hostname","bridge","some","allowedHost","sanitizeUser","newUser","user","String","getCurrentSiteCache","enabledExperimentalFeatures","isURLSupported","setCookie","expireDelay","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","document","cookie","getCookie","rawString","matches","exec","findCommaSeparatedValue","deleteCookie","getExperimentalFeatures","normalizeUrl","url","buildUrl","href","base","URL","checkURLSupported","test","Error","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","INTAKE_SITE_US1","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","createEndpointBuilder","initConfiguration","endpointType","configurationTags","site","clientToken","domainParts","split","extension","pop","baseUrl","proxyUrl","build","retry","tags","count","lastFailureStatus","encodeURIComponent","endpointUrl","buildIntakeUrl","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","computeTransportConfiguration","configuration","env","service","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeEndpoints","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","intakeEndpoint","validateAndBuildConfiguration","_c","sampleRate","telemetrySampleRate","enabledFeatures","telemetryConfigurationSampleRate","enableExperimentalFeatures","filter","flag","beforeSend","cookieOptions","buildCookieOptions","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","useSecureSessionCookie","useCrossSiteSessionCookie","mustUseSecureCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","getCurrentSite","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","exString","line","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","message","fileUrl","filePosition","ErrorSource","toStackTraceString","result","formatErrorMessage","frame","createHandlingStack","formattedStack","stackTrace","flattenErrorCauses","parentSource","currentError","causes","cause","type","Observable","onFirstSubscribe","observers","subscribe","f","_this","onLastUnsubscribe","unsubscribe","other","notify","data","observer","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","RawReportType","intervention","deprecation","cspViolation","initReportObservable","apis","handleCspViolation","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportFromCspViolation","reportTypes","ReportingObserver","handleReports","reports","report","id","types","buffered","observe","disconnect","createReportObservable","validateAndBuildForwardOption","option","allowedValues","label","every","__decorate","decorators","desc","getOwnPropertyDescriptor","Reflect","decorate","StatusType","HandlerType","STATUSES","Logger","handleLogStrategy","handlerType","level","loggerContext","contextManager","logger","messageContext","status","errorOrigin","addContext","removeContext","setHandler","handler","getHandler","setLevel","getLevel","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","getSyntheticsResultId","_DATADOG_SYNTHETICS_RESULT_ID","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryConfiguration","maxEventsPerPage","sentEventCount","telemetryEnabled","telemetryConfigurationEnabled","startTelemetry","telemetryService","contextProvider","_dd","format_version","telemetry","experimental_features","toTelemetryEvent","addTelemetryError","setContextProvider","provider","addTelemetry","kind","scrubCustomerFrames","formatError","allowedFrameUrl","HAS_MULTI_BYTES_CHARACTERS","Batch","request","pageExitObservable","pushOnlyBuffer","upsertBuffer","bufferBytesCount","bufferMessagesCount","flush","sendOnExit","flushPeriodically","addOrUpdate","upsert","sendFn","messages","bytesCount","computeBytesCount","TextEncoder","encode","Blob","size","process","processedMessage","messageBytesCount","hasMessageFor","willReachedBytesLimitWith","isFull","removedMessage","MAX_QUEUE_BYTES_COUNT","sendWithRetryStrategy","payload","state","sendStrategy","reportError","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","onSuccess","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","first","dequeue","currentBackoffTime","min","response","shouldRetryRequest","ongoingRequestCount","reason","queueFullReported","startClocks","previousQueue","newPayloadQueue","queue","shift","createHttpRequest","endpointBuilder","bytesLimit","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","Request","isKeepAliveSupported","fetchUrl","fetch","method","keepalive","then","sendXHR","fetchKeepAliveStrategy","navigator","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","sendBeaconStrategy","XMLHttpRequest","onLoadEnd","open","startBatchWithReplica","endpoint","replicaEndpoint","replicaBatch","primaryBatch","createBatch","replicated","END_OF_TIMES","Infinity","ContextHistory","entries","clearOldContextsInterval","setInterval","clearOldContexts","startTime","entry","endTime","index","close","unshift","find","closeActive","latestEntry","findAll","reset","clearInterval","oldTimeThreshold","ongoingOperations","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","SESSION_COOKIE_NAME","bufferedOperations","withCookieLockAccess","operations","numberOfRetries","next","currentLock","currentSession","retrieveSession","isCookieLockEnabled","lock","retryLater","setSession","processedSession","persistSession","isExpiredState","after","chrome","userAgent","currentNumberOfRetries","nextOperations","session","clearSession","expire","toSessionString","sessionString","isValidSessionString","startSessionStore","productKey","computeSessionState","renewObservable","expireObservable","watchSessionTimeoutId","cookieSession","isActiveSession","synchronizeSession","sessionCache","retrieveActiveSession","hasSessionInCache","isSessionInCacheOutdated","created","Number","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewCookie","renewSession","expandSession","getSession","stopCallbacks","startSessionManager","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","sessionStore","sessionContextHistory","buildSessionContext","clocksOrigin","expandSessionWhenVisible","visibilityState","visibilityCheckInterval","trackVisibility","findActiveSession","startLogsSessionManager","sessionManager","rawTrackingType","rawSessionType","hasValidLoggerSession","computeTrackingType","findTrackedSession","STATUS_PRIORITIES","isAuthorized","loggerHandler","sanitizedHandlerType","startLogsAssembly","lifeCycle","getCommonContext","mainLogger","statusWithCustom","logRateLimiters","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","_d","rawLogsEvent","_e","_f","savedCommonContext","_g","commonContext","session_id","usr","view","getRUMInternalContext","logsSentBeforeRumInjectionTelemetryAdded","browserWindow","getInternalContextFromRumGlobal","DD_RUM_SYNTHETICS","addTelemetryDebug","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","resultId","DD_RUM","rumGlobal","getInternalContext","consoleObservablesByApi","initConsoleObservable","consoleObservables","originalConsoleApi","params","handlingStack","buildConsoleLog","createConsoleObservable","param","formatConsoleParameters","firstErrorParam","predicate","LogStatusForApi","xhrObservable","LogStatusForReport","instrumentMethod","instrumentationFactory","original","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","fetchObservable","xhrContexts","WeakMap","initXhrObservable","stopInstrumentingStart","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","startContext","isAborted","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","readyState","DONE","onEnd","completeContext","duration","initFetchObservable","originalFetch","input","init","responsePromise","afterSend","reportFetch","resolveDuration","DOMException","code","ABORT_ERR","responseType","startNetworkErrorCollection","forwardErrorsToLogs","xhrSubscription","handleResponse","fetchSubscription","onResponseDataAvailable","responseData","format","http","status_code","isRejected","isServerError","truncateResponseText","computeXhrResponseData","TextDecoder","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","catch","collectStreamBody","completeBuffer_1","Uint8Array","offset_1","chunk","readMore","read","done","readBytesFromStream","responseText","decode","truncateResponseStream","clone","requestErrorResponseLengthLimit","text","computeFetchResponseText","computeFetchErrorText","substring","ERROR_TYPES_RE","startUnhandledErrorCollection","stopInstrumentingOnError","lineNo","columnNo","errorObj","name_1","location_1","msg","groups","instrumentOnError","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","trackRuntimeError","errorObservable","originalError","nonErrorPrefix","handling","computeRawError","LifeCycle","callbacks","eventCallbacks","existingGlobalVariable","datadogLogs","startLogsImpl","stub","publicApi","isAlreadyInitialized","globalContextManager","userContextManager","customLoggers","getInternalContextStrategy","beforeInitLoggerLog","_handleLogStrategy","logsMessage","getInitConfigurationStrategy","referrer","overrideInitConfigurationForBridge","canInitLogs","baseConfiguration","forwardConsoleLogs","forwardReports","validateAndBuildLogsConfiguration","handleLog","getLoggerGlobalContext","getGlobalContext","setLoggerGlobalContext","setGlobalContext","addLoggerGlobalContext","setGlobalContextProperty","removeLoggerGlobalContext","removeGlobalContextProperty","clearGlobalContext","createLogger","conf","getLogger","getInitConfiguration","setUser","isValid","checkUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","clearUser","onReady","makeLogsPublicApi","stopVisibilityChangeListener","stopBeforeUnloadListener","bridge_1","telemetryBatch_1","isTelemetryReplicationAllowed","startLogsTelemetry","application","application_id","action","user_action","rawErrorObservable","stopRuntimeErrorTracking","rawErrorSubscription","rawError","startRuntimeErrorCollection","consoleSubscription","startConsoleCollection","reportSubscription","startReportCollection","savedDate","startLoggerCollection","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","startLogsSessionManagerStub","serverLogsEvent","startLogsBridge","batch","startLogsBatch","addTelemetryConfiguration","baseSerializedInitConfiguration","session_sample_rate","telemetry_sample_rate","telemetry_configuration_sample_rate","use_before_send","use_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","track_resources","trackResources","track_long_task","trackLongTasks","serializeConfiguration","forward_errors_to_logs","forward_console_logs","forward_reports","serializeLogsConfiguration","trackedSession","q","isProduction"],"mappings":"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","file":"js/datadog_logs_init-92098b6c511f97fbfcc2.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 = 723);\n","/* eslint-disable no-console, 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};\ndisplay.debug = console.debug.bind(console);\ndisplay.log = console.log.bind(console);\ndisplay.info = console.info.bind(console);\ndisplay.warn = console.warn.bind(console);\ndisplay.error = console.error.bind(console);","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}","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}\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}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\nimport { display } from './display';\nimport { monitor } from './monitor';\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 var ONE_KIBI_BYTE = 1024;\nexport var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\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}\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}\nexport function shallowClone(object) {\n  return assign({}, object);\n}\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}\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}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() {}\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}\nfunction 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}\nexport 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 isPercentage(value) {\n  return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n  return typeof value === 'number';\n}\nexport function objectValues(object) {\n  return Object.keys(object).map(function (key) {\n    return object[key];\n  });\n}\nexport function objectHasValue(object, value) {\n  return Object.keys(object).some(function (key) {\n    return object[key] === value;\n  });\n}\nexport function objectEntries(object) {\n  return Object.keys(object).map(function (key) {\n    return [key, object[key]];\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}\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}\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}\nexport function getLocationOrigin() {\n  return getLinkElementOrigin(window.location);\n}\n/**\n * IE fallback\n * https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin\n */\nexport function getLinkElementOrigin(element) {\n  if (element.origin) {\n    return element.origin;\n  }\n  var sanitizedHost = element.host.replace(/(:80|:443)$/, '');\n  return \"\".concat(element.protocol, \"//\").concat(sanitizedHost);\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) return candidate;\n  return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}\n/**\n * Add an event listener to an event emitter 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(emitter, event, listener, options) {\n  return addEventListeners(emitter, [event], listener, options);\n}\n/**\n * Add event listeners to an event emitter 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(emitter, events, 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  events.forEach(function (event) {\n    return emitter.addEventListener(event, wrappedListener, options);\n  });\n  var stop = function stop() {\n    return events.forEach(function (event) {\n      return emitter.removeEventListener(event, wrappedListener, options);\n    });\n  };\n  return {\n    stop: stop\n  };\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}\nexport function runOnReadyState(expectedReadyState, callback) {\n  if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n    callback();\n  } else {\n    var eventName = expectedReadyState === 'complete' ? \"load\" /* LOAD */ : \"DOMContentLoaded\" /* DOM_CONTENT_LOADED */;\n    addEventListener(window, eventName, callback, {\n      once: true\n    });\n  }\n}\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}\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}\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}\nexport function requestIdleCallback(callback, opts) {\n  // Use 'requestIdleCallback' when available: it will throttle the mutation processing if the\n  // browser is busy rendering frames (ex: when frames are below 60fps). When not available, the\n  // fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any\n  // browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes\n  // efficiently.\n  if (window.requestIdleCallback) {\n    var id_1 = window.requestIdleCallback(monitor(callback), opts);\n    return function () {\n      return window.cancelIdleCallback(id_1);\n    };\n  }\n  var id = window.requestAnimationFrame(monitor(callback));\n  return function () {\n    return window.cancelAnimationFrame(id);\n  };\n}\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}\nexport function matchList(list, value) {\n  return list.some(function (item) {\n    if (typeof item === 'function') {\n      try {\n        return item(value);\n      } catch (e) {\n        display.error(e);\n        return false;\n      }\n    }\n    if (item instanceof RegExp) {\n      return item.test(value);\n    }\n    return item === value;\n  });\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}","import { deepClone } from './utils';\nexport function createContextManager() {\n  var context = {};\n  return {\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    },\n    /** @deprecated renamed to removeContextProperty */\n    remove: function remove(key) {\n      delete context[key];\n    },\n    /** @deprecated use setContext instead */\n    set: function set(newContext) {\n      context = newContext;\n    },\n    getContext: function getContext() {\n      return deepClone(context);\n    },\n    setContext: function setContext(newContext) {\n      context = deepClone(newContext);\n    },\n    setContextProperty: function setContextProperty(key, property) {\n      context[key] = deepClone(property);\n    },\n    removeContextProperty: function removeContextProperty(key) {\n      delete context[key];\n    },\n    clearContext: function clearContext() {\n      context = {};\n    }\n  };\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 { isNumber, ONE_YEAR, round } from './utils';\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}","import { endsWith, getGlobalObject } from '../tools/utils';\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 { assign, getType } from '../../tools/utils';\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 { display } from '../tools/display';\nimport { findCommaSeparatedValue, generateUUID, ONE_SECOND } from '../tools/utils';\nexport var COOKIE_ACCESS_DELAY = ONE_SECOND;\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_SECOND, 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 * 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 */\nimport { includes } from '../../tools/utils';\nimport { display } from '../../tools/display';\nvar enabledExperimentalFeatures;\nexport function updateExperimentalFeatures(enabledFeatures) {\n  // Safely handle external data\n  if (!Array.isArray(enabledFeatures)) {\n    return;\n  }\n  if (!enabledExperimentalFeatures) {\n    enabledExperimentalFeatures = new Set(enabledFeatures);\n  }\n  enabledFeatures.filter(function (flag) {\n    return typeof flag === 'string';\n  }).forEach(function (flag) {\n    if (includes(flag, '-')) {\n      display.warn(\"please use snake case for '\".concat(flag, \"'\"));\n    }\n    enabledExperimentalFeatures.add(flag);\n  });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n  return !!enabledExperimentalFeatures && enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n  enabledExperimentalFeatures = new Set();\n}\nexport function getExperimentalFeatures() {\n  return enabledExperimentalFeatures || new Set();\n}","import { getLinkElementOrigin, getLocationOrigin } from './utils';\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 haveSameOrigin(url1, url2) {\n  return getOrigin(url1) === getOrigin(url2);\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  if (checkURLSupported()) {\n    return base !== undefined ? new URL(url, base) : new URL(url);\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 isURLSupported;\nfunction checkURLSupported() {\n  if (isURLSupported !== undefined) {\n    return isURLSupported;\n  }\n  try {\n    var url = new URL('http://test/path');\n    isURLSupported = url.href === 'http://test/path';\n    return isURLSupported;\n  } catch (_a) {\n    isURLSupported = false;\n  }\n  return isURLSupported;\n}","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';","import { timeStampNow } from '../../tools/timeUtils';\nimport { normalizeUrl } from '../../tools/urlPolyfill';\nimport { generateUUID } from '../../tools/utils';\nimport { 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 _a = initConfiguration.site,\n    site = _a === void 0 ? INTAKE_SITE_US1 : _a,\n    clientToken = initConfiguration.clientToken;\n  var domainParts = site.split('.');\n  var extension = domainParts.pop();\n  var host = \"\".concat(ENDPOINTS[endpointType], \".browser-intake-\").concat(domainParts.join('-'), \".\").concat(extension);\n  var baseUrl = \"https://\".concat(host, \"/api/v2/\").concat(INTAKE_TRACKS[endpointType]);\n  var proxyUrl = initConfiguration.proxyUrl && normalizeUrl(initConfiguration.proxyUrl);\n  return {\n    build: function build(api, retry) {\n      var tags = [\"sdk_version:\".concat(\"4.26.0\"), \"api:\".concat(api)].concat(configurationTags);\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.26.0\")) + '&dd-evp-origin=browser' + \"&dd-request-id=\".concat(generateUUID());\n      if (endpointType === 'rum') {\n        parameters += \"&batch_time=\".concat(timeStampNow());\n      }\n      var endpointUrl = \"\".concat(baseUrl, \"?\").concat(parameters);\n      return proxyUrl ? \"\".concat(proxyUrl, \"?ddforward=\").concat(encodeURIComponent(endpointUrl)) : endpointUrl;\n    },\n    buildIntakeUrl: function buildIntakeUrl() {\n      return proxyUrl ? \"\".concat(proxyUrl, \"?ddforward\") : baseUrl;\n    },\n    endpointType: endpointType\n  };\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 { assign, objectValues } from '../../tools/utils';\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 intakeEndpoints = objectValues(endpointBuilders).map(function (builder) {\n    return builder.buildIntakeUrl();\n  });\n  var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeEndpoints, tags);\n  return assign({\n    isIntakeUrl: function isIntakeUrl(url) {\n      return intakeEndpoints.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, intakeEndpoints, 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  intakeEndpoints.push.apply(intakeEndpoints, objectValues(replicaEndpointBuilders).map(function (builder) {\n    return builder.buildIntakeUrl();\n  }));\n  return assign({\n    applicationId: initConfiguration.replica.applicationId\n  }, replicaEndpointBuilders);\n}","import { getCurrentSite } from '../../browser/cookie';\nimport { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { assign, isPercentage, ONE_KIBI_BYTE, ONE_SECOND } from '../../tools/utils';\nimport { updateExperimentalFeatures } from './experimentalFeatures';\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  if (initConfiguration.sampleRate !== undefined && !isPercentage(initConfiguration.sampleRate)) {\n    display.error('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  updateExperimentalFeatures(initConfiguration.enableExperimentalFeatures);\n  return assign({\n    beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n    cookieOptions: buildCookieOptions(initConfiguration),\n    sampleRate: (_a = initConfiguration.sampleRate) !== null && _a !== void 0 ? _a : 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 buildCookieOptions(initConfiguration) {\n  var cookieOptions = {};\n  cookieOptions.secure = mustUseSecureCookie(initConfiguration);\n  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;\n  if (initConfiguration.trackSessionAcrossSubdomains) {\n    cookieOptions.domain = getCurrentSite();\n  }\n  return cookieOptions;\n}\nfunction mustUseSecureCookie(initConfiguration) {\n  return !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n}\nexport function serializeConfiguration(configuration) {\n  return {\n    session_sample_rate: configuration.sampleRate,\n    telemetry_sample_rate: configuration.telemetrySampleRate,\n    telemetry_configuration_sample_rate: configuration.telemetryConfigurationSampleRate,\n    use_before_send: !!configuration.beforeSend,\n    use_cross_site_session_cookie: configuration.useCrossSiteSessionCookie,\n    use_secure_session_cookie: configuration.useSecureSessionCookie,\n    use_proxy: configuration.proxyUrl !== undefined ? !!configuration.proxyUrl : undefined,\n    silent_multiple_init: configuration.silentMultipleInit,\n    track_session_across_subdomains: configuration.trackSessionAcrossSubdomains,\n    track_resources: configuration.trackResources,\n    track_long_task: configuration.trackLongTasks\n  };\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\nimport { startsWith } from '../../tools/utils';\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|<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\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\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}","import { computeStackTrace } from '../domain/tracekit';\nimport { callMonitored } from './monitor';\nimport { jsonStringify, noop } from './utils';\nexport var ErrorSource = {\n  AGENT: 'agent',\n  CONSOLE: 'console',\n  CUSTOM: 'custom',\n  LOGGER: 'logger',\n  NETWORK: 'network',\n  SOURCE: 'source',\n  REPORT: 'report'\n};\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  if (!stackTrace || stackTrace.message === undefined && !(originalError instanceof Error)) {\n    return {\n      startClocks: startClocks,\n      source: source,\n      handling: handling,\n      originalError: originalError,\n      message: \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(originalError)),\n      stack: 'No stack, consider using an instance of Error',\n      handlingStack: handlingStack,\n      type: stackTrace && stackTrace.name\n    };\n  }\n  return {\n    startClocks: startClocks,\n    source: source,\n    handling: handling,\n    originalError: originalError,\n    message: stackTrace.message || 'Empty message',\n    stack: toStackTraceString(stackTrace),\n    handlingStack: handlingStack,\n    type: stackTrace.name,\n    causes: flattenErrorCauses(originalError, source)\n  };\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}","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}","import { toStackTraceString } from '../../tools/error';\nimport { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { includes, addEventListener, safeTruncate } from '../../tools/utils';\nexport var RawReportType = {\n  intervention: 'intervention',\n  deprecation: 'deprecation',\n  cspViolation: 'csp_violation'\n};\nexport function initReportObservable(apis) {\n  var observables = [];\n  if (includes(apis, RawReportType.cspViolation)) {\n    observables.push(createCspViolationReportObservable());\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() {\n  var observable = new Observable(function () {\n    var handleCspViolation = monitor(function (event) {\n      observable.notify(buildRawReportFromCspViolation(event));\n    });\n    var stop = addEventListener(document, \"securitypolicyviolation\" /* SECURITY_POLICY_VIOLATION */, handleCspViolation).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,\n      column: columnNumber\n    }]\n  });\n}","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}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\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--) {\n    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  }\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { deepClone, assign, combine, createContextManager, ErrorSource, monitored } 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);\nvar 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();\n    this.contextManager.set(assign({}, loggerContext, name ? {\n      logger: {\n        name: name\n      }\n    } : undefined));\n  }\n  Logger.prototype.log = function (message, messageContext, status) {\n    if (status === void 0) {\n      status = StatusType.info;\n    }\n    this.handleLogStrategy({\n      message: message,\n      context: deepClone(messageContext),\n      status: status\n    }, this);\n  };\n  Logger.prototype.debug = function (message, messageContext) {\n    this.log(message, messageContext, StatusType.debug);\n  };\n  Logger.prototype.info = function (message, messageContext) {\n    this.log(message, messageContext, StatusType.info);\n  };\n  Logger.prototype.warn = function (message, messageContext) {\n    this.log(message, messageContext, StatusType.warn);\n  };\n  Logger.prototype.error = function (message, messageContext) {\n    var errorOrigin = {\n      error: {\n        origin: ErrorSource.LOGGER\n      }\n    };\n    this.log(message, combine(errorOrigin, messageContext), StatusType.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}();\nexport { Logger };","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}","export var TelemetryType = {\n  log: 'log',\n  configuration: 'configuration'\n};","import { ConsoleApiName } from '../../tools/display';\nimport { toStackTraceString } from '../../tools/error';\nimport { assign, combine, jsonStringify, performDraw, includes, startsWith, arrayFrom } from '../../tools/utils';\nimport { getExperimentalFeatures, INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { computeStackTrace } from '../tracekit';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/timeUtils';\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor';\nimport { TelemetryType } from './rawTelemetryEvent.types';\nvar ALLOWED_FRAME_URLS = ['https://www.datadoghq-browser-agent.com', 'https://www.datad0g-browser-agent.com', '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 = performDraw(configuration.telemetrySampleRate);\n  telemetryConfiguration.telemetryConfigurationEnabled = telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate);\n  onRawTelemetryEventCollected = function onRawTelemetryEventCollected(event) {\n    if (!includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && telemetryConfiguration.telemetryEnabled) {\n      observable.notify(toTelemetryEvent(telemetryService, event));\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.26.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  };\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\" /* debug */\n  }, context));\n}\nexport function addTelemetryError(e) {\n  addTelemetry(assign({\n    type: TelemetryType.log,\n    status: \"error\" /* error */\n  }, formatError(e)));\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: 'Not an instance of error'\n    },\n    message: \"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}","import { display } from '../tools/display';\nimport { jsonStringify, objectValues } from '../tools/utils';\nimport { monitor } from '../tools/monitor';\n// https://en.wikipedia.org/wiki/UTF-8\n// eslint-disable-next-line no-control-regex\nvar HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nvar Batch = /** @class */function () {\n  function Batch(request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout, pageExitObservable) {\n    var _this = this;\n    this.request = request;\n    this.batchMessagesLimit = batchMessagesLimit;\n    this.batchBytesLimit = batchBytesLimit;\n    this.messageBytesLimit = messageBytesLimit;\n    this.flushTimeout = flushTimeout;\n    this.pageExitObservable = pageExitObservable;\n    this.pushOnlyBuffer = [];\n    this.upsertBuffer = {};\n    this.bufferBytesCount = 0;\n    this.bufferMessagesCount = 0;\n    pageExitObservable.subscribe(function () {\n      return _this.flush(_this.request.sendOnExit);\n    });\n    this.flushPeriodically();\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 (sendFn) {\n    if (sendFn === void 0) {\n      sendFn = this.request.send;\n    }\n    if (this.bufferMessagesCount !== 0) {\n      var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n      var bytesCount = this.bufferBytesCount;\n      this.pushOnlyBuffer = [];\n      this.upsertBuffer = {};\n      this.bufferBytesCount = 0;\n      this.bufferMessagesCount = 0;\n      sendFn({\n        data: messages.join('\\n'),\n        bytesCount: bytesCount\n      });\n    }\n  };\n  Batch.prototype.computeBytesCount = function (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  };\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    if (this.willReachedBytesLimitWith(messageBytesCount)) {\n      this.flush();\n    }\n    this.push(processedMessage, messageBytesCount, key);\n    if (this.isFull()) {\n      this.flush();\n    }\n  };\n  Batch.prototype.process = function (message) {\n    var processedMessage = jsonStringify(message);\n    var messageBytesCount = this.computeBytesCount(processedMessage);\n    return {\n      processedMessage: processedMessage,\n      messageBytesCount: messageBytesCount\n    };\n  };\n  Batch.prototype.push = function (processedMessage, messageBytesCount, key) {\n    if (this.bufferMessagesCount > 0) {\n      // \\n separator at serialization\n      this.bufferBytesCount += 1;\n    }\n    if (key !== undefined) {\n      this.upsertBuffer[key] = processedMessage;\n    } else {\n      this.pushOnlyBuffer.push(processedMessage);\n    }\n    this.bufferBytesCount += messageBytesCount;\n    this.bufferMessagesCount += 1;\n  };\n  Batch.prototype.remove = function (key) {\n    var removedMessage = this.upsertBuffer[key];\n    delete this.upsertBuffer[key];\n    var messageBytesCount = this.computeBytesCount(removedMessage);\n    this.bufferBytesCount -= messageBytesCount;\n    this.bufferMessagesCount -= 1;\n    if (this.bufferMessagesCount > 0) {\n      this.bufferBytesCount -= 1;\n    }\n  };\n  Batch.prototype.hasMessageFor = function (key) {\n    return key !== undefined && this.upsertBuffer[key] !== undefined;\n  };\n  Batch.prototype.willReachedBytesLimitWith = function (messageBytesCount) {\n    // byte of the separator at the end of the message\n    return this.bufferBytesCount + messageBytesCount + 1 >= this.batchBytesLimit;\n  };\n  Batch.prototype.isFull = function () {\n    return this.bufferMessagesCount === this.batchMessagesLimit || this.bufferBytesCount >= this.batchBytesLimit;\n  };\n  Batch.prototype.flushPeriodically = function () {\n    var _this = this;\n    setTimeout(monitor(function () {\n      _this.flush();\n      _this.flushPeriodically();\n    }), this.flushTimeout);\n  };\n  return Batch;\n}();\nexport { Batch };","import { monitor } from '../tools/monitor';\nimport { clocksNow } from '../tools/timeUtils';\nimport { ONE_KIBI_BYTE, ONE_MEBI_BYTE, ONE_SECOND, ONE_MINUTE } from '../tools/utils';\nimport { ErrorSource } from '../tools/error';\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 /* UP */ && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) {\n    send(payload, state, sendStrategy, {\n      onSuccess: function onSuccess() {\n        return retryQueuedPayloads(0 /* 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 /* DOWN */) {\n    return;\n  }\n  setTimeout(monitor(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 /* 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 /* 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 /* FAILURE_DETECTED */ : 2 /* 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 /* 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.status === 0 || response.status === 408 || response.status === 429 || response.status >= 500;\n}\nexport function newRetryState() {\n  return {\n    transportStatus: 0 /* 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 { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(endpointBuilder, bytesLimit, reportError) {\n  var retryState = newRetryState();\n  var sendStrategyForRetry = function sendStrategyForRetry(payload, onResponse) {\n    return fetchKeepAliveStrategy(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(endpointBuilder, bytesLimit, payload);\n    }\n  };\n}\nfunction sendBeaconStrategy(endpointBuilder, bytesLimit, _a) {\n  var data = _a.data,\n    bytesCount = _a.bytesCount;\n  var canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit;\n  if (canUseBeacon) {\n    try {\n      var beaconUrl = endpointBuilder.build('beacon');\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');\n  sendXHR(xhrUrl, data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n  if (!hasReportedBeaconError) {\n    hasReportedBeaconError = true;\n    addTelemetryError(e);\n  }\n}\nexport function fetchKeepAliveStrategy(endpointBuilder, bytesLimit, _a, onResponse) {\n  var data = _a.data,\n    bytesCount = _a.bytesCount,\n    retry = _a.retry;\n  var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit;\n  if (canUseKeepAlive) {\n    var fetchUrl = endpointBuilder.build('fetch', retry);\n    fetch(fetchUrl, {\n      method: 'POST',\n      body: data,\n      keepalive: true\n    }).then(monitor(function (response) {\n      return onResponse === null || onResponse === void 0 ? void 0 : onResponse({\n        status: response.status\n      });\n    }), monitor(function () {\n      var xhrUrl = endpointBuilder.build('xhr', retry);\n      // failed to queue the request\n      sendXHR(xhrUrl, data, onResponse);\n    }));\n  } else {\n    var xhrUrl = endpointBuilder.build('xhr', retry);\n    sendXHR(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(url, data, onResponse) {\n  var request = new XMLHttpRequest();\n  var onLoadEnd = monitor(function () {\n    // prevent multiple onResponse callbacks\n    // if the xhr instance is reused by a third party\n    request.removeEventListener('loadend', onLoadEnd);\n    onResponse === null || onResponse === void 0 ? void 0 : onResponse({\n      status: request.status\n    });\n  });\n  request.open('POST', url, true);\n  request.addEventListener('loadend', onLoadEnd);\n  request.send(data);\n}","import { Batch } from './batch';\nimport { createHttpRequest } from './httpRequest';\nexport function startBatchWithReplica(configuration, endpoint, reportError, pageExitObservable, replicaEndpoint) {\n  var primaryBatch = createBatch(endpoint);\n  var replicaBatch;\n  if (replicaEndpoint) {\n    replicaBatch = createBatch(replicaEndpoint);\n  }\n  function createBatch(endpointBuilder) {\n    return new Batch(createHttpRequest(endpointBuilder, configuration.batchBytesLimit, reportError), configuration.batchMessagesLimit, configuration.batchBytesLimit, configuration.messageBytesLimit, configuration.flushTimeout, pageExitObservable);\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 { relativeNow } from './timeUtils';\nimport { ONE_MINUTE } from './utils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE;\n/**\n * Store and keep track of contexts spans. This whole class assumes that contexts are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nvar ContextHistory = /** @class */function () {\n  function ContextHistory(expireDelay) {\n    var _this = this;\n    this.expireDelay = expireDelay;\n    this.entries = [];\n    this.clearOldContextsInterval = setInterval(function () {\n      return _this.clearOldContexts();\n    }, CLEAR_OLD_CONTEXTS_INTERVAL);\n  }\n  /**\n   * Add a context 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  ContextHistory.prototype.add = function (context, startTime) {\n    var _this = this;\n    var entry = {\n      context: context,\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    this.entries.unshift(entry);\n    return entry;\n  };\n  /**\n   * Return the latest context that was active during `startTime`, or the currently active context\n   * if no `startTime` is provided. This method assumes that entries are not overlapping.\n   */\n  ContextHistory.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.context;\n        }\n        break;\n      }\n    }\n  };\n  /**\n   * Helper function to close the currently active context, if any. This method assumes that entries\n   * are not overlapping.\n   */\n  ContextHistory.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 contexts that were active during `startTime`, or all currently active contexts if no\n   * `startTime` is provided.\n   */\n  ContextHistory.prototype.findAll = function (startTime) {\n    if (startTime === void 0) {\n      startTime = END_OF_TIMES;\n    }\n    return this.entries.filter(function (entry) {\n      return entry.startTime <= startTime && startTime <= entry.endTime;\n    }).map(function (entry) {\n      return entry.context;\n    });\n  };\n  /**\n   * Remove all entries from this collection.\n   */\n  ContextHistory.prototype.reset = function () {\n    this.entries = [];\n  };\n  /**\n   * Stop internal garbage collection of past entries.\n   */\n  ContextHistory.prototype.stop = function () {\n    clearInterval(this.clearOldContextsInterval);\n  };\n  ContextHistory.prototype.clearOldContexts = 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 ContextHistory;\n}();\nexport { ContextHistory };","import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;","import { getCookie, setCookie } from '../../browser/cookie';\nimport { isChromium } from '../../tools/browserDetection';\nimport { monitor } from '../../tools/monitor';\nimport { dateNow } from '../../tools/timeUtils';\nimport * as utils from '../../tools/utils';\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants';\nvar SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;\nvar SESSION_ENTRY_SEPARATOR = '&';\nexport var SESSION_COOKIE_NAME = '_dd_s';\n// arbitrary values\nexport var LOCK_RETRY_DELAY = 10;\nexport var MAX_NUMBER_OF_LOCK_RETRIES = 100;\nvar bufferedOperations = [];\nvar ongoingOperations;\nexport function withCookieLockAccess(operations, numberOfRetries) {\n  var _a;\n  if (numberOfRetries === void 0) {\n    numberOfRetries = 0;\n  }\n  if (!ongoingOperations) {\n    ongoingOperations = operations;\n  }\n  if (operations !== ongoingOperations) {\n    bufferedOperations.push(operations);\n    return;\n  }\n  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {\n    next();\n    return;\n  }\n  var currentLock;\n  var currentSession = retrieveSession();\n  if (isCookieLockEnabled()) {\n    // if someone has lock, retry later\n    if (currentSession.lock) {\n      retryLater(operations, numberOfRetries);\n      return;\n    }\n    // acquire lock\n    currentLock = utils.generateUUID();\n    currentSession.lock = currentLock;\n    setSession(currentSession, operations.options);\n    // if lock is not acquired, retry later\n    currentSession = retrieveSession();\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, numberOfRetries);\n      return;\n    }\n  }\n  var processedSession = operations.process(currentSession);\n  if (isCookieLockEnabled()) {\n    // if lock corrupted after process, retry later\n    currentSession = retrieveSession();\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, numberOfRetries);\n      return;\n    }\n  }\n  if (processedSession) {\n    persistSession(processedSession, operations.options);\n  }\n  if (isCookieLockEnabled()) {\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 && isExpiredState(processedSession))) {\n      // if lock corrupted after persist, retry later\n      currentSession = retrieveSession();\n      if (currentSession.lock !== currentLock) {\n        retryLater(operations, numberOfRetries);\n        return;\n      }\n      delete currentSession.lock;\n      setSession(currentSession, operations.options);\n      processedSession = currentSession;\n    }\n  }\n  // call after even if session is not persisted in order to perform operations on\n  // up-to-date cookie 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();\n}\n/**\n * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.\n * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.\n */\nfunction isCookieLockEnabled() {\n  return isChromium();\n}\nfunction retryLater(operations, currentNumberOfRetries) {\n  setTimeout(monitor(function () {\n    withCookieLockAccess(operations, currentNumberOfRetries + 1);\n  }), LOCK_RETRY_DELAY);\n}\nfunction next() {\n  ongoingOperations = undefined;\n  var nextOperations = bufferedOperations.shift();\n  if (nextOperations) {\n    withCookieLockAccess(nextOperations);\n  }\n}\nexport function persistSession(session, options) {\n  if (isExpiredState(session)) {\n    clearSession(options);\n    return;\n  }\n  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n  setSession(session, options);\n}\nfunction setSession(session, options) {\n  setCookie(SESSION_COOKIE_NAME, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n}\nexport function toSessionString(session) {\n  return utils.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 retrieveSession() {\n  var sessionString = getCookie(SESSION_COOKIE_NAME);\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 !== undefined && (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));\n}\nfunction isExpiredState(session) {\n  return utils.isEmptyObject(session);\n}\nfunction clearSession(options) {\n  setCookie(SESSION_COOKIE_NAME, '', 0, options);\n}","export function isIE() {\n  return Boolean(document.documentMode);\n}\nexport function isChromium() {\n  return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent);\n}","import { COOKIE_ACCESS_DELAY } from '../../browser/cookie';\nimport { monitor } from '../../tools/monitor';\nimport { Observable } from '../../tools/observable';\nimport { dateNow } from '../../tools/timeUtils';\nimport * as utils from '../../tools/utils';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { retrieveSession, withCookieLockAccess } from './sessionCookieStore';\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(options, productKey, computeSessionState) {\n  var renewObservable = new Observable();\n  var expireObservable = new Observable();\n  var watchSessionTimeoutId = setInterval(monitor(watchSession), COOKIE_ACCESS_DELAY);\n  var sessionCache = retrieveActiveSession();\n  function expandOrRenewSession() {\n    var isTracked;\n    withCookieLockAccess({\n      options: options,\n      process: function process(cookieSession) {\n        var synchronizedSession = synchronizeSession(cookieSession);\n        isTracked = expandOrRenewCookie(synchronizedSession);\n        return synchronizedSession;\n      },\n      after: function after(cookieSession) {\n        if (isTracked && !hasSessionInCache()) {\n          renewSession(cookieSession);\n        }\n        sessionCache = cookieSession;\n      }\n    });\n  }\n  function expandSession() {\n    withCookieLockAccess({\n      options: options,\n      process: function process(cookieSession) {\n        return hasSessionInCache() ? synchronizeSession(cookieSession) : undefined;\n      }\n    });\n  }\n  /**\n   * allows two behaviors:\n   * - if the session is active, synchronize the session cache without updating the session cookie\n   * - if the session is not active, clear the session cookie and expire the session cache\n   */\n  function watchSession() {\n    withCookieLockAccess({\n      options: options,\n      process: function process(cookieSession) {\n        return !isActiveSession(cookieSession) ? {} : undefined;\n      },\n      after: synchronizeSession\n    });\n  }\n  function synchronizeSession(cookieSession) {\n    if (!isActiveSession(cookieSession)) {\n      cookieSession = {};\n    }\n    if (hasSessionInCache()) {\n      if (isSessionInCacheOutdated(cookieSession)) {\n        expireSession();\n      } else {\n        sessionCache = cookieSession;\n      }\n    }\n    return cookieSession;\n  }\n  function expandOrRenewCookie(cookieSession) {\n    var _a = computeSessionState(cookieSession[productKey]),\n      trackingType = _a.trackingType,\n      isTracked = _a.isTracked;\n    cookieSession[productKey] = trackingType;\n    if (isTracked && !cookieSession.id) {\n      cookieSession.id = utils.generateUUID();\n      cookieSession.created = String(dateNow());\n    }\n    return isTracked;\n  }\n  function hasSessionInCache() {\n    return sessionCache[productKey] !== undefined;\n  }\n  function isSessionInCacheOutdated(cookieSession) {\n    return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey];\n  }\n  function expireSession() {\n    sessionCache = {};\n    expireObservable.notify();\n  }\n  function renewSession(cookieSession) {\n    sessionCache = cookieSession;\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(session) {\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 (session.created === undefined || dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) && (session.expire === undefined || dateNow() < Number(session.expire));\n  }\n  return {\n    expandOrRenewSession: utils.throttle(monitor(expandOrRenewSession), COOKIE_ACCESS_DELAY).throttled,\n    expandSession: expandSession,\n    getSession: function getSession() {\n      return sessionCache;\n    },\n    renewObservable: renewObservable,\n    expireObservable: expireObservable,\n    stop: function stop() {\n      clearInterval(watchSessionTimeoutId);\n    }\n  };\n}","import * as utils from '../../tools/utils';\nimport { ContextHistory } from '../../tools/contextHistory';\nimport { relativeNow, clocksOrigin } from '../../tools/timeUtils';\nimport { monitor } from '../../tools/monitor';\nimport { tryOldCookiesMigration } from './oldCookiesMigration';\nimport { startSessionStore } from './sessionStore';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nexport var VISIBILITY_CHECK_DELAY = utils.ONE_MINUTE;\nvar SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nvar stopCallbacks = [];\nexport function startSessionManager(options, productKey, computeSessionState) {\n  tryOldCookiesMigration(options);\n  var sessionStore = startSessionStore(options, productKey, computeSessionState);\n  stopCallbacks.push(function () {\n    return sessionStore.stop();\n  });\n  var sessionContextHistory = new ContextHistory(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(function () {\n    return sessionStore.expandOrRenewSession();\n  });\n  trackVisibility(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  };\n}\nexport function stopSessionManager() {\n  stopCallbacks.forEach(function (e) {\n    return e();\n  });\n  stopCallbacks = [];\n}\nfunction trackActivity(expandOrRenewSession) {\n  var stop = utils.addEventListeners(window, [\"click\" /* CLICK */, \"touchstart\" /* TOUCH_START */, \"keydown\" /* KEY_DOWN */, \"scroll\" /* SCROLL */], expandOrRenewSession, {\n    capture: true,\n    passive: true\n  }).stop;\n  stopCallbacks.push(stop);\n}\nfunction trackVisibility(expandSession) {\n  var expandSessionWhenVisible = monitor(function () {\n    if (document.visibilityState === 'visible') {\n      expandSession();\n    }\n  });\n  var stop = utils.addEventListener(document, \"visibilitychange\" /* 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 { getCookie } from '../../browser/cookie';\nimport { SESSION_COOKIE_NAME, persistSession } from './sessionCookieStore';\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(options) {\n  var sessionString = getCookie(SESSION_COOKIE_NAME);\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  if (!sessionString) {\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    persistSession(session, options);\n  }\n}","import { performDraw, startSessionManager } from '@datadog/browser-core';\nexport var LOGS_SESSION_KEY = 'logs';\nexport function startLogsSessionManager(configuration) {\n  var sessionManager = startSessionManager(configuration.cookieOptions, 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\" /* TRACKED */ ? {\n        id: session.id\n      } : undefined;\n    }\n  };\n}\nexport function startLogsSessionManagerStub(configuration) {\n  var isTracked = computeTrackingType(configuration) === \"1\" /* TRACKED */;\n  var session = isTracked ? {} : undefined;\n  return {\n    findTrackedSession: function findTrackedSession() {\n      return session;\n    }\n  };\n}\nfunction computeTrackingType(configuration) {\n  if (!performDraw(configuration.sampleRate)) {\n    return \"0\" /* NOT_TRACKED */;\n  }\n\n  return \"1\" /* TRACKED */;\n}\n\nfunction computeSessionState(configuration, rawSessionType) {\n  var trackingType = hasValidLoggerSession(rawSessionType) ? rawSessionType : computeTrackingType(configuration);\n  return {\n    trackingType: trackingType,\n    isTracked: trackingType === \"1\" /* TRACKED */\n  };\n}\n\nfunction hasValidLoggerSession(trackingType) {\n  return trackingType === \"0\" /* NOT_TRACKED */ || trackingType === \"1\" /* 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 /* 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, getCommonContext, 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 /* 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 || getCommonContext();\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 /* 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}","import { ErrorSource } from './error';\nimport { clocksNow } from './timeUtils';\nimport { ONE_MINUTE } from './utils';\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 { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString } from '../../tools/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { find, jsonStringify } from '../../tools/utils';\nimport { ConsoleApiName } from '../../tools/display';\nimport { callMonitored } from '../../tools/monitor';\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}\n/* eslint-disable no-console */\nfunction createConsoleObservable(api) {\n  var observable = new Observable(function () {\n    var originalConsoleApi = console[api];\n    console[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      console[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  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    message = \"console error: \".concat(message);\n  }\n  return {\n    api: api,\n    message: message,\n    stack: stack,\n    handlingStack: handlingStack\n  };\n}\nfunction formatConsoleParameters(param) {\n  if (typeof param === 'string') {\n    return param;\n  }\n  if (param instanceof Error) {\n    return formatErrorMessage(computeStackTrace(param));\n  }\n  return jsonStringify(param, undefined, 2);\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 /* 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        } : 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.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 /* 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 { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\nimport { monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/timeUtils';\nimport { normalizeUrl } from '../tools/urlPolyfill';\nimport { shallowClone } from '../tools/utils';\nvar xhrObservable;\nvar xhrContexts = new WeakMap();\nexport function initXhrObservable() {\n  if (!xhrObservable) {\n    xhrObservable = createXhrObservable();\n  }\n  return xhrObservable;\n}\nfunction createXhrObservable() {\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, 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(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 = monitor(function () {\n    _this.removeEventListener('loadend', onEnd);\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  this.addEventListener('loadend', onEnd);\n  observable.notify(startContext);\n}\nfunction abortXhr() {\n  var context = xhrContexts.get(this);\n  if (context) {\n    context.isAborted = true;\n  }\n}","import { callMonitored, monitor } from './monitor';\nimport { noop } from './utils';\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(monitor(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}","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\nimport { instrumentMethod } from '../tools/instrumentMethod';\nimport { callMonitored, monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { elapsed, clocksNow, timeStampNow } from '../tools/timeUtils';\nimport { normalizeUrl } from '../tools/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 || _typeof(input) === 'object' && input.method || 'GET';\n  var url = normalizeUrl(_typeof(input) === 'object' && input.url || 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    context.resolveDuration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\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 { ErrorSource, initXhrObservable, initFetchObservable, computeStackTrace, toStackTraceString, monitor, noop, readBytesFromStream } 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().subscribe(function (context) {\n    if (context.state === 'complete') {\n      handleResponse(\"xhr\" /* XHR */, context);\n    }\n  });\n  var fetchSubscription = initFetchObservable().subscribe(function (context) {\n    if (context.state === 'resolve') {\n      handleResponse(\"fetch\" /* FETCH */, context);\n    }\n  });\n  function handleResponse(type, request) {\n    if (!configuration.isIntakeUrl(request.url) && (isRejected(request) || isServerError(request))) {\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 /* 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  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    response.clone().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 if (!response.body) {\n    callback();\n  } else {\n    truncateResponseStream(response.clone().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 isServerError(request) {\n  return request.status >= 500;\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\" /* 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 { monitor } from './monitor';\nimport { noop } from './utils';\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) chunks.push(result.value);\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}","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): )?(.*)$/;\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(message, url, lineNo, columnNo, errorObj) {\n      var stack;\n      if (errorObj) {\n        stack = computeStackTrace(errorObj);\n        callback(stack, errorObj);\n      } else {\n        var location_1 = {\n          url: url,\n          column: columnNo,\n          line: lineNo\n        };\n        var name_1;\n        var msg = message;\n        if ({}.toString.call(message) === '[object String]') {\n          var groups = ERROR_TYPES_RE.exec(msg);\n          if (groups) {\n            name_1 = groups[1];\n            msg = groups[2];\n          }\n        }\n        stack = {\n          name: name_1,\n          message: typeof msg === 'string' ? msg : undefined,\n          stack: [location_1]\n        };\n        callback(stack, message);\n      }\n    }\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 { ErrorSource, computeRawError } from '../../tools/error';\nimport { clocksNow } from '../../tools/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\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',\n      source: ErrorSource.SOURCE,\n      handling: \"unhandled\" /* UNHANDLED */\n    }));\n  });\n}","var LifeCycle = /** @class */function () {\n  function LifeCycle() {\n    this.callbacks = {};\n  }\n  LifeCycle.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  LifeCycle.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 LifeCycle;\n}();\nexport { LifeCycle };","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 { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { assign } from '../tools/utils';\nexport function makePublicApi(stub) {\n  var publicApi = assign({\n    version: \"4.26.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 { assign, BoundedBuffer, createContextManager, makePublicApi, monitor, display, deepClone, canUseEventBridge, timeStampNow, checkUser, sanitizeUser } 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();\n  var userContextManager = createContextManager();\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(getCommonContext());\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 getCommonContext() {\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      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, getCommonContext, mainLogger), _handleLogStrategy = _a.handleLog, getInternalContextStrategy = _a.getInternalContext;\n      getInitConfigurationStrategy = function getInitConfigurationStrategy() {\n        return deepClone(initConfiguration);\n      };\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      }, name, conf.handler, conf.level, 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 { createPageExitObservable, willSyntheticsInjectRum, areCookiesAuthorized, canUseEventBridge, getEventBridge, startTelemetry, startBatchWithReplica, isTelemetryReplicationAllowed, ErrorSource, addTelemetryConfiguration } 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, getCommonContext, mainLogger) {\n  var lifeCycle = new LifeCycle();\n  var reportError = function reportError(error) {\n    return lifeCycle.notify(0 /* 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\n        origin: ErrorSource.AGENT,\n        status: StatusType.error\n      }\n    });\n  };\n  var pageExitObservable = createPageExitObservable();\n  var telemetry = startLogsTelemetry(configuration, reportError, pageExitObservable);\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  var session = areCookiesAuthorized(configuration.cookieOptions) && !canUseEventBridge() && !willSyntheticsInjectRum() ? startLogsSessionManager(configuration) : startLogsSessionManagerStub(configuration);\n  startLogsAssembly(session, configuration, lifeCycle, getCommonContext, mainLogger, reportError);\n  if (!canUseEventBridge()) {\n    startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable);\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) {\n  var _a;\n  var telemetry = startTelemetry(\"browser-logs-sdk\" /* 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, (_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 { Observable } from '../tools/observable';\nimport { addEventListener } from '../tools/utils';\nexport function createPageExitObservable() {\n  var observable = new Observable(function () {\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    var stopVisibilityChangeListener = addEventListener(document, \"visibilitychange\" /* VISIBILITY_CHANGE */, function () {\n      if (document.visibilityState === 'hidden') {\n        observable.notify({\n          reason: \"visibility_hidden\" /* HIDDEN */\n        });\n      }\n    }, {\n      capture: true\n    }).stop;\n    /**\n     * Safari does not support yet to send a request during:\n     * - a visibility change during doc unload (cf: https://bugs.webkit.org/show_bug.cgi?id=194897)\n     * - a page hide transition (cf: https://bugs.webkit.org/show_bug.cgi?id=188329)\n     */\n    var stopBeforeUnloadListener = addEventListener(window, \"beforeunload\" /* BEFORE_UNLOAD */, function () {\n      observable.notify({\n        reason: \"before_unload\" /* UNLOADING */\n      });\n    }).stop;\n    return function () {\n      stopVisibilityChangeListener();\n      stopBeforeUnloadListener();\n    };\n  });\n  return observable;\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 /* 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 /* LOG_COLLECTED */, function (serverLogsEvent) {\n    bridge.send('log', serverLogsEvent);\n  });\n}","import { startBatchWithReplica } from '@datadog/browser-core';\nexport function startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable) {\n  var _a;\n  var batch = startBatchWithReplica(configuration, configuration.logsEndpointBuilder, reportError, pageExitObservable, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.logsEndpointBuilder);\n  lifeCycle.subscribe(1 /* LOG_COLLECTED */, function (serverLogsEvent) {\n    batch.add(serverLogsEvent);\n  });\n}","import { datadogLogs, HandlerType } from \"@datadog/browser-logs\"\n\nconst isProduction = location.href.startsWith(\"https://market.trck.jp\")\n\ndatadogLogs.init({\n  clientToken: \"pub6b5e96ae94c2f7d2e07dbdb0dd766207\",\n  forwardErrorsToLogs: true\n})\ndatadogLogs.addLoggerGlobalContext(\"service\", \"truckers\")\ndatadogLogs.addLoggerGlobalContext(\"type\", \"browser\")\n\n// 本番以外はコンソールに出力\nif (!isProduction) {\n  datadogLogs.logger.setHandler(HandlerType.console)\n}\n"],"sourceRoot":""}