{"version":3,"sources":["webpack://asp.net/webpack/universalModuleDefinition","webpack://asp.net/./Scripts/app/config.js","webpack://asp.net/webpack/bootstrap","webpack://asp.net/webpack/runtime/define property getters","webpack://asp.net/webpack/runtime/hasOwnProperty shorthand","webpack://asp.net/webpack/runtime/make namespace object","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/tracekit/computeStackTrace.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/utils.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/error.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/timeUtils.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/configuration/experimentalFeatures.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/internalMonitoring/internalMonitoring.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/urlPolyfill.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/syntheticsContext.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceUtils.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/createEventRateLimiter.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/limitModification.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/ciTestContext.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/foregroundContexts.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/session/sessionCookieStore.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/browserDetection.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/contextHistory.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/waitIdlePage.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getActionNameFromElement.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/trackActions.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/actionCollection.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/tracekit/tracekit.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackFirstHidden.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/errorCollection.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackConsoleError.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackReportError.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/matchRequestTiming.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceCollection.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackInitialViewTimings.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewMetrics.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViews.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/viewCollection.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/types.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/constants.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/serialize.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/serializationUtils.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/utils.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/types.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/mutationObserver.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/observer.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/transport/send.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/deflateWorker.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/startDeflateWorker.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/tools/contextManager.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/configuration.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://asp.net/./node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/parentContexts.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/urlContexts.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/longTask/longTaskCollection.js","webpack://asp.net/./node_modules/@datadog/browser-rum-core/esm/domain/internalContext.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://asp.net/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://asp.net/./Scripts/app/main.js"],"names":["root","factory","exports","module","define","amd","a","i","self","isProduction","enableDatadog","stripePublishableKey","googleAnalyticsId","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","r","Symbol","toStringTag","value","display","log","console","bind","warn","error","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","split","forEach","line","stackFrame","parts","CHROME_LINE_RE","exec","isNative","indexOf","isEval","submatch","CHROME_EVAL_RE","args","column","func","url","parseChromeLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","push","message","name","candidate","property","ONE_SECOND","ONE_MINUTE","throttle","fn","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","_i","arguments","length","apply","setTimeout","cancel","clearTimeout","target","toAssign","source","shallowClone","object","generateUUID","placeholder","parseInt","Math","random","toString","concat","replace","performDraw","threshold","round","num","decimals","toFixed","noop","jsonStringify","replacer","space","JSON","stringify","originalToJSON","hasToJSON","toJSON","result","originalProtoToJSON","getPrototypeOf","_a","includes","search","find","array","predicate","item","isPercentage","isNumber","objectValues","keys","map","objectEntries","isEmptyObject","getGlobalObject","globalThis","this","configurable","globalObject","_dd_temp_","window","getLinkElementOrigin","element","origin","sanitizedHost","host","protocol","findCommaSeparatedValue","rawString","matches","RegExp","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","slice","addEventListener","emitter","event","listener","addEventListeners","events","_b","once","capture","passive","wrappedListener","monitor","stop","removeEventListener","runOnReadyState","expectedReadyState","callback","document","readyState","getType","Array","isArray","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","has","add","createCircularReferenceChecker","Date","getTime","flags","global","ignoreCase","multiline","sticky","unicode","join","merged_1","merged","deepClone","combine","sources","sources_1","ErrorSource","formatUnknownError","stackTrace","errorObject","nonErrorPrefix","handlingStack","Error","toStackTraceString","type","formatErrorMessage","frame","createHandlingStack","formattedStack","e","callMonitored","navigationStart","enabledExperimentalFeatures","Observable","onFirstSubscribe","observers","subscribe","f","_this","onLastUnsubscribe","unsubscribe","filter","other","notify","data","observer","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","relativeToClocks","relative","timeStamp","getCorrectedTimeStamp","relativeTime","correctedOrigin","now","performance","getNavigationStart","getTimeStamp","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","timing","isExperimentalFeatureEnabled","featureName","onInternalMonitoringMessageCollected","monitoringConfiguration","maxMessagesPerPage","sentMessageCount","startInternalMonitoring","configuration","externalContextProvider","telemetryContextProvider","monitoringMessageObservable","telemetryEventObservable","date","withContext","service","version","_dd","event_type","toTelemetryEvent","maxInternalMonitoringMessagesPerPage","setExternalContextProvider","provider","setTelemetryContextProvider","context","logErrorIfDebug","addMonitoringError","addMonitoringMessage","debugMode","logMessageIfDebug","addToMonitoring","status","kind","formatError","setDebugMode","catchUserErrors","errorMsg","err","BoundedBuffer","buffer","splice","drain","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","canUseEventBridge","bridge","location","hostname","getCurrentSiteCache","isURLSupported","setCookie","expireDelay","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","cookie","getCookie","deleteCookie","normalizeUrl","buildUrl","href","getOrigin","base","URL","checkURLSupported","test","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","INTAKE_SITE_US","createEndpointBuilder","initConfiguration","endpointType","tags","site","clientToken","domainParts","extension","pop","baseUrl","proxyUrl","build","encodeURIComponent","endpointUrl","buildIntakeUrl","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","computeTransportConfiguration","env","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","internalMonitoringApiKey","internalMonitoringEndpointBuilder","computeEndpointBuilders","intakeEndpoints","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","some","intakeEndpoint","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","enabledFeatures","sampleRate","enableExperimentalFeatures","Set","flag","beforeSend","cookieOptions","buildCookieOptions","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","flushTimeout","maxBatchSize","maxMessageSize","useSecureSessionCookie","useCrossSiteSessionCookie","mustUseSecureCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","getCurrentSite","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","HAS_MULTI_BYTES_CHARACTERS","Batch","request","maxSize","bytesLimit","beforeUnloadCallback","pushOnlyBuffer","upsertBuffer","bufferBytesSize","bufferMessageCount","flushOnVisibilityHidden","flushPeriodically","addOrUpdate","upsert","flush","reason","messages","sizeInBytes","TextEncoder","encode","Blob","size","process","processedMessage","messageBytesSize","hasMessageFor","remove","willReachedBytesLimitWith","isFull","removedMessage","navigator","sendBeacon","visibilityState","hasReportedXhrError","HttpRequest","endpointBuilder","flushReason","tryBeacon","hasReportedBeaconError","reportBeaconError","XMLHttpRequest","req","currentTarget","on_line","onLine","try_beacon","flush_reason","is_trusted","isTrusted","total","loaded","ready_state","response_text","responseText","transportIntrospection","open","getMutationObserverConstructor","constructor","browserWindow","Zone","symbol","__symbol__","MutationObserver","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","path","computeResourceKind","isValidUrl","pathname","getPathName","RESOURCE_TYPES_1","isType","areInOrder","numbers","computePerformanceResourceDetails","entry","validEntry","toValidEntry","startTime","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","responseEnd","first_byte","connect","ssl","dns","hasRedirection","redirect","computeSize","decodedBodySize","isAllowedRequestUrl","getDocumentTraceId","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","node","isTextNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","traceId","rawTraceTime","Number","nodeName","isCommentNode","match","supportPerformanceObject","supportPerformanceTimingEvent","entryType","PerformanceObserver","supportedEntryTypes","startPerformanceCollection","lifeCycle","handleRumPerformanceEntries","forcedAttributes","getEntriesByType","relativePerformanceTiming","computeRelativePerformanceTiming","performanceEntries_1","getEntries","handlePerformanceEntryList_1","entries","mainEntries","experimentalEntries","observe","buffered","entryTypes","clearResourceTimings","sendFakeTiming","retrieveNavigationTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","sendTimingIfPointerIsNotCancelled","sendTiming","delay","retrieveFirstInputTiming","numberKey","timingElement","rumAllowedPerformanceEntries","loadEventEnd","isIncompleteNavigation","isForbiddenResource","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","startClocks","current","field","isValidObjectContaining","set","fields","VIEW_EVENTS_MODIFIABLE_FIELD_PATHS","OTHER_EVENTS_MODIFIABLE_FIELD_PATHS","startRumAssembly","sessionManager","parentContexts","urlContexts","getCommonContext","reportError","eventRateLimiters","syntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","resultId","_DATADOG_SYNTHETICS_RESULT_ID","test_id","result_id","injected","getSyntheticsContext","ciTestContext","testExecutionId","Cypress","test_execution_id","getCiTestContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","session","findTrackedSession","actionContext","findAction","commonContext","rumContext","format_version","drift","plan","hasReplayPlan","browser_sdk_version","application","id","synthetics","ci_test","serverRumEvent","has_replay","hasReplay","user","usr","modifiableFieldPaths","modifier","clone","originalValue","newValue","originalType","newType","limitModification","shouldSend","foregroundPeriods","startForegroundContexts","hasFocus","addNewForegroundPeriod","onFocusChange","onBlurChange","stopForegroundTracking","stopBlurTracking","closeForegroundPeriod","isInForegroundAt","selectInForegroundPeriodsFor","currentForegroundPeriod","foregroundPeriod","eventStartTime","eventEndTime","filteredForegroundPeriods","earliestIndex","max","startDuration","endDuration","unshift","LifeCycle","callbacks","eventCallbacks","ongoingOperations","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","shift","clearSession","expire","String","SESSION_EXPIRATION_DELAY","toSessionString","sessionString","isValidSessionString","SESSION_TIME_OUT_DELAY","startSessionStore","productKey","computeSessionState","renewObservable","expireObservable","watchSessionTimeoutId","setInterval","cookieSession","isActiveSession","synchronizeSession","sessionCache","retrieveActiveSession","hasSessionInCache","isSessionInCacheOutdated","created","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewCookie","renewSession","expandSession","getSession","clearInterval","xhrObservable","ContextHistory","previousContexts","clearOldContextsInterval","clearOldContexts","currentStart","previousContext","endTime","setCurrent","getCurrent","clearCurrent","closeCurrent","oldTimeThreshold","reset","instrumentMethod","method","instrumentationFactory","original","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","fetchObservable","xhrContexts","WeakMap","initXhrObservable","stopInstrumentingStart","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","state","startContext","isAborted","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","completeContext","initFetchObservable","fetch","originalFetch","input","init","responsePromise","afterSend","reportFetch","response","DOMException","code","ABORT_ERR","responseType","then","clearTracingIfNeeded","spanId","injectHeadersIfTracingAllowed","inject","getCrypto","requestUrl","requestOrigin","allowedTracingOrigins","allowedOrigin","isAllowedUrl","TraceIdentifier","toDecimalString","crypto","msCrypto","Uint8Array","getRandomValues","radix","high","readInt32","low","str","mod","floor","offset","nextRequestIndex","startRequestCollection","tracer","traceFetch","tracingHeaders","Request","headers","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","rawContext","requestIndex","getNextRequestIndex","trackXhr","trackFetch","trackEventCounts","eventCounts","errorCount","longTaskCount","resourceCount","userActionCount","waitIdlePage","domMutationObservable","idlePageCallback","maxDuration","pageActivityObservable","idleTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","isBusy","lastChangeTime","doWaitIdlePage","firstRequestIndex","pendingRequestsCount","notifyPageActivity","startEvent","s","createPageActivityObservable","DEFAULT_PROGRAMMATIC_ATTRIBUTE","getActionNameFromElementProgrammatically","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","priorityStrategies","userProgrammaticAttribute","HTMLInputElement","supportsLabelProperty","labels","getTextualContent","label","ownerDocument","labelledByAttribute","refElement","getElementById","fallbackStrategies","getActionNameFromElementForStrategies","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","isContentEditable","text_1","innerText","removeTextFromElements","query","list","querySelectorAll","index","element_1","textToReplace","documentMode","textContent","trackActions","actionNameAttribute","action","currentAction","stopWaitingIdlePage","create","pendingAutoAction","PendingAutoAction","discard","discardCurrent","startActionManagement","stopListener","Element","eventCountsSubscription","counts","processAction","foregroundContexts","autoActionProperties","isAutoAction","count","loading_time","long_task","resource","actionEvent","inForeground","view","in_foreground","ERROR_TYPES_RE","startUnhandledErrorCollection","stopInstrumentingOnError","lineNo","columnNo","errorObj","location_1","msg","groups","instrumentOnError","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","ConsoleApiName","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","api","originalConsoleApi","params","buildConsoleLog","createConsoleObservable","param","formatConsoleParameters","firstErrorParam","trackFirstHiddenSingleton","stopListeners","RawReportType","initReportObservable","handleCspViolation","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportFromCspViolation","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportFromReport","types","disconnect","createReportObservable","startErrorCollection","errorObservable","consoleError","handling","trackConsoleError","originalError","trackRuntimeError","trackReportError","handling_stack","source_type","processError","addError","rawError","computeRawError","doStartErrorCollection","matchRequestTiming","sameNameEntries","getEntriesByName","correspondingEntries","candidates","errorMargin","startResourceCollection","matchingTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","span_id","trace_id","computeRequestTracingInfo","resourceEvent","status_code","performanceEntry","toPerformanceEntryRepresentation","requestInput","requestInit","processRequest","entries_1","processResourceEntry","entryMetrics","computeEntryTracingInfo","PerformanceEntry","trackFirstHidden","Infinity","TIMING_MAXIMUM_DELAY","trackInitialViewTimings","timings","setTimings","newTimings","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","trackNavigationTimings","stopFCPTracking","firstHidden","fcpEntry","trackFirstContentfulPaintTiming","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","findLast","trackLargestContentfulPaintTiming","largestContentfulPaint","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTime","trackFirstInputTimings","trackViewMetrics","scheduleViewUpdate","loadingType","viewStart","stopCLSTracking","viewMetrics","stopEventCountsTracking","newEventCounts","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","setLoadEvent","trackLoadingTime","newLoadingTime","loadingTime","stopLoadingTimeTracking","cumulativeLayoutShift","maxClsValue","update","slidingSessionWindow","hadRecentInput","trackCumulativeLayoutShift","trackViews","locationChangeObservable","areViewsTrackedAutomatically","initialViewName","locationChangeSubscription","initialView","newView","updateTimings","scheduleUpdate","trackInitialView","stopInitialViewTracking","currentView","stopViewLifeCycle","trackViewChange","triggerUpdate","keepAliveInterval","startViewLifeCycle","currentLocation","otherLocation","hash","correspondingId","oldLocation","newLocation","substr","getPathFromHash","renewViewOnLocationChange","addTiming","time","startView","initialLocation","endClocks","customTimings","documentVersion","triggerViewUpdate","cancelScheduleViewUpdate","stopViewMetricsTracking","currentEnd","isActive","clocks","looksLikeRelativeTime","sanitized","sanitizeTiming","startViewCollection","recorderApi","replayStats","getReplayStats","viewEvent","document_version","replay_stats","cumulative_layout_shift","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","is_active","largest_contentful_paint","load_event","discardNegativeDuration","loading_type","time_spent","in_foreground_periods","custom_timings","newObject","mapValues","processViewUpdate","trackViewsManually","stopCallbacks","startSessionManager","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","sessionStore","sessionContextHistory","buildSessionContext","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","startRumSessionManager","rawTrackingType","hasValidRumSession","replaySampleRate","isTypeTracked","hasLitePlan","rumSessionType","startRumBatch","batch","replicaBatch","primaryBatch","createRumBatch","unloadCallback","withReplicaApplicationId","makeRumBatch","createLocationChangeObservable","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","removeListener","onHashChange","stopHistoryTracking","onLocationChange","history","stopHashTracking","RecordType","NodePrivacyLevel","IGNORE","HIDDEN","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","CENSORED_STRING_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","defaultPrivacyLevel","parentNodePrivacyLevel","parentNode","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","nodeType","ELEMENT_NODE","isElement","privAttr","tagName","inputElement","autocomplete","classList","contains","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","TEXT_NODE","isFormElement","getTextContent","textNode","ignoreWhiteSpace","parentTagName","isStyle","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","nodePrivacyLevel","isTouchEvent","changedTouches","serializeDocument","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","serializeDocumentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","getValidTagName","isSVG","el","SVGElement","getBoundingClientRect","width","height","attributes","rr_width","rr_height","safeAttrs","attributeName","attributeValue","serializeAttribute","formValue","optionElement","selected","stylesheet","from","styleSheets","cssText","getCssRulesString","rel","_cssText","sheet","checked","mediaElement","rr_mediaState","paused","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getAttributesForPrivacyLevel","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","TAG_NAME_REGEX","processedTagName","rules","cssRules","getCssRuleString","rule","isCSSImportRule","styleSheet","IncrementalSource","MouseInteractions","MediaInteractions","createMutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","mutations","opts","requestIdleCallback","id_1","cancelIdleCallback","requestAnimationFrame","cancelAnimationFrame","timeout","startMutationObserver","controller","mutationCallback","mutationBatch","filteredMutations","mutation","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","removedNodes","Map","_loop_1","addedNodes","delete","mutations_1","sortedAddedAndMovedNodes","nodes","sort","b","position","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","parent","adds","removes","nextSibling","processChildListMutations","texts","textMutations","handledNodes","filteredMutations_1","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","filteredMutations_2","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","takeRecords","attributeOldValue","characterData","characterDataOldValue","childList","subtree","onFlush","MutationController","flushListener","convertMouseEventToLayoutCoordinates","clientX","clientY","visual","visualViewport","normalised","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","scale","getWindowWidth","innerWidth","getWindowHeight","innerHeight","getScrollX","pageXOffset","getScrollY","pageYOffset","initObservers","mutationController","cb","focusCb","mutationHandler","mutationCb","mousemoveHandler","updatePosition","timeOffset","x","y","initMoveObserver","mousemoveCb","mouseInteractionHandler","handler","eventTypeToMouseInteraction","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","initScrollObserver","scrollCb","viewportResizeHandler","updateDimension","initViewportResizeObserver","viewportResizeCb","inputHandler","lastInputStateMap","onElementChange","inputState","isChecked","text","cbWithDedup","lastInputState","stopEventListeners","HTMLTextAreaElement","HTMLSelectElement","instrumentationStoppers","stopper","initInputObserver","inputCb","mediaInteractionHandler","mediaInteractionCb","initMediaInteractionObserver","styleSheetObserver","restoreInsertRule","CSSStyleSheet","ownerNode","restoreDeleteRule","initStyleSheetObserver","styleSheetRuleCb","focusHandler","has_focus","visualViewportResizeHandler","cancelThrottle","initVisualViewportResizeObserver","visualViewportResizeCb","assembleIncrementalSnapshot","metadata","rawSegmentSize","formData","FormData","toFormEntries","byteLength","onEntry","prefix","statsPerView","getSegmentsCount","viewId","getOrCreateReplayStats","segments_count","addRecord","records_count","segments_total_raw_size","isFirst_1","_value","deleteOldestStats","workerURL","Segment","worker","creationReason","initialRecord","onWrote","onFlushed","isFlushed","timestamp","creation_reason","has_full_snapshot","index_in_view","additionalRawSize","rawSize","compressedSize","postMessage","record","MAX_SEGMENT_SIZE","startSegmentCollection","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribeBeforeUnload","unsubscribeVisibilityChange","segment","expirationTimeoutId","createNewSegment","compressedSegmentSize","doStartSegmentCollection","computeSegmentContext","createDeflateWorker","createObjectURL","workerCodeFn","Worker","Z_FIXED","Z_BINARY","Z_TEXT","Z_UNKNOWN","zero","buf","len","STORED_BLOCK","STATIC_TREES","DYN_TREES","MIN_MATCH","MAX_MATCH","LENGTH_CODES","LITERALS","L_CODES","D_CODES","BL_CODES","HEAP_SIZE","MAX_BITS","Buf_size","MAX_BL_BITS","END_BLOCK","REP_3_6","REPZ_3_10","REPZ_11_138","extra_lbits","extra_dbits","extra_blbits","bl_order","DIST_CODE_LEN","static_ltree","static_dtree","_dist_code","_length_code","base_length","static_l_desc","static_d_desc","static_bl_desc","base_dist","StaticTreeDesc","static_tree","extra_bits","extra_base","elems","max_length","has_stree","TreeDesc","dyn_tree","stat_desc","max_code","d_code","dist","put_short","w","pending_buf","pending","send_bits","bi_valid","bi_buf","send_code","c","tree","bi_reverse","res","bi_flush","gen_bitlen","desc","h","n","m","bits","xbits","stree","extra","overflow","bl_count","heap","heap_max","opt_len","static_len","gen_codes","next_code","tr_static_init","init_block","dyn_ltree","dyn_dtree","bl_tree","last_lit","bi_windup","copy_block","subarray","smaller","depth","_n2","_m2","pqdownheap","k","v","j","heap_len","compress_block","ltree","dtree","lc","lx","d_buf","l_buf","build_tree","scan_tree","curlen","prevlen","nextlen","max_count","min_count","send_tree","build_bl_tree","max_blindex","l_desc","d_desc","bl_desc","send_all_trees","lcodes","dcodes","blcodes","rank","detect_data_type","black_mask","static_init_done","_tr_stored_block","stored_len","last","_tr_flush_block","opt_lenb","static_lenb","level","strm","data_type","trees","_tr_init","_tr_tally","lit_bufsize","_tr_align","adler32_1","adler","pos","s1","s2","crcTable","Uint32Array","table","makeTable","crc32_1","crc","t","2","1","0","constants","Z_NO_FLUSH","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_FINISH","Z_BLOCK","Z_TREES","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_ERRNO","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_DEFAULT_STRATEGY","Z_DEFLATED","_tr_init$1","_tr_stored_block$1","_tr_flush_block$1","_tr_tally$1","_tr_align$1","Z_FIXED$1","Z_UNKNOWN$1","MAX_MEM_LEVEL","MAX_WBITS","DEF_MEM_LEVEL","L_CODES$1","LITERALS$1","D_CODES$1","BL_CODES$1","HEAP_SIZE$1","MAX_BITS$1","MIN_MATCH$1","MAX_MATCH$1","MIN_LOOKAHEAD","PRESET_DICT","INIT_STATE","EXTRA_STATE","NAME_STATE","COMMENT_STATE","HCRC_STATE","BUSY_STATE","FINISH_STATE","BS_NEED_MORE","BS_BLOCK_DONE","BS_FINISH_STARTED","BS_FINISH_DONE","OS_CODE","errorCode","zero$1","HASH","prev","hash_shift","hash_mask","flush_pending","avail_out","output","pending_out","next_out","total_out","flush_block_only","block_start","strstart","put_byte","putShortMSB","read_buf","avail_in","next_in","wrap","total_in","longest_match","cur_match","chain_length","max_chain_length","scan","best_len","prev_length","nice_match","w_size","_win","wmask","w_mask","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","p","more","_w_size","window_size","hash_size","insert","ins_h","deflate_fast","hash_head","bflush","match_length","max_lazy_match","deflate_slow","max_insert","prev_match","match_available","deflate_rle","deflate_huff","Config","good_length","max_lazy","nice_length","max_chain","configuration_table","max_block_size","pending_buf_size","max_start","lm_init","DeflateState","gzhead","gzindex","last_flush","w_bits","hash_bits","Uint16Array","deflateResetKeep","deflateReset","ret","deflateInit2","windowBits","memLevel","deflate_1","deflateInit","deflateSetHeader","deflate","beg","val","old_flush","hcrc","os","bstate","deflateEnd","deflateSetDictionary","dictionary","dictLength","tmpDict","avail","deflateInfo","flattenChunks","chunks","l","_l","chunk","_utf8len","q","ZStream","zstream","Z_NO_FLUSH$1","Z_FULL_FLUSH$1","Z_FINISH$1","Z_OK$1","Z_STREAM_END$1","Z_DEFAULT_COMPRESSION$1","Z_DEFAULT_STRATEGY$1","Z_DEFLATED$1","Deflate","chunkSize","opt","raw","gzip","ended","dict","_dict_set","string2buf","c2","m_pos","str_len","buf_len","flush_mode","_flush_mode","onData","makePakoDeflate","pushData","binaryData","reduce","startDeflateWorker","createDeflateWorkerImpl","worker_1","onError","doStartDeflateWorker","Event","existingGlobalVariable","datadogRum","startRumImpl","stub","publicApi","_c","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","globalContextManager","newContext","getInternalContextStrategy","getInitConfigurationStrategy","bufferApiCalls","addTimingStrategy","startViewStrategy","addActionStrategy","clonedCommonContext","addErrorStrategy","providedError","doStartRum","startRumResults","isRecording","addAction","getInternalContext","onRumStart","overrideInitConfigurationForBridge","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","canHandleSession","canInitRum","baseConfiguration","trackInteractions","validateAndBuildRumConfiguration","beforeInitCalls","addRumGlobalContext","removeRumGlobalContext","getRumGlobalContext","setRumGlobalContext","getInitConfiguration","setUser","newUser","sanitizedUser","email","sanitizeUser","removeUser","startSessionReplayRecording","stopSessionReplayRecording","onReady","makeRumPublicApi","internalMonitoring","bridge_1","batch_1","endpoint","replicaEndpoint","createBatch","startBatchWithReplica","startRumInternalMonitoring","application_id","startRumEventBridge","startRumSessionManagerStub","viewContextHistory","actionContextHistory","buildViewContext","buildActionContext","actionEndTime","startParentContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","referrer","changeTime","startUrlContexts","startRumEventCollection","startLongTaskCollection","startActionCollection","internalContext","session_id","user_action","startInternalContext","startRecordingImpl","startDeflateWorkerImpl","startStrategy","stopStrategy","stopRecording","makeRecorderApi","stopSegmentCollection","addRawRecord","rawRecord","emit","takeFullSnapshot","initialOffset","left","top","positions","flushMutations","unsubscribeViewEnded","config"],"mappings":"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","file":"main.bundle.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse {\n\t\tvar a = factory();\n\t\tfor(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n\t}\n})(self, function() {\nreturn ","\r\n\r\nlet developmentConfig = {\r\n    isProduction: false,\r\n    enableDatadog: false,\r\n    stripePublishableKey: \"pk_test_cz9mF5Fu1zcqXt2IYlDJsMwe\",\r\n    googleAnalyticsId: \"UA-100354578-1\"\r\n};\r\n\r\nlet productionConfig = {\r\n    isProduction: true,\r\n    enableDatadog: true,\r\n    stripePublishableKey: \"pk_live_uylQ0DB8LQTIO7IKaSB057kF\",\r\n    googleAnalyticsId: \"UA-52626549-1\"\r\n};\r\n\r\nlet config = PRODUCTION ? productionConfig : developmentConfig;\r\n\r\nexport default config;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\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 display = {\n    log: console.log.bind(console),\n    warn: console.warn.bind(console),\n    error: console.error.bind(console),\n};\n//# sourceMappingURL=display.js.map","var 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    if (stackProperty) {\n        stackProperty.split('\\n').forEach(function (line) {\n            var stackFrame = parseChromeLine(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 CHROME_LINE_RE = \n// eslint-disable-next-line max-len\n/^\\s*at (.*?) ?\\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar CHROME_EVAL_RE = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\nfunction parseChromeLine(line) {\n    var parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    var submatch = CHROME_EVAL_RE.exec(parts[2]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = submatch[1]; // url\n        parts[3] = submatch[2]; // line\n        parts[4] = submatch[3]; // column\n    }\n    return {\n        args: isNative ? [parts[2]] : [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: !isNative ? parts[2] : undefined,\n    };\n}\nvar 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 = \n// eslint-disable-next-line max-len\n/^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    var parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    var submatch = GECKO_EVAL_RE.exec(parts[3]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line number\n        parts[3] = submatch[1];\n        parts[4] = submatch[2];\n        parts[5] = undefined; // no column when eval\n    }\n    return {\n        args: parts[2] ? parts[2].split(',') : [],\n        column: parts[5] ? +parts[5] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[4] ? +parts[4] : undefined,\n        url: parts[3],\n    };\n}\nfunction tryToGetString(candidate, property) {\n    if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n        return undefined;\n    }\n    var value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=computeStackTrace.js.map","import { monitor } from '../domain/internalMonitoring';\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_KILO_BYTE = 1024;\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 () {\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            }\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 () {\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)\n        : \"\".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 value.toJSON.\n * We need to do that because some sites badly override toJSON on certain objects.\n * Note this still supposes that JSON.stringify is correct...\n */\nexport function jsonStringify(value, replacer, space) {\n    if (value === null || value === undefined) {\n        return JSON.stringify(value);\n    }\n    var originalToJSON = [false, undefined];\n    if (hasToJSON(value)) {\n        // We need to add a flag and not rely on the truthiness of value.toJSON\n        // because it can be set but undefined and that's actually significant.\n        originalToJSON = [true, value.toJSON];\n        delete value.toJSON;\n    }\n    var originalProtoToJSON = [false, undefined];\n    var prototype;\n    if (typeof value === 'object') {\n        prototype = Object.getPrototypeOf(value);\n        if (hasToJSON(prototype)) {\n            originalProtoToJSON = [true, prototype.toJSON];\n            delete prototype.toJSON;\n        }\n    }\n    var result;\n    try {\n        result = JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        result = '<error: unable to serialize object>';\n    }\n    finally {\n        if (originalToJSON[0]) {\n            ;\n            value.toJSON = originalToJSON[1];\n        }\n        if (originalProtoToJSON[0]) {\n            ;\n            prototype.toJSON = originalProtoToJSON[1];\n        }\n    }\n    return result;\n}\nfunction hasToJSON(value) {\n    return typeof value === 'object' && value !== null && Object.prototype.hasOwnProperty.call(value, 'toJSON');\n}\nexport function includes(candidate, search) {\n    return candidate.indexOf(search) !== -1;\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, array)) {\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) { return object[key]; });\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some(function (key) { return object[key] === value; });\n}\nexport function objectEntries(object) {\n    return Object.keys(object).map(function (key) { return [key, object[key]]; });\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}\n/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\nexport function getGlobalObject() {\n    if (typeof globalThis === 'object') {\n        return globalThis;\n    }\n    Object.defineProperty(Object.prototype, '_dd_temp_', {\n        get: function () {\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 === 'object') {\n            globalObject = self;\n        }\n        else if (typeof window === 'object') {\n            globalObject = window;\n        }\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) { suffix = ''; }\n    var lastChar = candidate.charCodeAt(length - 1);\n    var isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n    var correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n    if (candidate.length <= correctedLength)\n        return candidate;\n    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, once = _b.once, capture = _b.capture, passive = _b.passive;\n    var wrappedListener = monitor(once\n        ? function (event) {\n            stop();\n            listener(event);\n        }\n        : listener);\n    var options = passive ? { capture: capture, passive: passive } : capture;\n    events.forEach(function (event) { return emitter.addEventListener(event, wrappedListener, options); });\n    var stop = function () { return events.forEach(function (event) { return emitter.removeEventListener(event, wrappedListener, options); }); };\n    return {\n        stop: stop,\n    };\n}\nexport function runOnReadyState(expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n    }\n    else {\n        var eventName = expectedReadyState === 'complete' ? \"load\" /* LOAD */ : \"DOMContentLoaded\" /* DOM_CONTENT_LOADED */;\n        addEventListener(window, eventName, callback, { once: true });\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 (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 (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) { circularReferenceChecker = createCircularReferenceChecker(); }\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    }\n    else if (source instanceof Date) {\n        return new Date(source.getTime());\n    }\n    else if (source instanceof RegExp) {\n        var flags = source.flags ||\n            // old browsers compatibility\n            [\n                source.global ? 'g' : '',\n                source.ignoreCase ? 'i' : '',\n                source.multiline ? 'm' : '',\n                source.sticky ? 'y' : '',\n                source.unicode ? 'u' : '',\n            ].join('');\n        return new RegExp(source.source, flags);\n    }\n    if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n        // remove circular references\n        return undefined;\n    }\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 () { return window.cancelIdleCallback(id_1); };\n    }\n    var id = window.requestAnimationFrame(monitor(callback));\n    return function () { return window.cancelAnimationFrame(id); };\n}\nexport function removeDuplicates(array) {\n    var deduplicated = [];\n    var set = new Set();\n    array.forEach(function (item) { return set.add(item); });\n    set.forEach(function (item) { return deduplicated.push(item); });\n    return deduplicated;\n}\n//# sourceMappingURL=utils.js.map","import { callMonitored } from '../domain/internalMonitoring';\nimport { computeStackTrace } from '../domain/tracekit';\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 formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {\n    if (!stackTrace || (stackTrace.message === undefined && !(errorObject instanceof Error))) {\n        return {\n            message: \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(errorObject)),\n            stack: 'No stack, consider using an instance of Error',\n            handlingStack: handlingStack,\n            type: stackTrace && stackTrace.name,\n        };\n    }\n    return {\n        message: stackTrace.message || 'Empty message',\n        stack: toStackTraceString(stackTrace),\n        handlingStack: handlingStack,\n        type: stackTrace.name,\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 internal monitoring should encapsulate the function, that is why we need to use callMonitored inside of 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        }\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}\n//# sourceMappingURL=error.js.map","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 () {\n                _this.observers = _this.observers.filter(function (other) { return f !== other; });\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) { return observer(data); });\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) { return globalObservable.notify(data); });\n        });\n        return function () { return subscriptions.forEach(function (subscription) { return subscription.unsubscribe(); }); };\n    });\n    return globalObservable;\n}\n//# sourceMappingURL=observable.js.map","import { isNumber, ONE_YEAR, round } from './utils';\nexport function relativeToClocks(relative) {\n    return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    var correctedOrigin = Date.now() - performance.now();\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n        return Math.round(correctedOrigin + relativeTime);\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return Math.round(Date.now() - (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 timeStampNow() {\n    return Date.now();\n}\nexport function relativeNow() {\n    return performance.now();\n}\nexport function clocksNow() {\n    return { relative: relativeNow(), timeStamp: timeStampNow() };\n}\nexport function clocksOrigin() {\n    return { relative: 0, timeStamp: getNavigationStart() };\n}\nexport function elapsed(start, end) {\n    return (end - start);\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    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return Math.round(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}\n//# sourceMappingURL=timeUtils.js.map","/**\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 */\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\n        .filter(function (flag) { return typeof flag === 'string'; })\n        .forEach(function (flag) {\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}\n//# sourceMappingURL=experimentalFeatures.js.map","import { display } from '../../tools/display';\nimport { toStackTraceString } from '../../tools/error';\nimport { assign, combine, jsonStringify } from '../../tools/utils';\nimport { computeStackTrace } from '../tracekit';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/timeUtils';\nimport { isExperimentalFeatureEnabled } from '../configuration';\nvar monitoringConfiguration = { maxMessagesPerPage: 0, sentMessageCount: 0 };\nvar onInternalMonitoringMessageCollected;\nexport function startInternalMonitoring(configuration) {\n    var externalContextProvider;\n    var telemetryContextProvider;\n    var monitoringMessageObservable = new Observable();\n    var telemetryEventObservable = new Observable();\n    onInternalMonitoringMessageCollected = function (message) {\n        monitoringMessageObservable.notify(withContext(message));\n        if (isExperimentalFeatureEnabled('telemetry')) {\n            telemetryEventObservable.notify(toTelemetryEvent(message));\n        }\n    };\n    assign(monitoringConfiguration, {\n        maxMessagesPerPage: configuration.maxInternalMonitoringMessagesPerPage,\n        sentMessageCount: 0,\n    });\n    function withContext(message) {\n        return combine({ date: timeStampNow() }, externalContextProvider !== undefined ? externalContextProvider() : {}, message);\n    }\n    function toTelemetryEvent(message) {\n        return combine({\n            date: timeStampNow(),\n            service: 'browser-sdk',\n            version: \"4.7.0\",\n            _dd: {\n                event_type: 'internal_telemetry',\n            },\n        }, telemetryContextProvider !== undefined ? telemetryContextProvider() : {}, message);\n    }\n    return {\n        setExternalContextProvider: function (provider) {\n            externalContextProvider = provider;\n        },\n        monitoringMessageObservable: monitoringMessageObservable,\n        setTelemetryContextProvider: function (provider) {\n            telemetryContextProvider = provider;\n        },\n        telemetryEventObservable: telemetryEventObservable,\n    };\n}\nexport function startFakeInternalMonitoring() {\n    var messages = [];\n    assign(monitoringConfiguration, {\n        maxMessagesPerPage: Infinity,\n        sentMessageCount: 0,\n    });\n    onInternalMonitoringMessageCollected = function (message) {\n        messages.push(message);\n    };\n    return messages;\n}\nexport function resetInternalMonitoring() {\n    onInternalMonitoringMessageCollected = undefined;\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 = onInternalMonitoringMessageCollected ? monitor(originalMethod) : originalMethod;\n        return decorated.apply(this, args);\n    };\n}\nexport function monitor(fn) {\n    return function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return callMonitored(fn, this, arguments);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return fn.apply(context, args);\n    }\n    catch (e) {\n        logErrorIfDebug(e);\n        try {\n            addMonitoringError(e);\n        }\n        catch (e) {\n            logErrorIfDebug(e);\n        }\n    }\n}\nexport function addMonitoringMessage(message, context) {\n    logMessageIfDebug(message, context);\n    addToMonitoring(assign({\n        message: message,\n        status: \"debug\" /* debug */,\n    }, context));\n}\nexport function addMonitoringError(e) {\n    addToMonitoring(assign({\n        status: \"error\" /* error */,\n    }, formatError(e)));\n}\nfunction addToMonitoring(message) {\n    if (onInternalMonitoringMessageCollected &&\n        monitoringConfiguration.sentMessageCount < monitoringConfiguration.maxMessagesPerPage) {\n        monitoringConfiguration.sentMessageCount += 1;\n        onInternalMonitoringMessageCollected(message);\n    }\n}\nfunction formatError(e) {\n    if (e instanceof Error) {\n        var stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(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 setDebugMode(debugMode) {\n    monitoringConfiguration.debugMode = debugMode;\n}\nfunction logErrorIfDebug(e) {\n    if (monitoringConfiguration.debugMode) {\n        display.error('[INTERNAL ERROR]', e);\n    }\n}\nfunction logMessageIfDebug(message, context) {\n    if (monitoringConfiguration.debugMode) {\n        display.log('[MONITORING MESSAGE]', message, context);\n    }\n}\n//# sourceMappingURL=internalMonitoring.js.map","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        }\n        catch (err) {\n            display.error(errorMsg, err);\n        }\n    };\n}\n//# sourceMappingURL=catchUserErrors.js.map","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) { return callback(); });\n        this.buffer.length = 0;\n    };\n    return BoundedBuffer;\n}());\nexport { BoundedBuffer };\n//# sourceMappingURL=boundedBuffer.js.map","import { getGlobalObject, includes } from '..';\nexport function getEventBridge() {\n    var eventBridgeGlobal = getEventBridgeGlobal();\n    if (!eventBridgeGlobal) {\n        return;\n    }\n    return {\n        getAllowedWebViewHosts: function () {\n            return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n        },\n        send: function (eventType, event) {\n            eventBridgeGlobal.send(JSON.stringify({ eventType: eventType, event: event }));\n        },\n    };\n}\nexport function canUseEventBridge() {\n    var bridge = getEventBridge();\n    return !!bridge && includes(bridge.getAllowedWebViewHosts(), window.location.hostname);\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","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    }\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, { domain: candidateDomain });\n        }\n        deleteCookie(testCookieName, { domain: candidateDomain });\n        getCurrentSiteCache = candidateDomain;\n    }\n    return getCurrentSiteCache;\n}\n//# sourceMappingURL=cookie.js.map","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    }\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    }\n    catch (_a) {\n        isURLSupported = false;\n    }\n    return isURLSupported;\n}\n//# sourceMappingURL=urlPolyfill.js.map","import { timeStampNow } from '../../tools/timeUtils';\nimport { normalizeUrl } from '../../tools/urlPolyfill';\nimport { generateUUID } from '../../tools/utils';\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 var INTAKE_SITE_US = 'datadoghq.com';\nexport function createEndpointBuilder(initConfiguration, endpointType, tags, source) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US : _a, 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 () {\n            var parameters = \"ddsource=\".concat(source || 'browser') +\n                \"&ddtags=\".concat(encodeURIComponent([\"sdk_version:\".concat(\"4.7.0\")].concat(tags).join(','))) +\n                \"&dd-api-key=\".concat(clientToken) +\n                \"&dd-evp-origin-version=\".concat(encodeURIComponent(\"4.7.0\")) +\n                '&dd-evp-origin=browser' +\n                \"&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 () {\n            return proxyUrl ? \"\".concat(proxyUrl, \"?ddforward\") : baseUrl;\n        },\n    };\n}\n//# sourceMappingURL=endpointBuilder.js.map","import { display } from '../../tools/display';\nexport var TAG_SIZE_LIMIT = 200;\nexport function buildTags(configuration) {\n    var env = configuration.env, service = configuration.service, version = configuration.version, 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}\n//# sourceMappingURL=tags.js.map","import { assign, objectValues } from '../../tools/utils';\nimport { createEndpointBuilder, INTAKE_SITE_US } from './endpointBuilder';\nimport { buildTags } from './tags';\nexport function computeTransportConfiguration(initConfiguration) {\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var intakeEndpoints = objectValues(endpointBuilders).map(function (builder) { return builder.buildIntakeUrl(); });\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeEndpoints, tags);\n    return assign({\n        isIntakeUrl: function (url) { return intakeEndpoints.some(function (intakeEndpoint) { return url.indexOf(intakeEndpoint) === 0; }); },\n        replica: replicaConfiguration,\n    }, endpointBuilders);\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n    var endpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),\n    };\n    if (initConfiguration.internalMonitoringApiKey) {\n        return assign(endpointBuilders, {\n            internalMonitoringEndpointBuilder: createEndpointBuilder(assign({}, initConfiguration, { clientToken: initConfiguration.internalMonitoringApiKey }), 'logs', tags, 'browser-agent-internal-monitoring'),\n        });\n    }\n    return endpointBuilders;\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeEndpoints, tags) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    var replicaConfiguration = assign({}, initConfiguration, {\n        site: INTAKE_SITE_US,\n        clientToken: initConfiguration.replica.clientToken,\n    });\n    var replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n        internalMonitoringEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags, 'browser-agent-internal-monitoring'),\n    };\n    intakeEndpoints.push.apply(intakeEndpoints, objectValues(replicaEndpointBuilders).map(function (builder) { return builder.buildIntakeUrl(); }));\n    return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { getCurrentSite } from '../../browser/cookie';\nimport { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { assign, isPercentage, ONE_KILO_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;\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    // 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        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_KILO_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxInternalMonitoringMessagesPerPage: 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        maxBatchSize: 50,\n        maxMessageSize: 256 * ONE_KILO_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}\n//# sourceMappingURL=configuration.js.map","import { getCookie } from '@datadog/browser-core';\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 getSyntheticsContext() {\n    var testId = window._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    var resultId = window._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    if (typeof testId === 'string' && typeof resultId === 'string') {\n        return {\n            test_id: testId,\n            result_id: resultId,\n            injected: willSyntheticsInjectRum(),\n        };\n    }\n}\nexport function willSyntheticsInjectRum() {\n    return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { display } from '../tools/display';\nimport { addEventListener, jsonStringify, noop, objectValues } from '../tools/utils';\nimport { monitor } from '../domain/internalMonitoring';\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, maxSize, bytesLimit, maxMessageSize, flushTimeout, beforeUnloadCallback) {\n        if (beforeUnloadCallback === void 0) { beforeUnloadCallback = noop; }\n        this.request = request;\n        this.maxSize = maxSize;\n        this.bytesLimit = bytesLimit;\n        this.maxMessageSize = maxMessageSize;\n        this.flushTimeout = flushTimeout;\n        this.beforeUnloadCallback = beforeUnloadCallback;\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        this.bufferBytesSize = 0;\n        this.bufferMessageCount = 0;\n        this.flushOnVisibilityHidden();\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 (reason) {\n        if (this.bufferMessageCount !== 0) {\n            var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n            this.request.send(messages.join('\\n'), this.bufferBytesSize, reason);\n            this.pushOnlyBuffer = [];\n            this.upsertBuffer = {};\n            this.bufferBytesSize = 0;\n            this.bufferMessageCount = 0;\n        }\n    };\n    Batch.prototype.sizeInBytes = function (candidate) {\n        // Accurate byte size 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), processedMessage = _a.processedMessage, messageBytesSize = _a.messageBytesSize;\n        if (messageBytesSize >= this.maxMessageSize) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.maxMessageSize, \"KB.\"));\n            return;\n        }\n        if (this.hasMessageFor(key)) {\n            this.remove(key);\n        }\n        if (this.willReachedBytesLimitWith(messageBytesSize)) {\n            this.flush('willReachedBytesLimitWith');\n        }\n        this.push(processedMessage, messageBytesSize, key);\n        if (this.isFull()) {\n            this.flush('isFull');\n        }\n    };\n    Batch.prototype.process = function (message) {\n        var processedMessage = jsonStringify(message);\n        var messageBytesSize = this.sizeInBytes(processedMessage);\n        return { processedMessage: processedMessage, messageBytesSize: messageBytesSize };\n    };\n    Batch.prototype.push = function (processedMessage, messageBytesSize, key) {\n        if (this.bufferMessageCount > 0) {\n            // \\n separator at serialization\n            this.bufferBytesSize += 1;\n        }\n        if (key !== undefined) {\n            this.upsertBuffer[key] = processedMessage;\n        }\n        else {\n            this.pushOnlyBuffer.push(processedMessage);\n        }\n        this.bufferBytesSize += messageBytesSize;\n        this.bufferMessageCount += 1;\n    };\n    Batch.prototype.remove = function (key) {\n        var removedMessage = this.upsertBuffer[key];\n        delete this.upsertBuffer[key];\n        var messageBytesSize = this.sizeInBytes(removedMessage);\n        this.bufferBytesSize -= messageBytesSize;\n        this.bufferMessageCount -= 1;\n        if (this.bufferMessageCount > 0) {\n            this.bufferBytesSize -= 1;\n        }\n    };\n    Batch.prototype.hasMessageFor = function (key) {\n        return key !== undefined && this.upsertBuffer[key] !== undefined;\n    };\n    Batch.prototype.willReachedBytesLimitWith = function (messageBytesSize) {\n        // byte of the separator at the end of the message\n        return this.bufferBytesSize + messageBytesSize + 1 >= this.bytesLimit;\n    };\n    Batch.prototype.isFull = function () {\n        return this.bufferMessageCount === this.maxSize || this.bufferBytesSize >= this.bytesLimit;\n    };\n    Batch.prototype.flushPeriodically = function () {\n        var _this = this;\n        setTimeout(monitor(function () {\n            _this.flush('flushPeriodically');\n            _this.flushPeriodically();\n        }), this.flushTimeout);\n    };\n    Batch.prototype.flushOnVisibilityHidden = function () {\n        var _this = this;\n        /**\n         * With sendBeacon, requests are guaranteed to be successfully sent during document unload\n         */\n        // @ts-ignore this function is not always defined\n        if (navigator.sendBeacon) {\n            /**\n             * beforeunload is called before visibilitychange\n             * register first to be sure to be called before flush on beforeunload\n             * caveat: unload can still be canceled by another listener\n             */\n            addEventListener(window, \"beforeunload\" /* BEFORE_UNLOAD */, this.beforeUnloadCallback);\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            addEventListener(document, \"visibilitychange\" /* VISIBILITY_CHANGE */, function () {\n                if (document.visibilityState === 'hidden') {\n                    _this.flush(\"visibilitychange\" /* VISIBILITY_CHANGE */);\n                }\n            });\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            addEventListener(window, \"beforeunload\" /* BEFORE_UNLOAD */, function () { return _this.flush(\"beforeunload\" /* BEFORE_UNLOAD */); });\n        }\n    };\n    return Batch;\n}());\nexport { Batch };\n//# sourceMappingURL=batch.js.map","import { monitor, addMonitoringError, addMonitoringMessage } from '../domain/internalMonitoring';\nvar hasReportedXhrError = false;\n/**\n * Use POST request without content type to:\n * - avoid CORS preflight requests\n * - allow usage of sendBeacon\n *\n * multiple elements are sent separated by \\n in order\n * to be parsed correctly without content type header\n */\nvar HttpRequest = /** @class */ (function () {\n    function HttpRequest(endpointBuilder, bytesLimit) {\n        this.endpointBuilder = endpointBuilder;\n        this.bytesLimit = bytesLimit;\n    }\n    HttpRequest.prototype.send = function (data, size, flushReason) {\n        var url = this.endpointBuilder.build();\n        var tryBeacon = !!navigator.sendBeacon && size < this.bytesLimit;\n        if (tryBeacon) {\n            try {\n                var isQueued = navigator.sendBeacon(url, data);\n                if (isQueued) {\n                    return;\n                }\n            }\n            catch (e) {\n                reportBeaconError(e);\n            }\n        }\n        var transportIntrospection = function (event) {\n            var req = event === null || event === void 0 ? void 0 : event.currentTarget;\n            if (req.status >= 200 && req.status < 300) {\n                return;\n            }\n            if (!hasReportedXhrError) {\n                hasReportedXhrError = true;\n                addMonitoringMessage('XHR fallback failed', {\n                    on_line: navigator.onLine,\n                    size: size,\n                    url: url,\n                    try_beacon: tryBeacon,\n                    flush_reason: flushReason,\n                    event: {\n                        is_trusted: event.isTrusted,\n                        total: event.total,\n                        loaded: event.loaded,\n                    },\n                    request: {\n                        status: req.status,\n                        ready_state: req.readyState,\n                        response_text: req.responseText.slice(0, 512),\n                    },\n                });\n            }\n        };\n        var request = new XMLHttpRequest();\n        request.addEventListener('loadend', monitor(function (event) { return transportIntrospection(event); }));\n        request.open('POST', url, true);\n        request.send(data);\n    };\n    return HttpRequest;\n}());\nexport { HttpRequest };\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addMonitoringError(e);\n    }\n}\n//# sourceMappingURL=httpRequest.js.map","import { monitor, Observable } from '@datadog/browser-core';\nexport function createDOMMutationObservable() {\n    var MutationObserver = getMutationObserverConstructor();\n    var observable = new Observable(function () {\n        if (!MutationObserver) {\n            return;\n        }\n        var observer = new MutationObserver(monitor(function () { return observable.notify(); }));\n        observer.observe(document, {\n            attributes: true,\n            characterData: true,\n            childList: true,\n            subtree: true,\n        });\n        return function () { return observer.disconnect(); };\n    });\n    return observable;\n}\nexport function getMutationObserverConstructor() {\n    var constructor;\n    var browserWindow = window;\n    // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the\n    // global MutationObserver constructor with a patched version to support the context propagation.\n    // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular\n    // component: on some occasions, the callback is being called in an infinite loop, causing the\n    // page to freeze (even if the callback is completely empty).\n    //\n    // To work around this issue, we are using the Zone __symbol__ API to get the original, unpatched\n    // MutationObserver constructor.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        var symbol = browserWindow.Zone.__symbol__('MutationObserver');\n        constructor = browserWindow[symbol];\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { assign, addMonitoringMessage, elapsed, getPathName, includes, isValidUrl, toServerDuration, } from '@datadog/browser-core';\nexport var FAKE_INITIAL_DOCUMENT = 'initial_document';\nvar RESOURCE_TYPES = [\n    [\"document\" /* DOCUMENT */, function (initiatorType) { return FAKE_INITIAL_DOCUMENT === initiatorType; }],\n    [\"xhr\" /* XHR */, function (initiatorType) { return 'xmlhttprequest' === initiatorType; }],\n    [\"fetch\" /* FETCH */, function (initiatorType) { return 'fetch' === initiatorType; }],\n    [\"beacon\" /* BEACON */, function (initiatorType) { return 'beacon' === initiatorType; }],\n    [\"css\" /* CSS */, function (_, path) { return /\\.css$/i.test(path); }],\n    [\"js\" /* JS */, function (_, path) { return /\\.js$/i.test(path); }],\n    [\n        \"image\" /* IMAGE */,\n        function (initiatorType, path) {\n            return includes(['image', 'img', 'icon'], initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null;\n        },\n    ],\n    [\"font\" /* FONT */, function (_, path) { return /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null; }],\n    [\n        \"media\" /* MEDIA */,\n        function (initiatorType, path) {\n            return includes(['audio', 'video'], initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null;\n        },\n    ],\n];\nexport function computeResourceKind(timing) {\n    var url = timing.name;\n    if (!isValidUrl(url)) {\n        addMonitoringMessage(\"Failed to construct URL for \\\"\".concat(timing.name, \"\\\"\"));\n        return \"other\" /* OTHER */;\n    }\n    var path = getPathName(url);\n    for (var _i = 0, RESOURCE_TYPES_1 = RESOURCE_TYPES; _i < RESOURCE_TYPES_1.length; _i++) {\n        var _a = RESOURCE_TYPES_1[_i], type = _a[0], isType = _a[1];\n        if (isType(timing.initiatorType, path)) {\n            return type;\n        }\n    }\n    return \"other\" /* OTHER */;\n}\nfunction areInOrder() {\n    var numbers = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        numbers[_i] = arguments[_i];\n    }\n    for (var i = 1; i < numbers.length; i += 1) {\n        if (numbers[i - 1] > numbers[i]) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function isRequestKind(timing) {\n    return timing.initiatorType === 'xmlhttprequest' || timing.initiatorType === 'fetch';\n}\nexport function computePerformanceResourceDuration(entry) {\n    var duration = entry.duration, startTime = entry.startTime, responseEnd = entry.responseEnd;\n    // Safari duration is always 0 on timings blocked by cross origin policies.\n    if (duration === 0 && startTime < responseEnd) {\n        return toServerDuration(elapsed(startTime, responseEnd));\n    }\n    return toServerDuration(duration);\n}\nexport function computePerformanceResourceDetails(entry) {\n    var validEntry = toValidEntry(entry);\n    if (!validEntry) {\n        return undefined;\n    }\n    var startTime = validEntry.startTime, fetchStart = validEntry.fetchStart, redirectStart = validEntry.redirectStart, redirectEnd = validEntry.redirectEnd, domainLookupStart = validEntry.domainLookupStart, domainLookupEnd = validEntry.domainLookupEnd, connectStart = validEntry.connectStart, secureConnectionStart = validEntry.secureConnectionStart, connectEnd = validEntry.connectEnd, requestStart = validEntry.requestStart, responseStart = validEntry.responseStart, responseEnd = validEntry.responseEnd;\n    var details = {\n        download: formatTiming(startTime, responseStart, responseEnd),\n        first_byte: formatTiming(startTime, requestStart, responseStart),\n    };\n    // Make sure a connection occurred\n    if (connectEnd !== fetchStart) {\n        details.connect = formatTiming(startTime, connectStart, connectEnd);\n        // Make sure a secure connection occurred\n        if (areInOrder(connectStart, secureConnectionStart, connectEnd)) {\n            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);\n        }\n    }\n    // Make sure a domain lookup occurred\n    if (domainLookupEnd !== fetchStart) {\n        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);\n    }\n    if (hasRedirection(entry)) {\n        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);\n    }\n    return details;\n}\nexport function toValidEntry(entry) {\n    // Ensure timings are in the right order. On top of filtering out potential invalid\n    // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be\n    // collected, for example cross origin requests without a \"Timing-Allow-Origin\" header allowing\n    // it.\n    if (!areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd)) {\n        return undefined;\n    }\n    if (!hasRedirection(entry)) {\n        return entry;\n    }\n    var redirectStart = entry.redirectStart, redirectEnd = entry.redirectEnd;\n    // Firefox doesn't provide redirect timings on cross origin requests.\n    // Provide a default for those.\n    if (redirectStart < entry.startTime) {\n        redirectStart = entry.startTime;\n    }\n    if (redirectEnd < entry.startTime) {\n        redirectEnd = entry.fetchStart;\n    }\n    // Make sure redirect timings are in order\n    if (!areInOrder(entry.startTime, redirectStart, redirectEnd, entry.fetchStart)) {\n        return undefined;\n    }\n    return assign({}, entry, {\n        redirectEnd: redirectEnd,\n        redirectStart: redirectStart,\n    });\n}\nfunction hasRedirection(entry) {\n    // The only time fetchStart is different than startTime is if a redirection occurred.\n    return entry.fetchStart !== entry.startTime;\n}\nfunction formatTiming(origin, start, end) {\n    return {\n        duration: toServerDuration(elapsed(start, end)),\n        start: toServerDuration(elapsed(origin, start)),\n    };\n}\nexport function computeSize(entry) {\n    // Make sure a request actually occurred\n    if (entry.startTime < entry.responseStart) {\n        return entry.decodedBodySize;\n    }\n    return undefined;\n}\nexport function isAllowedRequestUrl(configuration, url) {\n    return url && !configuration.isIntakeUrl(url);\n}\n//# sourceMappingURL=resourceUtils.js.map","import { findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nexport var INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;\nexport function getDocumentTraceId(document) {\n    var data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document);\n    if (!data || data.traceTime <= Date.now() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {\n        return undefined;\n    }\n    return data.traceId;\n}\nexport function getDocumentTraceDataFromMeta(document) {\n    var traceIdMeta = document.querySelector('meta[name=dd-trace-id]');\n    var traceTimeMeta = document.querySelector('meta[name=dd-trace-time]');\n    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);\n}\nexport function getDocumentTraceDataFromComment(document) {\n    var comment = findTraceComment(document);\n    if (!comment) {\n        return undefined;\n    }\n    return createDocumentTraceData(findCommaSeparatedValue(comment, 'trace-id'), findCommaSeparatedValue(comment, 'trace-time'));\n}\nexport function createDocumentTraceData(traceId, rawTraceTime) {\n    var traceTime = rawTraceTime && Number(rawTraceTime);\n    if (!traceId || !traceTime) {\n        return undefined;\n    }\n    return {\n        traceId: traceId,\n        traceTime: traceTime,\n    };\n}\nexport function findTraceComment(document) {\n    // 1. Try to find the comment as a direct child of the document\n    // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated\n    // value is not an array or string (here, a NodeList).\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < document.childNodes.length; i += 1) {\n        var comment = getTraceCommentFromNode(document.childNodes[i]);\n        if (comment) {\n            return comment;\n        }\n    }\n    // 2. If the comment is placed after the </html> tag, but have some space or new lines before or\n    // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.\n    // Try to look for the comment at the end of the <body> by by iterating over its child nodes in\n    // reverse order, stopping if we come across a non-text node.\n    if (document.body) {\n        for (var i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n            var node = document.body.childNodes[i];\n            var comment = getTraceCommentFromNode(node);\n            if (comment) {\n                return comment;\n            }\n            if (!isTextNode(node)) {\n                break;\n            }\n        }\n    }\n}\nfunction getTraceCommentFromNode(node) {\n    if (node && isCommentNode(node)) {\n        var match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data);\n        if (match) {\n            return match[1];\n        }\n    }\n}\nfunction isCommentNode(node) {\n    return node.nodeName === '#comment';\n}\nfunction isTextNode(node) {\n    return node.nodeName === '#text';\n}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { assign, addEventListeners, getRelativeTime, isNumber, monitor, relativeNow, runOnReadyState, } from '@datadog/browser-core';\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/rumEventsCollection/resource/resourceUtils';\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId';\nfunction supportPerformanceObject() {\n    return window.performance !== undefined && 'getEntries' in performance;\n}\nexport function supportPerformanceTimingEvent(entryType) {\n    return (window.PerformanceObserver &&\n        PerformanceObserver.supportedEntryTypes !== undefined &&\n        PerformanceObserver.supportedEntryTypes.includes(entryType));\n}\nexport function supportPerformanceEntry() {\n    // Safari 10 doesn't support PerformanceEntry\n    return typeof PerformanceEntry === 'function';\n}\nexport function startPerformanceCollection(lifeCycle, configuration) {\n    retrieveInitialDocumentResourceTiming(function (timing) {\n        handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n    });\n    if (supportPerformanceObject()) {\n        var performanceEntries_1 = performance.getEntries();\n        // Because the performance entry list can be quite large\n        // delay the computation to prevent the SDK from blocking the main thread on init\n        setTimeout(monitor(function () { return handleRumPerformanceEntries(lifeCycle, configuration, performanceEntries_1); }));\n    }\n    if (window.PerformanceObserver) {\n        var handlePerformanceEntryList_1 = monitor(function (entries) {\n            return handleRumPerformanceEntries(lifeCycle, configuration, entries.getEntries());\n        });\n        var mainEntries = ['resource', 'navigation', 'longtask', 'paint'];\n        var experimentalEntries = ['largest-contentful-paint', 'first-input', 'layout-shift'];\n        try {\n            // Experimental entries are not retrieved by performance.getEntries()\n            // use a single PerformanceObserver with buffered flag by type\n            // to get values that could happen before SDK init\n            experimentalEntries.forEach(function (type) {\n                var observer = new PerformanceObserver(handlePerformanceEntryList_1);\n                observer.observe({ type: type, buffered: true });\n            });\n        }\n        catch (e) {\n            // Some old browser versions (ex: chrome 67) don't support the PerformanceObserver type and buffered options\n            // In these cases, fallback to PerformanceObserver with entryTypes\n            mainEntries.push.apply(mainEntries, experimentalEntries);\n        }\n        var mainObserver = new PerformanceObserver(handlePerformanceEntryList_1);\n        mainObserver.observe({ entryTypes: mainEntries });\n        if (supportPerformanceObject() && 'addEventListener' in performance) {\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n            performance.addEventListener('resourcetimingbufferfull', function () {\n                performance.clearResourceTimings();\n            });\n        }\n    }\n    if (!supportPerformanceTimingEvent('navigation')) {\n        retrieveNavigationTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n    if (!supportPerformanceTimingEvent('first-input')) {\n        retrieveFirstInputTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n}\nexport function retrieveInitialDocumentResourceTiming(callback) {\n    runOnReadyState('interactive', function () {\n        var timing;\n        var forcedAttributes = {\n            entryType: 'resource',\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n        };\n        if (supportPerformanceTimingEvent('navigation') && performance.getEntriesByType('navigation').length > 0) {\n            var navigationEntry = performance.getEntriesByType('navigation')[0];\n            timing = assign(navigationEntry.toJSON(), forcedAttributes);\n        }\n        else {\n            var relativePerformanceTiming = computeRelativePerformanceTiming();\n            timing = assign(relativePerformanceTiming, {\n                decodedBodySize: 0,\n                duration: relativePerformanceTiming.responseEnd,\n                name: window.location.href,\n                startTime: 0,\n            }, forcedAttributes);\n        }\n        callback(timing);\n    });\n}\nfunction retrieveNavigationTiming(callback) {\n    function sendFakeTiming() {\n        callback(assign(computeRelativePerformanceTiming(), {\n            entryType: 'navigation',\n        }));\n    }\n    runOnReadyState('complete', function () {\n        // Send it a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        setTimeout(monitor(sendFakeTiming));\n    });\n}\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nfunction retrieveFirstInputTiming(callback) {\n    var startTimeStamp = Date.now();\n    var timingSent = false;\n    var removeEventListeners = addEventListeners(window, [\"click\" /* CLICK */, \"mousedown\" /* MOUSE_DOWN */, \"keydown\" /* KEY_DOWN */, \"touchstart\" /* TOUCH_START */, \"pointerdown\" /* POINTER_DOWN */], function (evt) {\n        // Only count cancelable events, which should trigger behavior important to the user.\n        if (!evt.cancelable) {\n            return;\n        }\n        // This timing will be used to compute the \"first Input delay\", which is the delta between\n        // when the system received the event (e.g. evt.timeStamp) and when it could run the callback\n        // (e.g. performance.now()).\n        var timing = {\n            entryType: 'first-input',\n            processingStart: relativeNow(),\n            startTime: evt.timeStamp,\n        };\n        if (evt.type === \"pointerdown\" /* POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true }).stop;\n    /**\n     * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n     * We differentiate these cases based on whether or not we see a pointercancel event, which are\n     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n     * scrolling and pinch/zooming.\n     */\n    function sendTimingIfPointerIsNotCancelled(timing) {\n        addEventListeners(window, [\"pointerup\" /* POINTER_UP */, \"pointercancel\" /* POINTER_CANCEL */], function (event) {\n            if (event.type === \"pointerup\" /* POINTER_UP */) {\n                sendTiming(timing);\n            }\n        }, { once: true });\n    }\n    function sendTiming(timing) {\n        if (!timingSent) {\n            timingSent = true;\n            removeEventListeners();\n            // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than\n            // the time between now and when the page was loaded.\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7\n            var delay = timing.processingStart - timing.startTime;\n            if (delay >= 0 && delay < Date.now() - startTimeStamp) {\n                callback(timing);\n            }\n        }\n    }\n}\nfunction computeRelativePerformanceTiming() {\n    var result = {};\n    var timing = performance.timing;\n    for (var key in timing) {\n        if (isNumber(timing[key])) {\n            var numberKey = key;\n            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n            var timingElement = timing[numberKey];\n            result[numberKey] = timingElement === 0 ? 0 : getRelativeTime(timingElement);\n        }\n    }\n    return result;\n}\nfunction handleRumPerformanceEntries(lifeCycle, configuration, entries) {\n    var rumPerformanceEntries = entries.filter(function (entry) {\n        return entry.entryType === 'resource' ||\n            entry.entryType === 'navigation' ||\n            entry.entryType === 'paint' ||\n            entry.entryType === 'longtask' ||\n            entry.entryType === 'largest-contentful-paint' ||\n            entry.entryType === 'first-input' ||\n            entry.entryType === 'layout-shift';\n    });\n    var rumAllowedPerformanceEntries = rumPerformanceEntries.filter(function (entry) { return !isIncompleteNavigation(entry) && !isForbiddenResource(configuration, entry); });\n    if (rumAllowedPerformanceEntries.length) {\n        lifeCycle.notify(0 /* PERFORMANCE_ENTRIES_COLLECTED */, rumAllowedPerformanceEntries);\n    }\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.entryType === 'navigation' && entry.loadEventEnd <= 0;\n}\nfunction isForbiddenResource(configuration, entry) {\n    return entry.entryType === 'resource' && !isAllowedRequestUrl(configuration, entry.name);\n}\n//# sourceMappingURL=performanceCollection.js.map","import { clocksNow, ErrorSource, ONE_MINUTE } from '..';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n    var eventCount = 0;\n    var allowNextEvent = false;\n    return {\n        isLimitReached: function () {\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                }\n                finally {\n                    allowNextEvent = false;\n                }\n            }\n            return true;\n        },\n    };\n}\n//# sourceMappingURL=createEventRateLimiter.js.map","import { deepClone, getType } from './utils';\n/**\n * Current limitation:\n * - field path do not support array, 'a.b.c' only\n */\nexport function limitModification(object, modifiableFieldPaths, modifier) {\n    var clone = deepClone(object);\n    var result = modifier(clone);\n    modifiableFieldPaths.forEach(function (path) {\n        var originalValue = get(object, path);\n        var newValue = get(clone, path);\n        var originalType = getType(originalValue);\n        var newType = getType(newValue);\n        if (newType === originalType) {\n            set(object, path, newValue);\n        }\n        else if (originalType === 'object' && (newType === 'undefined' || newType === 'null')) {\n            set(object, path, {});\n        }\n    });\n    return result;\n}\nfunction get(object, path) {\n    var current = object;\n    for (var _i = 0, _a = path.split('.'); _i < _a.length; _i++) {\n        var field = _a[_i];\n        if (!isValidObjectContaining(current, field)) {\n            return;\n        }\n        current = current[field];\n    }\n    return current;\n}\nfunction set(object, path, value) {\n    var current = object;\n    var fields = path.split('.');\n    for (var i = 0; i < fields.length; i += 1) {\n        var field = fields[i];\n        if (!isValidObjectContaining(current, field)) {\n            return;\n        }\n        if (i !== fields.length - 1) {\n            current = current[field];\n        }\n        else {\n            current[field] = value;\n        }\n    }\n}\nfunction isValidObjectContaining(object, field) {\n    return typeof object === 'object' && object !== null && field in object;\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, limitModification, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './syntheticsContext';\nimport { getCiTestContext } from './ciTestContext';\nvar VIEW_EVENTS_MODIFIABLE_FIELD_PATHS = [\n    // Fields with sensitive data\n    'view.url',\n    'view.referrer',\n    'action.target.name',\n    'error.message',\n    'error.stack',\n    'error.resource.url',\n    'resource.url',\n];\nvar OTHER_EVENTS_MODIFIABLE_FIELD_PATHS = VIEW_EVENTS_MODIFIABLE_FIELD_PATHS.concat([\n    // User-customizable field\n    'context',\n]);\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, parentContexts, urlContexts, getCommonContext) {\n    var _a;\n    var reportError = function (error) {\n        lifeCycle.notify(14 /* RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var eventRateLimiters = (_a = {},\n        _a[\"error\" /* ERROR */] = createEventRateLimiter(\"error\" /* ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        _a[\"action\" /* ACTION */] = createEventRateLimiter(\"action\" /* ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        _a);\n    var syntheticsContext = getSyntheticsContext();\n    var ciTestContext = getCiTestContext();\n    lifeCycle.subscribe(12 /* RAW_RUM_EVENT_COLLECTED */, function (_a) {\n        var startTime = _a.startTime, rawRumEvent = _a.rawRumEvent, domainContext = _a.domainContext, savedCommonContext = _a.savedCommonContext, customerContext = _a.customerContext;\n        var viewContext = parentContexts.findView(startTime);\n        var urlContext = urlContexts.findUrl(startTime);\n        // allow to send events if the session was tracked when they start\n        // except for views which are continuously updated\n        // TODO: stop sending view updates when session is expired\n        var session = sessionManager.findTrackedSession(rawRumEvent.type !== \"view\" /* VIEW */ ? startTime : undefined);\n        if (session && viewContext && urlContext) {\n            var actionContext = parentContexts.findAction(startTime);\n            var commonContext = savedCommonContext || getCommonContext();\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    session: {\n                        plan: session.hasReplayPlan ? 2 /* REPLAY */ : 1 /* LITE */,\n                    },\n                    browser_sdk_version: canUseEventBridge() ? \"4.7.0\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: configuration.service,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext ? \"synthetics\" /* SYNTHETICS */ : ciTestContext ? \"ci_test\" /* CI_TEST */ : \"user\" /* USER */,\n                },\n                synthetics: syntheticsContext,\n                ci_test: ciTestContext,\n            };\n            var serverRumEvent = (needToAssembleWithAction(rawRumEvent)\n                ? combine(rumContext, urlContext, viewContext, actionContext, rawRumEvent)\n                : combine(rumContext, urlContext, viewContext, rawRumEvent));\n            serverRumEvent.context = combine(commonContext.context, customerContext);\n            if (!('has_replay' in serverRumEvent.session)) {\n                ;\n                serverRumEvent.session.has_replay = commonContext.hasReplay;\n            }\n            if (!isEmptyObject(commonContext.user)) {\n                ;\n                serverRumEvent.usr = commonContext.user;\n            }\n            if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {\n                if (isEmptyObject(serverRumEvent.context)) {\n                    delete serverRumEvent.context;\n                }\n                lifeCycle.notify(13 /* RUM_EVENT_COLLECTED */, serverRumEvent);\n            }\n        }\n    });\n}\nfunction shouldSend(event, beforeSend, domainContext, eventRateLimiters) {\n    var _a;\n    if (beforeSend) {\n        var result = limitModification(event, event.type === \"view\" /* VIEW */ ? VIEW_EVENTS_MODIFIABLE_FIELD_PATHS : OTHER_EVENTS_MODIFIABLE_FIELD_PATHS, function (event) { return beforeSend(event, domainContext); });\n        if (result === false && event.type !== \"view\" /* VIEW */) {\n            return false;\n        }\n        if (result === false) {\n            display.warn(\"Can't dismiss view events using beforeSend!\");\n        }\n    }\n    var rateLimitReached = (_a = eventRateLimiters[event.type]) === null || _a === void 0 ? void 0 : _a.isLimitReached();\n    return !rateLimitReached;\n}\nfunction needToAssembleWithAction(event) {\n    return [\"error\" /* ERROR */, \"resource\" /* RESOURCE */, \"long_task\" /* LONG_TASK */].indexOf(event.type) !== -1;\n}\n//# sourceMappingURL=assembly.js.map","export function getCiTestContext() {\n    var _a;\n    var testExecutionId = (_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId');\n    if (typeof testExecutionId === 'string') {\n        return {\n            test_execution_id: testExecutionId,\n        };\n    }\n}\n//# sourceMappingURL=ciTestContext.js.map","import { addEventListener, elapsed, relativeNow, toServerDuration } from '@datadog/browser-core';\n// Arbitrary value to cap number of element mostly for backend & to save bandwidth\nexport var MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS = 500;\n// Arbitrary value to cap number of element mostly for memory consumption in the browser\nexport var MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS = 2500;\nvar foregroundPeriods = [];\nexport function startForegroundContexts() {\n    if (document.hasFocus()) {\n        addNewForegroundPeriod();\n    }\n    var stopForegroundTracking = trackFocus(addNewForegroundPeriod).stop;\n    var stopBlurTracking = trackBlur(closeForegroundPeriod).stop;\n    return {\n        isInForegroundAt: isInForegroundAt,\n        selectInForegroundPeriodsFor: selectInForegroundPeriodsFor,\n        stop: function () {\n            foregroundPeriods = [];\n            stopForegroundTracking();\n            stopBlurTracking();\n        },\n    };\n}\nexport function addNewForegroundPeriod() {\n    if (foregroundPeriods.length > MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS) {\n        return;\n    }\n    var currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1];\n    var now = relativeNow();\n    if (currentForegroundPeriod !== undefined && currentForegroundPeriod.end === undefined) {\n        return;\n    }\n    foregroundPeriods.push({\n        start: now,\n    });\n}\nexport function closeForegroundPeriod() {\n    if (foregroundPeriods.length === 0) {\n        return;\n    }\n    var currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1];\n    var now = relativeNow();\n    if (currentForegroundPeriod.end !== undefined) {\n        return;\n    }\n    currentForegroundPeriod.end = now;\n}\nfunction trackFocus(onFocusChange) {\n    return addEventListener(window, \"focus\" /* FOCUS */, function (event) {\n        if (!event.isTrusted) {\n            return;\n        }\n        onFocusChange();\n    });\n}\nfunction trackBlur(onBlurChange) {\n    return addEventListener(window, \"blur\" /* BLUR */, function (event) {\n        if (!event.isTrusted) {\n            return;\n        }\n        onBlurChange();\n    });\n}\nfunction isInForegroundAt(startTime) {\n    for (var i = foregroundPeriods.length - 1; i >= 0; i--) {\n        var foregroundPeriod = foregroundPeriods[i];\n        if (foregroundPeriod.end !== undefined && startTime > foregroundPeriod.end) {\n            break;\n        }\n        if (startTime > foregroundPeriod.start &&\n            (foregroundPeriod.end === undefined || startTime < foregroundPeriod.end)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction selectInForegroundPeriodsFor(eventStartTime, duration) {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    var eventEndTime = (eventStartTime + duration);\n    var filteredForegroundPeriods = [];\n    var earliestIndex = Math.max(0, foregroundPeriods.length - MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS);\n    for (var i = foregroundPeriods.length - 1; i >= earliestIndex; i--) {\n        var foregroundPeriod = foregroundPeriods[i];\n        if (foregroundPeriod.end !== undefined && eventStartTime > foregroundPeriod.end) {\n            // event starts after the end of the current focus period\n            // since the array is sorted, we can stop looking for foreground periods\n            break;\n        }\n        if (eventEndTime < foregroundPeriod.start) {\n            // event ends before the start of the current focus period\n            // continue to previous one\n            continue;\n        }\n        var startTime = eventStartTime > foregroundPeriod.start ? eventStartTime : foregroundPeriod.start;\n        var startDuration = elapsed(eventStartTime, startTime);\n        var endTime = foregroundPeriod.end === undefined || eventEndTime < foregroundPeriod.end ? eventEndTime : foregroundPeriod.end;\n        var endDuration = elapsed(startTime, endTime);\n        filteredForegroundPeriods.unshift({\n            start: toServerDuration(startDuration),\n            duration: toServerDuration(endDuration),\n        });\n    }\n    return filteredForegroundPeriods;\n}\n//# sourceMappingURL=foregroundContexts.js.map","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) { return callback(data); });\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 () {\n                _this.callbacks[eventType] = _this.callbacks[eventType].filter(function (other) { return callback !== other; });\n            },\n        };\n    };\n    return LifeCycle;\n}());\nexport { LifeCycle };\n//# sourceMappingURL=lifeCycle.js.map","import { getCookie, setCookie } from '../../browser/cookie';\nimport { isChromium } from '../../tools/browserDetection';\nimport * as utils from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nimport { SESSION_EXPIRATION_DELAY } from './sessionStore';\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) { numberOfRetries = 0; }\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(Date.now() + 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\n        .objectEntries(session)\n        .map(function (_a) {\n        var key = _a[0], value = _a[1];\n        return \"\".concat(key, \"=\").concat(value);\n    })\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], value = matches[2];\n                session[key] = value;\n            }\n        });\n    }\n    return session;\n}\nfunction isValidSessionString(sessionString) {\n    return (sessionString !== undefined &&\n        (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}\n//# sourceMappingURL=sessionCookieStore.js.map","export function isIE() {\n    return Boolean(document.documentMode);\n}\nexport function isChromium() {\n    return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent);\n}\n//# sourceMappingURL=browserDetection.js.map","import { COOKIE_ACCESS_DELAY } from '../../browser/cookie';\nimport { Observable } from '../../tools/observable';\nimport * as utils from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nimport { retrieveSession, withCookieLockAccess } from './sessionCookieStore';\nexport var SESSION_EXPIRATION_DELAY = 15 * utils.ONE_MINUTE;\nexport var SESSION_TIME_OUT_DELAY = 4 * utils.ONE_HOUR;\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 (cookieSession) {\n                var synchronizedSession = synchronizeSession(cookieSession);\n                isTracked = expandOrRenewCookie(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: function (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 (cookieSession) { return (hasSessionInCache() ? synchronizeSession(cookieSession) : undefined); },\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 (cookieSession) { return (!isActiveSession(cookieSession) ? {} : undefined); },\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            }\n            else {\n                sessionCache = cookieSession;\n            }\n        }\n        return cookieSession;\n    }\n    function expandOrRenewCookie(cookieSession) {\n        var _a = computeSessionState(cookieSession[productKey]), trackingType = _a.trackingType, isTracked = _a.isTracked;\n        cookieSession[productKey] = trackingType;\n        if (isTracked && !cookieSession.id) {\n            cookieSession.id = utils.generateUUID();\n            cookieSession.created = String(Date.now());\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 || Date.now() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&\n            (session.expire === undefined || Date.now() < Number(session.expire)));\n    }\n    return {\n        expandOrRenewSession: utils.throttle(monitor(expandOrRenewSession), COOKIE_ACCESS_DELAY).throttled,\n        expandSession: expandSession,\n        getSession: function () { return sessionCache; },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        stop: function () {\n            clearInterval(watchSessionTimeoutId);\n        },\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { relativeNow } from './timeUtils';\nimport { ONE_MINUTE } from './utils';\nexport var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE;\nvar ContextHistory = /** @class */ (function () {\n    function ContextHistory(expireDelay) {\n        var _this = this;\n        this.expireDelay = expireDelay;\n        this.previousContexts = [];\n        this.clearOldContextsInterval = setInterval(function () { return _this.clearOldContexts(); }, CLEAR_OLD_CONTEXTS_INTERVAL);\n    }\n    ContextHistory.prototype.find = function (startTime) {\n        if (startTime === undefined ||\n            (this.current !== undefined && this.currentStart !== undefined && startTime >= this.currentStart)) {\n            return this.current;\n        }\n        for (var _i = 0, _a = this.previousContexts; _i < _a.length; _i++) {\n            var previousContext = _a[_i];\n            if (startTime > previousContext.endTime) {\n                break;\n            }\n            if (startTime >= previousContext.startTime) {\n                return previousContext.context;\n            }\n        }\n        return undefined;\n    };\n    ContextHistory.prototype.setCurrent = function (current, startTime) {\n        this.current = current;\n        this.currentStart = startTime;\n    };\n    ContextHistory.prototype.getCurrent = function () {\n        return this.current;\n    };\n    ContextHistory.prototype.clearCurrent = function () {\n        this.current = undefined;\n        this.currentStart = undefined;\n    };\n    ContextHistory.prototype.closeCurrent = function (endTime) {\n        if (this.current !== undefined && this.currentStart !== undefined) {\n            this.previousContexts.unshift({\n                endTime: endTime,\n                context: this.current,\n                startTime: this.currentStart,\n            });\n            this.clearCurrent();\n        }\n    };\n    ContextHistory.prototype.clearOldContexts = function () {\n        var oldTimeThreshold = relativeNow() - this.expireDelay;\n        while (this.previousContexts.length > 0 &&\n            this.previousContexts[this.previousContexts.length - 1].startTime < oldTimeThreshold) {\n            this.previousContexts.pop();\n        }\n    };\n    ContextHistory.prototype.reset = function () {\n        this.clearCurrent();\n        this.previousContexts = [];\n    };\n    ContextHistory.prototype.stop = function () {\n        clearInterval(this.clearOldContextsInterval);\n    };\n    return ContextHistory;\n}());\nexport { ContextHistory };\n//# sourceMappingURL=contextHistory.js.map","import { monitor } from '../domain/internalMonitoring';\nimport { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\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 () {\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(url.toString()),\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 () {\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}\n//# sourceMappingURL=xhrObservable.js.map","import { callMonitored, monitor } from '../domain/internalMonitoring';\nimport { noop } from './utils';\nexport function instrumentMethod(object, method, instrumentationFactory) {\n    var original = object[method];\n    var instrumentation = instrumentationFactory(original);\n    var instrumentationWrapper = function () {\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 () {\n            if (object[method] === instrumentationWrapper) {\n                object[method] = original;\n            }\n            else {\n                instrumentation = original;\n            }\n        },\n    };\n}\nexport function instrumentMethodAndCallOriginal(object, method, _a) {\n    var before = _a.before, 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 { stop: noop };\n    }\n    var instrumentation = function (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 (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 () {\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            }\n            else {\n                instrumentation = noop;\n            }\n        },\n    };\n}\n//# sourceMappingURL=instrumentMethod.js.map","import { monitor, callMonitored } from '../domain/internalMonitoring';\nimport { instrumentMethod } from '../tools/instrumentMethod';\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                }\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 (response) {\n        var context = startContext;\n        context.state = 'complete';\n        context.duration = elapsed(context.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            observable.notify(context);\n        }\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            observable.notify(context);\n        }\n    };\n    responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { getOrigin, objectEntries, shallowClone } from '@datadog/browser-core';\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the the\n * request did not reach the server, but we the browser does not expose this. So, we clear tracing\n * information if the request ended with status 0 without being aborted by the application.\n *\n * Reasoning:\n *\n * * Applications are usually aborting requests after a bit of time, for example when the user is\n * typing (autocompletion) or navigating away (in a SPA). With a performant device and good\n * network conditions, the request is likely to reach the server before being canceled.\n *\n * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)\n * are likely to finish quickly and without reaching the server.\n *\n * Of course it might not be the case every time, but it should limit having incomplete traces a\n * bit..\n * */\nexport function clearTracingIfNeeded(context) {\n    if (context.status === 0 && !context.isAborted) {\n        context.traceId = undefined;\n        context.spanId = undefined;\n    }\n}\nexport function startTracer(configuration, sessionManager) {\n    return {\n        clearTracingIfNeeded: clearTracingIfNeeded,\n        traceFetch: function (context) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                var _a;\n                if (context.input instanceof Request && !((_a = context.init) === null || _a === void 0 ? void 0 : _a.headers)) {\n                    context.input = new Request(context.input);\n                    Object.keys(tracingHeaders).forEach(function (key) {\n                        ;\n                        context.input.headers.append(key, tracingHeaders[key]);\n                    });\n                }\n                else {\n                    context.init = shallowClone(context.init);\n                    var headers_1 = [];\n                    if (context.init.headers instanceof Headers) {\n                        context.init.headers.forEach(function (value, key) {\n                            headers_1.push([key, value]);\n                        });\n                    }\n                    else if (Array.isArray(context.init.headers)) {\n                        context.init.headers.forEach(function (header) {\n                            headers_1.push(header);\n                        });\n                    }\n                    else if (context.init.headers) {\n                        Object.keys(context.init.headers).forEach(function (key) {\n                            headers_1.push([key, context.init.headers[key]]);\n                        });\n                    }\n                    context.init.headers = headers_1.concat(objectEntries(tracingHeaders));\n                }\n            });\n        },\n        traceXhr: function (context, xhr) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                Object.keys(tracingHeaders).forEach(function (name) {\n                    xhr.setRequestHeader(name, tracingHeaders[name]);\n                });\n            });\n        },\n    };\n}\nfunction injectHeadersIfTracingAllowed(configuration, context, sessionManager, inject) {\n    if (!isTracingSupported() || !isAllowedUrl(configuration, context.url) || !sessionManager.findTrackedSession()) {\n        return;\n    }\n    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\n    inject(makeTracingHeaders(context.traceId, context.spanId));\n}\nfunction isAllowedUrl(configuration, requestUrl) {\n    var requestOrigin = getOrigin(requestUrl);\n    for (var _i = 0, _a = configuration.allowedTracingOrigins; _i < _a.length; _i++) {\n        var allowedOrigin = _a[_i];\n        if (requestOrigin === allowedOrigin || (allowedOrigin instanceof RegExp && allowedOrigin.test(requestOrigin))) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\n}\nfunction getCrypto() {\n    return window.crypto || window.msCrypto;\n}\nfunction makeTracingHeaders(traceId, spanId) {\n    return {\n        'x-datadog-origin': 'rum',\n        'x-datadog-parent-id': spanId.toDecimalString(),\n        'x-datadog-sampled': '1',\n        'x-datadog-sampling-priority': '1',\n        'x-datadog-trace-id': traceId.toDecimalString(),\n    };\n}\n/* eslint-disable no-bitwise */\nvar TraceIdentifier = /** @class */ (function () {\n    function TraceIdentifier() {\n        this.buffer = new Uint8Array(8);\n        getCrypto().getRandomValues(this.buffer);\n        this.buffer[0] = this.buffer[0] & 0x7f; // force 63-bit\n    }\n    TraceIdentifier.prototype.toString = function (radix) {\n        var high = this.readInt32(0);\n        var low = this.readInt32(4);\n        var str = '';\n        do {\n            var mod = (high % radix) * 4294967296 + low;\n            high = Math.floor(high / radix);\n            low = Math.floor(mod / radix);\n            str = (mod % radix).toString(radix) + str;\n        } while (high || low);\n        return str;\n    };\n    /**\n     * Format used everywhere except the trace intake\n     */\n    TraceIdentifier.prototype.toDecimalString = function () {\n        return this.toString(10);\n    };\n    TraceIdentifier.prototype.readInt32 = function (offset) {\n        return (this.buffer[offset] * 16777216 +\n            (this.buffer[offset + 1] << 16) +\n            (this.buffer[offset + 2] << 8) +\n            this.buffer[offset + 3]);\n    };\n    return TraceIdentifier;\n}());\nexport { TraceIdentifier };\n/* eslint-enable no-bitwise */\n//# sourceMappingURL=tracer.js.map","import { initFetchObservable, initXhrObservable } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './rumEventsCollection/resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nvar nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager) {\n    var tracer = startTracer(configuration, sessionManager);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, configuration, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    var subscription = initXhrObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceXhr(context, context.xhr);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(7 /* REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(8 /* REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    type: \"xhr\" /* XHR */,\n                    url: context.url,\n                    xhr: context.xhr,\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nexport function trackFetch(lifeCycle, configuration, tracer) {\n    var subscription = initFetchObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceFetch(context);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(7 /* REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(8 /* REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    responseType: context.responseType,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    type: \"fetch\" /* FETCH */,\n                    url: context.url,\n                    response: context.response,\n                    init: context.init,\n                    input: context.input,\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nfunction getNextRequestIndex() {\n    var result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\n//# sourceMappingURL=requestCollection.js.map","import { noop } from '@datadog/browser-core';\nexport function trackEventCounts(lifeCycle, callback) {\n    if (callback === void 0) { callback = noop; }\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        userActionCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(13 /* RUM_EVENT_COLLECTED */, function (_a) {\n        var type = _a.type;\n        switch (type) {\n            case \"error\" /* ERROR */:\n                eventCounts.errorCount += 1;\n                callback(eventCounts);\n                break;\n            case \"action\" /* ACTION */:\n                eventCounts.userActionCount += 1;\n                callback(eventCounts);\n                break;\n            case \"long_task\" /* LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback(eventCounts);\n                break;\n            case \"resource\" /* RESOURCE */:\n                eventCounts.resourceCount += 1;\n                callback(eventCounts);\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { monitor, Observable, timeStampNow } from '@datadog/browser-core';\n// Delay to wait for a page activity to validate the tracking process\nexport var PAGE_ACTIVITY_VALIDATION_DELAY = 100;\n// Delay to wait after a page activity to end the tracking process\nexport var PAGE_ACTIVITY_END_DELAY = 100;\n/**\n * Wait for the next idle page time\n *\n * Detection lifecycle:\n * ```\n *                           Wait idle page\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitIdlePage(lifeCycle, domMutationObservable, idlePageCallback, maxDuration) {\n    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable);\n    return doWaitIdlePage(pageActivityObservable, idlePageCallback, maxDuration);\n}\nexport function doWaitIdlePage(pageActivityObservable, idlePageCallback, maxDuration) {\n    var idleTimeoutId;\n    var hasCompleted = false;\n    var validationTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: false }); }), PAGE_ACTIVITY_VALIDATION_DELAY);\n    var maxDurationTimeoutId = maxDuration &&\n        setTimeout(monitor(function () { return complete({ hadActivity: true, end: timeStampNow() }); }), maxDuration);\n    var pageActivitySubscription = pageActivityObservable.subscribe(function (_a) {\n        var isBusy = _a.isBusy;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(idleTimeoutId);\n        var lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            idleTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: true, end: lastChangeTime }); }), PAGE_ACTIVITY_END_DELAY);\n        }\n    });\n    var stop = function () {\n        hasCompleted = true;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(idleTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        idlePageCallback(event);\n    }\n    return { stop: stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable) {\n    var observable = new Observable(function () {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(function () { return notifyPageActivity(pendingRequestsCount); }), lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n            if (entries.some(function (_a) {\n                var entryType = _a.entryType;\n                return entryType === 'resource';\n            })) {\n                notifyPageActivity(pendingRequestsCount);\n            }\n        }), lifeCycle.subscribe(7 /* REQUEST_STARTED */, function (startEvent) {\n            if (firstRequestIndex === undefined) {\n                firstRequestIndex = startEvent.requestIndex;\n            }\n            notifyPageActivity(++pendingRequestsCount);\n        }), lifeCycle.subscribe(8 /* REQUEST_COMPLETED */, function (request) {\n            // If the request started before the tracking start, ignore it\n            if (firstRequestIndex === undefined || request.requestIndex < firstRequestIndex) {\n                return;\n            }\n            notifyPageActivity(--pendingRequestsCount);\n        }));\n        return function () { return subscriptions.forEach(function (s) { return s.unsubscribe(); }); };\n    });\n    function notifyPageActivity(pendingRequestsCount) {\n        observable.notify({ isBusy: pendingRequestsCount > 0 });\n    }\n    return observable;\n}\n//# sourceMappingURL=waitIdlePage.js.map","import { safeTruncate, isIE } from '@datadog/browser-core';\n/**\n * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.\n * It can also be retrieved from a user defined attribute.\n */\nvar DEFAULT_PROGRAMMATIC_ATTRIBUTE = 'data-dd-action-name';\nexport function getActionNameFromElement(element, userProgrammaticAttribute) {\n    // Proceed to get the action name in two steps:\n    // * first, get the name programmatically, explicitly defined by the user.\n    // * then, use strategies that are known to return good results. Those strategies will be used on\n    //   the element and a few parents, but it's likely that they won't succeed at all.\n    // * if no name is found this way, use strategies returning less accurate names as a fallback.\n    //   Those are much likely to succeed.\n    return (getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ATTRIBUTE) ||\n        (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute)) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, priorityStrategies) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies) ||\n        '');\n}\nfunction getActionNameFromElementProgrammatically(targetElement, programmaticAttribute) {\n    var elementWithAttribute;\n    // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n    // without limit. It is up to the user to declare a relevant naming strategy.\n    // If available, use element.closest() to match get the attribute from the element or any of its\n    // parent.  Else fallback to a more traditional implementation.\n    if (supportsElementClosest()) {\n        elementWithAttribute = targetElement.closest(\"[\".concat(programmaticAttribute, \"]\"));\n    }\n    else {\n        var element = targetElement;\n        while (element) {\n            if (element.hasAttribute(programmaticAttribute)) {\n                elementWithAttribute = element;\n                break;\n            }\n            element = element.parentElement;\n        }\n    }\n    if (!elementWithAttribute) {\n        return;\n    }\n    var name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nvar priorityStrategies = [\n    // associated LABEL text\n    function (element, userProgrammaticAttribute) {\n        // IE does not support element.labels, so we fallback to a CSS selector based on the element id\n        // instead\n        if (supportsLabelProperty()) {\n            if ('labels' in element && element.labels && element.labels.length > 0) {\n                return getTextualContent(element.labels[0], userProgrammaticAttribute);\n            }\n        }\n        else if (element.id) {\n            var label = element.ownerDocument && element.ownerDocument.querySelector(\"label[for=\\\"\".concat(element.id.replace('\"', '\\\\\"'), \"\\\"]\"));\n            return label && getTextualContent(label, userProgrammaticAttribute);\n        }\n    },\n    // INPUT button (and associated) value\n    function (element) {\n        if (element.nodeName === 'INPUT') {\n            var input = element;\n            var type = input.getAttribute('type');\n            if (type === 'button' || type === 'submit' || type === 'reset') {\n                return input.value;\n            }\n        }\n    },\n    // BUTTON, LABEL or button-like element text\n    function (element, userProgrammaticAttribute) {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getTextualContent(element, userProgrammaticAttribute);\n        }\n    },\n    function (element) { return element.getAttribute('aria-label'); },\n    // associated element text designated by the aria-labelledby attribute\n    function (element, userProgrammaticAttribute) {\n        var labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return labelledByAttribute\n                .split(/\\s+/)\n                .map(function (id) { return getElementById(element, id); })\n                .filter(function (label) { return Boolean(label); })\n                .map(function (element) { return getTextualContent(element, userProgrammaticAttribute); })\n                .join(' ');\n        }\n    },\n    function (element) { return element.getAttribute('alt'); },\n    function (element) { return element.getAttribute('name'); },\n    function (element) { return element.getAttribute('title'); },\n    function (element) { return element.getAttribute('placeholder'); },\n    // SELECT first OPTION text\n    function (element, userProgrammaticAttribute) {\n        if ('options' in element && element.options.length > 0) {\n            return getTextualContent(element.options[0], userProgrammaticAttribute);\n        }\n    },\n];\nvar fallbackStrategies = [\n    function (element, userProgrammaticAttribute) { return getTextualContent(element, userProgrammaticAttribute); },\n];\n/**\n * Iterates over the target element and its parent, using the strategies list to get an action name.\n * Each strategies are applied on each element, stopping as soon as a non-empty value is returned.\n */\nvar MAX_PARENTS_TO_CONSIDER = 10;\nfunction getActionNameFromElementForStrategies(targetElement, userProgrammaticAttribute, strategies) {\n    var element = targetElement;\n    var recursionCounter = 0;\n    while (recursionCounter <= MAX_PARENTS_TO_CONSIDER &&\n        element &&\n        element.nodeName !== 'BODY' &&\n        element.nodeName !== 'HTML' &&\n        element.nodeName !== 'HEAD') {\n        for (var _i = 0, strategies_1 = strategies; _i < strategies_1.length; _i++) {\n            var strategy = strategies_1[_i];\n            var name_1 = strategy(element, userProgrammaticAttribute);\n            if (typeof name_1 === 'string') {\n                var trimmedName = name_1.trim();\n                if (trimmedName) {\n                    return truncate(normalizeWhitespace(trimmedName));\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = element.parentElement;\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? \"\".concat(safeTruncate(s, 100), \" [...]\") : s;\n}\nfunction getElementById(refElement, id) {\n    // Use the element ownerDocument here, because tests are executed in an iframe, so\n    // document.getElementById won't work.\n    return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null;\n}\nfunction getTextualContent(element, userProgrammaticAttribute) {\n    if (element.isContentEditable) {\n        return;\n    }\n    if ('innerText' in element) {\n        var text_1 = element.innerText;\n        var removeTextFromElements = function (query) {\n            var list = element.querySelectorAll(query);\n            for (var index = 0; index < list.length; index += 1) {\n                var element_1 = list[index];\n                if ('innerText' in element_1) {\n                    var textToReplace = element_1.innerText;\n                    if (textToReplace && textToReplace.trim().length > 0) {\n                        text_1 = text_1.replace(textToReplace, '');\n                    }\n                }\n            }\n        };\n        if (!supportsInnerTextScriptAndStyleRemoval()) {\n            // remove the inner text of SCRIPT and STYLES from the result. This is a bit dirty, but should\n            // be relatively fast and work in most cases.\n            removeTextFromElements('script, style');\n        }\n        // remove the text of elements with programmatic attribute value\n        removeTextFromElements(\"[\".concat(DEFAULT_PROGRAMMATIC_ATTRIBUTE, \"]\"));\n        if (userProgrammaticAttribute) {\n            removeTextFromElements(\"[\".concat(userProgrammaticAttribute, \"]\"));\n        }\n        return text_1;\n    }\n    return element.textContent;\n}\n/**\n * Returns true if element.innerText excludes the text from inline SCRIPT and STYLE element. This\n * should be the case everywhere except on Internet Explorer 10 and 11 (see [1])\n *\n * The innerText property relies on what is actually rendered to compute its output, so to check if\n * it actually excludes SCRIPT and STYLE content, a solution would be to create a style element, set\n * its content to '*', inject it in the document body, and check if the style element innerText\n * property returns '*'. Using a new `document` instance won't work as it is not rendered.\n *\n * This solution requires specific CSP rules (see [2]) to be set by the customer. We want to avoid\n * this, so instead we rely on browser detection. In case of false negative, the impact should be\n * low, since we rely on this result to remove the SCRIPT and STYLE innerText (which will be empty)\n * from a parent element innerText.\n *\n * [1]: https://web.archive.org/web/20210602165716/http://perfectionkills.com/the-poor-misunderstood-innerText/#diff-with-textContent\n * [2]: https://github.com/DataDog/browser-sdk/issues/1084\n */\nfunction supportsInnerTextScriptAndStyleRemoval() {\n    return !isIE();\n}\n/**\n * Returns true if the browser supports the element.labels property.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsLabelPropertyResult;\nfunction supportsLabelProperty() {\n    if (supportsLabelPropertyResult === undefined) {\n        supportsLabelPropertyResult = 'labels' in HTMLInputElement.prototype;\n    }\n    return supportsLabelPropertyResult;\n}\n/**\n * Returns true if the browser supports the element.closest method.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsElementClosestResult;\nfunction supportsElementClosest() {\n    if (supportsElementClosestResult === undefined) {\n        supportsElementClosestResult = 'closest' in HTMLElement.prototype;\n    }\n    return supportsElementClosestResult;\n}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { addEventListener, generateUUID, clocksNow, ONE_SECOND, elapsed } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { waitIdlePage } from '../../waitIdlePage';\nimport { getActionNameFromElement } from './getActionNameFromElement';\n// Maximum duration for automatic actions\nexport var AUTO_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport function trackActions(lifeCycle, domMutationObservable, _a) {\n    var actionNameAttribute = _a.actionNameAttribute;\n    var action = startActionManagement(lifeCycle, domMutationObservable);\n    // New views trigger the discard of the current pending Action\n    lifeCycle.subscribe(4 /* VIEW_CREATED */, function () {\n        action.discardCurrent();\n    });\n    var stopListener = addEventListener(window, \"click\" /* CLICK */, function (event) {\n        if (!(event.target instanceof Element)) {\n            return;\n        }\n        var name = getActionNameFromElement(event.target, actionNameAttribute);\n        if (!name) {\n            return;\n        }\n        action.create(\"click\" /* CLICK */, name, event);\n    }, { capture: true }).stop;\n    return {\n        stop: function () {\n            action.discardCurrent();\n            stopListener();\n        },\n    };\n}\nfunction startActionManagement(lifeCycle, domMutationObservable) {\n    var currentAction;\n    var stopWaitingIdlePage;\n    return {\n        create: function (type, name, event) {\n            if (currentAction) {\n                // Ignore any new action if another one is already occurring.\n                return;\n            }\n            var pendingAutoAction = new PendingAutoAction(lifeCycle, type, name, event);\n            currentAction = pendingAutoAction;\n            (stopWaitingIdlePage = waitIdlePage(lifeCycle, domMutationObservable, function (event) {\n                if (event.hadActivity) {\n                    var duration = elapsed(pendingAutoAction.startClocks.timeStamp, event.end);\n                    if (duration >= 0) {\n                        pendingAutoAction.complete(duration);\n                    }\n                    else {\n                        pendingAutoAction.discard();\n                    }\n                }\n                else {\n                    pendingAutoAction.discard();\n                }\n                currentAction = undefined;\n            }, AUTO_ACTION_MAX_DURATION).stop);\n        },\n        discardCurrent: function () {\n            if (currentAction) {\n                stopWaitingIdlePage();\n                currentAction.discard();\n                currentAction = undefined;\n            }\n        },\n    };\n}\nvar PendingAutoAction = /** @class */ (function () {\n    function PendingAutoAction(lifeCycle, type, name, event) {\n        this.lifeCycle = lifeCycle;\n        this.type = type;\n        this.name = name;\n        this.event = event;\n        this.id = generateUUID();\n        this.startClocks = clocksNow();\n        this.eventCountsSubscription = trackEventCounts(lifeCycle);\n        this.lifeCycle.notify(1 /* AUTO_ACTION_CREATED */, { id: this.id, startClocks: this.startClocks });\n    }\n    PendingAutoAction.prototype.complete = function (duration) {\n        var eventCounts = this.eventCountsSubscription.eventCounts;\n        this.lifeCycle.notify(2 /* AUTO_ACTION_COMPLETED */, {\n            counts: {\n                errorCount: eventCounts.errorCount,\n                longTaskCount: eventCounts.longTaskCount,\n                resourceCount: eventCounts.resourceCount,\n            },\n            duration: duration,\n            id: this.id,\n            name: this.name,\n            startClocks: this.startClocks,\n            type: this.type,\n            event: this.event,\n        });\n        this.eventCountsSubscription.stop();\n    };\n    PendingAutoAction.prototype.discard = function () {\n        this.lifeCycle.notify(3 /* AUTO_ACTION_DISCARDED */);\n        this.eventCountsSubscription.stop();\n    };\n    return PendingAutoAction;\n}());\n//# sourceMappingURL=trackActions.js.map","import { assign, combine, toServerDuration, generateUUID } from '@datadog/browser-core';\nimport { trackActions } from './trackActions';\nexport function startActionCollection(lifeCycle, domMutationObservable, configuration, foregroundContexts) {\n    lifeCycle.subscribe(2 /* AUTO_ACTION_COMPLETED */, function (action) {\n        return lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, processAction(action, foregroundContexts));\n    });\n    if (configuration.trackInteractions) {\n        trackActions(lifeCycle, domMutationObservable, configuration);\n    }\n    return {\n        addAction: function (action, savedCommonContext) {\n            lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, assign({\n                savedCommonContext: savedCommonContext,\n            }, processAction(action, foregroundContexts)));\n        },\n    };\n}\nfunction processAction(action, foregroundContexts) {\n    var autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                error: {\n                    count: action.counts.errorCount,\n                },\n                id: action.id,\n                loading_time: toServerDuration(action.duration),\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n        }\n        : undefined;\n    var customerContext = !isAutoAction(action) ? action.context : undefined;\n    var actionEvent = combine({\n        action: {\n            id: generateUUID(),\n            target: {\n                name: action.name,\n            },\n            type: action.type,\n        },\n        date: action.startClocks.timeStamp,\n        type: \"action\" /* ACTION */,\n    }, autoActionProperties);\n    var inForeground = foregroundContexts.isInForegroundAt(action.startClocks.relative);\n    if (inForeground !== undefined) {\n        actionEvent.view = { in_foreground: inForeground };\n    }\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: isAutoAction(action) ? { event: action.event } : {},\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* CUSTOM */;\n}\n//# sourceMappingURL=actionCollection.js.map","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 () {\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 (message, url, lineNo, columnNo, errorObj) {\n            var stack;\n            if (errorObj) {\n                stack = computeStackTrace(errorObj);\n                callback(stack, errorObj);\n            }\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 (e) {\n            var reason = e.reason || 'Empty reason';\n            var stack = computeStackTrace(reason);\n            callback(stack, reason);\n        },\n    });\n}\n//# sourceMappingURL=tracekit.js.map","import { callMonitored } from '../internalMonitoring';\nimport { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString } from '../../tools/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { find, jsonStringify } from '../../tools/utils';\nexport var ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\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    var log = {\n        message: [\"console \".concat(api, \":\")]\n            .concat(params)\n            .map(function (param) { return formatConsoleParameters(param); })\n            .join(' '),\n        api: api,\n    };\n    if (api === ConsoleApiName.error) {\n        var firstErrorParam = find(params, function (param) { return param instanceof Error; });\n        log.stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;\n        log.handlingStack = handlingStack;\n    }\n    return log;\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}\n//# sourceMappingURL=consoleObservable.js.map","import { toStackTraceString } from '../../tools/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { includes, addEventListener, safeTruncate } from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\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) { return api !== RawReportType.cspViolation; });\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, 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, \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\"), event.sourceFile, event.lineNumber, event.columnNumber),\n    };\n}\nfunction buildStack(name, message, sourceFile, lineNumber, columnNumber) {\n    return (sourceFile &&\n        toStackTraceString({\n            name: name,\n            message: message,\n            stack: [\n                {\n                    func: '?',\n                    url: sourceFile,\n                    line: lineNumber,\n                    column: columnNumber,\n                },\n            ],\n        }));\n}\n//# sourceMappingURL=reportObservable.js.map","import { addEventListeners } from '@datadog/browser-core';\nvar trackFirstHiddenSingleton;\nvar stopListeners;\nexport function trackFirstHidden(emitter) {\n    if (emitter === void 0) { emitter = window; }\n    if (!trackFirstHiddenSingleton) {\n        if (document.visibilityState === 'hidden') {\n            trackFirstHiddenSingleton = {\n                timeStamp: 0,\n            };\n        }\n        else {\n            trackFirstHiddenSingleton = {\n                timeStamp: Infinity,\n            };\n            (stopListeners = addEventListeners(emitter, [\"pagehide\" /* PAGE_HIDE */, \"visibilitychange\" /* VISIBILITY_CHANGE */], function (event) {\n                if (event.type === 'pagehide' || document.visibilityState === 'hidden') {\n                    trackFirstHiddenSingleton.timeStamp = event.timeStamp;\n                    stopListeners();\n                }\n            }, { capture: true }).stop);\n        }\n    }\n    return trackFirstHiddenSingleton;\n}\nexport function resetFirstHidden() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    trackFirstHiddenSingleton = undefined;\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { assign, computeStackTrace, formatUnknownError, ErrorSource, generateUUID, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, foregroundContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(14 /* RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, foregroundContexts);\n}\nexport function doStartErrorCollection(lifeCycle, foregroundContexts) {\n    lifeCycle.subscribe(14 /* RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, assign({\n            customerContext: customerContext,\n            savedCommonContext: savedCommonContext,\n        }, processError(error, foregroundContexts)));\n    });\n    return {\n        addError: function (_a, savedCommonContext) {\n            var error = _a.error, handlingStack = _a.handlingStack, startClocks = _a.startClocks, customerContext = _a.context;\n            var rawError = computeRawError(error, handlingStack, startClocks);\n            lifeCycle.notify(14 /* RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction computeRawError(error, handlingStack, startClocks) {\n    var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n    return assign({\n        startClocks: startClocks,\n        source: ErrorSource.CUSTOM,\n        originalError: error,\n        handling: \"handled\" /* HANDLED */,\n    }, formatUnknownError(stackTrace, error, 'Provided', handlingStack));\n}\nfunction processError(error, foregroundContexts) {\n    var rawRumEvent = {\n        date: error.startClocks.timeStamp,\n        error: {\n            id: generateUUID(),\n            message: error.message,\n            source: error.source,\n            stack: error.stack,\n            handling_stack: error.handlingStack,\n            type: error.type,\n            handling: error.handling,\n            source_type: 'browser',\n        },\n        type: \"error\" /* ERROR */,\n    };\n    var inForeground = foregroundContexts.isInForegroundAt(error.startClocks.relative);\n    if (inForeground !== undefined) {\n        rawRumEvent.view = { in_foreground: inForeground };\n    }\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext: {\n            error: error.originalError,\n        },\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { clocksNow, initConsoleObservable, ErrorSource, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    var subscription = initConsoleObservable([ConsoleApiName.error]).subscribe(function (consoleError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: consoleError.message,\n            stack: consoleError.stack,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* HANDLED */,\n            handlingStack: consoleError.handlingStack,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { ErrorSource, formatUnknownError } from '../../tools/error';\nimport { clocksNow } from '../../tools/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\nexport function trackRuntimeError(errorObservable) {\n    return startUnhandledErrorCollection(function (stackTrace, errorObject) {\n        var _a = formatUnknownError(stackTrace, errorObject, 'Uncaught'), stack = _a.stack, message = _a.message, type = _a.type;\n        errorObservable.notify({\n            message: message,\n            stack: stack,\n            type: type,\n            source: ErrorSource.SOURCE,\n            startClocks: clocksNow(),\n            originalError: errorObject,\n            handling: \"unhandled\" /* UNHANDLED */,\n        });\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { clocksNow, ErrorSource, initReportObservable, RawReportType, isExperimentalFeatureEnabled, noop, } from '@datadog/browser-core';\nexport function trackReportError(errorObservable) {\n    if (!isExperimentalFeatureEnabled('forward-reports')) {\n        return {\n            stop: noop,\n        };\n    }\n    var subscription = initReportObservable([RawReportType.cspViolation, RawReportType.intervention]).subscribe(function (reportError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: reportError.message,\n            stack: reportError.stack,\n            type: reportError.subtype,\n            source: ErrorSource.REPORT,\n            handling: \"unhandled\" /* UNHANDLED */,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { toValidEntry } from './resourceUtils';\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n * - Browsers generate a timing entry for OPTIONS request\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - if a single timing match, return the timing\n * - if two following timings match (OPTIONS request), return the timing for the actual request\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestTiming(request) {\n    if (!performance || !('getEntriesByName' in performance)) {\n        return;\n    }\n    var sameNameEntries = performance.getEntriesByName(request.url, 'resource');\n    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n        return;\n    }\n    var candidates = sameNameEntries\n        .map(function (entry) { return entry.toJSON(); })\n        .filter(toValidEntry)\n        .filter(function (entry) {\n        return isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration }));\n    });\n    if (candidates.length === 1) {\n        return candidates[0];\n    }\n    if (candidates.length === 2 && firstCanBeOptionRequest(candidates)) {\n        return candidates[1];\n    }\n    return;\n}\nfunction firstCanBeOptionRequest(correspondingEntries) {\n    return endTime(correspondingEntries[0]) <= correspondingEntries[1].startTime;\n}\nfunction endTime(timing) {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return (timing.startTime + timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    var errorMargin = 1;\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return timing.startTime >= start - errorMargin && endTime(timing) <= end + errorMargin;\n}\n//# sourceMappingURL=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, } from '@datadog/browser-core';\nimport { supportPerformanceEntry } from '../../../browser/performanceCollection';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle) {\n    lifeCycle.subscribe(8 /* REQUEST_COMPLETED */, function (request) {\n        lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, processRequest(request));\n    });\n    lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'resource' && !isRequestKind(entry)) {\n                lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, processResourceEntry(entry));\n            }\n        }\n    });\n}\nfunction processRequest(request) {\n    var type = request.type === \"xhr\" /* XHR */ ? \"xhr\" /* XHR */ : \"fetch\" /* FETCH */;\n    var matchingTiming = matchRequestTiming(request);\n    var startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    var correspondingTimingOverrides = matchingTiming ? computePerformanceEntryMetrics(matchingTiming) : undefined;\n    var tracingInfo = computeRequestTracingInfo(request);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: toServerDuration(request.duration),\n            method: request.method,\n            status_code: request.status,\n            url: request.url,\n        },\n        type: \"resource\" /* RESOURCE */,\n    }, tracingInfo, correspondingTimingOverrides);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: matchingTiming && toPerformanceEntryRepresentation(matchingTiming),\n            xhr: request.xhr,\n            response: request.response,\n            requestInput: request.input,\n            requestInit: request.init,\n            error: request.error,\n        },\n    };\n}\nfunction processResourceEntry(entry) {\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var tracingInfo = computeEntryTracingInfo(entry);\n    var startClocks = relativeToClocks(entry.startTime);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            url: entry.name,\n        },\n        type: \"resource\" /* RESOURCE */,\n    }, tracingInfo, entryMetrics);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: toPerformanceEntryRepresentation(entry),\n        },\n    };\n}\nfunction computePerformanceEntryMetrics(timing) {\n    return {\n        resource: assign({\n            duration: computePerformanceResourceDuration(timing),\n            size: computeSize(timing),\n        }, computePerformanceResourceDetails(timing)),\n    };\n}\nfunction computeRequestTracingInfo(request) {\n    var hasBeenTraced = request.traceId && request.spanId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            span_id: request.spanId.toDecimalString(),\n            trace_id: request.traceId.toDecimalString(),\n        },\n    };\n}\nfunction computeEntryTracingInfo(entry) {\n    return entry.traceId ? { _dd: { trace_id: entry.traceId } } : undefined;\n}\nfunction toPerformanceEntryRepresentation(entry) {\n    if (supportPerformanceEntry() && entry instanceof PerformanceEntry) {\n        entry.toJSON();\n    }\n    return entry;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { assign, addEventListeners, elapsed, ONE_MINUTE, find, findLast } from '@datadog/browser-core';\nimport { trackFirstHidden } from './trackFirstHidden';\n// Discard LCP and FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport var TIMING_MAXIMUM_DELAY = 10 * ONE_MINUTE;\nexport function trackInitialViewTimings(lifeCycle, callback) {\n    var timings = {};\n    function setTimings(newTimings) {\n        assign(timings, newTimings);\n        callback(timings);\n    }\n    var stopNavigationTracking = trackNavigationTimings(lifeCycle, setTimings).stop;\n    var stopFCPTracking = trackFirstContentfulPaintTiming(lifeCycle, function (firstContentfulPaint) {\n        return setTimings({ firstContentfulPaint: firstContentfulPaint });\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaintTiming(lifeCycle, window, function (largestContentfulPaint) {\n        setTimings({\n            largestContentfulPaint: largestContentfulPaint,\n        });\n    }).stop;\n    var stopFIDTracking = trackFirstInputTimings(lifeCycle, function (_a) {\n        var firstInputDelay = _a.firstInputDelay, firstInputTime = _a.firstInputTime;\n        setTimings({\n            firstInputDelay: firstInputDelay,\n            firstInputTime: firstInputTime,\n        });\n    }).stop;\n    return {\n        stop: function () {\n            stopNavigationTracking();\n            stopFCPTracking();\n            stopLCPTracking();\n            stopFIDTracking();\n        },\n    };\n}\nexport function trackNavigationTimings(lifeCycle, callback) {\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'navigation') {\n                callback({\n                    domComplete: entry.domComplete,\n                    domContentLoaded: entry.domContentLoadedEventEnd,\n                    domInteractive: entry.domInteractive,\n                    loadEvent: entry.loadEventEnd,\n                });\n            }\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\nexport function trackFirstContentfulPaintTiming(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.entryType === 'paint' &&\n                entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getLCP.ts\n */\nexport function trackLargestContentfulPaintTiming(lifeCycle, emitter, callback) {\n    var firstHidden = trackFirstHidden();\n    // Ignore entries that come after the first user interaction.  According to the documentation, the\n    // browser should not send largest-contentful-paint entries after a user interact with the page,\n    // but the web-vitals reference implementation uses this as a safeguard.\n    var firstInteractionTimestamp = Infinity;\n    var stopEventListener = addEventListeners(emitter, [\"pointerdown\" /* POINTER_DOWN */, \"keydown\" /* KEY_DOWN */], function (event) {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true }).stop;\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return entry.entryType === 'largest-contentful-paint' &&\n                entry.startTime < firstInteractionTimestamp &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (lcpEntry) {\n            callback(lcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return {\n        stop: function () {\n            stopEventListener();\n            unsubscribeLifeCycle();\n        },\n    };\n}\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInputTimings(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var firstInputEntry = find(entries, function (entry) {\n            return entry.entryType === 'first-input' && entry.startTime < firstHidden.timeStamp;\n        });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                firstInputDelay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                firstInputTime: firstInputEntry.startTime,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=trackInitialViewTimings.js.map","import { noop, round, ONE_SECOND, elapsed } from '@datadog/browser-core';\nimport { supportPerformanceTimingEvent } from '../../../browser/performanceCollection';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { waitIdlePage } from '../../waitIdlePage';\nexport function trackViewMetrics(lifeCycle, domMutationObservable, scheduleViewUpdate, loadingType, viewStart) {\n    var viewMetrics = {\n        eventCounts: {\n            errorCount: 0,\n            longTaskCount: 0,\n            resourceCount: 0,\n            userActionCount: 0,\n        },\n    };\n    var stopEventCountsTracking = trackEventCounts(lifeCycle, function (newEventCounts) {\n        viewMetrics.eventCounts = newEventCounts;\n        scheduleViewUpdate();\n    }).stop;\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, loadingType, viewStart, function (newLoadingTime) {\n        viewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopCLSTracking;\n    if (isLayoutShiftSupported()) {\n        viewMetrics.cumulativeLayoutShift = 0;\n        (stopCLSTracking = trackCumulativeLayoutShift(lifeCycle, function (cumulativeLayoutShift) {\n            viewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n            scheduleViewUpdate();\n        }).stop);\n    }\n    else {\n        stopCLSTracking = noop;\n    }\n    return {\n        stop: function () {\n            stopEventCountsTracking();\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n        },\n        setLoadEvent: setLoadEvent,\n        viewMetrics: viewMetrics,\n    };\n}\nfunction trackLoadingTime(lifeCycle, domMutationObservable, loadType, viewStart, callback) {\n    var isWaitingForLoadEvent = loadType === \"initial_load\" /* INITIAL_LOAD */;\n    var isWaitingForActivityLoadingTime = true;\n    var loadingTimeCandidates = [];\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            callback(Math.max.apply(Math, loadingTimeCandidates));\n        }\n    }\n    var stop = waitIdlePage(lifeCycle, domMutationObservable, function (event) {\n        if (isWaitingForActivityLoadingTime) {\n            isWaitingForActivityLoadingTime = false;\n            if (event.hadActivity) {\n                loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end));\n            }\n            invokeCallbackIfAllCandidatesAreReceived();\n        }\n    }).stop;\n    return {\n        stop: stop,\n        setLoadEvent: function (loadEvent) {\n            if (isWaitingForLoadEvent) {\n                isWaitingForLoadEvent = false;\n                loadingTimeCandidates.push(loadEvent);\n                invokeCallbackIfAllCandidatesAreReceived();\n            }\n        },\n    };\n}\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nfunction trackCumulativeLayoutShift(lifeCycle, callback) {\n    var maxClsValue = 0;\n    var window = slidingSessionWindow();\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'layout-shift' && !entry.hadRecentInput) {\n                window.update(entry);\n                if (window.value() > maxClsValue) {\n                    maxClsValue = window.value();\n                    callback(round(maxClsValue, 4));\n                }\n            }\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\nfunction slidingSessionWindow() {\n    var value = 0;\n    var startTime;\n    var endTime;\n    return {\n        update: function (entry) {\n            var shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= ONE_SECOND ||\n                entry.startTime - startTime >= 5 * ONE_SECOND;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                value = entry.value;\n            }\n            else {\n                value += entry.value;\n                endTime = entry.startTime;\n            }\n        },\n        value: function () { return value; },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nfunction isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent('layout-shift');\n}\n//# sourceMappingURL=trackViewMetrics.js.map","import { shallowClone, assign, elapsed, generateUUID, monitor, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, } from '@datadog/browser-core';\nimport { trackInitialViewTimings } from './trackInitialViewTimings';\nimport { trackViewMetrics } from './trackViewMetrics';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, locationChangeObservable, areViewsTrackedAutomatically, initialViewName) {\n    var _a = trackInitialView(initialViewName), stopInitialViewTracking = _a.stop, initialView = _a.initialView;\n    var currentView = initialView;\n    var stopViewLifeCycle = startViewLifeCycle().stop;\n    var locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function trackInitialView(name) {\n        var initialView = newView(lifeCycle, domMutationObservable, location, \"initial_load\" /* INITIAL_LOAD */, clocksOrigin(), name);\n        var stop = trackInitialViewTimings(lifeCycle, function (timings) {\n            initialView.updateTimings(timings);\n            initialView.scheduleUpdate();\n        }).stop;\n        return { initialView: initialView, stop: stop };\n    }\n    function trackViewChange(startClocks, name) {\n        return newView(lifeCycle, domMutationObservable, location, \"route_change\" /* ROUTE_CHANGE */, startClocks, name);\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(10 /* SESSION_RENEWED */, function () {\n            // do not trigger view update to avoid wrong data\n            currentView.end();\n            // Renew view on session renewal\n            currentView = trackViewChange(undefined, currentView.name);\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(11 /* BEFORE_UNLOAD */, function () {\n            currentView.end();\n            currentView.triggerUpdate();\n        });\n        // Session keep alive\n        var keepAliveInterval = window.setInterval(monitor(function () {\n            currentView.triggerUpdate();\n        }), SESSION_KEEP_ALIVE_INTERVAL);\n        return {\n            stop: function () {\n                clearInterval(keepAliveInterval);\n            },\n        };\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(function (_a) {\n            var oldLocation = _a.oldLocation, newLocation = _a.newLocation;\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView.triggerUpdate();\n                currentView = trackViewChange();\n                return;\n            }\n        });\n    }\n    return {\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            currentView.addTiming(name, time);\n            currentView.scheduleUpdate();\n        },\n        startView: function (name, startClocks) {\n            currentView.end(startClocks);\n            currentView.triggerUpdate();\n            currentView = trackViewChange(startClocks, name);\n        },\n        stop: function () {\n            locationChangeSubscription === null || locationChangeSubscription === void 0 ? void 0 : locationChangeSubscription.unsubscribe();\n            stopInitialViewTracking();\n            stopViewLifeCycle();\n            currentView.end();\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, initialLocation, loadingType, startClocks, name) {\n    if (startClocks === void 0) { startClocks = clocksNow(); }\n    // Setup initial values\n    var id = generateUUID();\n    var timings = {};\n    var customTimings = {};\n    var documentVersion = 0;\n    var endClocks;\n    var location = shallowClone(initialLocation);\n    lifeCycle.notify(4 /* VIEW_CREATED */, { id: id, name: name, startClocks: startClocks });\n    // Update the view every time the measures are changing\n    var _a = throttle(monitor(triggerViewUpdate), THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    }), scheduleViewUpdate = _a.throttled, cancelScheduleViewUpdate = _a.cancel;\n    var _b = trackViewMetrics(lifeCycle, domMutationObservable, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, stopViewMetricsTracking = _b.stop, viewMetrics = _b.viewMetrics;\n    // Initial view update\n    triggerViewUpdate();\n    function triggerViewUpdate() {\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(5 /* VIEW_UPDATED */, assign({\n            customTimings: customTimings,\n            documentVersion: documentVersion,\n            id: id,\n            name: name,\n            loadingType: loadingType,\n            location: location,\n            startClocks: startClocks,\n            timings: timings,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n        }, viewMetrics));\n    }\n    return {\n        name: name,\n        scheduleUpdate: scheduleViewUpdate,\n        end: function (clocks) {\n            if (clocks === void 0) { clocks = clocksNow(); }\n            endClocks = clocks;\n            stopViewMetricsTracking();\n            lifeCycle.notify(6 /* VIEW_ENDED */, { endClocks: endClocks });\n        },\n        triggerUpdate: function () {\n            // cancel any pending view updates execution\n            cancelScheduleViewUpdate();\n            triggerViewUpdate();\n        },\n        updateTimings: function (newTimings) {\n            timings = newTimings;\n            if (newTimings.loadEvent !== undefined) {\n                setLoadEvent(newTimings.loadEvent);\n            }\n        },\n        addTiming: function (name, time) {\n            var relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n        },\n    };\n}\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name) {\n    var sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(\"Invalid timing name: \".concat(name, \", sanitized to: \").concat(sanitized));\n    }\n    return sanitized;\n}\nfunction areDifferentLocation(currentLocation, otherLocation) {\n    return (currentLocation.pathname !== otherLocation.pathname ||\n        (!isHashAnAnchor(otherLocation.hash) &&\n            getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash)));\n}\nfunction isHashAnAnchor(hash) {\n    var correspondingId = hash.substr(1);\n    return !!document.getElementById(correspondingId);\n}\nfunction getPathFromHash(hash) {\n    var index = hash.indexOf('?');\n    return index < 0 ? hash : hash.slice(0, index);\n}\n//# sourceMappingURL=trackViews.js.map","import { isEmptyObject, mapValues, toServerDuration, isNumber } from '@datadog/browser-core';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, recorderApi, initialViewName) {\n    lifeCycle.subscribe(5 /* VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, foregroundContexts, recorderApi));\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, locationChangeObservable, !configuration.trackViewsManually, initialViewName);\n}\nfunction processViewUpdate(view, foregroundContexts, recorderApi) {\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n        },\n        date: view.startClocks.timeStamp,\n        type: \"view\" /* VIEW */,\n        view: {\n            action: {\n                count: view.eventCounts.userActionCount,\n            },\n            cumulative_layout_shift: view.cumulativeLayoutShift,\n            dom_complete: toServerDuration(view.timings.domComplete),\n            dom_content_loaded: toServerDuration(view.timings.domContentLoaded),\n            dom_interactive: toServerDuration(view.timings.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.timings.firstContentfulPaint),\n            first_input_delay: toServerDuration(view.timings.firstInputDelay),\n            first_input_time: toServerDuration(view.timings.firstInputTime),\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration(view.timings.largestContentfulPaint),\n            load_event: toServerDuration(view.timings.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.loadingTime)),\n            loading_type: view.loadingType,\n            long_task: {\n                count: view.eventCounts.longTaskCount,\n            },\n            resource: {\n                count: view.eventCounts.resourceCount,\n            },\n            time_spent: toServerDuration(view.duration),\n            in_foreground_periods: foregroundContexts.selectInForegroundPeriodsFor(view.startClocks.relative, view.duration),\n        },\n        session: {\n            has_replay: replayStats ? true : undefined,\n        },\n    };\n    if (!isEmptyObject(view.customTimings)) {\n        viewEvent.view.custom_timings = mapValues(view.customTimings, toServerDuration);\n    }\n    return {\n        rawRumEvent: viewEvent,\n        startTime: view.startClocks.relative,\n        domainContext: {\n            location: view.location,\n        },\n    };\n}\nfunction discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=viewCollection.js.map","import * as utils from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nimport { ContextHistory } from '../../tools/contextHistory';\nimport { relativeNow, clocksOrigin } from '../../tools/timeUtils';\nimport { tryOldCookiesMigration } from './oldCookiesMigration';\nimport { startSessionStore, SESSION_TIME_OUT_DELAY } from './sessionStore';\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 () { return sessionStore.stop(); });\n    var sessionContextHistory = new ContextHistory(SESSION_CONTEXT_TIMEOUT_DELAY);\n    stopCallbacks.push(function () { return sessionContextHistory.stop(); });\n    sessionStore.renewObservable.subscribe(function () {\n        sessionContextHistory.setCurrent(buildSessionContext(), relativeNow());\n    });\n    sessionStore.expireObservable.subscribe(function () {\n        sessionContextHistory.closeCurrent(relativeNow());\n    });\n    sessionStore.expandOrRenewSession();\n    sessionContextHistory.setCurrent(buildSessionContext(), clocksOrigin().relative);\n    trackActivity(function () { return sessionStore.expandOrRenewSession(); });\n    trackVisibility(function () { return sessionStore.expandSession(); });\n    function buildSessionContext() {\n        return {\n            id: sessionStore.getSession().id,\n            trackingType: sessionStore.getSession()[productKey],\n        };\n    }\n    return {\n        findActiveSession: function (startTime) { return sessionContextHistory.find(startTime); },\n        renewObservable: sessionStore.renewObservable,\n        expireObservable: sessionStore.expireObservable,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach(function (e) { return e(); });\n    stopCallbacks = [];\n}\nfunction trackActivity(expandOrRenewSession) {\n    var stop = utils.addEventListeners(window, [\"click\" /* CLICK */, \"touchstart\" /* TOUCH_START */, \"keydown\" /* KEY_DOWN */, \"scroll\" /* SCROLL */], expandOrRenewSession, { capture: true, passive: true }).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}\n//# sourceMappingURL=sessionManager.js.map","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}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { performDraw, startSessionManager } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle) {\n    var sessionManager = startSessionManager(configuration.cookieOptions, RUM_SESSION_KEY, function (rawTrackingType) {\n        return computeSessionState(configuration, rawTrackingType);\n    });\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(9 /* SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(10 /* SESSION_RENEWED */);\n    });\n    return {\n        findTrackedSession: function (startTime) {\n            var session = sessionManager.findActiveSession(startTime);\n            if (!session || !isTypeTracked(session.trackingType)) {\n                return;\n            }\n            return {\n                id: session.id,\n                hasReplayPlan: session.trackingType === \"1\" /* TRACKED_REPLAY */,\n                hasLitePlan: session.trackingType === \"2\" /* TRACKED_LITE */,\n            };\n        },\n    };\n}\n/**\n * Start a tracked replay session stub\n * It needs to be a replay plan in order to get long tasks\n */\nexport function startRumSessionManagerStub() {\n    var session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        hasReplayPlan: true,\n        hasLitePlan: false,\n    };\n    return {\n        findTrackedSession: function () { return session; },\n    };\n}\nfunction computeSessionState(configuration, rawTrackingType) {\n    var trackingType;\n    if (hasValidRumSession(rawTrackingType)) {\n        trackingType = rawTrackingType;\n    }\n    else if (!performDraw(configuration.sampleRate)) {\n        trackingType = \"0\" /* NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.replaySampleRate)) {\n        trackingType = \"2\" /* TRACKED_LITE */;\n    }\n    else {\n        trackingType = \"1\" /* TRACKED_REPLAY */;\n    }\n    return {\n        trackingType: trackingType,\n        isTracked: isTypeTracked(trackingType),\n    };\n}\nfunction hasValidRumSession(trackingType) {\n    return (trackingType === \"0\" /* NOT_TRACKED */ ||\n        trackingType === \"1\" /* TRACKED_REPLAY */ ||\n        trackingType === \"2\" /* TRACKED_LITE */);\n}\nfunction isTypeTracked(rumSessionType) {\n    return rumSessionType === \"2\" /* TRACKED_LITE */ || rumSessionType === \"1\" /* TRACKED_REPLAY */;\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { Batch, combine, HttpRequest } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable) {\n    var batch = makeRumBatch(configuration, lifeCycle);\n    lifeCycle.subscribe(13 /* RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        if (serverRumEvent.type === \"view\" /* VIEW */) {\n            batch.upsert(serverRumEvent, serverRumEvent.view.id);\n        }\n        else {\n            batch.add(serverRumEvent);\n        }\n    });\n    telemetryEventObservable.subscribe(function (event) { return batch.add(event); });\n}\nfunction makeRumBatch(configuration, lifeCycle) {\n    var primaryBatch = createRumBatch(configuration.rumEndpointBuilder, function () {\n        return lifeCycle.notify(11 /* BEFORE_UNLOAD */);\n    });\n    var replicaBatch;\n    var replica = configuration.replica;\n    if (replica !== undefined) {\n        replicaBatch = createRumBatch(replica.rumEndpointBuilder);\n    }\n    function createRumBatch(endpointBuilder, unloadCallback) {\n        return new Batch(new HttpRequest(endpointBuilder, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout, unloadCallback);\n    }\n    function withReplicaApplicationId(message) {\n        return combine(message, { application: { id: replica.applicationId } });\n    }\n    return {\n        add: function (message) {\n            primaryBatch.add(message);\n            if (replicaBatch) {\n                replicaBatch.add(withReplicaApplicationId(message));\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(withReplicaApplicationId(message), key);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startRumBatch.js.map","import { addEventListener, instrumentMethodAndCallOriginal, Observable, shallowClone, } from '@datadog/browser-core';\nexport function createLocationChangeObservable(location) {\n    var currentLocation = shallowClone(location);\n    var observable = new Observable(function () {\n        var stopHistoryTracking = trackHistory(onLocationChange).stop;\n        var stopHashTracking = trackHash(onLocationChange).stop;\n        return function () {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n    function onLocationChange() {\n        if (currentLocation.href === location.href) {\n            return;\n        }\n        var newLocation = shallowClone(location);\n        observable.notify({\n            newLocation: newLocation,\n            oldLocation: currentLocation,\n        });\n        currentLocation = newLocation;\n    }\n    return observable;\n}\nfunction trackHistory(onHistoryChange) {\n    var stopInstrumentingPushState = instrumentMethodAndCallOriginal(history, 'pushState', {\n        after: onHistoryChange,\n    }).stop;\n    var stopInstrumentingReplaceState = instrumentMethodAndCallOriginal(history, 'replaceState', {\n        after: onHistoryChange,\n    }).stop;\n    var removeListener = addEventListener(window, \"popstate\" /* POP_STATE */, onHistoryChange).stop;\n    return {\n        stop: function () {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(onHashChange) {\n    return addEventListener(window, \"hashchange\" /* HASH_CHANGE */, onHashChange);\n}\n//# sourceMappingURL=locationChangeObservable.js.map","export { IncrementalSource } from './domain/record';\nexport var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n};\n//# sourceMappingURL=types.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nexport var NodePrivacyLevel = {\n    IGNORE: 'ignore',\n    HIDDEN: 'hidden',\n    ALLOW: DefaultPrivacyLevel.ALLOW,\n    MASK: DefaultPrivacyLevel.MASK,\n    MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n};\nexport var PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport var PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport var PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport var PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport var PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport var PRIVACY_CLASS_ALLOW = 'dd-privacy-allow';\nexport var PRIVACY_CLASS_MASK = 'dd-privacy-mask';\nexport var PRIVACY_CLASS_MASK_USER_INPUT = 'dd-privacy-mask-user-input';\nexport var PRIVACY_CLASS_HIDDEN = 'dd-privacy-hidden';\n// Private Replacement Templates\nexport var CENSORED_STRING_MARK = '***';\nexport var CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport var FORM_PRIVATE_TAG_NAMES = {\n    INPUT: true,\n    OUTPUT: true,\n    TEXTAREA: true,\n    SELECT: true,\n    OPTION: true,\n    DATALIST: true,\n    OPTGROUP: true,\n};\n//# sourceMappingURL=constants.js.map","import { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_CLASS_ALLOW, PRIVACY_CLASS_MASK, PRIVACY_CLASS_MASK_USER_INPUT, PRIVACY_CLASS_HIDDEN, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, } from '../../constants';\nexport var MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 100000;\nimport { shouldIgnoreElement } from './serialize';\nvar TEXT_MASKING_CHAR = 'x';\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(node, defaultPrivacyLevel) {\n    var parentNodePrivacyLevel = node.parentNode\n        ? getNodePrivacyLevel(node.parentNode, defaultPrivacyLevel)\n        : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    return reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\n}\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {\n    switch (parentNodePrivacyLevel) {\n        // These values cannot be overridden\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return parentNodePrivacyLevel;\n    }\n    switch (childPrivacyLevel) {\n        case NodePrivacyLevel.ALLOW:\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.MASK_USER_INPUT:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return childPrivacyLevel;\n        default:\n            return parentNodePrivacyLevel;\n    }\n}\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node) {\n    // Only Element types can have a privacy level set\n    if (!isElement(node)) {\n        return;\n    }\n    var privAttr = node.getAttribute(PRIVACY_ATTR_NAME);\n    // Overrules for replay purpose\n    if (node.tagName === 'BASE') {\n        return NodePrivacyLevel.ALLOW;\n    }\n    // Overrules to enforce end-user protection\n    if (node.tagName === 'INPUT') {\n        var inputElement = node;\n        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n            return NodePrivacyLevel.MASK;\n        }\n        if (inputElement.type === 'hidden') {\n            return NodePrivacyLevel.MASK;\n        }\n        var autocomplete = inputElement.getAttribute('autocomplete');\n        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year]\n        if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (privAttr === PRIVACY_ATTR_VALUE_HIDDEN || node.classList.contains(PRIVACY_CLASS_HIDDEN)) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK || node.classList.contains(PRIVACY_CLASS_MASK)) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK_USER_INPUT || node.classList.contains(PRIVACY_CLASS_MASK_USER_INPUT)) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_ALLOW || node.classList.contains(PRIVACY_CLASS_ALLOW)) {\n        return NodePrivacyLevel.ALLOW;\n    }\n    if (shouldIgnoreElement(node)) {\n        return NodePrivacyLevel.IGNORE;\n    }\n}\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node, privacyLevel) {\n    switch (privacyLevel) {\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return true;\n        case NodePrivacyLevel.MASK_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isElement(node) {\n    return node.nodeType === node.ELEMENT_NODE;\n}\nfunction isTextNode(node) {\n    return node.nodeType === node.TEXT_NODE;\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    var element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport var censorText = function (text) { return text.replace(/\\S/g, TEXT_MASKING_CHAR); };\nexport function getTextContent(textNode, ignoreWhiteSpace, parentNodePrivacyLevel) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = textNode.textContent || '';\n    if (ignoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    var nodePrivacyLevel = parentNodePrivacyLevel;\n    var isStyle = parentTagName === 'STYLE' ? true : undefined;\n    var isScript = parentTagName === 'SCRIPT';\n    if (isScript) {\n        // For perf reasons, we don't record script (heuristic)\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // Should never occur, but just in case, we set to CENSORED_MARK.\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (shouldMaskNode(textNode, nodePrivacyLevel) &&\n        // Style tags are `overruled` (Use `hide` to enforce privacy)\n        !isStyle) {\n        if (\n        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n        parentTagName === 'DATALIST' ||\n            parentTagName === 'SELECT' ||\n            parentTagName === 'OPTGROUP') {\n            if (!textContent.trim()) {\n                return;\n            }\n        }\n        else if (parentTagName === 'OPTION') {\n            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n            textContent = CENSORED_STRING_MARK;\n        }\n        else {\n            textContent = censorText(textContent);\n        }\n    }\n    return textContent;\n}\n//# sourceMappingURL=privacy.js.map","import { assign } from '@datadog/browser-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, CENSORED_STRING_MARK, CENSORED_IMG_MARK, } from '../../constants';\nimport { getTextContent, shouldMaskNode, reducePrivacyLevel, getNodeSelfPrivacyLevel, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH, } from './privacy';\nimport { getSerializedNodeId, setSerializedNodeId, getElementInputValue } from './serializationUtils';\nimport { forEach } from './utils';\nexport function serializeDocument(document, defaultPrivacyLevel) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        document: document,\n        parentNodePrivacyLevel: defaultPrivacyLevel,\n    });\n}\nexport function serializeNodeWithId(node, options) {\n    var serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    var id = getSerializedNodeId(node) || generateNextId();\n    var serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, options);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, options) {\n    return {\n        type: 0 /* Document */,\n        childNodes: serializeChildNodes(document, options),\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: 1 /* DocumentType */,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serialzing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, otpion selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nexport function serializeElementNode(element, options) {\n    var _a;\n    var tagName = getValidTagName(element.tagName);\n    var isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    var nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        var _b = element.getBoundingClientRect(), width = _b.width, height = _b.height;\n        return {\n            type: 2 /* Element */,\n            tagName: tagName,\n            attributes: (_a = {\n                    rr_width: \"\".concat(width, \"px\"),\n                    rr_height: \"\".concat(height, \"px\")\n                },\n                _a[PRIVACY_ATTR_NAME] = PRIVACY_ATTR_VALUE_HIDDEN,\n                _a),\n            childNodes: [],\n            isSVG: isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    var attributes = getAttributesForPrivacyLevel(element, nodePrivacyLevel);\n    var childNodes = [];\n    if (element.childNodes.length) {\n        // OBJECT POOLING OPTIMIZATION:\n        // We should not create a new object systematically as it could impact performances. Try to reuse\n        // the same object as much as possible, and clone it only if we need to.\n        var childNodesSerializationOptions = void 0;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = assign({}, options, {\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            });\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    return {\n        type: 2 /* Element */,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\n}\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element) {\n    if (element.nodeName === 'SCRIPT') {\n        return true;\n    }\n    if (element.nodeName === 'LINK') {\n        var relAttribute = getLowerCaseAttribute('rel');\n        return (\n        // Scripts\n        (relAttribute === 'preload' && getLowerCaseAttribute('as') === 'script') ||\n            // Favicons\n            relAttribute === 'shortcut icon' ||\n            relAttribute === 'icon');\n    }\n    if (element.nodeName === 'META') {\n        var nameAttribute = getLowerCaseAttribute('name');\n        var relAttribute = getLowerCaseAttribute('rel');\n        var propertyAttribute = getLowerCaseAttribute('property');\n        return (\n        // Favicons\n        /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n            nameAttribute === 'application-name' ||\n            relAttribute === 'icon' ||\n            relAttribute === 'apple-touch-icon' ||\n            relAttribute === 'shortcut icon' ||\n            // Description\n            nameAttribute === 'keywords' ||\n            nameAttribute === 'description' ||\n            // Social\n            /^(og|twitter|fb):/.test(propertyAttribute) ||\n            /^(og|twitter):/.test(nameAttribute) ||\n            nameAttribute === 'pinterest' ||\n            // Robots\n            nameAttribute === 'robots' ||\n            nameAttribute === 'googlebot' ||\n            nameAttribute === 'bingbot' ||\n            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n            // X-Translated-By\n            element.hasAttribute('http-equiv') ||\n            // Authorship\n            nameAttribute === 'author' ||\n            nameAttribute === 'generator' ||\n            nameAttribute === 'framework' ||\n            nameAttribute === 'publisher' ||\n            nameAttribute === 'progid' ||\n            /^article:/.test(propertyAttribute) ||\n            /^product:/.test(propertyAttribute) ||\n            // Verification\n            nameAttribute === 'google-site-verification' ||\n            nameAttribute === 'yandex-verification' ||\n            nameAttribute === 'csrf-token' ||\n            nameAttribute === 'p:domain_verify' ||\n            nameAttribute === 'verify-v1' ||\n            nameAttribute === 'verification' ||\n            nameAttribute === 'shopify-checkout-api-token');\n    }\n    function getLowerCaseAttribute(name) {\n        return (element.getAttribute(name) || '').toLowerCase();\n    }\n    return false;\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, options) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (!textContent) {\n        return;\n    }\n    return {\n        type: 3 /* Text */,\n        textContent: textContent,\n        isStyle: parentTagName === 'STYLE' ? true : undefined,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: 4 /* CDATA */,\n        textContent: '',\n    };\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    forEach(node.childNodes, function (childNode) {\n        var serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    var attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' || tagName === 'SOURCE') {\n            if (attributeName === 'src' || attributeName === 'srcset') {\n                return CENSORED_IMG_MARK;\n            }\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && attributeName.indexOf('data-') === 0 && attributeName !== PRIVACY_ATTR_NAME) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (attributeValue.length > MAX_ATTRIBUTE_VALUE_CHAR_LENGTH && attributeValue.slice(0, 5) === 'data:') {\n        return 'data:truncated';\n    }\n    return attributeValue;\n}\nvar _nextId = 1;\nfunction generateNextId() {\n    return _nextId++;\n}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nfunction getValidTagName(tagName) {\n    var processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\nfunction getCssRulesString(s) {\n    try {\n        var rules = s.rules || s.cssRules;\n        return rules ? Array.from(rules).map(getCssRuleString).join('') : null;\n    }\n    catch (error) {\n        return null;\n    }\n}\nfunction getCssRuleString(rule) {\n    return isCSSImportRule(rule) ? getCssRulesString(rule.styleSheet) || '' : rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\nfunction getAttributesForPrivacyLevel(element, nodePrivacyLevel) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    var safeAttrs = {};\n    var tagName = getValidTagName(element.tagName);\n    var doc = element.ownerDocument;\n    for (var i = 0; i < element.attributes.length; i += 1) {\n        var attribute = element.attributes.item(i);\n        var attributeName = attribute.name;\n        var attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        var formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        var optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        var stylesheet = Array.from(doc.styleSheets).find(function (s) { return s.href === element.href; });\n        var cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            delete safeAttrs.rel;\n            delete safeAttrs.href;\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' &&\n        element.sheet &&\n        // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n        !(element.innerText || element.textContent || '').trim().length) {\n        var cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    var inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            safeAttrs.checked = CENSORED_STRING_MARK;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        var mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element\n     */\n    if (element.scrollLeft) {\n        safeAttrs.rr_scrollLeft = Math.round(element.scrollLeft);\n    }\n    if (element.scrollTop) {\n        safeAttrs.rr_scrollTop = Math.round(element.scrollTop);\n    }\n    return safeAttrs;\n}\n//# sourceMappingURL=serialize.js.map","import { CENSORED_STRING_MARK } from '../../constants';\nimport { shouldMaskNode } from './privacy';\nvar serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    var current = node;\n    while (current) {\n        if (!hasSerializedNode(current)) {\n            return false;\n        }\n        current = current.parentNode;\n    }\n    return true;\n}\nexport function getSerializedNodeId(node) {\n    return serializedNodeIds.get(node);\n}\nexport function setSerializedNodeId(node, serializeNodeId) {\n    serializedNodeIds.set(node, serializeNodeId);\n}\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element, nodePrivacyLevel) {\n    /*\n     BROWSER SPEC NOTE: <input>, <select>\n     For some <input> elements, the `value` is an exceptional property/attribute that has the\n     value synced between el.value and el.getAttribute()\n     input[type=button,checkbox,hidden,image,radio,reset,submit]\n     */\n    var tagName = element.tagName;\n    var value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        var type = element.type;\n        if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n            // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n            // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n            return value;\n        }\n        else if (!value || tagName === 'OPTION') {\n            // <Option> value provides no benefit\n            return;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (tagName === 'OPTION' || tagName === 'SELECT') {\n        return element.value;\n    }\n    if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n        return;\n    }\n    return value;\n}\n//# sourceMappingURL=serializationUtils.js.map","export function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\n//# sourceMappingURL=utils.js.map","export var IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport var MouseInteractions = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport var MediaInteractions = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=types.js.map","import { noop, requestIdleCallback } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nvar MUTATION_PROCESS_MAX_DELAY = 100;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(flush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { getMutationObserverConstructor } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { getNodePrivacyLevel, getTextContent } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, } from './serializationUtils';\nimport { serializeNodeWithId, serializeAttribute } from './serialize';\nimport { forEach } from './utils';\nimport { createMutationBatch } from './mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function startMutationObserver(controller, mutationCallback, defaultPrivacyLevel) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, defaultPrivacyLevel);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(document, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    controller.onFlush(mutationBatch.flush);\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n    };\n}\n/**\n * Controls how mutations are processed, allowing to flush pending mutations.\n */\nvar MutationController = /** @class */ (function () {\n    function MutationController() {\n    }\n    MutationController.prototype.flush = function () {\n        var _a;\n        (_a = this.flushListener) === null || _a === void 0 ? void 0 : _a.call(this);\n    };\n    MutationController.prototype.onFlush = function (listener) {\n        this.flushListener = listener;\n    };\n    return MutationController;\n}());\nexport { MutationController };\nfunction processMutations(mutations, mutationCallback, defaultPrivacyLevel) {\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    var filteredMutations = mutations.filter(function (mutation) {\n        return document.contains(mutation.target) &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), defaultPrivacyLevel), adds = _a.adds, removes = _a.removes, hasBeenSerialized = _a.hasBeenSerialized;\n    var texts = processCharacterDataMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'characterData' && !hasBeenSerialized(mutation.target);\n    }), defaultPrivacyLevel);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), defaultPrivacyLevel);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback({\n        adds: adds,\n        removes: removes,\n        texts: texts,\n        attributes: attributes,\n    });\n}\nfunction processChildListMutations(mutations, defaultPrivacyLevel) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    var addedAndMovedNodes = new Set();\n    var removedNodes = new Map();\n    var _loop_1 = function (mutation) {\n        forEach(mutation.addedNodes, function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        forEach(mutation.removedNodes, function (node) {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    };\n    for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        _loop_1(mutation);\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    var sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    var serializedNodeIds = new Set();\n    var addedNodeMutations = [];\n    for (var _a = 0, sortedAddedAndMovedNodes_1 = sortedAddedAndMovedNodes; _a < sortedAddedAndMovedNodes_1.length; _a++) {\n        var node = sortedAddedAndMovedNodes_1[_a];\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            document: document,\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(node.parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    var removedNodeMutations = [];\n    removedNodes.forEach(function (parent, node) {\n        if (hasSerializedNode(node)) {\n            removedNodeMutations.push({\n                parentId: getSerializedNodeId(parent),\n                id: getSerializedNodeId(node),\n            });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized: hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        var nextSibling = node.nextSibling;\n        while (nextSibling) {\n            if (hasSerializedNode(nextSibling)) {\n                return getSerializedNodeId(nextSibling);\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, defaultPrivacyLevel) {\n    var _a;\n    var textMutations = [];\n    // Deduplicate mutations based on their target node\n    var handledNodes = new Set();\n    var filteredMutations = mutations.filter(function (mutation) {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (var _i = 0, filteredMutations_1 = filteredMutations; _i < filteredMutations_1.length; _i++) {\n        var mutation = filteredMutations_1[_i];\n        var value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(mutation.target.parentNode, defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id: getSerializedNodeId(mutation.target),\n            // TODO: pass a valid \"ignoreWhiteSpace\" argument\n            value: (_a = getTextContent(mutation.target, false, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, defaultPrivacyLevel) {\n    var attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    var handledElements = new Map();\n    var filteredMutations = mutations.filter(function (mutation) {\n        var handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes === null || handledAttributes === void 0 ? void 0 : handledAttributes.has(mutation.attributeName)) {\n            return false;\n        }\n        if (!handledAttributes) {\n            handledElements.set(mutation.target, new Set([mutation.attributeName]));\n        }\n        else {\n            handledAttributes.add(mutation.attributeName);\n        }\n        return true;\n    });\n    // Emit mutations\n    var emittedMutations = new Map();\n    for (var _i = 0, filteredMutations_2 = filteredMutations; _i < filteredMutations_2.length; _i++) {\n        var mutation = filteredMutations_2[_i];\n        var uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        var privacyLevel = getNodePrivacyLevel(mutation.target, defaultPrivacyLevel);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName);\n        var transformedValue = void 0;\n        if (mutation.attributeName === 'value') {\n            var inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (attributeValue && typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        var emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = {\n                id: getSerializedNodeId(mutation.target),\n                attributes: {},\n            };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort(function (a, b) {\n        var position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\n//# sourceMappingURL=mutationObserver.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nvar TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn() {\n    var visual = window.visualViewport;\n    return (Math.abs(visual.pageTop - visual.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visual.pageLeft - visual.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visual = window.visualViewport;\n    var normalised = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visual) {\n        // On old browsers, we cannot normalise, so fallback to clientX/Y\n        return normalised;\n    }\n    else if (isVisualViewportFactoredIn()) {\n        // Typically Mobile Devices\n        normalised.layoutViewportX = Math.round(clientX + visual.offsetLeft);\n        normalised.layoutViewportY = Math.round(clientY + visual.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalised.visualViewportX = Math.round(clientX - visual.offsetLeft);\n        normalised.visualViewportY = Math.round(clientY - visual.offsetTop);\n    }\n    return normalised;\n};\nexport var getVisualViewport = function () {\n    var visual = window.visualViewport;\n    return {\n        scale: visual.scale,\n        offsetLeft: visual.offsetLeft,\n        offsetTop: visual.offsetTop,\n        pageLeft: visual.pageLeft,\n        pageTop: visual.pageTop,\n        height: visual.height,\n        width: visual.width,\n    };\n};\n// excludes the width of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getWindowWidth() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.width * visual.scale;\n    }\n    return window.innerWidth || 0;\n}\n// excludes the height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getWindowHeight() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.height * visual.scale;\n    }\n    return window.innerHeight || 0;\n}\nexport function getScrollX() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.pageLeft - visual.offsetLeft;\n    }\n    if (window.scrollX !== undefined) {\n        return window.scrollX;\n    }\n    return window.pageXOffset || 0;\n}\nexport function getScrollY() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.pageTop - visual.offsetTop;\n    }\n    if (window.scrollY !== undefined) {\n        return window.scrollY;\n    }\n    return window.pageYOffset || 0;\n}\n//# sourceMappingURL=viewports.js.map","var _a;\nimport { instrumentSetter, instrumentMethodAndCallOriginal, assign, monitor, throttle, addEventListeners, addEventListener, noop, } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { getNodePrivacyLevel, shouldMaskNode } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from './serializationUtils';\nimport { IncrementalSource, MediaInteractions, MouseInteractions } from './types';\nimport { forEach, isTouchEvent } from './utils';\nimport { startMutationObserver } from './mutationObserver';\nimport { getVisualViewport, getWindowHeight, getWindowWidth, getScrollX, getScrollY, convertMouseEventToLayoutCoordinates, } from './viewports';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function initObservers(o) {\n    var mutationHandler = initMutationObserver(o.mutationController, o.mutationCb, o.defaultPrivacyLevel);\n    var mousemoveHandler = initMoveObserver(o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.defaultPrivacyLevel);\n    var scrollHandler = initScrollObserver(o.scrollCb, o.defaultPrivacyLevel);\n    var viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb);\n    var inputHandler = initInputObserver(o.inputCb, o.defaultPrivacyLevel);\n    var mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetRuleCb);\n    var focusHandler = initFocusObserver(o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb);\n    return function () {\n        mutationHandler();\n        mousemoveHandler();\n        mouseInteractionHandler();\n        scrollHandler();\n        viewportResizeHandler();\n        inputHandler();\n        mediaInteractionHandler();\n        styleSheetObserver();\n        focusHandler();\n        visualViewportResizeHandler();\n    };\n}\nfunction initMutationObserver(mutationController, cb, defaultPrivacyLevel) {\n    return startMutationObserver(mutationController, cb, defaultPrivacyLevel).stop;\n}\nfunction initMoveObserver(cb) {\n    var updatePosition = throttle(monitor(function (event) {\n        var target = event.target;\n        if (hasSerializedNode(target)) {\n            var _a = isTouchEvent(event) ? event.changedTouches[0] : event, clientX = _a.clientX, clientY = _a.clientY;\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: clientX,\n                y: clientY,\n            };\n            if (window.visualViewport) {\n                var _b = convertMouseEventToLayoutCoordinates(clientX, clientY), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n                position.x = visualViewportX;\n                position.y = visualViewportY;\n            }\n            cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove);\n        }\n    }), MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }).throttled;\n    return addEventListeners(document, [\"mousemove\" /* MOUSE_MOVE */, \"touchmove\" /* TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nvar eventTypeToMouseInteraction = (_a = {},\n    _a[\"mouseup\" /* MOUSE_UP */] = MouseInteractions.MouseUp,\n    _a[\"mousedown\" /* MOUSE_DOWN */] = MouseInteractions.MouseDown,\n    _a[\"click\" /* CLICK */] = MouseInteractions.Click,\n    _a[\"contextmenu\" /* CONTEXT_MENU */] = MouseInteractions.ContextMenu,\n    _a[\"dblclick\" /* DBL_CLICK */] = MouseInteractions.DblClick,\n    _a[\"focus\" /* FOCUS */] = MouseInteractions.Focus,\n    _a[\"blur\" /* BLUR */] = MouseInteractions.Blur,\n    _a[\"touchstart\" /* TOUCH_START */] = MouseInteractions.TouchStart,\n    _a[\"touchend\" /* TOUCH_END */] = MouseInteractions.TouchEnd,\n    _a);\nfunction initMouseInteractionObserver(cb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = event.target;\n        if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !hasSerializedNode(target)) {\n            return;\n        }\n        var _a = isTouchEvent(event) ? event.changedTouches[0] : event, clientX = _a.clientX, clientY = _a.clientY;\n        var position = {\n            id: getSerializedNodeId(target),\n            type: eventTypeToMouseInteraction[event.type],\n            x: clientX,\n            y: clientY,\n        };\n        if (window.visualViewport) {\n            var _b = convertMouseEventToLayoutCoordinates(clientX, clientY), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n            position.x = visualViewportX;\n            position.y = visualViewportY;\n        }\n        cb(position);\n    };\n    return addEventListeners(document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nfunction initScrollObserver(cb, defaultPrivacyLevel) {\n    var updatePosition = throttle(monitor(function (event) {\n        var target = event.target;\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        if (target === document) {\n            cb({\n                id: id,\n                x: getScrollX(),\n                y: getScrollY(),\n            });\n        }\n        else {\n            cb({\n                id: id,\n                x: target.scrollLeft,\n                y: target.scrollTop,\n            });\n        }\n    }), SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(document, \"scroll\" /* SCROLL */, updatePosition, { capture: true, passive: true }).stop;\n}\nfunction initViewportResizeObserver(cb) {\n    var updateDimension = throttle(monitor(function () {\n        var height = getWindowHeight();\n        var width = getWindowWidth();\n        cb({\n            height: Number(height),\n            width: Number(width),\n        });\n    }), 200).throttled;\n    return addEventListener(window, \"resize\" /* RESIZE */, updateDimension, { capture: true, passive: true }).stop;\n}\nexport function initInputObserver(cb, defaultPrivacyLevel) {\n    var lastInputStateMap = new WeakMap();\n    function onElementChange(target) {\n        var nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        var type = target.type;\n        var inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            var value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        var name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            forEach(document.querySelectorAll(\"input[type=\\\"radio\\\"][name=\\\"\".concat(name, \"\\\"]\")), function (el) {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState) {\n        if (!hasSerializedNode(target)) {\n            return;\n        }\n        var lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            cb(assign({\n                id: getSerializedNodeId(target),\n            }, inputState));\n        }\n    }\n    var stopEventListeners = addEventListeners(document, [\"input\" /* INPUT */, \"change\" /* CHANGE */], function (event) {\n        if (event.target instanceof HTMLInputElement ||\n            event.target instanceof HTMLTextAreaElement ||\n            event.target instanceof HTMLSelectElement) {\n            onElementChange(event.target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    }).stop;\n    var instrumentationStoppers = [\n        instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n    ];\n    return function () {\n        instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); });\n        stopEventListeners();\n    };\n}\nfunction initStyleSheetObserver(cb) {\n    var restoreInsertRule = instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n        before: function (rule, index) {\n            if (hasSerializedNode(this.ownerNode)) {\n                cb({\n                    id: getSerializedNodeId(this.ownerNode),\n                    adds: [{ rule: rule, index: index }],\n                });\n            }\n        },\n    }).stop;\n    var restoreDeleteRule = instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n        before: function (index) {\n            if (hasSerializedNode(this.ownerNode)) {\n                cb({\n                    id: getSerializedNodeId(this.ownerNode),\n                    removes: [{ index: index }],\n                });\n            }\n        },\n    }).stop;\n    return function () {\n        restoreInsertRule();\n        restoreDeleteRule();\n    };\n}\nfunction initMediaInteractionObserver(mediaInteractionCb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = event.target;\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb({\n            id: getSerializedNodeId(target),\n            type: event.type === \"play\" /* PLAY */ ? MediaInteractions.Play : MediaInteractions.Pause,\n        });\n    };\n    return addEventListeners(document, [\"play\" /* PLAY */, \"pause\" /* PAUSE */], handler, { capture: true, passive: true }).stop;\n}\nfunction initFocusObserver(focusCb) {\n    return addEventListeners(window, [\"focus\" /* FOCUS */, \"blur\" /* BLUR */], function () {\n        focusCb({ has_focus: document.hasFocus() });\n    }).stop;\n}\nfunction initVisualViewportResizeObserver(cb) {\n    if (!window.visualViewport) {\n        return noop;\n    }\n    var _a = throttle(monitor(function () {\n        cb(getVisualViewport());\n    }), VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(window.visualViewport, [\"resize\" /* RESIZE */, \"scroll\" /* SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return function stop() {\n        removeListener();\n        cancelThrottle();\n    };\n}\n//# sourceMappingURL=observer.js.map","import { assign } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { serializeDocument } from './serialize';\nimport { initObservers } from './observer';\nimport { IncrementalSource } from './types';\nimport { MutationController } from './mutationObserver';\nimport { getVisualViewport, getScrollX, getScrollY, getWindowHeight, getWindowWidth } from './viewports';\nexport function record(options) {\n    var emit = options.emit;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var mutationController = new MutationController();\n    var takeFullSnapshot = function () {\n        mutationController.flush(); // process any pending mutation before taking a full snapshot\n        emit({\n            data: {\n                height: getWindowHeight(),\n                href: window.location.href,\n                width: getWindowWidth(),\n            },\n            type: RecordType.Meta,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n        });\n        emit({\n            data: {\n                node: serializeDocument(document, options.defaultPrivacyLevel),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n        });\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(),\n                type: RecordType.VisualViewport,\n            });\n        }\n    };\n    takeFullSnapshot();\n    var stopObservers = initObservers({\n        mutationController: mutationController,\n        defaultPrivacyLevel: options.defaultPrivacyLevel,\n        inputCb: function (v) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, v)); },\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (d) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, d));\n        },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: function (m) { return emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, m)); },\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetRuleCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        focusCb: function (data) {\n            return emit({\n                type: RecordType.Focus,\n                data: data,\n            });\n        },\n        visualViewportResizeCb: function (data) {\n            emit({\n                data: data,\n                type: RecordType.VisualViewport,\n            });\n        },\n    });\n    return {\n        stop: stopObservers,\n        takeFullSnapshot: takeFullSnapshot,\n        flushMutations: function () { return mutationController.flush(); },\n    };\n}\nfunction assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n    };\n}\n//# sourceMappingURL=record.js.map","import { HttpRequest, objectEntries } from '@datadog/browser-core';\nexport var SEND_BEACON_BYTE_LENGTH_LIMIT = 60000;\nexport function send(endpointBuilder, data, metadata, rawSegmentSize, flushReason) {\n    var formData = new FormData();\n    formData.append('segment', new Blob([data], {\n        type: 'application/octet-stream',\n    }), \"\".concat(metadata.session.id, \"-\").concat(metadata.start));\n    toFormEntries(metadata, function (key, value) { return formData.append(key, value); });\n    formData.append('raw_segment_size', rawSegmentSize.toString());\n    var request = new HttpRequest(endpointBuilder, SEND_BEACON_BYTE_LENGTH_LIMIT);\n    request.send(formData, data.byteLength, flushReason);\n}\nexport function toFormEntries(input, onEntry, prefix) {\n    if (prefix === void 0) { prefix = ''; }\n    objectEntries(input).forEach(function (_a) {\n        var key = _a[0], value = _a[1];\n        if (typeof value === 'object' && value !== null) {\n            toFormEntries(value, onEntry, \"\".concat(prefix).concat(key, \".\"));\n        }\n        else {\n            onEntry(\"\".concat(prefix).concat(key), String(value));\n        }\n    });\n}\n//# sourceMappingURL=send.js.map","export var MAX_STATS_HISTORY = 10;\nvar statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalRawSize) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalRawSize;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    var replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    if (statsPerView.keys) {\n        statsPerView.delete(statsPerView.keys().next().value);\n    }\n    else {\n        // IE11 doesn't support map.keys\n        var isFirst_1 = true;\n        statsPerView.forEach(function (_value, key) {\n            if (isFirst_1) {\n                statsPerView.delete(key);\n                isFirst_1 = false;\n            }\n        });\n    }\n}\n//# sourceMappingURL=replayStats.js.map","import { addMonitoringMessage, assign, monitor } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nvar nextId = 0;\nvar Segment = /** @class */ (function () {\n    function Segment(worker, context, creationReason, initialRecord, onWrote, onFlushed) {\n        var _this = this;\n        this.worker = worker;\n        this.isFlushed = false;\n        this.id = nextId++;\n        var viewId = context.view.id;\n        this.metadata = assign({\n            start: initialRecord.timestamp,\n            end: initialRecord.timestamp,\n            creation_reason: creationReason,\n            records_count: 1,\n            has_full_snapshot: initialRecord.type === RecordType.FullSnapshot,\n            index_in_view: replayStats.getSegmentsCount(viewId),\n        }, context);\n        replayStats.addSegment(viewId);\n        replayStats.addRecord(viewId);\n        var listener = monitor(function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored' || data.type === 'initialized') {\n                return;\n            }\n            if (data.id === _this.id) {\n                replayStats.addWroteData(viewId, data.additionalRawSize);\n                if (data.type === 'flushed') {\n                    onFlushed(data.result, data.rawSize);\n                    worker.removeEventListener('message', listener);\n                }\n                else {\n                    onWrote(data.compressedSize);\n                }\n            }\n            else if (data.id > _this.id) {\n                // Messages should be received in the same order as they are sent, so if we receive a\n                // message with an id superior to this Segment instance id, we know that another, more\n                // recent Segment instance is being used.\n                //\n                // In theory, a \"flush\" response should have been received at this point, so the listener\n                // should already have been removed. But if something goes wrong and we didn't receive a\n                // \"flush\" response, remove the listener to avoid any leak, and send a monitor message to\n                // help investigate the issue.\n                worker.removeEventListener('message', listener);\n                addMonitoringMessage(\"Segment did not receive a 'flush' response before being replaced.\");\n            }\n        });\n        worker.addEventListener('message', listener);\n        this.worker.postMessage({ data: \"{\\\"records\\\":[\".concat(JSON.stringify(initialRecord)), id: this.id, action: 'write' });\n    }\n    Segment.prototype.addRecord = function (record) {\n        var _a;\n        this.metadata.end = record.timestamp;\n        this.metadata.records_count += 1;\n        replayStats.addRecord(this.metadata.view.id);\n        (_a = this.metadata).has_full_snapshot || (_a.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        this.worker.postMessage({ data: \",\".concat(JSON.stringify(record)), id: this.id, action: 'write' });\n    };\n    Segment.prototype.flush = function (reason) {\n        this.worker.postMessage({\n            data: \"],\".concat(JSON.stringify(this.metadata).slice(1), \"\\n\"),\n            id: this.id,\n            action: 'flush',\n        });\n        this.isFlushed = true;\n        this.flushReason = reason;\n    };\n    return Segment;\n}());\nexport { Segment };\n//# sourceMappingURL=segment.js.map","var workerURL;\nexport function createDeflateWorker() {\n    // Lazily compute the worker URL to allow importing the SDK in NodeJS\n    if (!workerURL) {\n        workerURL = URL.createObjectURL(new Blob([\"(\".concat(workerCodeFn, \")(self)\")]));\n    }\n    return new Worker(workerURL);\n}\nfunction workerCodeFn() {\n    monitor(function () {\n        var _a = makePakoDeflate(), Deflate = _a.Deflate, constants = _a.constants, string2buf = _a.string2buf;\n        var deflate = new Deflate();\n        var rawSize = 0;\n        self.addEventListener('message', monitor(function (event) {\n            var data = event.data;\n            switch (data.action) {\n                case 'init':\n                    self.postMessage({\n                        type: 'initialized',\n                    });\n                    break;\n                case 'write': {\n                    var additionalRawSize = pushData(data.data);\n                    self.postMessage({\n                        type: 'wrote',\n                        id: data.id,\n                        compressedSize: deflate.chunks.reduce(function (total, chunk) { return total + chunk.length; }, 0),\n                        additionalRawSize: additionalRawSize,\n                    });\n                    break;\n                }\n                case 'flush': {\n                    var additionalRawSize = data.data ? pushData(data.data) : 0;\n                    deflate.push('', constants.Z_FINISH);\n                    self.postMessage({\n                        type: 'flushed',\n                        id: data.id,\n                        result: deflate.result,\n                        additionalRawSize: additionalRawSize,\n                        rawSize: rawSize,\n                    });\n                    deflate = new Deflate();\n                    rawSize = 0;\n                    break;\n                }\n            }\n        }));\n        function pushData(data) {\n            // TextEncoder is not supported on old browser version like Edge 18, therefore we use string2buf\n            var binaryData = string2buf(data);\n            deflate.push(binaryData, constants.Z_SYNC_FLUSH);\n            rawSize += binaryData.length;\n            return binaryData.length;\n        }\n    })();\n    function monitor(fn) {\n        return function () {\n            try {\n                return fn.apply(this, arguments);\n            }\n            catch (e) {\n                try {\n                    self.postMessage({\n                        type: 'errored',\n                        error: e,\n                    });\n                }\n                catch (_) {\n                    // DATA_CLONE_ERR, cf https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n                    self.postMessage({\n                        type: 'errored',\n                        error: \"\".concat(e),\n                    });\n                }\n            }\n        };\n    }\n    // https://github.com/nodeca/pako/blob/034669ba0f1a4c0590e45f7c2820128200f972b3/dist/pako_deflate.es5.js\n    function makePakoDeflate() {\n        /* eslint-disable camelcase, no-bitwise */\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        // const Z_FILTERED          = 1;\n        // const Z_HUFFMAN_ONLY      = 2;\n        // const Z_RLE               = 3;\n        var Z_FIXED = 4; // const Z_DEFAULT_STRATEGY  = 0;\n        /* Possible values of the data_type field (though see inflate()) */\n        var Z_BINARY = 0;\n        var Z_TEXT = 1; // const Z_ASCII             = 1; // = Z_TEXT\n        var Z_UNKNOWN = 2;\n        /* ============================================================================ */\n        function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        } // From zutil.h\n        var STORED_BLOCK = 0;\n        var STATIC_TREES = 1;\n        var DYN_TREES = 2;\n        /* The three kinds of block type */\n        var MIN_MATCH = 3;\n        var MAX_MATCH = 258;\n        /* The minimum and maximum match lengths */\n        // From deflate.h\n        /* ===========================================================================\n         * Internal compression state.\n         */\n        var LENGTH_CODES = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES = LITERALS + 1 + LENGTH_CODES;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES = 30;\n        /* number of distance codes */\n        var BL_CODES = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE = 2 * L_CODES + 1;\n        /* maximum heap size */\n        var MAX_BITS = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var Buf_size = 16;\n        /* size of bit buffer in bi_buf */\n        /* ===========================================================================\n         * Constants\n         */\n        var MAX_BL_BITS = 7;\n        /* Bit length codes must not exceed MAX_BL_BITS bits */\n        var END_BLOCK = 256;\n        /* end of block literal code */\n        var REP_3_6 = 16;\n        /* repeat previous bit length 3-6 times (2 bits of repeat count) */\n        var REPZ_3_10 = 17;\n        /* repeat a zero length 3-10 times  (3 bits of repeat count) */\n        var REPZ_11_138 = 18;\n        /* repeat a zero length 11-138 times  (7 bits of repeat count) */\n        var extra_lbits = \n        /* extra bits for each length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);\n        var extra_dbits = \n        /* extra bits for each distance code */\n        new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);\n        var extra_blbits = \n        /* extra bits for each bit length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);\n        var bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n        /* eslint-enable comma-spacing,array-bracket-spacing */\n        /* The lengths of the bit length codes are sent in order of decreasing\n         * probability, to avoid transmitting the lengths for unused bit length codes.\n         */\n        /* ===========================================================================\n         * Local data. These are initialized only once.\n         */\n        // We pre-fill arrays with 0 to avoid uninitialized gaps\n        var DIST_CODE_LEN = 512;\n        /* see definition of array dist_code below */\n        // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\n        var static_ltree = new Array((L_CODES + 2) * 2);\n        zero(static_ltree);\n        /* The static literal tree. Since the bit lengths are imposed, there is no\n         * need for the L_CODES extra codes used during heap construction. However\n         * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n         * below).\n         */\n        var static_dtree = new Array(D_CODES * 2);\n        zero(static_dtree);\n        /* The static distance tree. (Actually a trivial tree since all codes use\n         * 5 bits.)\n         */\n        var _dist_code = new Array(DIST_CODE_LEN);\n        zero(_dist_code);\n        /* Distance codes. The first 256 values correspond to the distances\n         * 3 .. 258, the last 256 values correspond to the top 8 bits of\n         * the 15 bit distances.\n         */\n        var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);\n        zero(_length_code);\n        /* length code for each normalized match length (0 == MIN_MATCH) */\n        var base_length = new Array(LENGTH_CODES);\n        zero(base_length);\n        /* First normalized length for each code (0 = MIN_MATCH) */\n        var base_dist = new Array(D_CODES);\n        zero(base_dist);\n        /* First normalized distance for each code (0 = distance of 1) */\n        function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n            this.static_tree = static_tree;\n            /* static tree or NULL */\n            this.extra_bits = extra_bits;\n            /* extra bits for each code or NULL */\n            this.extra_base = extra_base;\n            /* base index for extra_bits */\n            this.elems = elems;\n            /* max number of elements in the tree */\n            this.max_length = max_length;\n            /* max bit length for the codes */\n            // show if `static_tree` has data or dummy - needed for monomorphic objects\n            this.has_stree = static_tree && static_tree.length;\n        }\n        var static_l_desc;\n        var static_d_desc;\n        var static_bl_desc;\n        function TreeDesc(dyn_tree, stat_desc) {\n            this.dyn_tree = dyn_tree;\n            /* the dynamic tree */\n            this.max_code = 0;\n            /* largest code with non zero frequency */\n            this.stat_desc = stat_desc;\n            /* the corresponding static tree */\n        }\n        var d_code = function d_code(dist) {\n            return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n        };\n        /* ===========================================================================\n         * Output a short LSB first on the stream.\n         * IN assertion: there is enough room in pendingBuf.\n         */\n        var put_short = function put_short(s, w) {\n            //    put_byte(s, (uch)((w) & 0xff));\n            //    put_byte(s, (uch)((ush)(w) >> 8));\n            s.pending_buf[s.pending++] = w & 0xff;\n            s.pending_buf[s.pending++] = (w >>> 8) & 0xff;\n        };\n        /* ===========================================================================\n         * Send a value on a given number of bits.\n         * IN assertion: length <= 16 and value fits in length bits.\n         */\n        var send_bits = function send_bits(s, value, length) {\n            if (s.bi_valid > Buf_size - length) {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                put_short(s, s.bi_buf);\n                s.bi_buf = value >> (Buf_size - s.bi_valid);\n                s.bi_valid += length - Buf_size;\n            }\n            else {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                s.bi_valid += length;\n            }\n        };\n        var send_code = function send_code(s, c, tree) {\n            send_bits(s, tree[c * 2], \n            /* .Code */\n            tree[c * 2 + 1]\n            /* .Len */\n            );\n        };\n        /* ===========================================================================\n         * Reverse the first len bits of a code, using straightforward code (a faster\n         * method would use a table)\n         * IN assertion: 1 <= len <= 15\n         */\n        var bi_reverse = function bi_reverse(code, len) {\n            var res = 0;\n            do {\n                res |= code & 1;\n                code >>>= 1;\n                res <<= 1;\n            } while (--len > 0);\n            return res >>> 1;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer, keeping at most 7 bits in it.\n         */\n        var bi_flush = function bi_flush(s) {\n            if (s.bi_valid === 16) {\n                put_short(s, s.bi_buf);\n                s.bi_buf = 0;\n                s.bi_valid = 0;\n            }\n            else if (s.bi_valid >= 8) {\n                s.pending_buf[s.pending++] = s.bi_buf & 0xff;\n                s.bi_buf >>= 8;\n                s.bi_valid -= 8;\n            }\n        };\n        /* ===========================================================================\n         * Compute the optimal bit lengths for a tree and update the total bit length\n         * for the current block.\n         * IN assertion: the fields freq and dad are set, heap[heap_max] and\n         *    above are the tree nodes sorted by increasing frequency.\n         * OUT assertions: the field len is set to the optimal bit length, the\n         *     array bl_count contains the frequencies for each bit length.\n         *     The length opt_len is updated; static_len is also updated if stree is\n         *     not null.\n         */\n        var gen_bitlen = function gen_bitlen(s, desc //    deflate_state *s; //    tree_desc *desc;    /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var max_code = desc.max_code;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var extra = desc.stat_desc.extra_bits;\n            var base = desc.stat_desc.extra_base;\n            var max_length = desc.stat_desc.max_length;\n            var h;\n            /* heap index */\n            var n;\n            var m;\n            /* iterate over the tree elements */\n            var bits;\n            /* bit length */\n            var xbits;\n            /* extra bits */\n            var f;\n            /* frequency */\n            var overflow = 0;\n            /* number of elements with bit length too large */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                s.bl_count[bits] = 0;\n            }\n            /* In a first pass, compute the optimal bit lengths (which may\n             * overflow in the case of the bit length tree).\n             */\n            tree[s.heap[s.heap_max] * 2 + 1] =\n                /* .Len */\n                0;\n            /* root of the heap */\n            for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n                n = s.heap[h];\n                bits =\n                    tree[tree[n * 2 + 1] *\n                        /* .Dad */\n                        2 +\n                        1] +\n                        /* .Len */\n                        1;\n                if (bits > max_length) {\n                    bits = max_length;\n                    overflow++;\n                }\n                tree[n * 2 + 1] =\n                    /* .Len */\n                    bits;\n                /* We overwrite tree[n].Dad which is no longer needed */\n                if (n > max_code) {\n                    continue;\n                }\n                /* not a leaf node */\n                s.bl_count[bits]++;\n                xbits = 0;\n                if (n >= base) {\n                    xbits = extra[n - base];\n                }\n                f = tree[n * 2];\n                /* .Freq */\n                s.opt_len += f * (bits + xbits);\n                if (has_stree) {\n                    s.static_len +=\n                        f *\n                            (stree[n * 2 + 1] +\n                                /* .Len */\n                                xbits);\n                }\n            }\n            if (overflow === 0) {\n                return;\n            } // Trace((stderr,\"\\nbit length overflow\\n\"));\n            /* This happens for example on obj2 and pic of the Calgary corpus */\n            /* Find the first bit length which could increase: */\n            do {\n                bits = max_length - 1;\n                while (s.bl_count[bits] === 0) {\n                    bits--;\n                }\n                s.bl_count[bits]--;\n                /* move one leaf down the tree */\n                s.bl_count[bits + 1] += 2;\n                /* move one overflow item as its brother */\n                s.bl_count[max_length]--;\n                /* The brother of the overflow item also moves one step up,\n                 * but this does not affect bl_count[max_length]\n                 */\n                overflow -= 2;\n            } while (overflow > 0);\n            /* Now recompute all bit lengths, scanning in increasing frequency.\n             * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n             * lengths instead of fixing only the wrong ones. This idea is taken\n             * from 'ar' written by Haruhiko Okumura.)\n             */\n            for (bits = max_length; bits !== 0; bits--) {\n                n = s.bl_count[bits];\n                while (n !== 0) {\n                    m = s.heap[--h];\n                    if (m > max_code) {\n                        continue;\n                    }\n                    if (tree[m * 2 + 1] !==\n                        /* .Len */\n                        bits) {\n                        // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n                        s.opt_len +=\n                            (bits - tree[m * 2 + 1]) *\n                                /* .Len */\n                                tree[m * 2];\n                        /* .Freq */\n                        tree[m * 2 + 1] =\n                            /* .Len */\n                            bits;\n                    }\n                    n--;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Generate the codes for a given tree and bit counts (which need not be\n         * optimal).\n         * IN assertion: the array bl_count contains the bit length statistics for\n         * the given tree and the field len is set for all tree elements.\n         * OUT assertion: the field code is set for all tree elements of non\n         *     zero code length.\n         */\n        var gen_codes = function gen_codes(tree, max_code, bl_count\n        //    ct_data *tree;             /* the tree to decorate */\n        //    int max_code;              /* largest code with non zero frequency */\n        //    ushf *bl_count;            /* number of codes at each bit length */\n        ) {\n            var next_code = new Array(MAX_BITS + 1);\n            /* next code value for each bit length */\n            var code = 0;\n            /* running code value */\n            var bits;\n            /* bit index */\n            var n;\n            /* code index */\n            /* The distribution counts are first used to generate the code values\n             * without bit reversal.\n             */\n            for (bits = 1; bits <= MAX_BITS; bits++) {\n                next_code[bits] = code = (code + bl_count[bits - 1]) << 1;\n            }\n            /* Check that the bit counts in bl_count are consistent. The last code\n             * must be all ones.\n             */\n            // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n            //        \"inconsistent bit counts\");\n            // Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n            for (n = 0; n <= max_code; n++) {\n                var len = tree[n * 2 + 1];\n                /* .Len */\n                if (len === 0) {\n                    continue;\n                }\n                /* Now reverse the bits */\n                tree[n * 2] =\n                    /* .Code */\n                    bi_reverse(next_code[len]++, len); // Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n                //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n            }\n        };\n        /* ===========================================================================\n         * Initialize the various 'constant' tables.\n         */\n        var tr_static_init = function tr_static_init() {\n            var n;\n            /* iterates over tree elements */\n            var bits;\n            /* bit counter */\n            var length;\n            /* length value */\n            var code;\n            /* code value */\n            var dist;\n            /* distance index */\n            var bl_count = new Array(MAX_BITS + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // do check in _tr_init()\n            // if (static_init_done) return;\n            /* For some embedded targets, global variables are not initialized: */\n            /* #ifdef NO_INIT_GLOBAL_POINTERS\n            static_l_desc.static_tree = static_ltree;\n            static_l_desc.extra_bits = extra_lbits;\n            static_d_desc.static_tree = static_dtree;\n            static_d_desc.extra_bits = extra_dbits;\n            static_bl_desc.extra_bits = extra_blbits;\n          #endif */\n            /* Initialize the mapping length (0..255) -> length code (0..28) */\n            length = 0;\n            for (code = 0; code < LENGTH_CODES - 1; code++) {\n                base_length[code] = length;\n                for (n = 0; n < 1 << extra_lbits[code]; n++) {\n                    _length_code[length++] = code;\n                }\n            } // Assert (length == 256, \"tr_static_init: length != 256\");\n            /* Note that the length 255 (match length 258) can be represented\n             * in two different ways: code 284 + 5 bits or code 285, so we\n             * overwrite length_code[255] to use the best encoding:\n             */\n            _length_code[length - 1] = code;\n            /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n            dist = 0;\n            for (code = 0; code < 16; code++) {\n                base_dist[code] = dist;\n                for (n = 0; n < 1 << extra_dbits[code]; n++) {\n                    _dist_code[dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: dist != 256\");\n            dist >>= 7;\n            /* from now on, all distances are divided by 128 */\n            for (; code < D_CODES; code++) {\n                base_dist[code] = dist << 7;\n                for (n = 0; n < 1 << (extra_dbits[code] - 7); n++) {\n                    _dist_code[256 + dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n            /* Construct the codes of the static literal tree */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                bl_count[bits] = 0;\n            }\n            n = 0;\n            while (n <= 143) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            while (n <= 255) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    9;\n                n++;\n                bl_count[9]++;\n            }\n            while (n <= 279) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    7;\n                n++;\n                bl_count[7]++;\n            }\n            while (n <= 287) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            /* Codes 286 and 287 do not exist, but we must include them in the\n             * tree construction to get a canonical Huffman tree (longest code\n             * all ones)\n             */\n            gen_codes(static_ltree, L_CODES + 1, bl_count);\n            /* The static distance tree is trivial: */\n            for (n = 0; n < D_CODES; n++) {\n                static_dtree[n * 2 + 1] =\n                    /* .Len */\n                    5;\n                static_dtree[n * 2] =\n                    /* .Code */\n                    bi_reverse(n, 5);\n            } // Now data ready and we can init static trees\n            static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);\n            static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);\n            static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);\n            // static_init_done = true;\n        };\n        /* ===========================================================================\n         * Initialize a new block.\n         */\n        var init_block = function init_block(s) {\n            var n;\n            /* iterates over tree elements */\n            /* Initialize the trees. */\n            for (n = 0; n < L_CODES; n++) {\n                s.dyn_ltree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < D_CODES; n++) {\n                s.dyn_dtree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < BL_CODES; n++) {\n                s.bl_tree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            s.dyn_ltree[END_BLOCK * 2] =\n                /* .Freq */\n                1;\n            s.opt_len = s.static_len = 0;\n            s.last_lit = s.matches = 0;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer and align the output on a byte boundary\n         */\n        var bi_windup = function bi_windup(s) {\n            if (s.bi_valid > 8) {\n                put_short(s, s.bi_buf);\n            }\n            else if (s.bi_valid > 0) {\n                // put_byte(s, (Byte)s->bi_buf);\n                s.pending_buf[s.pending++] = s.bi_buf;\n            }\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n        };\n        /* ===========================================================================\n         * Copy a stored block, storing first the length and its\n         * one's complement if requested.\n         */\n        var copy_block = function copy_block(s, buf, len, header\n        // DeflateState *s;\n        // charf    *buf;    /* the input data */\n        // unsigned len;     /* its length */\n        // int      header;  /* true if block header must be written */\n        ) {\n            bi_windup(s);\n            /* align on byte boundary */\n            if (header) {\n                put_short(s, len);\n                put_short(s, ~len);\n            }\n            //  while (len--) {\n            //    put_byte(s, *buf++);\n            //  }\n            s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending);\n            s.pending += len;\n        };\n        /* ===========================================================================\n         * Compares to subtrees, using the tree depth as tie breaker when\n         * the subtrees have equal frequency. This minimizes the worst case length.\n         */\n        var smaller = function smaller(tree, n, m, depth) {\n            var _n2 = n * 2;\n            var _m2 = m * 2;\n            return (tree[_n2] <\n                /* .Freq */\n                tree[_m2] ||\n                /* .Freq */\n                (tree[_n2] ===\n                    /* .Freq */\n                    tree[_m2] &&\n                    /* .Freq */\n                    depth[n] <= depth[m]));\n        };\n        /* ===========================================================================\n         * Restore the heap property by moving down the tree starting at node k,\n         * exchanging a node with the smallest of its two sons if necessary, stopping\n         * when the heap property is re-established (each father smaller than its\n         * two sons).\n         */\n        var pqdownheap = function pqdownheap(s, tree, k\n        //    deflate_state *s;\n        //    ct_data *tree;  /* the tree to restore */\n        //    int k;               /* node to move down */\n        ) {\n            var v = s.heap[k];\n            var j = k << 1;\n            /* left son of k */\n            while (j <= s.heap_len) {\n                /* Set j to the smallest of the two sons: */\n                if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n                    j++;\n                }\n                /* Exit if v is smaller than both sons */\n                if (smaller(tree, v, s.heap[j], s.depth)) {\n                    break;\n                }\n                /* Exchange v with the smallest son */\n                s.heap[k] = s.heap[j];\n                k = j;\n                /* And continue down the tree, setting j to the left son of k */\n                j <<= 1;\n            }\n            s.heap[k] = v;\n        }; // inlined manually\n        // const SMALLEST = 1;\n        /* ===========================================================================\n         * Send the block data compressed using the given Huffman trees\n         */\n        var compress_block = function compress_block(s, ltree, dtree\n        //    deflate_state *s;\n        //    const ct_data *ltree; /* literal tree */\n        //    const ct_data *dtree; /* distance tree */\n        ) {\n            var dist;\n            /* distance of matched string */\n            var lc;\n            /* match length or unmatched char (if dist == 0) */\n            var lx = 0;\n            /* running index in l_buf */\n            var code;\n            /* the code to send */\n            var extra;\n            /* number of extra bits to send */\n            if (s.last_lit !== 0) {\n                do {\n                    dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | s.pending_buf[s.d_buf + lx * 2 + 1];\n                    lc = s.pending_buf[s.l_buf + lx];\n                    lx++;\n                    if (dist === 0) {\n                        send_code(s, lc, ltree);\n                        /* send a literal byte */\n                        // Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n                    }\n                    else {\n                        /* Here, lc is the match length - MIN_MATCH */\n                        code = _length_code[lc];\n                        send_code(s, code + LITERALS + 1, ltree);\n                        /* send the length code */\n                        extra = extra_lbits[code];\n                        if (extra !== 0) {\n                            lc -= base_length[code];\n                            send_bits(s, lc, extra);\n                            /* send the extra length bits */\n                        }\n                        dist--;\n                        /* dist is now the match distance - 1 */\n                        code = d_code(dist); // Assert (code < D_CODES, \"bad d_code\");\n                        send_code(s, code, dtree);\n                        /* send the distance code */\n                        extra = extra_dbits[code];\n                        if (extra !== 0) {\n                            dist -= base_dist[code];\n                            send_bits(s, dist, extra);\n                            /* send the extra distance bits */\n                        }\n                    }\n                    /* literal or match pair ? */\n                    /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n                    // Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n                    //       \"pendingBuf overflow\");\n                } while (lx < s.last_lit);\n            }\n            send_code(s, END_BLOCK, ltree);\n        };\n        /* ===========================================================================\n         * Construct one Huffman tree and assigns the code bit strings and lengths.\n         * Update the total bit length for the current block.\n         * IN assertion: the field freq is set for all tree elements.\n         * OUT assertions: the fields len and code are set to the optimal bit length\n         *     and corresponding code. The length opt_len is updated; static_len is\n         *     also updated if stree is not null. The field max_code is set.\n         */\n        var build_tree = function build_tree(s, desc //    deflate_state *s; //    tree_desc *desc; /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var elems = desc.stat_desc.elems;\n            var n;\n            var m;\n            /* iterate over heap elements */\n            var max_code = -1;\n            /* largest code with non zero frequency */\n            var node;\n            /* new node being created */\n            /* Construct the initial heap, with least frequent element in\n             * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n             * heap[0] is not used.\n             */\n            s.heap_len = 0;\n            s.heap_max = HEAP_SIZE;\n            for (n = 0; n < elems; n++) {\n                if (tree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    s.heap[++s.heap_len] = max_code = n;\n                    s.depth[n] = 0;\n                }\n                else {\n                    tree[n * 2 + 1] =\n                        /* .Len */\n                        0;\n                }\n            }\n            /* The pkzip format requires that at least one distance code exists,\n             * and that at least one bit should be sent even if there is only one\n             * possible code. So to avoid special checks later on we force at least\n             * two codes of non zero frequency.\n             */\n            while (s.heap_len < 2) {\n                node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;\n                tree[node * 2] =\n                    /* .Freq */\n                    1;\n                s.depth[node] = 0;\n                s.opt_len--;\n                if (has_stree) {\n                    s.static_len -= stree[node * 2 + 1];\n                    /* .Len */\n                }\n                /* node is 0 or 1 so it does not have extra bits */\n            }\n            desc.max_code = max_code;\n            /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n             * establish sub-heaps of increasing lengths:\n             */\n            for (n = s.heap_len >> 1; \n            /* int /2 */\n            n >= 1; n--) {\n                pqdownheap(s, tree, n);\n            }\n            /* Construct the Huffman tree by repeatedly combining the least two\n             * frequent nodes.\n             */\n            node = elems;\n            /* next internal node of the tree */\n            do {\n                // pqremove(s, tree, n);  /* n = node of least frequency */\n                /** * pqremove ** */\n                n = s.heap[1];\n                /* SMALLEST */\n                s.heap[1] = s.heap[s.heap_len--];\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n                /***/\n                m = s.heap[1];\n                /* SMALLEST */\n                /* m = node of next least frequency */\n                s.heap[--s.heap_max] = n;\n                /* keep the nodes sorted by frequency */\n                s.heap[--s.heap_max] = m;\n                /* Create a new node father of n and m */\n                tree[node * 2] =\n                    /* .Freq */\n                    tree[n * 2] +\n                        /* .Freq */\n                        tree[m * 2];\n                /* .Freq */\n                s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n                tree[n * 2 + 1] =\n                    /* .Dad */\n                    tree[m * 2 + 1] =\n                        /* .Dad */\n                        node;\n                /* and insert the new node in the heap */\n                s.heap[1] = node++;\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n            } while (s.heap_len >= 2);\n            s.heap[--s.heap_max] = s.heap[1];\n            /* SMALLEST */\n            /* At this point, the fields freq and dad are set. We can now\n             * generate the bit lengths.\n             */\n            gen_bitlen(s, desc);\n            /* The field len is now set, we can generate the bit codes */\n            gen_codes(tree, max_code, s.bl_count);\n        };\n        /* ===========================================================================\n         * Scan a literal or distance tree to determine the frequencies of the codes\n         * in the bit length tree.\n         */\n        var scan_tree = function scan_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree;   /* the tree to be scanned */\n        //    int max_code;    /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            tree[(max_code + 1) * 2 + 1] =\n                /* .Len */\n                0xffff;\n            /* guard */\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    s.bl_tree[curlen * 2] +=\n                        /* .Freq */\n                        count;\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        s.bl_tree[curlen * 2] /* .Freq */++;\n                    }\n                    s.bl_tree[REP_3_6 * 2] /* .Freq */++;\n                }\n                else if (count <= 10) {\n                    s.bl_tree[REPZ_3_10 * 2] /* .Freq */++;\n                }\n                else {\n                    s.bl_tree[REPZ_11_138 * 2] /* .Freq */++;\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Send a literal or distance tree in compressed form, using the codes in\n         * bl_tree.\n         */\n        var send_tree = function send_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree; /* the tree to be scanned */\n        //    int max_code;       /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            /* tree[max_code+1].Len = -1; */\n            /* guard already set */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    do {\n                        send_code(s, curlen, s.bl_tree);\n                    } while (--count !== 0);\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        send_code(s, curlen, s.bl_tree);\n                        count--;\n                    } // Assert(count >= 3 && count <= 6, \" 3_6?\");\n                    send_code(s, REP_3_6, s.bl_tree);\n                    send_bits(s, count - 3, 2);\n                }\n                else if (count <= 10) {\n                    send_code(s, REPZ_3_10, s.bl_tree);\n                    send_bits(s, count - 3, 3);\n                }\n                else {\n                    send_code(s, REPZ_11_138, s.bl_tree);\n                    send_bits(s, count - 11, 7);\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Construct the Huffman tree for the bit lengths and return the index in\n         * bl_order of the last bit length code to send.\n         */\n        var build_bl_tree = function build_bl_tree(s) {\n            var max_blindex;\n            /* index of last bit length code of non zero freq */\n            /* Determine the bit length frequencies for literal and distance trees */\n            scan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n            scan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n            /* Build the bit length tree: */\n            build_tree(s, s.bl_desc);\n            /* opt_len now includes the length of the tree representations, except\n             * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n             */\n            /* Determine the number of bit length codes to send. The pkzip format\n             * requires that at least 4 bit length codes be sent. (appnote.txt says\n             * 3 but the actual value used is 4.)\n             */\n            for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n                if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !==\n                    /* .Len */\n                    0) {\n                    break;\n                }\n            }\n            /* Update opt_len to include the bit length tree and counts */\n            s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; // Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n            //        s->opt_len, s->static_len));\n            return max_blindex;\n        };\n        /* ===========================================================================\n         * Send the header for a block using dynamic Huffman trees: the counts, the\n         * lengths of the bit length codes, the literal tree and the distance tree.\n         * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n         */\n        var send_all_trees = function send_all_trees(s, lcodes, dcodes, blcodes //    deflate_state *s; //    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n        ) {\n            var rank;\n            /* index in bl_order */\n            // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n            // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n            //        \"too many codes\");\n            // Tracev((stderr, \"\\nbl counts: \"));\n            send_bits(s, lcodes - 257, 5);\n            /* not +255 as stated in appnote.txt */\n            send_bits(s, dcodes - 1, 5);\n            send_bits(s, blcodes - 4, 4);\n            /* not -3 as stated in appnote.txt */\n            for (rank = 0; rank < blcodes; rank++) {\n                // Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n                send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], \n                /* .Len */\n                3);\n            } // Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_ltree, lcodes - 1);\n            /* literal tree */\n            // Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_dtree, dcodes - 1);\n            /* distance tree */\n            // Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n        };\n        /* ===========================================================================\n         * Check if the data type is TEXT or BINARY, using the following algorithm:\n         * - TEXT if the two conditions below are satisfied:\n         *    a) There are no non-portable control characters belonging to the\n         *       \"black list\" (0..6, 14..25, 28..31).\n         *    b) There is at least one printable character belonging to the\n         *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n         * - BINARY otherwise.\n         * - The following partially-portable control characters form a\n         *   \"gray list\" that is ignored in this detection algorithm:\n         *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n         * IN assertion: the fields Freq of dyn_ltree are set.\n         */\n        var detect_data_type = function detect_data_type(s) {\n            /* black_mask is the bit mask of black-listed bytes\n             * set bits 0..6, 14..25, and 28..31\n             * 0xf3ffc07f = binary 11110011111111111100000001111111\n             */\n            var black_mask = 0xf3ffc07f;\n            var n;\n            /* Check for non-textual (\"black-listed\") bytes. */\n            for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n                if (black_mask & 1 &&\n                    s.dyn_ltree[n * 2] !==\n                        /* .Freq */\n                        0) {\n                    return Z_BINARY;\n                }\n            }\n            /* Check for textual (\"white-listed\") bytes. */\n            if (s.dyn_ltree[9 * 2] !==\n                /* .Freq */\n                0 ||\n                s.dyn_ltree[10 * 2] !==\n                    /* .Freq */\n                    0 ||\n                s.dyn_ltree[13 * 2] !==\n                    /* .Freq */\n                    0) {\n                return Z_TEXT;\n            }\n            for (n = 32; n < LITERALS; n++) {\n                if (s.dyn_ltree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    return Z_TEXT;\n                }\n            }\n            /* There are no \"black-listed\" or \"white-listed\" bytes:\n             * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n             */\n            return Z_BINARY;\n        };\n        var static_init_done = false;\n        /* ===========================================================================\n         * Initialize the tree data structures for a new zlib stream.\n         */\n        var _tr_init = function _tr_init(s) {\n            if (!static_init_done) {\n                tr_static_init();\n                static_init_done = true;\n            }\n            s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);\n            s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);\n            s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n            /* Initialize the first block of the first file: */\n            init_block(s);\n        };\n        /* ===========================================================================\n         * Send a stored block\n         */\n        var _tr_stored_block = function _tr_stored_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);\n            /* send block type */\n            copy_block(s, buf, stored_len, true);\n            /* with header */\n        };\n        /* ===========================================================================\n         * Send one empty static block to give enough lookahead for inflate.\n         * This takes 10 bits, of which 7 may remain in the bit buffer.\n         */\n        var _tr_align = function _tr_align(s) {\n            send_bits(s, STATIC_TREES << 1, 3);\n            send_code(s, END_BLOCK, static_ltree);\n            bi_flush(s);\n        };\n        /* ===========================================================================\n         * Determine the best encoding for the current block: dynamic trees, static\n         * trees or store, and output the encoded block to the zip file.\n         */\n        var _tr_flush_block = function _tr_flush_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block, or NULL if too old */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            var opt_lenb;\n            var static_lenb;\n            /* opt_len and static_len in bytes */\n            var max_blindex = 0;\n            /* index of last bit length code of non zero freq */\n            /* Build the Huffman trees unless a stored block is forced */\n            if (s.level > 0) {\n                /* Check if the file is binary or text */\n                if (s.strm.data_type === Z_UNKNOWN) {\n                    s.strm.data_type = detect_data_type(s);\n                }\n                /* Construct the literal and distance trees */\n                build_tree(s, s.l_desc); // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                build_tree(s, s.d_desc); // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                /* At this point, opt_len and static_len are the total bit lengths of\n                 * the compressed block data, excluding the tree representations.\n                 */\n                /* Build the bit length tree for the above two trees, and get the index\n                 * in bl_order of the last bit length code to send.\n                 */\n                max_blindex = build_bl_tree(s);\n                /* Determine the best encoding. Compute the block lengths in bytes. */\n                opt_lenb = (s.opt_len + 3 + 7) >>> 3;\n                static_lenb = (s.static_len + 3 + 7) >>> 3; // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n                //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n                //        s->last_lit));\n                if (static_lenb <= opt_lenb) {\n                    opt_lenb = static_lenb;\n                }\n            }\n            else {\n                // Assert(buf != (char*)0, \"lost buf\");\n                opt_lenb = static_lenb = stored_len + 5;\n                /* force a stored block */\n            }\n            if (stored_len + 4 <= opt_lenb && buf !== -1) {\n                /* 4: two words for the lengths */\n                /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n                 * Otherwise we can't have processed more than WSIZE input bytes since\n                 * the last block flush, because compression would have been\n                 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n                 * transform a block into a stored block.\n                 */\n                _tr_stored_block(s, buf, stored_len, last);\n            }\n            else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n                send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n                compress_block(s, static_ltree, static_dtree);\n            }\n            else {\n                send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n                send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n                compress_block(s, s.dyn_ltree, s.dyn_dtree);\n            } // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n            /* The above check is made mod 2^32, for files larger than 512 MB\n             * and uLong implemented on 32 bits.\n             */\n            init_block(s);\n            if (last) {\n                bi_windup(s);\n            } // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n            //       s->compressed_len-7*last));\n        };\n        /* ===========================================================================\n         * Save the match info and tally the frequency counts. Return true if\n         * the current block must be flushed.\n         */\n        var _tr_tally = function _tr_tally(s, dist, lc\n        //    deflate_state *s;\n        //    unsigned dist;  /* distance of matched string */\n        //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n        ) {\n            // let out_length, in_length, dcode;\n            s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;\n            s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;\n            s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;\n            s.last_lit++;\n            if (dist === 0) {\n                /* lc is the unmatched char */\n                s.dyn_ltree[lc * 2] /* .Freq */++;\n            }\n            else {\n                s.matches++;\n                /* Here, lc is the match length - MIN_MATCH */\n                dist--;\n                /* dist = match distance - 1 */\n                // Assert((ush)dist < (ush)MAX_DIST(s) &&\n                //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n                //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n                s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /* .Freq */++;\n                s.dyn_dtree[d_code(dist) * 2] /* .Freq */++;\n            } // (!) This block is disabled in zlib defaults,\n            // don't enable it for binary compatibility\n            // #ifdef TRUNCATE_BLOCK\n            //  /* Try to guess if it is profitable to stop the current block here */\n            //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n            //    /* Compute an upper bound for the compressed length */\n            //    out_length = s.last_lit*8;\n            //    in_length = s.strstart - s.block_start;\n            //\n            //    for (dcode = 0; dcode < D_CODES; dcode++) {\n            //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n            //    }\n            //    out_length >>>= 3;\n            //    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n            //    //       s->last_lit, in_length, out_length,\n            //    //       100L - out_length*100L/in_length));\n            //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n            //      return true;\n            //    }\n            //  }\n            // #endif\n            return s.last_lit === s.lit_bufsize - 1;\n            /* We avoid equality with lit_bufsize because of wraparound at 64K\n             * on 16 bit machines and because stored blocks are restricted to\n             * 64K-1 bytes.\n             */\n        };\n        var _tr_init_1 = _tr_init;\n        var _tr_stored_block_1 = _tr_stored_block;\n        var _tr_flush_block_1 = _tr_flush_block;\n        var _tr_tally_1 = _tr_tally;\n        var _tr_align_1 = _tr_align;\n        var trees = {\n            _tr_init: _tr_init_1,\n            _tr_stored_block: _tr_stored_block_1,\n            _tr_flush_block: _tr_flush_block_1,\n            _tr_tally: _tr_tally_1,\n            _tr_align: _tr_align_1,\n        };\n        // It isn't worth it to make additional optimizations as in original.\n        // Small size is preferable.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var adler32 = function adler32(adler, buf, len, pos) {\n            var s1 = (adler & 0xffff) | 0;\n            var s2 = ((adler >>> 16) & 0xffff) | 0;\n            var n = 0;\n            while (len !== 0) {\n                // Set limit ~ twice less than 5552, to keep\n                // s2 in 31-bits, because we force signed ints.\n                // in other case %= will fail.\n                n = len > 2000 ? 2000 : len;\n                len -= n;\n                do {\n                    s1 = (s1 + buf[pos++]) | 0;\n                    s2 = (s2 + s1) | 0;\n                } while (--n);\n                s1 %= 65521;\n                s2 %= 65521;\n            }\n            return s1 | (s2 << 16) | 0;\n        };\n        var adler32_1 = adler32;\n        // So write code to minimize size - no pregenerated tables\n        // and array tools dependencies.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        // Use ordinary array, since untyped makes no boost here\n        var makeTable = function makeTable() {\n            var c;\n            var table = [];\n            for (var n = 0; n < 256; n++) {\n                c = n;\n                for (var k = 0; k < 8; k++) {\n                    c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n                }\n                table[n] = c;\n            }\n            return table;\n        }; // Create table on load. Just 255 signed longs. Not a problem.\n        var crcTable = new Uint32Array(makeTable());\n        var crc32 = function crc32(crc, buf, len, pos) {\n            var t = crcTable;\n            var end = pos + len;\n            crc ^= -1;\n            for (var i = pos; i < end; i++) {\n                crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xff];\n            }\n            return crc ^ -1; // >>> 0;\n        };\n        var crc32_1 = crc32;\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var messages = {\n            2: 'need dictionary',\n            /* Z_NEED_DICT       2  */\n            1: 'stream end',\n            /* Z_STREAM_END      1  */\n            0: '',\n            /* Z_OK              0  */\n            '-1': 'file error',\n            /* Z_ERRNO         (-1) */\n            '-2': 'stream error',\n            /* Z_STREAM_ERROR  (-2) */\n            '-3': 'data error',\n            /* Z_DATA_ERROR    (-3) */\n            '-4': 'insufficient memory',\n            /* Z_MEM_ERROR     (-4) */\n            '-5': 'buffer error',\n            /* Z_BUF_ERROR     (-5) */\n            '-6': 'incompatible version',\n            /* Z_VERSION_ERROR (-6) */\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var constants = {\n            /* Allowed flush values; see deflate() and inflate() below for details */\n            Z_NO_FLUSH: 0,\n            Z_PARTIAL_FLUSH: 1,\n            Z_SYNC_FLUSH: 2,\n            Z_FULL_FLUSH: 3,\n            Z_FINISH: 4,\n            Z_BLOCK: 5,\n            Z_TREES: 6,\n            /* Return codes for the compression/decompression functions. Negative values\n             * are errors, positive values are used for special but normal events.\n             */\n            Z_OK: 0,\n            Z_STREAM_END: 1,\n            Z_NEED_DICT: 2,\n            Z_ERRNO: -1,\n            Z_STREAM_ERROR: -2,\n            Z_DATA_ERROR: -3,\n            Z_MEM_ERROR: -4,\n            Z_BUF_ERROR: -5,\n            // Z_VERSION_ERROR: -6,\n            /* compression levels */\n            Z_NO_COMPRESSION: 0,\n            Z_BEST_SPEED: 1,\n            Z_BEST_COMPRESSION: 9,\n            Z_DEFAULT_COMPRESSION: -1,\n            Z_FILTERED: 1,\n            Z_HUFFMAN_ONLY: 2,\n            Z_RLE: 3,\n            Z_FIXED: 4,\n            Z_DEFAULT_STRATEGY: 0,\n            /* Possible values of the data_type field (though see inflate()) */\n            Z_BINARY: 0,\n            Z_TEXT: 1,\n            // Z_ASCII:                1, // = Z_TEXT (deprecated)\n            Z_UNKNOWN: 2,\n            /* The deflate compression method */\n            Z_DEFLATED: 8, // Z_NULL:                 null // Use -1 or null inline, depending on var type\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var _tr_init$1 = trees._tr_init;\n        var _tr_stored_block$1 = trees._tr_stored_block;\n        var _tr_flush_block$1 = trees._tr_flush_block;\n        var _tr_tally$1 = trees._tr_tally;\n        var _tr_align$1 = trees._tr_align;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH = constants.Z_NO_FLUSH;\n        var Z_PARTIAL_FLUSH = constants.Z_PARTIAL_FLUSH;\n        var Z_FULL_FLUSH = constants.Z_FULL_FLUSH;\n        var Z_FINISH = constants.Z_FINISH;\n        var Z_BLOCK = constants.Z_BLOCK;\n        var Z_OK = constants.Z_OK;\n        var Z_STREAM_END = constants.Z_STREAM_END;\n        var Z_STREAM_ERROR = constants.Z_STREAM_ERROR;\n        var Z_DATA_ERROR = constants.Z_DATA_ERROR;\n        var Z_BUF_ERROR = constants.Z_BUF_ERROR;\n        var Z_DEFAULT_COMPRESSION = constants.Z_DEFAULT_COMPRESSION;\n        var Z_FILTERED = constants.Z_FILTERED;\n        var Z_HUFFMAN_ONLY = constants.Z_HUFFMAN_ONLY;\n        var Z_RLE = constants.Z_RLE;\n        var Z_FIXED$1 = constants.Z_FIXED;\n        var Z_DEFAULT_STRATEGY = constants.Z_DEFAULT_STRATEGY;\n        var Z_UNKNOWN$1 = constants.Z_UNKNOWN;\n        var Z_DEFLATED = constants.Z_DEFLATED;\n        /* ============================================================================ */\n        var MAX_MEM_LEVEL = 9;\n        /* Maximum value for memLevel in deflateInit2 */\n        var MAX_WBITS = 15;\n        /* 32K LZ77 window */\n        var DEF_MEM_LEVEL = 8;\n        var LENGTH_CODES$1 = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS$1 = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES$1 = 30;\n        /* number of distance codes */\n        var BL_CODES$1 = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE$1 = 2 * L_CODES$1 + 1;\n        /* maximum heap size */\n        var MAX_BITS$1 = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var MIN_MATCH$1 = 3;\n        var MAX_MATCH$1 = 258;\n        var MIN_LOOKAHEAD = MAX_MATCH$1 + MIN_MATCH$1 + 1;\n        var PRESET_DICT = 0x20;\n        var INIT_STATE = 42;\n        var EXTRA_STATE = 69;\n        var NAME_STATE = 73;\n        var COMMENT_STATE = 91;\n        var HCRC_STATE = 103;\n        var BUSY_STATE = 113;\n        var FINISH_STATE = 666;\n        var BS_NEED_MORE = 1;\n        /* block not completed, need more input or more output */\n        var BS_BLOCK_DONE = 2;\n        /* block flush performed */\n        var BS_FINISH_STARTED = 3;\n        /* finish started, need only more output at next deflate */\n        var BS_FINISH_DONE = 4;\n        /* finish done, accept no more input or output */\n        var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n        var err = function err(strm, errorCode) {\n            strm.msg = messages[errorCode];\n            return errorCode;\n        };\n        var rank = function rank(f) {\n            return (f << 1) - (f > 4 ? 9 : 0);\n        };\n        var zero$1 = function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        };\n        var HASH_ZLIB = function HASH_ZLIB(s, prev, data) {\n            return ((prev << s.hash_shift) ^ data) & s.hash_mask;\n        }; // This hash causes less collisions, https://github.com/nodeca/pako/issues/135\n        // But breaks binary compatibility\n        // let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;\n        var HASH = HASH_ZLIB;\n        /* =========================================================================\n         * Flush as much pending output as possible. All deflate() output goes\n         * through this function so some applications may wish to modify it\n         * to avoid allocating a large strm->output buffer and copying into it.\n         * (See also read_buf()).\n         */\n        var flush_pending = function flush_pending(strm) {\n            var s = strm.state; // _tr_flush_bits(s);\n            var len = s.pending;\n            if (len > strm.avail_out) {\n                len = strm.avail_out;\n            }\n            if (len === 0) {\n                return;\n            }\n            strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);\n            strm.next_out += len;\n            s.pending_out += len;\n            strm.total_out += len;\n            strm.avail_out -= len;\n            s.pending -= len;\n            if (s.pending === 0) {\n                s.pending_out = 0;\n            }\n        };\n        var flush_block_only = function flush_block_only(s, last) {\n            _tr_flush_block$1(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);\n            s.block_start = s.strstart;\n            flush_pending(s.strm);\n        };\n        var put_byte = function put_byte(s, b) {\n            s.pending_buf[s.pending++] = b;\n        };\n        /* =========================================================================\n         * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n         * IN assertion: the stream state is correct and there is enough room in\n         * pending_buf.\n         */\n        var putShortMSB = function putShortMSB(s, b) {\n            //  put_byte(s, (Byte)(b >> 8));\n            //  put_byte(s, (Byte)(b & 0xff));\n            s.pending_buf[s.pending++] = (b >>> 8) & 0xff;\n            s.pending_buf[s.pending++] = b & 0xff;\n        };\n        /* ===========================================================================\n         * Read a new buffer from the current input stream, update the adler32\n         * and total number of bytes read.  All deflate() input goes through\n         * this function so some applications may wish to modify it to avoid\n         * allocating a large strm->input buffer and copying from it.\n         * (See also flush_pending()).\n         */\n        var read_buf = function read_buf(strm, buf, start, size) {\n            var len = strm.avail_in;\n            if (len > size) {\n                len = size;\n            }\n            if (len === 0) {\n                return 0;\n            }\n            strm.avail_in -= len; // zmemcpy(buf, strm->next_in, len);\n            buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);\n            if (strm.state.wrap === 1) {\n                strm.adler = adler32_1(strm.adler, buf, len, start);\n            }\n            else if (strm.state.wrap === 2) {\n                strm.adler = crc32_1(strm.adler, buf, len, start);\n            }\n            strm.next_in += len;\n            strm.total_in += len;\n            return len;\n        };\n        /* ===========================================================================\n         * Set match_start to the longest match starting at the given string and\n         * return its length. Matches shorter or equal to prev_length are discarded,\n         * in which case the result is equal to prev_length and match_start is\n         * garbage.\n         * IN assertions: cur_match is the head of the hash chain for the current\n         *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n         * OUT assertion: the match length is not greater than s->lookahead.\n         */\n        var longest_match = function longest_match(s, cur_match) {\n            var chain_length = s.max_chain_length;\n            /* max hash chain length */\n            var scan = s.strstart;\n            /* current string */\n            var match;\n            /* matched string */\n            var len;\n            /* length of current match */\n            var best_len = s.prev_length;\n            /* best match length so far */\n            var nice_match = s.nice_match;\n            /* stop if match long enough */\n            var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;\n            /* NIL */\n            var _win = s.window; // shortcut\n            var wmask = s.w_mask;\n            var prev = s.prev;\n            /* Stop when cur_match becomes <= limit. To simplify the code,\n             * we prevent matches with the string of window index 0.\n             */\n            var strend = s.strstart + MAX_MATCH$1;\n            var scan_end1 = _win[scan + best_len - 1];\n            var scan_end = _win[scan + best_len];\n            /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n             * It is easy to get rid of this optimization if necessary.\n             */\n            // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n            /* Do not waste too much time if we already have a good match: */\n            if (s.prev_length >= s.good_match) {\n                chain_length >>= 2;\n            }\n            /* Do not look for matches beyond the end of the input. This is necessary\n             * to make deflate deterministic.\n             */\n            if (nice_match > s.lookahead) {\n                nice_match = s.lookahead;\n            } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n            do {\n                // Assert(cur_match < s->strstart, \"no future\");\n                match = cur_match;\n                /* Skip to next match if the match length cannot increase\n                 * or if the match length is less than 2.  Note that the checks below\n                 * for insufficient lookahead only occur occasionally for performance\n                 * reasons.  Therefore uninitialized memory will be accessed, and\n                 * conditional jumps will be made that depend on those values.\n                 * However the length of the match is limited to the lookahead, so\n                 * the output of deflate is not affected by the uninitialized values.\n                 */\n                if (_win[match + best_len] !== scan_end ||\n                    _win[match + best_len - 1] !== scan_end1 ||\n                    _win[match] !== _win[scan] ||\n                    _win[++match] !== _win[scan + 1]) {\n                    continue;\n                }\n                /* The check at best_len-1 can be removed because it will be made\n                 * again later. (This heuristic is not always a win.)\n                 * It is not necessary to compare scan[2] and match[2] since they\n                 * are always equal when the other bytes match, given that\n                 * the hash keys are equal and that HASH_BITS >= 8.\n                 */\n                scan += 2;\n                match++; // Assert(*scan == *match, \"match[2]?\");\n                /* We check for insufficient lookahead only every 8th comparison;\n                 * the 256th check will be made at strstart+258.\n                 */\n                do {\n                    /* jshint noempty:false */\n                } while (_win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    scan < strend); // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n                len = MAX_MATCH$1 - (strend - scan);\n                scan = strend - MAX_MATCH$1;\n                if (len > best_len) {\n                    s.match_start = cur_match;\n                    best_len = len;\n                    if (len >= nice_match) {\n                        break;\n                    }\n                    scan_end1 = _win[scan + best_len - 1];\n                    scan_end = _win[scan + best_len];\n                }\n            } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n            if (best_len <= s.lookahead) {\n                return best_len;\n            }\n            return s.lookahead;\n        };\n        /* ===========================================================================\n         * Fill the window when the lookahead becomes insufficient.\n         * Updates strstart and lookahead.\n         *\n         * IN assertion: lookahead < MIN_LOOKAHEAD\n         * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n         *    At least one byte has been read, or avail_in == 0; reads are\n         *    performed for at least two bytes (required for the zip translate_eol\n         *    option -- not supported here).\n         */\n        var fill_window = function fill_window(s) {\n            var _w_size = s.w_size;\n            var p;\n            var n;\n            var m;\n            var more;\n            var str; // Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n            do {\n                more = s.window_size - s.lookahead - s.strstart; // JS ints have 32 bit, block below not needed\n                /* Deal with !@#$% 64K limit: */\n                // if (sizeof(int) <= 2) {\n                //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n                //        more = wsize;\n                //\n                //  } else if (more == (unsigned)(-1)) {\n                //        /* Very unlikely, but possible on 16 bit machine if\n                //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n                //         */\n                //        more--;\n                //    }\n                // }\n                /* If the window is almost full and there is insufficient lookahead,\n                 * move the upper half to the lower one to make room in the upper half.\n                 */\n                if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n                    s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0);\n                    s.match_start -= _w_size;\n                    s.strstart -= _w_size;\n                    /* we now have strstart >= MAX_DIST */\n                    s.block_start -= _w_size;\n                    /* Slide the hash table (could be avoided with 32 bit values\n                   at the expense of memory usage). We slide even when level == 0\n                   to keep the hash table consistent if we switch back to level > 0\n                   later. (Using level 0 permanently is not an optimal usage of\n                   zlib, so we don't care about this pathological case.)\n                   */\n                    n = s.hash_size;\n                    p = n;\n                    do {\n                        m = s.head[--p];\n                        s.head[p] = m >= _w_size ? m - _w_size : 0;\n                    } while (--n);\n                    n = _w_size;\n                    p = n;\n                    do {\n                        m = s.prev[--p];\n                        s.prev[p] = m >= _w_size ? m - _w_size : 0;\n                        /* If n is not on any hash chain, prev[n] is garbage but\n                         * its value will never be used.\n                         */\n                    } while (--n);\n                    more += _w_size;\n                }\n                if (s.strm.avail_in === 0) {\n                    break;\n                }\n                /* If there was no sliding:\n                 *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n                 *    more == window_size - lookahead - strstart\n                 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n                 * => more >= window_size - 2*WSIZE + 2\n                 * In the BIG_MEM or MMAP case (not yet supported),\n                 *   window_size == input_size + MIN_LOOKAHEAD  &&\n                 *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n                 * Otherwise, window_size == 2*WSIZE so more >= 2.\n                 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n                 */\n                // Assert(more >= 2, \"more < 2\");\n                n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n                s.lookahead += n;\n                /* Initialize the hash value now that we have some input: */\n                if (s.lookahead + s.insert >= MIN_MATCH$1) {\n                    str = s.strstart - s.insert;\n                    s.ins_h = s.window[str];\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + 1]); // #if MIN_MATCH != 3\n                    //        Call update_hash() MIN_MATCH-3 more times\n                    // #endif\n                    while (s.insert) {\n                        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                        s.prev[str & s.w_mask] = s.head[s.ins_h];\n                        s.head[s.ins_h] = str;\n                        str++;\n                        s.insert--;\n                        if (s.lookahead + s.insert < MIN_MATCH$1) {\n                            break;\n                        }\n                    }\n                }\n                /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n                 * but this is not important since only literal bytes will be emitted.\n                 */\n            } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n            /* If the WIN_INIT bytes after the end of the current data have never been\n             * written, then zero those bytes in order to avoid memory check reports of\n             * the use of uninitialized (or uninitialised as Julian writes) bytes by\n             * the longest match routines.  Update the high water mark for the next\n             * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n             * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n             */\n            //  if (s.high_water < s.window_size) {\n            //    const curr = s.strstart + s.lookahead;\n            //    let init = 0;\n            //\n            //    if (s.high_water < curr) {\n            //      /* Previous high water mark below current data -- zero WIN_INIT\n            //       * bytes or up to end of window, whichever is less.\n            //       */\n            //      init = s.window_size - curr;\n            //      if (init > WIN_INIT)\n            //        init = WIN_INIT;\n            //      zmemzero(s->window + curr, (unsigned)init);\n            //      s->high_water = curr + init;\n            //    }\n            //    else if (s->high_water < (ulg)curr + WIN_INIT) {\n            //      /* High water mark at or above current data, but below current data\n            //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n            //       * to end of window, whichever is less.\n            //       */\n            //      init = (ulg)curr + WIN_INIT - s->high_water;\n            //      if (init > s->window_size - s->high_water)\n            //        init = s->window_size - s->high_water;\n            //      zmemzero(s->window + s->high_water, (unsigned)init);\n            //      s->high_water += init;\n            //    }\n            //  }\n            //\n            //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n            //    \"not enough room for search\");\n        };\n        /* ===========================================================================\n         * Copy without compression as much as possible from the input stream, return\n         * the current block state.\n         * This function does not insert new strings in the dictionary since\n         * uncompressible data is probably not useful. This function is used\n         * only for the level=0 compression option.\n         * NOTE: this function should be optimized to avoid extra copying from\n         * window to pending_buf.\n         */\n        var deflate_stored = function deflate_stored(s, flush) {\n            /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n             * to pending_buf_size, and each stored block has a 5 byte header:\n             */\n            var max_block_size = 0xffff;\n            if (max_block_size > s.pending_buf_size - 5) {\n                max_block_size = s.pending_buf_size - 5;\n            }\n            /* Copy as much as possible from input to output: */\n            for (;;) {\n                /* Fill the window as much as possible: */\n                if (s.lookahead <= 1) {\n                    // Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n                    //  s->block_start >= (long)s->w_size, \"slide too late\");\n                    //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n                    //        s.block_start >= s.w_size)) {\n                    //        throw  new Error(\"slide too late\");\n                    //      }\n                    fill_window(s);\n                    if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                } // Assert(s->block_start >= 0L, \"block gone\");\n                //    if (s.block_start < 0) throw new Error(\"block gone\");\n                s.strstart += s.lookahead;\n                s.lookahead = 0;\n                /* Emit a stored block if pending_buf will be full: */\n                var max_start = s.block_start + max_block_size;\n                if (s.strstart === 0 || s.strstart >= max_start) {\n                    /* strstart == 0 is possible when wraparound on 16-bit machine */\n                    s.lookahead = s.strstart - max_start;\n                    s.strstart = max_start;\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n                /* Flush if we may have to slide, otherwise block_start may become\n                 * negative and the data will be gone:\n                 */\n                if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.strstart > s.block_start) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_NEED_MORE;\n        };\n        /* ===========================================================================\n         * Compress as much as possible from the input stream, return the current\n         * block state.\n         * This function does not perform lazy evaluation of matches and inserts\n         * new strings in the dictionary only for unmatched strings or for short\n         * matches. It is used only for the fast compression options.\n         */\n        var deflate_fast = function deflate_fast(s, flush) {\n            var hash_head;\n            /* head of the hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 * At this point we have always match_length < MIN_MATCH\n                 */\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                }\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n                    /** * _tr_tally_dist(s, s.strstart - s.match_start,\n                                 s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    /* Insert new strings in the hash table only if the match length\n                     * is not too large. This saves time but degrades compression.\n                     */\n                    if (s.match_length <= s.max_lazy_match &&\n                        /* max_insert_length */\n                        s.lookahead >= MIN_MATCH$1) {\n                        s.match_length--;\n                        /* string at strstart already in table */\n                        do {\n                            s.strstart++;\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                            /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n                             * always MIN_MATCH bytes ahead.\n                             */\n                        } while (--s.match_length !== 0);\n                        s.strstart++;\n                    }\n                    else {\n                        s.strstart += s.match_length;\n                        s.match_length = 0;\n                        s.ins_h = s.window[s.strstart];\n                        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]); // #if MIN_MATCH != 3\n                        //                Call UPDATE_HASH() MIN_MATCH-3 more times\n                        // #endif\n                        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n                         * matter since it will be recomputed at next deflate call.\n                         */\n                    }\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s.window[s.strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * Same as above, but achieves better compression. We use a lazy\n         * evaluation for matches: a match is finally adopted only if there is\n         * no better match at the next window position.\n         */\n        var deflate_slow = function deflate_slow(s, flush) {\n            var hash_head;\n            /* head of hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            var max_insert;\n            /* Process the input block. */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 */\n                s.prev_length = s.match_length;\n                s.prev_match = s.match_start;\n                s.match_length = MIN_MATCH$1 - 1;\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.prev_length < s.max_lazy_match &&\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n                /* MAX_DIST(s) */\n                ) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                    if (s.match_length <= 5 &&\n                        (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096))\n                    /* TOO_FAR */\n                    ) {\n                        /* If prev_match is also MIN_MATCH, match_start is garbage\n                         * but we will ignore the current match anyway.\n                         */\n                        s.match_length = MIN_MATCH$1 - 1;\n                    }\n                }\n                /* If there was a match at the previous step and the current\n                 * match is not better, output the previous match:\n                 */\n                if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {\n                    max_insert = s.strstart + s.lookahead - MIN_MATCH$1;\n                    /* Do not insert strings in hash table beyond this. */\n                    // check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n                    /** *_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                                 s.prev_length - MIN_MATCH, bflush);** */\n                    bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1);\n                    /* Insert in hash table all strings up to the end of the match.\n                     * strstart-1 and strstart are already inserted. If there is not\n                     * enough lookahead, the last two strings are not inserted in\n                     * the hash table.\n                     */\n                    s.lookahead -= s.prev_length - 1;\n                    s.prev_length -= 2;\n                    do {\n                        if (++s.strstart <= max_insert) {\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                        }\n                    } while (--s.prev_length !== 0);\n                    s.match_available = 0;\n                    s.match_length = MIN_MATCH$1 - 1;\n                    s.strstart++;\n                    if (bflush) {\n                        /** * FLUSH_BLOCK(s, 0); ** */\n                        flush_block_only(s, false);\n                        if (s.strm.avail_out === 0) {\n                            return BS_NEED_MORE;\n                        }\n                        /***/\n                    }\n                }\n                else if (s.match_available) {\n                    /* If there was no match at the previous position, output a\n                     * single literal. If there was a match but the current match\n                     * is longer, truncate the previous match to a single literal.\n                     */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                    if (bflush) {\n                        /** * FLUSH_BLOCK_ONLY(s, 0) ** */\n                        flush_block_only(s, false);\n                        /***/\n                    }\n                    s.strstart++;\n                    s.lookahead--;\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                }\n                else {\n                    /* There is no previous match to compare with, wait for\n                     * the next step to decide.\n                     */\n                    s.match_available = 1;\n                    s.strstart++;\n                    s.lookahead--;\n                }\n            } // Assert (flush != Z_NO_FLUSH, \"no flush?\");\n            if (s.match_available) {\n                // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                s.match_available = 0;\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n         * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n         * deflate switches away from Z_RLE.)\n         */\n        var deflate_rle = function deflate_rle(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            var prev;\n            /* byte at distance one to match */\n            var scan;\n            var strend;\n            /* scan goes up to strend for length of run */\n            var _win = s.window;\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the longest run, plus one for the unrolled loop.\n                 */\n                if (s.lookahead <= MAX_MATCH$1) {\n                    fill_window(s);\n                    if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* See how many times the previous byte repeats */\n                s.match_length = 0;\n                if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {\n                    scan = s.strstart - 1;\n                    prev = _win[scan];\n                    if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n                        strend = s.strstart + MAX_MATCH$1;\n                        do {\n                            /* jshint noempty:false */\n                        } while (prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            scan < strend);\n                        s.match_length = MAX_MATCH$1 - (strend - scan);\n                        if (s.match_length > s.lookahead) {\n                            s.match_length = s.lookahead;\n                        }\n                    } // Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n                }\n                /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.strstart - 1, s.match_length);\n                    /** * _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    s.strstart += s.match_length;\n                    s.match_length = 0;\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n         * (It will be regenerated if this run of deflate switches away from Huffman.)\n         */\n        var deflate_huff = function deflate_huff(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we have a literal to write. */\n                if (s.lookahead === 0) {\n                    fill_window(s);\n                    if (s.lookahead === 0) {\n                        if (flush === Z_NO_FLUSH) {\n                            return BS_NEED_MORE;\n                        }\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Output a literal byte */\n                s.match_length = 0; // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                s.lookahead--;\n                s.strstart++;\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* Values for max_lazy_match, good_match and max_chain_length, depending on\n         * the desired pack level (0..9). The values given below have been tuned to\n         * exclude worst case performance for pathological files. Better values may be\n         * found for specific files.\n         */\n        function Config(good_length, max_lazy, nice_length, max_chain, func) {\n            this.good_length = good_length;\n            this.max_lazy = max_lazy;\n            this.nice_length = nice_length;\n            this.max_chain = max_chain;\n            this.func = func;\n        }\n        var configuration_table = [\n            /*      good lazy nice chain */\n            new Config(0, 0, 0, 0, deflate_stored),\n            /* 0 store only */\n            new Config(4, 4, 8, 4, deflate_fast),\n            /* 1 max speed, no lazy matches */\n            new Config(4, 5, 16, 8, deflate_fast),\n            /* 2 */\n            new Config(4, 6, 32, 32, deflate_fast),\n            /* 3 */\n            new Config(4, 4, 16, 16, deflate_slow),\n            /* 4 lazy matches */\n            new Config(8, 16, 32, 32, deflate_slow),\n            /* 5 */\n            new Config(8, 16, 128, 128, deflate_slow),\n            /* 6 */\n            new Config(8, 32, 128, 256, deflate_slow),\n            /* 7 */\n            new Config(32, 128, 258, 1024, deflate_slow),\n            /* 8 */\n            new Config(32, 258, 258, 4096, deflate_slow),\n            /* 9 max compression */\n        ];\n        /* ===========================================================================\n         * Initialize the \"longest match\" routines for a new zlib stream\n         */\n        var lm_init = function lm_init(s) {\n            s.window_size = 2 * s.w_size;\n            /** * CLEAR_HASH(s); ** */\n            zero$1(s.head); // Fill with NIL (= 0);\n            /* Set the default configuration parameters:\n             */\n            s.max_lazy_match = configuration_table[s.level].max_lazy;\n            s.good_match = configuration_table[s.level].good_length;\n            s.nice_match = configuration_table[s.level].nice_length;\n            s.max_chain_length = configuration_table[s.level].max_chain;\n            s.strstart = 0;\n            s.block_start = 0;\n            s.lookahead = 0;\n            s.insert = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            s.ins_h = 0;\n        };\n        function DeflateState() {\n            this.strm = null;\n            /* pointer back to this zlib stream */\n            this.status = 0;\n            /* as the name implies */\n            this.pending_buf = null;\n            /* output still pending */\n            this.pending_buf_size = 0;\n            /* size of pending_buf */\n            this.pending_out = 0;\n            /* next pending byte to output to the stream */\n            this.pending = 0;\n            /* nb of bytes in the pending buffer */\n            this.wrap = 0;\n            /* bit 0 true for zlib, bit 1 true for gzip */\n            this.gzhead = null;\n            /* gzip header information to write */\n            this.gzindex = 0;\n            /* where in extra, name, or comment */\n            this.method = Z_DEFLATED;\n            /* can only be DEFLATED */\n            this.last_flush = -1;\n            /* value of flush param for previous deflate call */\n            this.w_size = 0;\n            /* LZ77 window size (32K by default) */\n            this.w_bits = 0;\n            /* log2(w_size)  (8..16) */\n            this.w_mask = 0;\n            /* w_size - 1 */\n            this.window = null;\n            /* Sliding window. Input bytes are read into the second half of the window,\n             * and move to the first half later to keep a dictionary of at least wSize\n             * bytes. With this organization, matches are limited to a distance of\n             * wSize-MAX_MATCH bytes, but this ensures that IO is always\n             * performed with a length multiple of the block size.\n             */\n            this.window_size = 0;\n            /* Actual size of window: 2*wSize, except when the user input buffer\n             * is directly used as sliding window.\n             */\n            this.prev = null;\n            /* Link to older string with same hash index. To limit the size of this\n             * array to 64K, this link is maintained only for the last 32K strings.\n             * An index in this array is thus a window index modulo 32K.\n             */\n            this.head = null;\n            /* Heads of the hash chains or NIL. */\n            this.ins_h = 0;\n            /* hash index of string to be inserted */\n            this.hash_size = 0;\n            /* number of elements in hash table */\n            this.hash_bits = 0;\n            /* log2(hash_size) */\n            this.hash_mask = 0;\n            /* hash_size-1 */\n            this.hash_shift = 0;\n            /* Number of bits by which ins_h must be shifted at each input\n             * step. It must be such that after MIN_MATCH steps, the oldest\n             * byte no longer takes part in the hash key, that is:\n             *   hash_shift * MIN_MATCH >= hash_bits\n             */\n            this.block_start = 0;\n            /* Window position at the beginning of the current output block. Gets\n             * negative when the window is moved backwards.\n             */\n            this.match_length = 0;\n            /* length of best match */\n            this.prev_match = 0;\n            /* previous match */\n            this.match_available = 0;\n            /* set if previous match exists */\n            this.strstart = 0;\n            /* start of string to insert */\n            this.match_start = 0;\n            /* start of matching string */\n            this.lookahead = 0;\n            /* number of valid bytes ahead in window */\n            this.prev_length = 0;\n            /* Length of the best match at previous step. Matches not greater than this\n             * are discarded. This is used in the lazy match evaluation.\n             */\n            this.max_chain_length = 0;\n            /* To speed up deflation, hash chains are never searched beyond this\n             * length.  A higher limit improves compression ratio but degrades the\n             * speed.\n             */\n            this.max_lazy_match = 0;\n            /* Attempt to find a better match only when the current match is strictly\n             * smaller than this value. This mechanism is used only for compression\n             * levels >= 4.\n             */\n            // That's alias to max_lazy_match, don't use directly\n            // this.max_insert_length = 0;\n            /* Insert new strings in the hash table only if the match length is not\n             * greater than this length. This saves time but degrades compression.\n             * max_insert_length is used only for compression levels <= 3.\n             */\n            this.level = 0;\n            /* compression level (1..9) */\n            this.strategy = 0;\n            /* favor or force Huffman coding */\n            this.good_match = 0;\n            /* Use a faster search when the previous match is longer than this */\n            this.nice_match = 0;\n            /* Stop searching when current match exceeds this */\n            /* used by trees.c: */\n            /* Didn't use ct_data typedef below to suppress compiler warning */\n            // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n            // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n            // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n            // Use flat array of DOUBLE size, with interleaved fata,\n            // because JS does not support effective\n            this.dyn_ltree = new Uint16Array(HEAP_SIZE$1 * 2);\n            this.dyn_dtree = new Uint16Array((2 * D_CODES$1 + 1) * 2);\n            this.bl_tree = new Uint16Array((2 * BL_CODES$1 + 1) * 2);\n            zero$1(this.dyn_ltree);\n            zero$1(this.dyn_dtree);\n            zero$1(this.bl_tree);\n            this.l_desc = null;\n            /* desc. for literal tree */\n            this.d_desc = null;\n            /* desc. for distance tree */\n            this.bl_desc = null;\n            /* desc. for bit length tree */\n            // ush bl_count[MAX_BITS+1];\n            this.bl_count = new Uint16Array(MAX_BITS$1 + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n            this.heap = new Uint16Array(2 * L_CODES$1 + 1);\n            /* heap used to build the Huffman trees */\n            zero$1(this.heap);\n            this.heap_len = 0;\n            /* number of elements in the heap */\n            this.heap_max = 0;\n            /* element of largest frequency */\n            /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n             * The same heap array is used to build all trees.\n             */\n            this.depth = new Uint16Array(2 * L_CODES$1 + 1); // uch depth[2*L_CODES+1];\n            zero$1(this.depth);\n            /* Depth of each subtree used as tie breaker for trees of equal frequency\n             */\n            this.l_buf = 0;\n            /* buffer index for literals or lengths */\n            this.lit_bufsize = 0;\n            /* Size of match buffer for literals/lengths.  There are 4 reasons for\n             * limiting lit_bufsize to 64K:\n             *   - frequencies can be kept in 16 bit counters\n             *   - if compression is not successful for the first block, all input\n             *     data is still in the window so we can still emit a stored block even\n             *     when input comes from standard input.  (This can also be done for\n             *     all blocks if lit_bufsize is not greater than 32K.)\n             *   - if compression is not successful for a file smaller than 64K, we can\n             *     even emit a stored file instead of a stored block (saving 5 bytes).\n             *     This is applicable only for zip (not gzip or zlib).\n             *   - creating new Huffman trees less frequently may not provide fast\n             *     adaptation to changes in the input data statistics. (Take for\n             *     example a binary file with poorly compressible code followed by\n             *     a highly compressible string table.) Smaller buffer sizes give\n             *     fast adaptation but have of course the overhead of transmitting\n             *     trees more frequently.\n             *   - I can't count above 4\n             */\n            this.last_lit = 0;\n            /* running index in l_buf */\n            this.d_buf = 0;\n            /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n             * the same number of elements. To use different lengths, an extra flag\n             * array would be necessary.\n             */\n            this.opt_len = 0;\n            /* bit length of current block with optimal trees */\n            this.static_len = 0;\n            /* bit length of current block with static trees */\n            this.matches = 0;\n            /* number of string matches in current block */\n            this.insert = 0;\n            /* bytes at end of window left to insert */\n            this.bi_buf = 0;\n            /* Output buffer. bits are inserted starting at the bottom (least\n             * significant bits).\n             */\n            this.bi_valid = 0;\n            /* Number of valid bits in bi_buf.  All bits above the last valid bit\n             * are always zero.\n             */\n            // Used for window memory init. We safely ignore it for JS. That makes\n            // sense only for pointers and memory check tools.\n            // this.high_water = 0;\n            /* High water mark offset in window for initialized bytes -- bytes above\n             * this are set to zero in order to avoid memory check warnings when\n             * longest match routines access bytes past the input.  This is then\n             * updated to the new high water mark.\n             */\n        }\n        var deflateResetKeep = function deflateResetKeep(strm) {\n            if (!strm || !strm.state) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.total_in = strm.total_out = 0;\n            strm.data_type = Z_UNKNOWN$1;\n            var s = strm.state;\n            s.pending = 0;\n            s.pending_out = 0;\n            if (s.wrap < 0) {\n                s.wrap = -s.wrap;\n                /* was made negative by deflate(..., Z_FINISH); */\n            }\n            s.status = s.wrap ? INIT_STATE : BUSY_STATE;\n            strm.adler =\n                s.wrap === 2\n                    ? 0 // crc32(0, Z_NULL, 0)\n                    : 1; // adler32(0, Z_NULL, 0)\n            s.last_flush = Z_NO_FLUSH;\n            _tr_init$1(s);\n            return Z_OK;\n        };\n        var deflateReset = function deflateReset(strm) {\n            var ret = deflateResetKeep(strm);\n            if (ret === Z_OK) {\n                lm_init(strm.state);\n            }\n            return ret;\n        };\n        var deflateSetHeader = function deflateSetHeader(strm, head) {\n            if (!strm || !strm.state) {\n                return Z_STREAM_ERROR;\n            }\n            if (strm.state.wrap !== 2) {\n                return Z_STREAM_ERROR;\n            }\n            strm.state.gzhead = head;\n            return Z_OK;\n        };\n        var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n            if (!strm) {\n                // === Z_NULL\n                return Z_STREAM_ERROR;\n            }\n            var wrap = 1;\n            if (level === Z_DEFAULT_COMPRESSION) {\n                level = 6;\n            }\n            if (windowBits < 0) {\n                /* suppress zlib wrapper */\n                wrap = 0;\n                windowBits = -windowBits;\n            }\n            else if (windowBits > 15) {\n                wrap = 2;\n                /* write gzip wrapper instead */\n                windowBits -= 16;\n            }\n            if (memLevel < 1 ||\n                memLevel > MAX_MEM_LEVEL ||\n                method !== Z_DEFLATED ||\n                windowBits < 8 ||\n                windowBits > 15 ||\n                level < 0 ||\n                level > 9 ||\n                strategy < 0 ||\n                strategy > Z_FIXED$1) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            if (windowBits === 8) {\n                windowBits = 9;\n            }\n            /* until 256-byte window bug fixed */\n            var s = new DeflateState();\n            strm.state = s;\n            s.strm = strm;\n            s.wrap = wrap;\n            s.gzhead = null;\n            s.w_bits = windowBits;\n            s.w_size = 1 << s.w_bits;\n            s.w_mask = s.w_size - 1;\n            s.hash_bits = memLevel + 7;\n            s.hash_size = 1 << s.hash_bits;\n            s.hash_mask = s.hash_size - 1;\n            s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1);\n            s.window = new Uint8Array(s.w_size * 2);\n            s.head = new Uint16Array(s.hash_size);\n            s.prev = new Uint16Array(s.w_size); // Don't need mem init magic for JS.\n            // s.high_water = 0;  /* nothing written to s->window yet */\n            s.lit_bufsize = 1 << (memLevel + 6);\n            /* 16K elements by default */\n            s.pending_buf_size = s.lit_bufsize * 4;\n            // overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n            // s->pending_buf = (uchf *) overlay;\n            // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n            s.pending_buf = new Uint8Array(s.pending_buf_size);\n            // s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n            s.d_buf = 1 * s.lit_bufsize; // s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n            s.l_buf = (1 + 2) * s.lit_bufsize;\n            s.level = level;\n            s.strategy = strategy;\n            s.method = method;\n            return deflateReset(strm);\n        };\n        var deflateInit = function deflateInit(strm, level) {\n            return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n        };\n        var deflate = function deflate(strm, flush) {\n            var beg;\n            var val; // for gzip header write only\n            if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {\n                return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            if (!strm.output || (!strm.input && strm.avail_in !== 0) || (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n                return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);\n            }\n            s.strm = strm;\n            /* just in case */\n            var old_flush = s.last_flush;\n            s.last_flush = flush;\n            /* Write the header */\n            if (s.status === INIT_STATE) {\n                if (s.wrap === 2) {\n                    // GZIP header\n                    strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                    put_byte(s, 31);\n                    put_byte(s, 139);\n                    put_byte(s, 8);\n                    if (!s.gzhead) {\n                        // s->gzhead == Z_NULL\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, OS_CODE);\n                        s.status = BUSY_STATE;\n                    }\n                    else {\n                        put_byte(s, (s.gzhead.text ? 1 : 0) +\n                            (s.gzhead.hcrc ? 2 : 0) +\n                            (!s.gzhead.extra ? 0 : 4) +\n                            (!s.gzhead.name ? 0 : 8) +\n                            (!s.gzhead.comment ? 0 : 16));\n                        put_byte(s, s.gzhead.time & 0xff);\n                        put_byte(s, (s.gzhead.time >> 8) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 16) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 24) & 0xff);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, s.gzhead.os & 0xff);\n                        if (s.gzhead.extra && s.gzhead.extra.length) {\n                            put_byte(s, s.gzhead.extra.length & 0xff);\n                            put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);\n                        }\n                        if (s.gzhead.hcrc) {\n                            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);\n                        }\n                        s.gzindex = 0;\n                        s.status = EXTRA_STATE;\n                    }\n                } // DEFLATE header\n                else {\n                    var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;\n                    var level_flags = -1;\n                    if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n                        level_flags = 0;\n                    }\n                    else if (s.level < 6) {\n                        level_flags = 1;\n                    }\n                    else if (s.level === 6) {\n                        level_flags = 2;\n                    }\n                    else {\n                        level_flags = 3;\n                    }\n                    header |= level_flags << 6;\n                    if (s.strstart !== 0) {\n                        header |= PRESET_DICT;\n                    }\n                    header += 31 - (header % 31);\n                    s.status = BUSY_STATE;\n                    putShortMSB(s, header);\n                    /* Save the adler32 of the preset dictionary: */\n                    if (s.strstart !== 0) {\n                        putShortMSB(s, strm.adler >>> 16);\n                        putShortMSB(s, strm.adler & 0xffff);\n                    }\n                    strm.adler = 1; // adler32(0L, Z_NULL, 0);\n                }\n            } // #ifdef GZIP\n            if (s.status === EXTRA_STATE) {\n                if (s.gzhead.extra\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                break;\n                            }\n                        }\n                        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n                        s.gzindex++;\n                    }\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (s.gzindex === s.gzhead.extra.length) {\n                        s.gzindex = 0;\n                        s.status = NAME_STATE;\n                    }\n                }\n                else {\n                    s.status = NAME_STATE;\n                }\n            }\n            if (s.status === NAME_STATE) {\n                if (s.gzhead.name\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.name.length) {\n                            val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.gzindex = 0;\n                        s.status = COMMENT_STATE;\n                    }\n                }\n                else {\n                    s.status = COMMENT_STATE;\n                }\n            }\n            if (s.status === COMMENT_STATE) {\n                if (s.gzhead.comment\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.comment.length) {\n                            val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.status = HCRC_STATE;\n                    }\n                }\n                else {\n                    s.status = HCRC_STATE;\n                }\n            }\n            if (s.status === HCRC_STATE) {\n                if (s.gzhead.hcrc) {\n                    if (s.pending + 2 > s.pending_buf_size) {\n                        flush_pending(strm);\n                    }\n                    if (s.pending + 2 <= s.pending_buf_size) {\n                        put_byte(s, strm.adler & 0xff);\n                        put_byte(s, (strm.adler >> 8) & 0xff);\n                        strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                        s.status = BUSY_STATE;\n                    }\n                }\n                else {\n                    s.status = BUSY_STATE;\n                }\n            } // #endif\n            /* Flush as much pending output as possible */\n            if (s.pending !== 0) {\n                flush_pending(strm);\n                if (strm.avail_out === 0) {\n                    /* Since avail_out is 0, deflate will be called again with\n                     * more output space, but possibly with both pending and\n                     * avail_in equal to zero. There won't be anything to do,\n                     * but this is not an error situation so make sure we\n                     * return OK instead of BUF_ERROR at next call of deflate:\n                     */\n                    s.last_flush = -1;\n                    return Z_OK;\n                }\n                /* Make sure there is something to do and avoid duplicate consecutive\n                 * flushes. For repeated and useless calls with Z_FINISH, we keep\n                 * returning Z_STREAM_END instead of Z_BUF_ERROR.\n                 */\n            }\n            else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* User must not provide more input after the first FINISH: */\n            if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* Start a new block or continue the current one.\n             */\n            if (strm.avail_in !== 0 || s.lookahead !== 0 || (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n                var bstate = s.strategy === Z_HUFFMAN_ONLY\n                    ? deflate_huff(s, flush)\n                    : s.strategy === Z_RLE\n                        ? deflate_rle(s, flush)\n                        : configuration_table[s.level].func(s, flush);\n                if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n                    s.status = FINISH_STATE;\n                }\n                if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR next call, see above */\n                    }\n                    return Z_OK;\n                    /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n                     * of deflate should use the same flush parameter to make sure\n                     * that the flush is complete. So we don't have to output an\n                     * empty block here, this will be done at next call. This also\n                     * ensures that for a very small output buffer, we emit at most\n                     * one empty block.\n                     */\n                }\n                if (bstate === BS_BLOCK_DONE) {\n                    if (flush === Z_PARTIAL_FLUSH) {\n                        _tr_align$1(s);\n                    }\n                    else if (flush !== Z_BLOCK) {\n                        /* FULL_FLUSH or SYNC_FLUSH */\n                        _tr_stored_block$1(s, 0, 0, false);\n                        /* For a full flush, this empty block will be recognized\n                         * as a special marker by inflate_sync().\n                         */\n                        if (flush === Z_FULL_FLUSH) {\n                            /** * CLEAR_HASH(s); ** */\n                            /* forget history */\n                            zero$1(s.head); // Fill with NIL (= 0);\n                            if (s.lookahead === 0) {\n                                s.strstart = 0;\n                                s.block_start = 0;\n                                s.insert = 0;\n                            }\n                        }\n                    }\n                    flush_pending(strm);\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR at next call, see above */\n                        return Z_OK;\n                    }\n                }\n            } // Assert(strm->avail_out > 0, \"bug2\");\n            // if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n            if (flush !== Z_FINISH) {\n                return Z_OK;\n            }\n            if (s.wrap <= 0) {\n                return Z_STREAM_END;\n            }\n            /* Write the trailer */\n            if (s.wrap === 2) {\n                put_byte(s, strm.adler & 0xff);\n                put_byte(s, (strm.adler >> 8) & 0xff);\n                put_byte(s, (strm.adler >> 16) & 0xff);\n                put_byte(s, (strm.adler >> 24) & 0xff);\n                put_byte(s, strm.total_in & 0xff);\n                put_byte(s, (strm.total_in >> 8) & 0xff);\n                put_byte(s, (strm.total_in >> 16) & 0xff);\n                put_byte(s, (strm.total_in >> 24) & 0xff);\n            }\n            else {\n                putShortMSB(s, strm.adler >>> 16);\n                putShortMSB(s, strm.adler & 0xffff);\n            }\n            flush_pending(strm);\n            /* If avail_out is zero, the application will call deflate again\n             * to flush the rest.\n             */\n            if (s.wrap > 0) {\n                s.wrap = -s.wrap;\n            }\n            /* write the trailer only once! */\n            return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n        };\n        var deflateEnd = function deflateEnd(strm) {\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var status = strm.state.status;\n            if (status !== INIT_STATE &&\n                status !== EXTRA_STATE &&\n                status !== NAME_STATE &&\n                status !== COMMENT_STATE &&\n                status !== HCRC_STATE &&\n                status !== BUSY_STATE &&\n                status !== FINISH_STATE) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.state = null;\n            return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n        };\n        /* =========================================================================\n         * Initializes the compression dictionary from the given byte\n         * sequence without producing any compressed output.\n         */\n        var deflateSetDictionary = function deflateSetDictionary(strm, dictionary) {\n            var dictLength = dictionary.length;\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            var wrap = s.wrap;\n            if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n                return Z_STREAM_ERROR;\n            }\n            /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n            if (wrap === 1) {\n                /* adler32(strm->adler, dictionary, dictLength); */\n                strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);\n            }\n            s.wrap = 0;\n            /* avoid computing Adler-32 in read_buf */\n            /* if dictionary would fill window, just replace the history */\n            if (dictLength >= s.w_size) {\n                if (wrap === 0) {\n                    /* already empty otherwise */\n                    /** * CLEAR_HASH(s); ** */\n                    zero$1(s.head); // Fill with NIL (= 0);\n                    s.strstart = 0;\n                    s.block_start = 0;\n                    s.insert = 0;\n                }\n                /* use the tail */\n                // dictionary = dictionary.slice(dictLength - s.w_size);\n                var tmpDict = new Uint8Array(s.w_size);\n                tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);\n                dictionary = tmpDict;\n                dictLength = s.w_size;\n            }\n            /* insert dictionary into window and hash */\n            var avail = strm.avail_in;\n            var next = strm.next_in;\n            var input = strm.input;\n            strm.avail_in = dictLength;\n            strm.next_in = 0;\n            strm.input = dictionary;\n            fill_window(s);\n            while (s.lookahead >= MIN_MATCH$1) {\n                var str = s.strstart;\n                var n = s.lookahead - (MIN_MATCH$1 - 1);\n                do {\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                    s.prev[str & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = str;\n                    str++;\n                } while (--n);\n                s.strstart = str;\n                s.lookahead = MIN_MATCH$1 - 1;\n                fill_window(s);\n            }\n            s.strstart += s.lookahead;\n            s.block_start = s.strstart;\n            s.insert = s.lookahead;\n            s.lookahead = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            strm.next_in = next;\n            strm.input = input;\n            strm.avail_in = avail;\n            s.wrap = wrap;\n            return Z_OK;\n        };\n        var deflateInit_1 = deflateInit;\n        var deflateInit2_1 = deflateInit2;\n        var deflateReset_1 = deflateReset;\n        var deflateResetKeep_1 = deflateResetKeep;\n        var deflateSetHeader_1 = deflateSetHeader;\n        var deflate_2 = deflate;\n        var deflateEnd_1 = deflateEnd;\n        var deflateSetDictionary_1 = deflateSetDictionary;\n        var deflateInfo = 'pako deflate (from Nodeca project)';\n        /* Not implemented\n      module.exports.deflateBound = deflateBound;\n      module.exports.deflateCopy = deflateCopy;\n      module.exports.deflateParams = deflateParams;\n      module.exports.deflatePending = deflatePending;\n      module.exports.deflatePrime = deflatePrime;\n      module.exports.deflateTune = deflateTune;\n      */\n        var deflate_1 = {\n            deflateInit: deflateInit_1,\n            deflateInit2: deflateInit2_1,\n            deflateReset: deflateReset_1,\n            deflateResetKeep: deflateResetKeep_1,\n            deflateSetHeader: deflateSetHeader_1,\n            deflate: deflate_2,\n            deflateEnd: deflateEnd_1,\n            deflateSetDictionary: deflateSetDictionary_1,\n            deflateInfo: deflateInfo,\n        };\n        // Join array of chunks to single array.\n        function flattenChunks(chunks) {\n            // calculate data length\n            var len = 0;\n            for (var i = 0, l = chunks.length; i < l; i++) {\n                len += chunks[i].length;\n            } // join chunks\n            var result = new Uint8Array(len);\n            for (var _i = 0, pos = 0, _l = chunks.length; _i < _l; _i++) {\n                var chunk = chunks[_i];\n                result.set(chunk, pos);\n                pos += chunk.length;\n            }\n            return result;\n        }\n        // String encode/decode helpers\n        //\n        // - apply(Array) can fail on Android 2.2\n        // - apply(Uint8Array) can fail on iOS 5.1 Safari\n        //\n        // Table with utf8 lengths (calculated by first byte of sequence)\n        // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n        // because max possible codepoint is 0x10ffff\n        var _utf8len = new Uint8Array(256);\n        for (var q = 0; q < 256; q++) {\n            _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;\n        }\n        _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n        // convert string to array (typed, when possible)\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        function ZStream() {\n            /* next input byte */\n            this.input = null; // JS specific, because we have no pointers\n            this.next_in = 0;\n            /* number of bytes available at input */\n            this.avail_in = 0;\n            /* total number of input bytes read so far */\n            this.total_in = 0;\n            /* next output byte should be put there */\n            this.output = null; // JS specific, because we have no pointers\n            this.next_out = 0;\n            /* remaining free space at output */\n            this.avail_out = 0;\n            /* total number of bytes output so far */\n            this.total_out = 0;\n            /* last error message, NULL if no error */\n            this.msg = '';\n            /* Z_NULL */\n            /* not visible by applications */\n            this.state = null;\n            /* best guess about the data type: binary or text */\n            this.data_type = 2;\n            /* Z_UNKNOWN */\n            /* adler32 value of the uncompressed data */\n            this.adler = 0;\n        }\n        var zstream = ZStream;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var toString = Object.prototype.toString;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH$1 = constants.Z_NO_FLUSH;\n        var Z_SYNC_FLUSH = constants.Z_SYNC_FLUSH;\n        var Z_FULL_FLUSH$1 = constants.Z_FULL_FLUSH;\n        var Z_FINISH$1 = constants.Z_FINISH;\n        var Z_OK$1 = constants.Z_OK;\n        var Z_STREAM_END$1 = constants.Z_STREAM_END;\n        var Z_DEFAULT_COMPRESSION$1 = constants.Z_DEFAULT_COMPRESSION;\n        var Z_DEFAULT_STRATEGY$1 = constants.Z_DEFAULT_STRATEGY;\n        var Z_DEFLATED$1 = constants.Z_DEFLATED;\n        /* =========================================================================== */\n        /**\n         * class Deflate\n         *\n         * Generic JS-style wrapper for zlib calls. If you don't need\n         * streaming behaviour - use more simple functions: [[deflate]],\n         * [[deflateRaw]] and [[gzip]].\n         * */\n        /* internal\n         * Deflate.chunks -> Array\n         *\n         * Chunks of output data, if [[Deflate#onData]] not overridden.\n         * */\n        /**\n         * Deflate.result -> Uint8Array\n         *\n         * Compressed result, generated by default [[Deflate#onData]]\n         * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n         * (call [[Deflate#push]] with `Z_FINISH` / `true` param).\n         * */\n        /**\n         * Deflate.err -> Number\n         *\n         * Error code after deflate finished. 0 (Z_OK) on success.\n         * You will not need it in real life, because deflate errors\n         * are possible only on wrong options or bad `onData` / `onEnd`\n         * custom handlers.\n         * */\n        /**\n         * Deflate.msg -> String\n         *\n         * Error message, if [[Deflate.err]] != 0\n         * */\n        /**\n         * new Deflate(options)\n         * - options (Object): zlib deflate options.\n         *\n         * Creates new deflator instance with specified params. Throws exception\n         * on bad params. Supported options:\n         *\n         * - `level`\n         * - `windowBits`\n         * - `memLevel`\n         * - `strategy`\n         * - `dictionary`\n         *\n         * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n         * for more information on these.\n         *\n         * Additional options, for internal needs:\n         *\n         * * `chunkSize` - size of generated data chunks (16K by default)\n         * * `raw` (Boolean) - do raw deflate\n         * * `gzip` (Boolean) - create gzip wrapper\n         * * `header` (Object) - custom header for gzip\n         * ** `text` (Boolean) - true if compressed data believed to be text\n         * ** `time` (Number) - modification time, unix timestamp\n         * ** `os` (Number) - operation system code\n         * ** `extra` (Array) - array of bytes with extra data (max 65536)\n         * ** `name` (String) - file name (binary string)\n         * ** `comment` (String) - comment (binary string)\n         * ** `hcrc` (Boolean) - true if header crc should be added\n         *\n         * ##### Example:\n         *\n         * ```javascript\n         * const pako = require('pako')\n         *   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n         *   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n         *\n         * const deflate = new pako.Deflate({ level: 3});\n         *\n         * deflate.push(chunk1, false);\n         * deflate.push(chunk2, true);  // true -> last chunk\n         *\n         * if (deflate.err) { throw new Error(deflate.err); }\n         *\n         * console.log(deflate.result);\n         * ```\n         * */\n        function Deflate() {\n            this.options = {\n                level: Z_DEFAULT_COMPRESSION$1,\n                method: Z_DEFLATED$1,\n                chunkSize: 16384,\n                windowBits: 15,\n                memLevel: 8,\n                strategy: Z_DEFAULT_STRATEGY$1,\n            };\n            var opt = this.options;\n            if (opt.raw && opt.windowBits > 0) {\n                opt.windowBits = -opt.windowBits;\n            }\n            else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {\n                opt.windowBits += 16;\n            }\n            this.err = 0; // error code, if happens (0 = Z_OK)\n            this.msg = ''; // error message\n            this.ended = false; // used to avoid multiple onEnd() calls\n            this.chunks = []; // chunks of compressed data\n            this.strm = new zstream();\n            this.strm.avail_out = 0;\n            var status = deflate_1.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);\n            if (status !== Z_OK$1) {\n                throw new Error(messages[status]);\n            }\n            if (opt.header) {\n                deflate_1.deflateSetHeader(this.strm, opt.header);\n            }\n            if (opt.dictionary) {\n                var dict; // Convert data if needed\n                if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n                    dict = new Uint8Array(opt.dictionary);\n                }\n                else {\n                    dict = opt.dictionary;\n                }\n                status = deflate_1.deflateSetDictionary(this.strm, dict);\n                if (status !== Z_OK$1) {\n                    throw new Error(messages[status]);\n                }\n                this._dict_set = true;\n            }\n        }\n        /**\n         * Deflate#push(data[, flush_mode]) -> Boolean\n         * - data (Uint8Array|ArrayBuffer|String): input data. Strings will be\n         * converted to utf8 byte sequence.\n         * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n         * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n         *\n         * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n         * new compressed chunks. Returns `true` on success. The last data block must\n         * have `flush_mode` Z_FINISH (or `true`). That will flush internal pending\n         * buffers and call [[Deflate#onEnd]].\n         *\n         * On fail call [[Deflate#onEnd]] with error code and return false.\n         *\n         * ##### Example\n         *\n         * ```javascript\n         * push(chunk, false); // push one of data chunks\n         * ...\n         * push(chunk, true);  // push last chunk\n         * ```\n         * */\n        Deflate.prototype.push = function (data, flush_mode) {\n            var strm = this.strm;\n            var chunkSize = this.options.chunkSize;\n            var status;\n            var _flush_mode;\n            if (this.ended) {\n                return false;\n            }\n            if (flush_mode === ~~flush_mode) {\n                _flush_mode = flush_mode;\n            }\n            else {\n                _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1;\n            } // Convert data if needed\n            if (toString.call(data) === '[object ArrayBuffer]') {\n                strm.input = new Uint8Array(data);\n            }\n            else {\n                strm.input = data;\n            }\n            strm.next_in = 0;\n            strm.avail_in = strm.input.length;\n            for (;;) {\n                if (strm.avail_out === 0) {\n                    strm.output = new Uint8Array(chunkSize);\n                    strm.next_out = 0;\n                    strm.avail_out = chunkSize;\n                } // Make sure avail_out > 6 to avoid repeating markers\n                if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                status = deflate_1.deflate(strm, _flush_mode); // Ended => flush and finish\n                if (status === Z_STREAM_END$1) {\n                    if (strm.next_out > 0) {\n                        this.onData(strm.output.subarray(0, strm.next_out));\n                    }\n                    status = deflate_1.deflateEnd(this.strm);\n                    this.onEnd(status);\n                    this.ended = true;\n                    return status === Z_OK$1;\n                } // Flush if out buffer full\n                if (strm.avail_out === 0) {\n                    this.onData(strm.output);\n                    continue;\n                } // Flush if requested and has data\n                if (_flush_mode > 0 && strm.next_out > 0) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                if (strm.avail_in === 0) {\n                    break;\n                }\n            }\n            return true;\n        };\n        /**\n         * Deflate#onData(chunk) -> Void\n         * - chunk (Uint8Array): output data.\n         *\n         * By default, stores data blocks in `chunks[]` property and glue\n         * those in `onEnd`. Override this handler, if you need another behaviour.\n         * */\n        Deflate.prototype.onData = function (chunk) {\n            this.chunks.push(chunk);\n        };\n        /**\n         * Deflate#onEnd(status) -> Void\n         * - status (Number): deflate status. 0 (Z_OK) on success,\n         * other if not.\n         *\n         * Called once after you tell deflate that the input stream is\n         * complete (Z_FINISH). By default - join collected chunks,\n         * free memory and fill `results` / `err` properties.\n         * */\n        Deflate.prototype.onEnd = function (status) {\n            // On success - join\n            if (status === Z_OK$1) {\n                this.result = flattenChunks(this.chunks);\n            }\n            this.chunks = [];\n            this.err = status;\n            this.msg = this.strm.msg;\n        };\n        // https://github.com/nodeca/pako/blob/26dff4fb3472c5532b3bd8856421146d35ab7592/lib/utils/strings.js#L26\n        function string2buf(str) {\n            if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n                return new TextEncoder().encode(str);\n            }\n            var buf;\n            var c;\n            var c2;\n            var m_pos;\n            var i;\n            var str_len = str.length;\n            var buf_len = 0;\n            // count binary size\n            for (m_pos = 0; m_pos < str_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n            }\n            // allocate buffer\n            buf = new Uint8Array(buf_len);\n            // convert\n            for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                if (c < 0x80) {\n                    /* one byte */\n                    buf[i++] = c;\n                }\n                else if (c < 0x800) {\n                    /* two bytes */\n                    buf[i++] = 0xc0 | (c >>> 6);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else if (c < 0x10000) {\n                    /* three bytes */\n                    buf[i++] = 0xe0 | (c >>> 12);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else {\n                    /* four bytes */\n                    buf[i++] = 0xf0 | (c >>> 18);\n                    buf[i++] = 0x80 | ((c >>> 12) & 0x3f);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n            }\n            return buf;\n        }\n        return { Deflate: Deflate, constants: constants, string2buf: string2buf };\n    }\n}\n//# sourceMappingURL=deflateWorker.js.map","import { addEventListener, monitor } from '@datadog/browser-core';\nimport { SEND_BEACON_BYTE_LENGTH_LIMIT } from '../../transport/send';\nimport { Segment } from './segment';\nexport var MAX_SEGMENT_DURATION = 30000;\nvar MAX_SEGMENT_SIZE = SEND_BEACON_BYTE_LENGTH_LIMIT;\n// Segments are the main data structure for session replays. They contain context information used\n// for indexing or UI needs, and a list of records (RRWeb 'events', renamed to avoid confusing\n// namings). They are stored without any processing from the intake, and fetched one after the\n// other while a session is being replayed. Their encoding (deflate) are carefully crafted to allow\n// concatenating multiple segments together. Segments have a size overhead (metadata), so our goal is to\n// build segments containing as much records as possible while complying with the various flush\n// strategies to guarantee a good replay quality.\n//\n// When the recording starts, a segment is initially created.  The segment is flushed (finalized and\n// sent) based on various events (non-exhaustive list):\n//\n// * the page visibility change or becomes to unload\n// * the segment duration reaches a limit\n// * the encoded segment size reaches a limit\n// * ...\n//\n// A segment cannot be created without its context.  If the RUM session ends and no session id is\n// available when creating a new segment, records will be ignored, until the session is renewed and\n// a new session id is available.\n//\n// Empty segments (segments with no record) aren't useful and should be ignored.\n//\n// To help investigate session replays issues, each segment is created with a \"creation reason\",\n// indicating why the session has been created.\nexport function startSegmentCollection(lifeCycle, applicationId, sessionManager, parentContexts, send, worker) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(applicationId, sessionManager, parentContexts); }, send, worker);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, send, worker, emitter) {\n    if (emitter === void 0) { emitter = window; }\n    var state = {\n        status: 0 /* WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    var unsubscribeViewCreated = lifeCycle.subscribe(4 /* VIEW_CREATED */, function () {\n        flushSegment('view_change');\n    }).unsubscribe;\n    var unsubscribeBeforeUnload = lifeCycle.subscribe(11 /* BEFORE_UNLOAD */, function () {\n        flushSegment('before_unload');\n    }).unsubscribe;\n    var unsubscribeVisibilityChange = addEventListener(emitter, \"visibilitychange\" /* VISIBILITY_CHANGE */, function () {\n        if (document.visibilityState === 'hidden') {\n            flushSegment('visibility_hidden');\n        }\n    }, { capture: true }).stop;\n    function flushSegment(nextSegmentCreationReason) {\n        if (state.status === 1 /* SegmentPending */) {\n            state.segment.flush(nextSegmentCreationReason || 'sdk_stopped');\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (nextSegmentCreationReason) {\n            state = {\n                status: 0 /* WaitingForInitialRecord */,\n                nextSegmentCreationReason: nextSegmentCreationReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* Stopped */,\n            };\n        }\n    }\n    function createNewSegment(creationReason, initialRecord) {\n        var context = getSegmentContext();\n        if (!context) {\n            return;\n        }\n        var segment = new Segment(worker, context, creationReason, initialRecord, function (compressedSegmentSize) {\n            if (!segment.isFlushed && compressedSegmentSize > MAX_SEGMENT_SIZE) {\n                flushSegment('max_size');\n            }\n        }, function (data, rawSegmentSize) {\n            send(data, segment.metadata, rawSegmentSize, segment.flushReason);\n        });\n        state = {\n            status: 1 /* SegmentPending */,\n            segment: segment,\n            expirationTimeoutId: setTimeout(monitor(function () {\n                flushSegment('max_duration');\n            }), MAX_SEGMENT_DURATION),\n        };\n    }\n    return {\n        addRecord: function (record) {\n            switch (state.status) {\n                case 0 /* WaitingForInitialRecord */:\n                    createNewSegment(state.nextSegmentCreationReason, record);\n                    break;\n                case 1 /* SegmentPending */:\n                    state.segment.addRecord(record);\n                    break;\n            }\n        },\n        stop: function () {\n            flushSegment();\n            unsubscribeViewCreated();\n            unsubscribeBeforeUnload();\n            unsubscribeVisibilityChange();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, parentContexts) {\n    var session = sessionManager.findTrackedSession();\n    var viewContext = parentContexts.findView();\n    if (!session || !viewContext) {\n        return undefined;\n    }\n    return {\n        application: {\n            id: applicationId,\n        },\n        session: {\n            id: session.id,\n        },\n        view: {\n            id: viewContext.view.id,\n        },\n    };\n}\nexport function setMaxSegmentSize(newSize) {\n    if (newSize === void 0) { newSize = SEND_BEACON_BYTE_LENGTH_LIMIT; }\n    MAX_SEGMENT_SIZE = newSize;\n}\n//# sourceMappingURL=segmentCollection.js.map","import { addMonitoringError, display, includes, monitor } from '@datadog/browser-core';\nimport { createDeflateWorker } from './deflateWorker';\nvar state = { status: 0 /* Nil */ };\nexport function startDeflateWorker(callback, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    switch (state.status) {\n        case 0 /* Nil */:\n            state = { status: 1 /* Loading */, callbacks: [callback] };\n            doStartDeflateWorker(createDeflateWorkerImpl);\n            break;\n        case 1 /* Loading */:\n            state.callbacks.push(callback);\n            break;\n        case 2 /* Error */:\n            callback();\n            break;\n        case 3 /* Initialized */:\n            callback(state.worker);\n            break;\n    }\n}\nexport function resetDeflateWorkerState() {\n    state = { status: 0 /* Nil */ };\n}\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker_1 = createDeflateWorkerImpl();\n        worker_1.addEventListener('error', monitor(onError));\n        worker_1.addEventListener('message', monitor(function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored') {\n                onError(data.error);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(worker_1);\n            }\n        }));\n        worker_1.postMessage({ action: 'init' });\n        return worker_1;\n    }\n    catch (error) {\n        onError(error);\n    }\n}\nfunction onInitialized(worker) {\n    if (state.status === 1 /* Loading */) {\n        state.callbacks.forEach(function (callback) { return callback(worker); });\n        state = { status: 3 /* Initialized */, worker: worker };\n    }\n}\nfunction onError(error) {\n    if (state.status === 1 /* Loading */) {\n        display.error('Session Replay recording failed to start: an error occurred while creating the Worker:', error);\n        if (error instanceof Event || (error instanceof Error && includes(error.message, 'Content Security Policy'))) {\n            display.error('Please make sure CSP is correctly configured ' +\n                'https://docs.datadoghq.com/real_user_monitoring/faq/content_security_policy');\n        }\n        else {\n            addMonitoringError(error);\n        }\n        state.callbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* Error */ };\n    }\n    else {\n        addMonitoringError(error);\n    }\n}\n//# sourceMappingURL=startDeflateWorker.js.map","// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core';\nimport { startRecording } from '../boot/startRecording';\nimport { makeRecorderApi } from '../boot/recorderApi';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nvar recorderApi = makeRecorderApi(startRecording);\nexport var datadogRum = makeRumPublicApi(startRum, recorderApi);\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { setDebugMode } from '../domain/internalMonitoring';\nimport { catchUserErrors } from '../tools/catchUserErrors';\nimport { assign } from '../tools/utils';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"4.7.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 (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 () {\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) { return catchUserErrors(fn, 'onReady callback threw an error:')(); });\n    }\n}\n//# sourceMappingURL=init.js.map","import { assign, BoundedBuffer, buildCookieOptions, createContextManager, deepClone, makePublicApi, monitor, clocksNow, timeStampNow, display, callMonitored, createHandlingStack, canUseEventBridge, areCookiesAuthorized, } from '@datadog/browser-core';\nimport { willSyntheticsInjectRum } from '../domain/syntheticsContext';\nimport { validateAndBuildRumConfiguration } from '../domain/configuration';\nexport function makeRumPublicApi(startRumImpl, recorderApi, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.ignoreInitIfSyntheticsWillInjectRum, ignoreInitIfSyntheticsWillInjectRum = _c === void 0 ? true : _c;\n    var isAlreadyInitialized = false;\n    var globalContextManager = createContextManager();\n    var user = {};\n    var getInternalContextStrategy = function () { return undefined; };\n    var getInitConfigurationStrategy = function () { return undefined; };\n    var bufferApiCalls = new BoundedBuffer();\n    var addTimingStrategy = function (name, time) {\n        if (time === void 0) { time = timeStampNow(); }\n        bufferApiCalls.add(function () { return addTimingStrategy(name, time); });\n    };\n    var startViewStrategy = function (name, startClocks) {\n        if (startClocks === void 0) { startClocks = clocksNow(); }\n        bufferApiCalls.add(function () { return startViewStrategy(name, startClocks); });\n    };\n    var addActionStrategy = function (action, commonContext) {\n        if (commonContext === void 0) { commonContext = clonedCommonContext(); }\n        bufferApiCalls.add(function () { return addActionStrategy(action, commonContext); });\n    };\n    var addErrorStrategy = function (providedError, commonContext) {\n        if (commonContext === void 0) { commonContext = clonedCommonContext(); }\n        bufferApiCalls.add(function () { return addErrorStrategy(providedError, commonContext); });\n    };\n    function clonedCommonContext() {\n        return deepClone({\n            context: globalContextManager.get(),\n            user: user,\n        });\n    }\n    function initRum(initConfiguration) {\n        // If we are in a Synthetics test configured to automatically inject a RUM instance, we want to\n        // completely discard the customer application RUM instance by ignoring their init() call.  But,\n        // we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n        // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n        if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n            return;\n        }\n        if (canUseEventBridge()) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        else if (!canHandleSession(initConfiguration)) {\n            return;\n        }\n        if (!canInitRum(initConfiguration)) {\n            return;\n        }\n        var configuration = validateAndBuildRumConfiguration(initConfiguration);\n        if (!configuration) {\n            return;\n        }\n        if (!configuration.trackViewsManually) {\n            doStartRum(configuration);\n        }\n        else {\n            // drain beforeInitCalls by buffering them until we start RUM\n            // if we get a startView, drain re-buffered calls before continuing to drain beforeInitCalls\n            // in order to ensure that calls are processed in order\n            var beforeInitCalls = bufferApiCalls;\n            bufferApiCalls = new BoundedBuffer();\n            startViewStrategy = function (name) {\n                doStartRum(configuration, name);\n            };\n            beforeInitCalls.drain();\n        }\n        getInitConfigurationStrategy = function () { return deepClone(initConfiguration); };\n        isAlreadyInitialized = true;\n    }\n    function doStartRum(configuration, initialViewName) {\n        var startRumResults = startRumImpl(configuration, function () { return ({\n            user: user,\n            context: globalContextManager.get(),\n            hasReplay: recorderApi.isRecording() ? true : undefined,\n        }); }, recorderApi, initialViewName);\n        (startViewStrategy = startRumResults.startView, addActionStrategy = startRumResults.addAction, addErrorStrategy = startRumResults.addError, addTimingStrategy = startRumResults.addTiming, getInternalContextStrategy = startRumResults.getInternalContext);\n        bufferApiCalls.drain();\n        recorderApi.onRumStart(startRumResults.lifeCycle, configuration, startRumResults.session, startRumResults.parentContexts);\n    }\n    var rumPublicApi = makePublicApi({\n        init: monitor(initRum),\n        addRumGlobalContext: monitor(globalContextManager.add),\n        removeRumGlobalContext: monitor(globalContextManager.remove),\n        getRumGlobalContext: monitor(globalContextManager.get),\n        setRumGlobalContext: monitor(globalContextManager.set),\n        getInternalContext: monitor(function (startTime) { return getInternalContextStrategy(startTime); }),\n        getInitConfiguration: monitor(function () { return getInitConfigurationStrategy(); }),\n        addAction: monitor(function (name, context) {\n            addActionStrategy({\n                name: name,\n                context: deepClone(context),\n                startClocks: clocksNow(),\n                type: \"custom\" /* CUSTOM */,\n            });\n        }),\n        addError: function (error, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                addErrorStrategy({\n                    error: error,\n                    handlingStack: handlingStack,\n                    context: deepClone(context),\n                    startClocks: clocksNow(),\n                });\n            });\n        },\n        addTiming: monitor(function (name, time) {\n            addTimingStrategy(name, time);\n        }),\n        setUser: monitor(function (newUser) {\n            var sanitizedUser = sanitizeUser(newUser);\n            if (sanitizedUser) {\n                user = sanitizedUser;\n            }\n            else {\n                display.error('Unsupported user:', newUser);\n            }\n        }),\n        removeUser: monitor(function () {\n            user = {};\n        }),\n        startView: monitor(function (name) {\n            startViewStrategy(name);\n        }),\n        startSessionReplayRecording: monitor(recorderApi.start),\n        stopSessionReplayRecording: monitor(recorderApi.stop),\n    });\n    return rumPublicApi;\n    function sanitizeUser(newUser) {\n        if (typeof newUser !== 'object' || !newUser) {\n            return;\n        }\n        var result = deepClone(newUser);\n        if ('id' in result) {\n            result.id = String(result.id);\n        }\n        if ('name' in result) {\n            result.name = String(result.name);\n        }\n        if ('email' in result) {\n            result.email = String(result.email);\n        }\n        return result;\n    }\n    function canHandleSession(initConfiguration) {\n        if (!areCookiesAuthorized(buildCookieOptions(initConfiguration))) {\n            display.warn('Cookies are not authorized, we will not send any data.');\n            return false;\n        }\n        if (isLocalFile()) {\n            display.error('Execution is not allowed in the current context.');\n            return false;\n        }\n        return true;\n    }\n    function canInitRum(initConfiguration) {\n        if (isAlreadyInitialized) {\n            if (!initConfiguration.silentMultipleInit) {\n                display.error('DD_RUM is already initialized.');\n            }\n            return false;\n        }\n        return true;\n    }\n    function overrideInitConfigurationForBridge(initConfiguration) {\n        return assign({}, initConfiguration, {\n            applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n            clientToken: 'empty',\n            sampleRate: 100,\n        });\n    }\n    function isLocalFile() {\n        return window.location.protocol === 'file:';\n    }\n}\n//# sourceMappingURL=rumPublicApi.js.map","export function createContextManager() {\n    var context = {};\n    return {\n        get: function () { return context; },\n        add: function (key, value) {\n            context[key] = value;\n        },\n        remove: function (key) {\n            delete context[key];\n        },\n        set: function (newContext) {\n            context = newContext;\n        },\n    };\n}\n//# sourceMappingURL=contextManager.js.map","import { assign, DefaultPrivacyLevel, display, isPercentage, objectHasValue, validateAndBuildConfiguration, } from '@datadog/browser-core';\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (initConfiguration.replaySampleRate !== undefined && !isPercentage(initConfiguration.replaySampleRate)) {\n        display.error('Replay Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.allowedTracingOrigins !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingOrigins)) {\n            display.error('Allowed Tracing Origins should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingOrigins.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service need to be configured when tracing is enabled');\n            return;\n        }\n    }\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        replaySampleRate: (_a = initConfiguration.replaySampleRate) !== null && _a !== void 0 ? _a : 100,\n        allowedTracingOrigins: (_b = initConfiguration.allowedTracingOrigins) !== null && _b !== void 0 ? _b : [],\n        trackInteractions: !!initConfiguration.trackInteractions,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK_USER_INPUT,\n    }, baseConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","import { startInternalMonitoring, combine, canUseEventBridge, startBatchWithReplica, getEventBridge, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { startPerformanceCollection } from '../browser/performanceCollection';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startForegroundContexts } from '../domain/foregroundContexts';\nimport { startInternalContext } from '../domain/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startParentContexts } from '../domain/parentContexts';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/rumEventsCollection/action/actionCollection';\nimport { startErrorCollection } from '../domain/rumEventsCollection/error/errorCollection';\nimport { startLongTaskCollection } from '../domain/rumEventsCollection/longTask/longTaskCollection';\nimport { startResourceCollection } from '../domain/rumEventsCollection/resource/resourceCollection';\nimport { startViewCollection } from '../domain/rumEventsCollection/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nexport function startRum(configuration, getCommonContext, recorderApi, initialViewName) {\n    var lifeCycle = new LifeCycle();\n    var internalMonitoring = startRumInternalMonitoring(configuration);\n    internalMonitoring.setExternalContextProvider(function () {\n        var _a;\n        return combine({\n            application_id: configuration.applicationId,\n            session: {\n                id: (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id,\n            },\n        }, parentContexts.findView(), { view: { name: null } });\n    });\n    internalMonitoring.setTelemetryContextProvider(function () {\n        var _a, _b, _c;\n        return ({\n            application: {\n                id: configuration.applicationId,\n            },\n            session: {\n                id: (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id,\n            },\n            view: {\n                id: (_b = parentContexts.findView()) === null || _b === void 0 ? void 0 : _b.view.id,\n            },\n            action: {\n                id: (_c = parentContexts.findAction()) === null || _c === void 0 ? void 0 : _c.action.id,\n            },\n        });\n    });\n    if (!canUseEventBridge()) {\n        startRumBatch(configuration, lifeCycle, internalMonitoring.telemetryEventObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var session = !canUseEventBridge() ? startRumSessionManager(configuration, lifeCycle) : startRumSessionManagerStub();\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(location);\n    var _a = startRumEventCollection(lifeCycle, configuration, location, session, locationChangeObservable, getCommonContext), parentContexts = _a.parentContexts, foregroundContexts = _a.foregroundContexts, urlContexts = _a.urlContexts;\n    startLongTaskCollection(lifeCycle, session);\n    startResourceCollection(lifeCycle);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, recorderApi, initialViewName), addTiming = _b.addTiming, startView = _b.startView;\n    var addError = startErrorCollection(lifeCycle, foregroundContexts).addError;\n    var addAction = startActionCollection(lifeCycle, domMutationObservable, configuration, foregroundContexts).addAction;\n    startRequestCollection(lifeCycle, configuration, session);\n    startPerformanceCollection(lifeCycle, configuration);\n    var internalContext = startInternalContext(configuration.applicationId, session, parentContexts, urlContexts);\n    return {\n        addAction: addAction,\n        addError: addError,\n        addTiming: addTiming,\n        startView: startView,\n        lifeCycle: lifeCycle,\n        parentContexts: parentContexts,\n        session: session,\n        getInternalContext: internalContext.get,\n    };\n}\nfunction startRumInternalMonitoring(configuration) {\n    var _a;\n    var internalMonitoring = startInternalMonitoring(configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        internalMonitoring.monitoringMessageObservable.subscribe(function (message) { return bridge_1.send('internal_log', message); });\n        internalMonitoring.telemetryEventObservable.subscribe(function (message) { return bridge_1.send('internal_telemetry', message); });\n    }\n    else if (configuration.internalMonitoringEndpointBuilder) {\n        var batch_1 = startBatchWithReplica(configuration, configuration.internalMonitoringEndpointBuilder, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.internalMonitoringEndpointBuilder);\n        internalMonitoring.monitoringMessageObservable.subscribe(function (message) { return batch_1.add(message); });\n    }\n    return internalMonitoring;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, locationChangeObservable, getCommonContext) {\n    var parentContexts = startParentContexts(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var foregroundContexts = startForegroundContexts();\n    startRumAssembly(configuration, lifeCycle, sessionManager, parentContexts, urlContexts, getCommonContext);\n    return {\n        parentContexts: parentContexts,\n        foregroundContexts: foregroundContexts,\n        urlContexts: urlContexts,\n        stop: function () {\n            parentContexts.stop();\n            foregroundContexts.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { Batch, HttpRequest } from './index';\nexport function startBatchWithReplica(configuration, endpoint, 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(new HttpRequest(endpointBuilder, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout);\n    }\n    return {\n        add: function (message) {\n            primaryBatch.add(message);\n            if (replicaBatch) {\n                replicaBatch.add(message);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startBatchWithReplica.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRumEventBridge(lifeCycle) {\n    var bridge = getEventBridge();\n    lifeCycle.subscribe(13 /* RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { ONE_MINUTE, SESSION_TIME_OUT_DELAY, ContextHistory } from '@datadog/browser-core';\nexport var VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function startParentContexts(lifeCycle) {\n    var viewContextHistory = new ContextHistory(VIEW_CONTEXT_TIME_OUT_DELAY);\n    var actionContextHistory = new ContextHistory(ACTION_CONTEXT_TIME_OUT_DELAY);\n    lifeCycle.subscribe(4 /* VIEW_CREATED */, function (view) {\n        viewContextHistory.setCurrent(buildViewContext(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(5 /* VIEW_UPDATED */, function (view) {\n        // A view can be updated after its end.  We have to ensure that the view being updated is the\n        // most recently created.\n        var current = viewContextHistory.getCurrent();\n        if (current && current.view.id === view.id) {\n            viewContextHistory.setCurrent(buildViewContext(view), view.startClocks.relative);\n        }\n    });\n    lifeCycle.subscribe(6 /* VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewContextHistory.closeCurrent(endClocks.relative);\n    });\n    lifeCycle.subscribe(1 /* AUTO_ACTION_CREATED */, function (action) {\n        actionContextHistory.setCurrent(buildActionContext(action), action.startClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* AUTO_ACTION_COMPLETED */, function (action) {\n        if (actionContextHistory.getCurrent()) {\n            // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n            var actionEndTime = (action.startClocks.relative + action.duration);\n            actionContextHistory.closeCurrent(actionEndTime);\n        }\n    });\n    lifeCycle.subscribe(3 /* AUTO_ACTION_DISCARDED */, function () {\n        actionContextHistory.clearCurrent();\n    });\n    lifeCycle.subscribe(10 /* SESSION_RENEWED */, function () {\n        viewContextHistory.reset();\n        actionContextHistory.reset();\n    });\n    function buildViewContext(view) {\n        return {\n            view: {\n                id: view.id,\n                name: view.name,\n            },\n        };\n    }\n    function buildActionContext(action) {\n        return { action: { id: action.id } };\n    }\n    return {\n        findAction: function (startTime) { return actionContextHistory.find(startTime); },\n        findView: function (startTime) { return viewContextHistory.find(startTime); },\n        stop: function () {\n            viewContextHistory.stop();\n            actionContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=parentContexts.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, ContextHistory } from '@datadog/browser-core';\n/**\n * We want to attach to an event:\n * - the url corresponding to its start\n * - the referrer corresponding to the previous view url (or document referrer for initial view)\n */\nexport var URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startUrlContexts(lifeCycle, locationChangeObservable, location) {\n    var urlContextHistory = new ContextHistory(URL_CONTEXT_TIME_OUT_DELAY);\n    var previousViewUrl;\n    lifeCycle.subscribe(6 /* VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeCurrent(endClocks.relative);\n    });\n    lifeCycle.subscribe(4 /* VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        var viewUrl = location.href;\n        urlContextHistory.setCurrent(buildUrlContext({\n            url: viewUrl,\n            referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n        }), startClocks.relative);\n        previousViewUrl = viewUrl;\n    });\n    var locationChangeSubscription = locationChangeObservable.subscribe(function (_a) {\n        var newLocation = _a.newLocation;\n        var current = urlContextHistory.getCurrent();\n        if (current) {\n            var changeTime = relativeNow();\n            urlContextHistory.closeCurrent(changeTime);\n            urlContextHistory.setCurrent(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.view.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            view: {\n                url: url,\n                referrer: referrer,\n            },\n        };\n    }\n    return {\n        findUrl: function (startTime) { return urlContextHistory.find(startTime); },\n        stop: function () {\n            locationChangeSubscription.unsubscribe();\n            urlContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=urlContexts.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nexport function startLongTaskCollection(lifeCycle, sessionManager) {\n    lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType !== 'longtask') {\n                break;\n            }\n            var session = sessionManager.findTrackedSession(entry.startTime);\n            if (!session || session.hasLitePlan) {\n                break;\n            }\n            var startClocks = relativeToClocks(entry.startTime);\n            var rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    duration: toServerDuration(entry.duration),\n                },\n                type: \"long_task\" /* LONG_TASK */,\n            };\n            lifeCycle.notify(12 /* RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry.toJSON() },\n            });\n        }\n    });\n}\n//# sourceMappingURL=longTaskCollection.js.map","import { assign } from '@datadog/browser-core';\n/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(applicationId, sessionManager, parentContexts, urlContexts) {\n    return {\n        get: function (startTime) {\n            var viewContext = parentContexts.findView(startTime);\n            var urlContext = urlContexts.findUrl(startTime);\n            var session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                var actionContext = parentContexts.findAction(startTime);\n                return {\n                    application_id: applicationId,\n                    session_id: session.id,\n                    user_action: actionContext\n                        ? {\n                            id: actionContext.action.id,\n                        }\n                        : undefined,\n                    view: assign({}, viewContext.view, urlContext.view),\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","import { canUseEventBridge, noop, runOnReadyState } from '@datadog/browser-core';\nimport { getReplayStats } from '../domain/replayStats';\nimport { startDeflateWorker } from '../domain/segmentCollection';\nexport function makeRecorderApi(startRecordingImpl, startDeflateWorkerImpl) {\n    if (startDeflateWorkerImpl === void 0) { startDeflateWorkerImpl = startDeflateWorker; }\n    if (canUseEventBridge()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n        };\n    }\n    var state = {\n        status: 0 /* Stopped */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* Stopped */ };\n    };\n    return {\n        start: function () { return startStrategy(); },\n        stop: function () { return stopStrategy(); },\n        getReplayStats: getReplayStats,\n        onRumStart: function (lifeCycle, configuration, sessionManager, parentContexts) {\n            lifeCycle.subscribe(9 /* SESSION_EXPIRED */, function () {\n                if (state.status === 2 /* Starting */ || state.status === 3 /* Started */) {\n                    stopStrategy();\n                    state = { status: 1 /* IntentToStart */ };\n                }\n            });\n            lifeCycle.subscribe(10 /* SESSION_RENEWED */, function () {\n                if (state.status === 1 /* IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            startStrategy = function () {\n                var session = sessionManager.findTrackedSession();\n                if (!session || !session.hasReplayPlan) {\n                    state = { status: 1 /* IntentToStart */ };\n                    return;\n                }\n                if (state.status === 2 /* Starting */ || state.status === 3 /* Started */) {\n                    return;\n                }\n                state = { status: 2 /* Starting */ };\n                runOnReadyState('interactive', function () {\n                    if (state.status !== 2 /* Starting */) {\n                        return;\n                    }\n                    startDeflateWorkerImpl(function (worker) {\n                        if (state.status !== 2 /* Starting */) {\n                            return;\n                        }\n                        if (!worker) {\n                            state = {\n                                status: 0 /* Stopped */,\n                            };\n                            return;\n                        }\n                        var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, parentContexts, worker).stop;\n                        state = {\n                            status: 3 /* Started */,\n                            stopRecording: stopRecording,\n                        };\n                    });\n                });\n            };\n            stopStrategy = function () {\n                if (state.status === 0 /* Stopped */) {\n                    return;\n                }\n                if (state.status === 3 /* Started */) {\n                    state.stopRecording();\n                }\n                state = {\n                    status: 0 /* Stopped */,\n                };\n            };\n            if (state.status === 1 /* IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () { return state.status === 3 /* Started */; },\n    };\n}\n//# sourceMappingURL=recorderApi.js.map","import { assign } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection } from '../domain/segmentCollection';\nimport { send } from '../transport/send';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, parentContexts, worker) {\n    var _a = startSegmentCollection(lifeCycle, configuration.applicationId, sessionManager, parentContexts, function (data, metadata, rawSegmentSize, flushReason) {\n        return send(configuration.sessionReplayEndpointBuilder, data, metadata, rawSegmentSize, flushReason);\n    }, worker), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    function addRawRecord(rawRecord) {\n        addRecord(assign({ timestamp: Date.now() }, rawRecord));\n    }\n    var _b = record({\n        emit: addRawRecord,\n        defaultPrivacyLevel: configuration.defaultPrivacyLevel,\n    }), stopRecording = _b.stop, takeFullSnapshot = _b.takeFullSnapshot, flushMutations = _b.flushMutations;\n    var unsubscribeViewEnded = lifeCycle.subscribe(6 /* VIEW_ENDED */, function () {\n        flushMutations();\n        addRawRecord({\n            type: RecordType.ViewEnd,\n        });\n    }).unsubscribe;\n    var unsubscribeViewCreated = lifeCycle.subscribe(4 /* VIEW_CREATED */, takeFullSnapshot).unsubscribe;\n    return {\n        stop: function () {\n            unsubscribeViewEnded();\n            unsubscribeViewCreated();\n            stopRecording();\n            stopSegmentCollection();\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { datadogRum } from \"@datadog/browser-rum\";\r\n\r\nimport config from \"./config.js\"\r\n\r\n//console.log(`enableDatadog is: ${config.enableDatadog}`, config.enableDatadog);\r\n\r\nif (config.enableDatadog) {\r\n    datadogRum.init({\r\n        applicationId: \"d98f5402-7b8d-443b-8745-8359be6e59fb\",\r\n        clientToken: \"pubf8c2bda621019f63218d1de9b1bd10c4\",\r\n        site: \"datadoghq.com\",\r\n        service: \"ninja\",\r\n        env: \"ninjaoutreach-prod\",\r\n        // Specify a version number to identify the deployed version of your application in Datadog\r\n        // version: '1.0.0',\r\n        sampleRate: 100,\r\n        trackInteractions: true,\r\n        defaultPrivacyLevel: \"mask-user-input\"\r\n    });\r\n    datadogRum.startSessionReplayRecording();\r\n}\r\n\r\n"],"sourceRoot":""}