{"version":3,"file":"static/chunks/pages/_app-038376515eaa6b2c.js","mappings":"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","sources":["webpack://_N_E/?adc8","webpack://_N_E/./configs/settings.ts","webpack://_N_E/./contents/landingPage.js","webpack://_N_E/./node_modules/next/dist/shared/lib/dynamic.js","webpack://_N_E/./node_modules/next/dist/shared/lib/loadable-context.js","webpack://_N_E/./node_modules/next/dist/shared/lib/loadable.js","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/logger.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/removable.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/query.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/queryCache.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/mutation.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/mutationCache.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/infiniteQueryBehavior.mjs","webpack://_N_E/./node_modules/@tanstack/react-query-devtools/build/lib/index.mjs","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/display.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/monitor.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/polyfills.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/getGlobalObject.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/byteUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/getZoneJsOriginalValue.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/timer.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/functionUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/typeUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/mergeInto.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/serialisation/jsonStringify.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/serialisation/sanitize.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/context/heavyCustomerDataWarning.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/context/contextManager.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/numberUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/timeUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/stringUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/synthetics/syntheticsWorkerValues.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/browser/addEventListener.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/context/storedContextManager.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/tracekit/computeStackTrace.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/error/error.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/experimentalFeatures.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/user/user.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/objectUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/sessionConstants.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/browserDetection.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionStoreStrategy.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/sessionState.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInCookie.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/storeStrategies/sessionInLocalStorage.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/sessionStoreOperations.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/urlPolyfill.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/configuration/intakeSites.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/matchOption.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/configuration.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/commonContext.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/sendToExtension.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/telemetry/rawTelemetryEvent.types.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/telemetry/telemetry.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/browser/pageExitObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/browser/runOnReadyState.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/browser/htmlDomUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/error/error.types.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/eventRateLimiter/createEventRateLimiter.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/syntheticsContext.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/limitModification.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/ciTestContext.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/abstractLifeCycle.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/valueHistory.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/utils/responseUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/tools/readBytesFromStream.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/waitPageActivityEnd.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/action/getActionNameFromElement.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/getSelectorFromElement.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/action/clickChain.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/action/listenActionEvents.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/action/computeFrustration.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/action/trackClickActions.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/action/actionCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/tracekit/tracekit.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/error/errorCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/error/trackConsoleError.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/error/trackReportError.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/resource/matchRequestTiming.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/resource/resourceCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/foregroundContexts.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackLargestContentfulPaint.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/interactionCountPolyfill.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackInitialViewMetrics.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackNavigationTimings.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstHidden.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstContentfulPaint.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackFirstInput.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackCumulativeLayoutShift.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/browser/viewportObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackInteractionToNextPaint.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/browser/scroll.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackScrollMetrics.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackCommonViewMetrics.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewMetrics/trackLoadingTime.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/trackViews.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/trackViewEventCounts.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/view/viewCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/transport/sendWithRetryStrategy.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/transport/flushController.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/startCustomerDataTelemetry.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/pageStateHistory.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/getSessionReplayUrl.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/constants.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeStyleSheets.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttribute.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttributes.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNode.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeDocument.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/eventsUtils.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/moveObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/scrollObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/mouseInteractionObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/inputObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/styleSheetObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/mutationObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/observers.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/mediaInteractionObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/focusObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/recordIds.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/viewportResizeObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/observers/frustrationObserver.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/boot/isBrowserSupported.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/getSessionReplayLink.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/deflate/deflateEncoder.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/domain/deflate/deflateWorker.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://_N_E/../../node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://_N_E/../../node_modules/@datadog/browser-core/esm/boot/init.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/featureFlagContext.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/viewContexts.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/urlContexts.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/displayContext.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/longTask/longTaskCollection.js","webpack://_N_E/../../node_modules/@datadog/browser-rum-core/esm/domain/contexts/internalContext.js","webpack://_N_E/../../packages/datadog/dist/index.js","webpack://_N_E/../../node_modules/react-cookie/es6/CookiesContext.js","webpack://_N_E/../../node_modules/react-cookie/es6/CookiesProvider.js","webpack://_N_E/../../node_modules/recoil/es/index.js","webpack://_N_E/./pages/_app.tsx","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/queryClient.mjs","webpack://_N_E/./node_modules/next/dynamic.js","webpack://_N_E/./node_modules/next/head.js","webpack://_N_E/./node_modules/next/router.js","webpack://_N_E/../../node_modules/cookie/index.js","webpack://_N_E/../../node_modules/process/browser.js","webpack://_N_E/../../node_modules/react-cookie/es6/Cookies.js","webpack://_N_E/../../node_modules/universal-cookie/es6/utils.js","webpack://_N_E/../../node_modules/universal-cookie/es6/Cookies.js","webpack://_N_E/../../node_modules/universal-cookie/es6/index.js","webpack://_N_E/./node_modules/@swc/helpers/src/_define_property.mjs","webpack://_N_E/./node_modules/@swc/helpers/src/_object_spread.mjs","webpack://_N_E/./node_modules/@swc/helpers/src/_object_spread_props.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/focusManager.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/notifyManager.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/onlineManager.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/retryer.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/subscribable.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/lib/utils.mjs","webpack://_N_E/./node_modules/@tanstack/react-query/build/lib/QueryClientProvider.mjs"],"sourcesContent":["\n    (window.__NEXT_P = window.__NEXT_P || []).push([\n      \"/_app\",\n      function () {\n        return require(\"private-next-pages/_app.tsx\");\n      }\n    ]);\n    if(module.hot) {\n      module.hot.dispose(function () {\n        window.__NEXT_P.push([\"/_app\"])\n      });\n    }\n  ","type Settings = {\n  API_DOMAIN: string;\n  CDN_DOMAIN: string;\n  MODE?: string;\n  PEOPLES_S3_DOMAIN: string;\n};\n\nconst ENV_MODE = process.env.NEXT_PUBLIC_MODE;\n\nconst devDefaultSettings: Settings = {\n  API_DOMAIN: \"https://api.elecle.me\",\n  CDN_DOMAIN: \"https://d12plrb6tqz2pw.cloudfront.net/assets\",\n  PEOPLES_S3_DOMAIN:\n    \"https://nine2one.s3.ap-northeast-2.amazonaws.com/station/people/data.json\"\n};\n\nconst prodDefaultSettings: Settings = {\n  API_DOMAIN: \"https://api.elecle.bike\",\n  CDN_DOMAIN: \"https://cdn.elecle.bike/assets\",\n  PEOPLES_S3_DOMAIN:\n    \"https://nine2one.s3.ap-northeast-2.amazonaws.com/station/people/data.json\"\n};\n\nconst environmentSettings: { [key: string]: Settings } = {\n  development: {\n    ...devDefaultSettings,\n    MODE: \"development\"\n  },\n  production: {\n    ...prodDefaultSettings,\n    MODE: \"production\"\n  }\n};\n\nexport const settings: Partial<Settings> = {\n  ...environmentSettings[ENV_MODE]\n};\n\nexport const chatbotSettings = {\n  BRAND_KEY: process.env.NEXT_PUBLIC_CHAT_BRAND_KEY,\n  CHANNEL_TYPE: process.env.NEXT_PUBLIC_CHAT_CHANNEL_TYPE,\n  SCENARIO_ID: process.env.NEXT_PUBLIC_CHAT_SCENARIOD_ID\n};\n","export const SPIRIT = [\n  {\n    id: \"1.\",\n    title: \"우리는 어떤 의견이든 일단 경청합니다.\"\n  },\n  {\n    id: \"2.\",\n    title: \"나인투원에서는 누구나 의견을 이야기할 수 있습니다.\"\n  },\n  {\n    id: \"3.\",\n    title:\n      \"우리는 자유롭게 일할 수 있는 회사에서 최고의 퍼포먼스가 나온다고 믿습니다.\"\n  },\n  {\n    id: \"4.\",\n    title: \"우리는 스스로, 열정적으로 경쟁력을 만들어 나갑니다.\"\n  },\n  {\n    id: \"5.\",\n    title:\n      \"나인투원의 프로페셔널은 각자의 역할과 자부심으로 서로를 편견없이 존중하는 것입니다.\"\n  },\n  {\n    id: \"6.\",\n    title: \"우리는 세상에 없던 무언가를 만들어내기 위해 즐겁게 일합니다.\"\n  },\n  {\n    id: \"7.\",\n    title: \"우리는 똑똑과 열정 이전에 올바름을 갖춘 사람을 지향합니다.\"\n  },\n  {\n    id: \"8.\",\n    title: \"고민과 토론은 충분히, 결정은 신속히, 실행은 지금 즉시합니다.\"\n  },\n  {\n    id: \"9.\",\n    title: \"우리는 투명한 정보공유가 최선의 의사결정을 만든다고 믿습니다.\"\n  }\n];\n\nexport const PARTNERS = [\n  \"molit\",\n  \"mois\",\n  \"seoul\",\n  \"sejong\",\n  \"gimpo\",\n  \"bucheon\",\n  \"jeju\",\n  \"samsung\",\n  \"h-ec\",\n  \"socar\",\n  \"lgcns\",\n  \"ktpowertel\"\n];\n\nexport const ARTICLES = [\n  {\n    title: \"쏘카 공유전기자전거 3기 가맹사업자 모집\",\n    subtitle: \"헤럴드경제 | 2024.01.15\",\n    link: \"https://news.heraldcorp.com/view.php?ud=20240115000351\"\n  },\n  {\n    title: \"쏘카 공유 퍼스널 모빌리티 플랫폼 일레클, 3기 가맹사업자 모집\",\n    subtitle: \"매일일보 | 2024.01.12\",\n    link: \"https://www.m-i.kr/news/articleView.html?idxno=1084024\"\n  },\n  {\n    title:\n      \"전기자전거 일레클, 가맹사업자 3기 모집…상반기 가맹 규모 1만 대까지 확대\",\n    subtitle: \"서울경제 | 2024.01.12\",\n    link: \"https://www.sedaily.com/NewsView/2D420IAVKO\"\n  },\n  {\n    title: \"일레클, 3기 가맹사업자 모집…상반기 가맹 운영대수 1만대로\",\n    subtitle: \"연합뉴스 | 2024.01.12\",\n    link: \"https://www.yna.co.kr/view/AKR20240112024900030?input=1195m\"\n  },\n  {\n    title: \"'이동의 모든 순간을 연결하라'…쏘카, 스트리밍 모빌리티 고도화\",\n    subtitle: \"이데일리 | 2023.10.31\",\n    link: \"https://www.edaily.co.kr/news/read?newsId=01292326635778496&mediaCodeNo=257&OutLnkChk=Y\"\n  },\n  {\n    title: \"메이트네트웍스, 속초 이어 강릉으로 전기자전거 '일레클' 서비스 확대\",\n    subtitle: \"에너지경제신문 | 2023.09.08\",\n    link: \"https://www.ekn.kr/web/view.php?key=20230908001049034\"\n  },\n  {\n    title: \"'일레클' 고성장…쏘카, 연간 흑자 기대감 '솔솔'\",\n    subtitle: \"딜사이트 | 2023.08.21\",\n    link: \"https://dealsite.co.kr/articles/108810\"\n  },\n  {\n    title: \"“전기자전거로만 110억원”...쏘카 일레클 매출 3배 ‘쑥’\",\n    subtitle: \"매일경제 | 2023.02.18\",\n    link: \"https://www.mk.co.kr/news/business/10650077\"\n  }\n];\n\nexport const GA_ID = \"UA-144258378-1\";\n","\"client\";\n\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.default = dynamic;\nexports.noSSR = noSSR;\nvar _extends = require(\"@swc/helpers/lib/_extends.js\").default;\nvar _interop_require_default = require(\"@swc/helpers/lib/_interop_require_default.js\").default;\nvar _react = _interop_require_default(require(\"react\"));\nvar _loadable = _interop_require_default(require(\"./loadable\"));\nfunction dynamic(dynamicOptions, options) {\n    let loadableFn = _loadable.default;\n    let loadableOptions = (options == null ? void 0 : options.suspense) ? {} : {\n        // A loading component is not required, so we default it\n        loading: ({ error , isLoading , pastDelay  })=>{\n            if (!pastDelay) return null;\n            if (process.env.NODE_ENV === 'development') {\n                if (isLoading) {\n                    return null;\n                }\n                if (error) {\n                    return /*#__PURE__*/ _react.default.createElement(\"p\", null, error.message, /*#__PURE__*/ _react.default.createElement(\"br\", null), error.stack);\n                }\n            }\n            return null;\n        }\n    };\n    // Support for direct import(), eg: dynamic(import('../hello-world'))\n    // Note that this is only kept for the edge case where someone is passing in a promise as first argument\n    // The react-loadable babel plugin will turn dynamic(import('../hello-world')) into dynamic(() => import('../hello-world'))\n    // To make sure we don't execute the import without rendering first\n    if (dynamicOptions instanceof Promise) {\n        loadableOptions.loader = ()=>dynamicOptions;\n    // Support for having import as a function, eg: dynamic(() => import('../hello-world'))\n    } else if (typeof dynamicOptions === 'function') {\n        loadableOptions.loader = dynamicOptions;\n    // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')})\n    } else if (typeof dynamicOptions === 'object') {\n        loadableOptions = _extends({}, loadableOptions, dynamicOptions);\n    }\n    // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () => <p>Loading something</p>})\n    loadableOptions = _extends({}, loadableOptions, options);\n    // Error if Fizz rendering is not enabled and `suspense` option is set to true\n    if (!process.env.__NEXT_REACT_ROOT && loadableOptions.suspense) {\n        throw new Error(`Invalid suspense option usage in next/dynamic. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense`);\n    }\n    if (loadableOptions.suspense) {\n        if (process.env.NODE_ENV !== 'production') {\n            /**\n       * TODO: Currently, next/dynamic will opt-in to React.lazy if { suspense: true } is used\n       * React 18 will always resolve the Suspense boundary on the server-side, effectively ignoring the ssr option\n       *\n       * In the future, when React Suspense with third-party libraries is stable, we can implement a custom version of\n       * React.lazy that can suspense on the server-side while only loading the component on the client-side\n       */ if (loadableOptions.ssr === false) {\n                console.warn(`\"ssr: false\" is ignored by next/dynamic because you can not enable \"suspense\" while disabling \"ssr\" at the same time. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense`);\n            }\n            if (loadableOptions.loading != null) {\n                console.warn(`\"loading\" is ignored by next/dynamic because you have enabled \"suspense\". Place your loading element in your suspense boundary's \"fallback\" prop instead. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense`);\n            }\n        }\n        delete loadableOptions.ssr;\n        delete loadableOptions.loading;\n    }\n    // coming from build/babel/plugins/react-loadable-plugin.js\n    if (loadableOptions.loadableGenerated) {\n        loadableOptions = _extends({}, loadableOptions, loadableOptions.loadableGenerated);\n        delete loadableOptions.loadableGenerated;\n    }\n    // support for disabling server side rendering, eg: dynamic(import('../hello-world'), {ssr: false}).\n    // skip `ssr` for suspense mode and opt-in React.lazy directly\n    if (typeof loadableOptions.ssr === 'boolean' && !loadableOptions.suspense) {\n        if (!loadableOptions.ssr) {\n            delete loadableOptions.ssr;\n            return noSSR(loadableFn, loadableOptions);\n        }\n        delete loadableOptions.ssr;\n    }\n    return loadableFn(loadableOptions);\n}\n'client';\nconst isServerSide = typeof window === 'undefined';\nfunction noSSR(LoadableInitializer, loadableOptions) {\n    // Removing webpack and modules means react-loadable won't try preloading\n    delete loadableOptions.webpack;\n    delete loadableOptions.modules;\n    // This check is necessary to prevent react-loadable from initializing on the server\n    if (!isServerSide) {\n        return LoadableInitializer(loadableOptions);\n    }\n    const Loading = loadableOptions.loading;\n    // This will only be rendered on the server side\n    return ()=>/*#__PURE__*/ _react.default.createElement(Loading, {\n            error: null,\n            isLoading: true,\n            pastDelay: false,\n            timedOut: false\n        });\n}\n\nif ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {\n  Object.defineProperty(exports.default, '__esModule', { value: true });\n  Object.assign(exports.default, exports);\n  module.exports = exports.default;\n}\n\n//# sourceMappingURL=dynamic.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.LoadableContext = void 0;\nvar _interop_require_default = require(\"@swc/helpers/lib/_interop_require_default.js\").default;\nvar _react = _interop_require_default(require(\"react\"));\nconst LoadableContext = _react.default.createContext(null);\nexports.LoadableContext = LoadableContext;\nif (process.env.NODE_ENV !== 'production') {\n    LoadableContext.displayName = 'LoadableContext';\n}\n\n//# sourceMappingURL=loadable-context.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.default = void 0;\nvar _extends = require(\"@swc/helpers/lib/_extends.js\").default;\nvar _interop_require_default = require(\"@swc/helpers/lib/_interop_require_default.js\").default;\nvar _react = _interop_require_default(require(\"react\"));\nvar _loadableContext = require(\"./loadable-context\");\nconst { useSyncExternalStore  } = process.env.__NEXT_REACT_ROOT ? require('react') : require('use-sync-external-store/shim');\nconst ALL_INITIALIZERS = [];\nconst READY_INITIALIZERS = [];\nlet initialized = false;\nfunction load(loader) {\n    let promise = loader();\n    let state = {\n        loading: true,\n        loaded: null,\n        error: null\n    };\n    state.promise = promise.then((loaded)=>{\n        state.loading = false;\n        state.loaded = loaded;\n        return loaded;\n    }).catch((err)=>{\n        state.loading = false;\n        state.error = err;\n        throw err;\n    });\n    return state;\n}\nfunction resolve(obj) {\n    return obj && obj.__esModule ? obj.default : obj;\n}\nfunction createLoadableComponent(loadFn, options) {\n    let opts = Object.assign({\n        loader: null,\n        loading: null,\n        delay: 200,\n        timeout: null,\n        webpack: null,\n        modules: null,\n        suspense: false\n    }, options);\n    if (opts.suspense) {\n        opts.lazy = _react.default.lazy(opts.loader);\n    }\n    /** @type LoadableSubscription */ let subscription = null;\n    function init() {\n        if (!subscription) {\n            const sub = new LoadableSubscription(loadFn, opts);\n            subscription = {\n                getCurrentValue: sub.getCurrentValue.bind(sub),\n                subscribe: sub.subscribe.bind(sub),\n                retry: sub.retry.bind(sub),\n                promise: sub.promise.bind(sub)\n            };\n        }\n        return subscription.promise();\n    }\n    // Server only\n    if (typeof window === 'undefined') {\n        ALL_INITIALIZERS.push(init);\n    }\n    // Client only\n    if (!initialized && typeof window !== 'undefined') {\n        // require.resolveWeak check is needed for environments that don't have it available like Jest\n        const moduleIds = opts.webpack && typeof require.resolveWeak === 'function' ? opts.webpack() : opts.modules;\n        if (moduleIds) {\n            READY_INITIALIZERS.push((ids)=>{\n                for (const moduleId of moduleIds){\n                    if (ids.indexOf(moduleId) !== -1) {\n                        return init();\n                    }\n                }\n            });\n        }\n    }\n    function useLoadableModule() {\n        init();\n        const context = _react.default.useContext(_loadableContext.LoadableContext);\n        if (context && Array.isArray(opts.modules)) {\n            opts.modules.forEach((moduleName)=>{\n                context(moduleName);\n            });\n        }\n    }\n    function LoadableImpl(props, ref) {\n        useLoadableModule();\n        const state = useSyncExternalStore(subscription.subscribe, subscription.getCurrentValue, subscription.getCurrentValue);\n        _react.default.useImperativeHandle(ref, ()=>({\n                retry: subscription.retry\n            }), []);\n        return _react.default.useMemo(()=>{\n            if (state.loading || state.error) {\n                return _react.default.createElement(opts.loading, {\n                    isLoading: state.loading,\n                    pastDelay: state.pastDelay,\n                    timedOut: state.timedOut,\n                    error: state.error,\n                    retry: subscription.retry\n                });\n            } else if (state.loaded) {\n                return _react.default.createElement(resolve(state.loaded), props);\n            } else {\n                return null;\n            }\n        }, [\n            props,\n            state\n        ]);\n    }\n    function LazyImpl(props, ref) {\n        useLoadableModule();\n        return _react.default.createElement(opts.lazy, _extends({}, props, {\n            ref\n        }));\n    }\n    const LoadableComponent = opts.suspense ? LazyImpl : LoadableImpl;\n    LoadableComponent.preload = ()=>init();\n    LoadableComponent.displayName = 'LoadableComponent';\n    return _react.default.forwardRef(LoadableComponent);\n}\nclass LoadableSubscription {\n    promise() {\n        return this._res.promise;\n    }\n    retry() {\n        this._clearTimeouts();\n        this._res = this._loadFn(this._opts.loader);\n        this._state = {\n            pastDelay: false,\n            timedOut: false\n        };\n        const { _res: res , _opts: opts  } = this;\n        if (res.loading) {\n            if (typeof opts.delay === 'number') {\n                if (opts.delay === 0) {\n                    this._state.pastDelay = true;\n                } else {\n                    this._delay = setTimeout(()=>{\n                        this._update({\n                            pastDelay: true\n                        });\n                    }, opts.delay);\n                }\n            }\n            if (typeof opts.timeout === 'number') {\n                this._timeout = setTimeout(()=>{\n                    this._update({\n                        timedOut: true\n                    });\n                }, opts.timeout);\n            }\n        }\n        this._res.promise.then(()=>{\n            this._update({});\n            this._clearTimeouts();\n        }).catch((_err)=>{\n            this._update({});\n            this._clearTimeouts();\n        });\n        this._update({});\n    }\n    _update(partial) {\n        this._state = _extends({}, this._state, {\n            error: this._res.error,\n            loaded: this._res.loaded,\n            loading: this._res.loading\n        }, partial);\n        this._callbacks.forEach((callback)=>callback());\n    }\n    _clearTimeouts() {\n        clearTimeout(this._delay);\n        clearTimeout(this._timeout);\n    }\n    getCurrentValue() {\n        return this._state;\n    }\n    subscribe(callback) {\n        this._callbacks.add(callback);\n        return ()=>{\n            this._callbacks.delete(callback);\n        };\n    }\n    constructor(loadFn, opts){\n        this._loadFn = loadFn;\n        this._opts = opts;\n        this._callbacks = new Set();\n        this._delay = null;\n        this._timeout = null;\n        this.retry();\n    }\n}\nfunction Loadable(opts) {\n    return createLoadableComponent(load, opts);\n}\nfunction flushInitializers(initializers, ids) {\n    let promises = [];\n    while(initializers.length){\n        let init = initializers.pop();\n        promises.push(init(ids));\n    }\n    return Promise.all(promises).then(()=>{\n        if (initializers.length) {\n            return flushInitializers(initializers, ids);\n        }\n    });\n}\nLoadable.preloadAll = ()=>{\n    return new Promise((resolveInitializers, reject)=>{\n        flushInitializers(ALL_INITIALIZERS).then(resolveInitializers, reject);\n    });\n};\nLoadable.preloadReady = (ids = [])=>{\n    return new Promise((resolvePreload)=>{\n        const res = ()=>{\n            initialized = true;\n            return resolvePreload();\n        };\n        // We always will resolve, errors should be handled within loading UIs.\n        flushInitializers(READY_INITIALIZERS, ids).then(res, res);\n    });\n};\nif (typeof window !== 'undefined') {\n    window.__NEXT_PRELOADREADY = Loadable.preloadReady;\n}\nvar _default = Loadable;\nexports.default = _default;\n\n//# sourceMappingURL=loadable.js.map","const defaultLogger = console;\n\nexport { defaultLogger };\n//# sourceMappingURL=logger.mjs.map\n","import { isValidTimeout, isServer } from './utils.mjs';\n\nclass Removable {\n  destroy() {\n    this.clearGcTimeout();\n  }\n\n  scheduleGc() {\n    this.clearGcTimeout();\n\n    if (isValidTimeout(this.cacheTime)) {\n      this.gcTimeout = setTimeout(() => {\n        this.optionalRemove();\n      }, this.cacheTime);\n    }\n  }\n\n  updateCacheTime(newCacheTime) {\n    // Default to 5 minutes (Infinity for server-side) if no cache time is set\n    this.cacheTime = Math.max(this.cacheTime || 0, newCacheTime != null ? newCacheTime : isServer ? Infinity : 5 * 60 * 1000);\n  }\n\n  clearGcTimeout() {\n    if (this.gcTimeout) {\n      clearTimeout(this.gcTimeout);\n      this.gcTimeout = undefined;\n    }\n  }\n\n}\n\nexport { Removable };\n//# sourceMappingURL=removable.mjs.map\n","import { replaceData, noop, timeUntilStale, getAbortController } from './utils.mjs';\nimport { defaultLogger } from './logger.mjs';\nimport { notifyManager } from './notifyManager.mjs';\nimport { createRetryer, isCancelledError, canFetch } from './retryer.mjs';\nimport { Removable } from './removable.mjs';\n\n// CLASS\nclass Query extends Removable {\n  constructor(config) {\n    super();\n    this.abortSignalConsumed = false;\n    this.defaultOptions = config.defaultOptions;\n    this.setOptions(config.options);\n    this.observers = [];\n    this.cache = config.cache;\n    this.logger = config.logger || defaultLogger;\n    this.queryKey = config.queryKey;\n    this.queryHash = config.queryHash;\n    this.initialState = config.state || getDefaultState(this.options);\n    this.state = this.initialState;\n    this.scheduleGc();\n  }\n\n  get meta() {\n    return this.options.meta;\n  }\n\n  setOptions(options) {\n    this.options = { ...this.defaultOptions,\n      ...options\n    };\n    this.updateCacheTime(this.options.cacheTime);\n  }\n\n  optionalRemove() {\n    if (!this.observers.length && this.state.fetchStatus === 'idle') {\n      this.cache.remove(this);\n    }\n  }\n\n  setData(newData, options) {\n    const data = replaceData(this.state.data, newData, this.options); // Set data and mark it as cached\n\n    this.dispatch({\n      data,\n      type: 'success',\n      dataUpdatedAt: options == null ? void 0 : options.updatedAt,\n      manual: options == null ? void 0 : options.manual\n    });\n    return data;\n  }\n\n  setState(state, setStateOptions) {\n    this.dispatch({\n      type: 'setState',\n      state,\n      setStateOptions\n    });\n  }\n\n  cancel(options) {\n    var _this$retryer;\n\n    const promise = this.promise;\n    (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);\n    return promise ? promise.then(noop).catch(noop) : Promise.resolve();\n  }\n\n  destroy() {\n    super.destroy();\n    this.cancel({\n      silent: true\n    });\n  }\n\n  reset() {\n    this.destroy();\n    this.setState(this.initialState);\n  }\n\n  isActive() {\n    return this.observers.some(observer => observer.options.enabled !== false);\n  }\n\n  isDisabled() {\n    return this.getObserversCount() > 0 && !this.isActive();\n  }\n\n  isStale() {\n    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(observer => observer.getCurrentResult().isStale);\n  }\n\n  isStaleByTime(staleTime = 0) {\n    return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);\n  }\n\n  onFocus() {\n    var _this$retryer2;\n\n    const observer = this.observers.find(x => x.shouldFetchOnWindowFocus());\n\n    if (observer) {\n      observer.refetch({\n        cancelRefetch: false\n      });\n    } // Continue fetch if currently paused\n\n\n    (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();\n  }\n\n  onOnline() {\n    var _this$retryer3;\n\n    const observer = this.observers.find(x => x.shouldFetchOnReconnect());\n\n    if (observer) {\n      observer.refetch({\n        cancelRefetch: false\n      });\n    } // Continue fetch if currently paused\n\n\n    (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();\n  }\n\n  addObserver(observer) {\n    if (!this.observers.includes(observer)) {\n      this.observers.push(observer); // Stop the query from being garbage collected\n\n      this.clearGcTimeout();\n      this.cache.notify({\n        type: 'observerAdded',\n        query: this,\n        observer\n      });\n    }\n  }\n\n  removeObserver(observer) {\n    if (this.observers.includes(observer)) {\n      this.observers = this.observers.filter(x => x !== observer);\n\n      if (!this.observers.length) {\n        // If the transport layer does not support cancellation\n        // we'll let the query continue so the result can be cached\n        if (this.retryer) {\n          if (this.abortSignalConsumed) {\n            this.retryer.cancel({\n              revert: true\n            });\n          } else {\n            this.retryer.cancelRetry();\n          }\n        }\n\n        this.scheduleGc();\n      }\n\n      this.cache.notify({\n        type: 'observerRemoved',\n        query: this,\n        observer\n      });\n    }\n  }\n\n  getObserversCount() {\n    return this.observers.length;\n  }\n\n  invalidate() {\n    if (!this.state.isInvalidated) {\n      this.dispatch({\n        type: 'invalidate'\n      });\n    }\n  }\n\n  fetch(options, fetchOptions) {\n    var _this$options$behavio, _context$fetchOptions;\n\n    if (this.state.fetchStatus !== 'idle') {\n      if (this.state.dataUpdatedAt && fetchOptions != null && fetchOptions.cancelRefetch) {\n        // Silently cancel current fetch if the user wants to cancel refetches\n        this.cancel({\n          silent: true\n        });\n      } else if (this.promise) {\n        var _this$retryer4;\n\n        // make sure that retries that were potentially cancelled due to unmounts can continue\n        (_this$retryer4 = this.retryer) == null ? void 0 : _this$retryer4.continueRetry(); // Return current promise if we are already fetching\n\n        return this.promise;\n      }\n    } // Update config if passed, otherwise the config from the last execution is used\n\n\n    if (options) {\n      this.setOptions(options);\n    } // Use the options from the first observer with a query function if no function is found.\n    // This can happen when the query is hydrated or created with setQueryData.\n\n\n    if (!this.options.queryFn) {\n      const observer = this.observers.find(x => x.options.queryFn);\n\n      if (observer) {\n        this.setOptions(observer.options);\n      }\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!Array.isArray(this.options.queryKey)) {\n        this.logger.error(\"As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']\");\n      }\n    }\n\n    const abortController = getAbortController(); // Create query function context\n\n    const queryFnContext = {\n      queryKey: this.queryKey,\n      pageParam: undefined,\n      meta: this.meta\n    }; // Adds an enumerable signal property to the object that\n    // which sets abortSignalConsumed to true when the signal\n    // is read.\n\n    const addSignalProperty = object => {\n      Object.defineProperty(object, 'signal', {\n        enumerable: true,\n        get: () => {\n          if (abortController) {\n            this.abortSignalConsumed = true;\n            return abortController.signal;\n          }\n\n          return undefined;\n        }\n      });\n    };\n\n    addSignalProperty(queryFnContext); // Create fetch function\n\n    const fetchFn = () => {\n      if (!this.options.queryFn) {\n        return Promise.reject(\"Missing queryFn for queryKey '\" + this.options.queryHash + \"'\");\n      }\n\n      this.abortSignalConsumed = false;\n      return this.options.queryFn(queryFnContext);\n    }; // Trigger behavior hook\n\n\n    const context = {\n      fetchOptions,\n      options: this.options,\n      queryKey: this.queryKey,\n      state: this.state,\n      fetchFn\n    };\n    addSignalProperty(context);\n    (_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch(context); // Store state in case the current fetch needs to be reverted\n\n    this.revertState = this.state; // Set to fetching state if not already in it\n\n    if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {\n      var _context$fetchOptions2;\n\n      this.dispatch({\n        type: 'fetch',\n        meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta\n      });\n    }\n\n    const onError = error => {\n      // Optimistically update state if needed\n      if (!(isCancelledError(error) && error.silent)) {\n        this.dispatch({\n          type: 'error',\n          error: error\n        });\n      }\n\n      if (!isCancelledError(error)) {\n        var _this$cache$config$on, _this$cache$config, _this$cache$config$on2, _this$cache$config2;\n\n        // Notify cache callback\n        (_this$cache$config$on = (_this$cache$config = this.cache.config).onError) == null ? void 0 : _this$cache$config$on.call(_this$cache$config, error, this);\n        (_this$cache$config$on2 = (_this$cache$config2 = this.cache.config).onSettled) == null ? void 0 : _this$cache$config$on2.call(_this$cache$config2, this.state.data, error, this);\n\n        if (process.env.NODE_ENV !== 'production') {\n          this.logger.error(error);\n        }\n      }\n\n      if (!this.isFetchingOptimistic) {\n        // Schedule query gc after fetching\n        this.scheduleGc();\n      }\n\n      this.isFetchingOptimistic = false;\n    }; // Try to fetch the data\n\n\n    this.retryer = createRetryer({\n      fn: context.fetchFn,\n      abort: abortController == null ? void 0 : abortController.abort.bind(abortController),\n      onSuccess: data => {\n        var _this$cache$config$on3, _this$cache$config3, _this$cache$config$on4, _this$cache$config4;\n\n        if (typeof data === 'undefined') {\n          if (process.env.NODE_ENV !== 'production') {\n            this.logger.error(\"Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: \" + this.queryHash);\n          }\n\n          onError(new Error(this.queryHash + \" data is undefined\"));\n          return;\n        }\n\n        this.setData(data); // Notify cache callback\n\n        (_this$cache$config$on3 = (_this$cache$config3 = this.cache.config).onSuccess) == null ? void 0 : _this$cache$config$on3.call(_this$cache$config3, data, this);\n        (_this$cache$config$on4 = (_this$cache$config4 = this.cache.config).onSettled) == null ? void 0 : _this$cache$config$on4.call(_this$cache$config4, data, this.state.error, this);\n\n        if (!this.isFetchingOptimistic) {\n          // Schedule query gc after fetching\n          this.scheduleGc();\n        }\n\n        this.isFetchingOptimistic = false;\n      },\n      onError,\n      onFail: (failureCount, error) => {\n        this.dispatch({\n          type: 'failed',\n          failureCount,\n          error\n        });\n      },\n      onPause: () => {\n        this.dispatch({\n          type: 'pause'\n        });\n      },\n      onContinue: () => {\n        this.dispatch({\n          type: 'continue'\n        });\n      },\n      retry: context.options.retry,\n      retryDelay: context.options.retryDelay,\n      networkMode: context.options.networkMode\n    });\n    this.promise = this.retryer.promise;\n    return this.promise;\n  }\n\n  dispatch(action) {\n    const reducer = state => {\n      var _action$meta, _action$dataUpdatedAt;\n\n      switch (action.type) {\n        case 'failed':\n          return { ...state,\n            fetchFailureCount: action.failureCount,\n            fetchFailureReason: action.error\n          };\n\n        case 'pause':\n          return { ...state,\n            fetchStatus: 'paused'\n          };\n\n        case 'continue':\n          return { ...state,\n            fetchStatus: 'fetching'\n          };\n\n        case 'fetch':\n          return { ...state,\n            fetchFailureCount: 0,\n            fetchFailureReason: null,\n            fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,\n            fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',\n            ...(!state.dataUpdatedAt && {\n              error: null,\n              status: 'loading'\n            })\n          };\n\n        case 'success':\n          return { ...state,\n            data: action.data,\n            dataUpdateCount: state.dataUpdateCount + 1,\n            dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),\n            error: null,\n            isInvalidated: false,\n            status: 'success',\n            ...(!action.manual && {\n              fetchStatus: 'idle',\n              fetchFailureCount: 0,\n              fetchFailureReason: null\n            })\n          };\n\n        case 'error':\n          const error = action.error;\n\n          if (isCancelledError(error) && error.revert && this.revertState) {\n            return { ...this.revertState,\n              fetchStatus: 'idle'\n            };\n          }\n\n          return { ...state,\n            error: error,\n            errorUpdateCount: state.errorUpdateCount + 1,\n            errorUpdatedAt: Date.now(),\n            fetchFailureCount: state.fetchFailureCount + 1,\n            fetchFailureReason: error,\n            fetchStatus: 'idle',\n            status: 'error'\n          };\n\n        case 'invalidate':\n          return { ...state,\n            isInvalidated: true\n          };\n\n        case 'setState':\n          return { ...state,\n            ...action.state\n          };\n      }\n    };\n\n    this.state = reducer(this.state);\n    notifyManager.batch(() => {\n      this.observers.forEach(observer => {\n        observer.onQueryUpdate(action);\n      });\n      this.cache.notify({\n        query: this,\n        type: 'updated',\n        action\n      });\n    });\n  }\n\n}\n\nfunction getDefaultState(options) {\n  const data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;\n  const hasData = typeof data !== 'undefined';\n  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === 'function' ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;\n  return {\n    data,\n    dataUpdateCount: 0,\n    dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,\n    error: null,\n    errorUpdateCount: 0,\n    errorUpdatedAt: 0,\n    fetchFailureCount: 0,\n    fetchFailureReason: null,\n    fetchMeta: null,\n    isInvalidated: false,\n    status: hasData ? 'success' : 'loading',\n    fetchStatus: 'idle'\n  };\n}\n\nexport { Query };\n//# sourceMappingURL=query.mjs.map\n","import { hashQueryKeyByOptions, parseFilterArgs, matchQuery } from './utils.mjs';\nimport { Query } from './query.mjs';\nimport { notifyManager } from './notifyManager.mjs';\nimport { Subscribable } from './subscribable.mjs';\n\n// CLASS\nclass QueryCache extends Subscribable {\n  constructor(config) {\n    super();\n    this.config = config || {};\n    this.queries = [];\n    this.queriesMap = {};\n  }\n\n  build(client, options, state) {\n    var _options$queryHash;\n\n    const queryKey = options.queryKey;\n    const queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);\n    let query = this.get(queryHash);\n\n    if (!query) {\n      query = new Query({\n        cache: this,\n        logger: client.getLogger(),\n        queryKey,\n        queryHash,\n        options: client.defaultQueryOptions(options),\n        state,\n        defaultOptions: client.getQueryDefaults(queryKey)\n      });\n      this.add(query);\n    }\n\n    return query;\n  }\n\n  add(query) {\n    if (!this.queriesMap[query.queryHash]) {\n      this.queriesMap[query.queryHash] = query;\n      this.queries.push(query);\n      this.notify({\n        type: 'added',\n        query\n      });\n    }\n  }\n\n  remove(query) {\n    const queryInMap = this.queriesMap[query.queryHash];\n\n    if (queryInMap) {\n      query.destroy();\n      this.queries = this.queries.filter(x => x !== query);\n\n      if (queryInMap === query) {\n        delete this.queriesMap[query.queryHash];\n      }\n\n      this.notify({\n        type: 'removed',\n        query\n      });\n    }\n  }\n\n  clear() {\n    notifyManager.batch(() => {\n      this.queries.forEach(query => {\n        this.remove(query);\n      });\n    });\n  }\n\n  get(queryHash) {\n    return this.queriesMap[queryHash];\n  }\n\n  getAll() {\n    return this.queries;\n  }\n\n  find(arg1, arg2) {\n    const [filters] = parseFilterArgs(arg1, arg2);\n\n    if (typeof filters.exact === 'undefined') {\n      filters.exact = true;\n    }\n\n    return this.queries.find(query => matchQuery(filters, query));\n  }\n\n  findAll(arg1, arg2) {\n    const [filters] = parseFilterArgs(arg1, arg2);\n    return Object.keys(filters).length > 0 ? this.queries.filter(query => matchQuery(filters, query)) : this.queries;\n  }\n\n  notify(event) {\n    notifyManager.batch(() => {\n      this.listeners.forEach(({\n        listener\n      }) => {\n        listener(event);\n      });\n    });\n  }\n\n  onFocus() {\n    notifyManager.batch(() => {\n      this.queries.forEach(query => {\n        query.onFocus();\n      });\n    });\n  }\n\n  onOnline() {\n    notifyManager.batch(() => {\n      this.queries.forEach(query => {\n        query.onOnline();\n      });\n    });\n  }\n\n}\n\nexport { QueryCache };\n//# sourceMappingURL=queryCache.mjs.map\n","import { defaultLogger } from './logger.mjs';\nimport { notifyManager } from './notifyManager.mjs';\nimport { Removable } from './removable.mjs';\nimport { createRetryer, canFetch } from './retryer.mjs';\n\n// CLASS\nclass Mutation extends Removable {\n  constructor(config) {\n    super();\n    this.defaultOptions = config.defaultOptions;\n    this.mutationId = config.mutationId;\n    this.mutationCache = config.mutationCache;\n    this.logger = config.logger || defaultLogger;\n    this.observers = [];\n    this.state = config.state || getDefaultState();\n    this.setOptions(config.options);\n    this.scheduleGc();\n  }\n\n  setOptions(options) {\n    this.options = { ...this.defaultOptions,\n      ...options\n    };\n    this.updateCacheTime(this.options.cacheTime);\n  }\n\n  get meta() {\n    return this.options.meta;\n  }\n\n  setState(state) {\n    this.dispatch({\n      type: 'setState',\n      state\n    });\n  }\n\n  addObserver(observer) {\n    if (!this.observers.includes(observer)) {\n      this.observers.push(observer); // Stop the mutation from being garbage collected\n\n      this.clearGcTimeout();\n      this.mutationCache.notify({\n        type: 'observerAdded',\n        mutation: this,\n        observer\n      });\n    }\n  }\n\n  removeObserver(observer) {\n    this.observers = this.observers.filter(x => x !== observer);\n    this.scheduleGc();\n    this.mutationCache.notify({\n      type: 'observerRemoved',\n      mutation: this,\n      observer\n    });\n  }\n\n  optionalRemove() {\n    if (!this.observers.length) {\n      if (this.state.status === 'loading') {\n        this.scheduleGc();\n      } else {\n        this.mutationCache.remove(this);\n      }\n    }\n  }\n\n  continue() {\n    var _this$retryer$continu, _this$retryer;\n\n    return (_this$retryer$continu = (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.continue()) != null ? _this$retryer$continu : this.execute();\n  }\n\n  async execute() {\n    const executeMutation = () => {\n      var _this$options$retry;\n\n      this.retryer = createRetryer({\n        fn: () => {\n          if (!this.options.mutationFn) {\n            return Promise.reject('No mutationFn found');\n          }\n\n          return this.options.mutationFn(this.state.variables);\n        },\n        onFail: (failureCount, error) => {\n          this.dispatch({\n            type: 'failed',\n            failureCount,\n            error\n          });\n        },\n        onPause: () => {\n          this.dispatch({\n            type: 'pause'\n          });\n        },\n        onContinue: () => {\n          this.dispatch({\n            type: 'continue'\n          });\n        },\n        retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,\n        retryDelay: this.options.retryDelay,\n        networkMode: this.options.networkMode\n      });\n      return this.retryer.promise;\n    };\n\n    const restored = this.state.status === 'loading';\n\n    try {\n      var _this$mutationCache$c3, _this$mutationCache$c4, _this$options$onSucce, _this$options2, _this$mutationCache$c5, _this$mutationCache$c6, _this$options$onSettl, _this$options3;\n\n      if (!restored) {\n        var _this$mutationCache$c, _this$mutationCache$c2, _this$options$onMutat, _this$options;\n\n        this.dispatch({\n          type: 'loading',\n          variables: this.options.variables\n        }); // Notify cache callback\n\n        await ((_this$mutationCache$c = (_this$mutationCache$c2 = this.mutationCache.config).onMutate) == null ? void 0 : _this$mutationCache$c.call(_this$mutationCache$c2, this.state.variables, this));\n        const context = await ((_this$options$onMutat = (_this$options = this.options).onMutate) == null ? void 0 : _this$options$onMutat.call(_this$options, this.state.variables));\n\n        if (context !== this.state.context) {\n          this.dispatch({\n            type: 'loading',\n            context,\n            variables: this.state.variables\n          });\n        }\n      }\n\n      const data = await executeMutation(); // Notify cache callback\n\n      await ((_this$mutationCache$c3 = (_this$mutationCache$c4 = this.mutationCache.config).onSuccess) == null ? void 0 : _this$mutationCache$c3.call(_this$mutationCache$c4, data, this.state.variables, this.state.context, this));\n      await ((_this$options$onSucce = (_this$options2 = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options2, data, this.state.variables, this.state.context)); // Notify cache callback\n\n      await ((_this$mutationCache$c5 = (_this$mutationCache$c6 = this.mutationCache.config).onSettled) == null ? void 0 : _this$mutationCache$c5.call(_this$mutationCache$c6, data, null, this.state.variables, this.state.context, this));\n      await ((_this$options$onSettl = (_this$options3 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options3, data, null, this.state.variables, this.state.context));\n      this.dispatch({\n        type: 'success',\n        data\n      });\n      return data;\n    } catch (error) {\n      try {\n        var _this$mutationCache$c7, _this$mutationCache$c8, _this$options$onError, _this$options4, _this$mutationCache$c9, _this$mutationCache$c10, _this$options$onSettl2, _this$options5;\n\n        // Notify cache callback\n        await ((_this$mutationCache$c7 = (_this$mutationCache$c8 = this.mutationCache.config).onError) == null ? void 0 : _this$mutationCache$c7.call(_this$mutationCache$c8, error, this.state.variables, this.state.context, this));\n\n        if (process.env.NODE_ENV !== 'production') {\n          this.logger.error(error);\n        }\n\n        await ((_this$options$onError = (_this$options4 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options4, error, this.state.variables, this.state.context)); // Notify cache callback\n\n        await ((_this$mutationCache$c9 = (_this$mutationCache$c10 = this.mutationCache.config).onSettled) == null ? void 0 : _this$mutationCache$c9.call(_this$mutationCache$c10, undefined, error, this.state.variables, this.state.context, this));\n        await ((_this$options$onSettl2 = (_this$options5 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options5, undefined, error, this.state.variables, this.state.context));\n        throw error;\n      } finally {\n        this.dispatch({\n          type: 'error',\n          error: error\n        });\n      }\n    }\n  }\n\n  dispatch(action) {\n    const reducer = state => {\n      switch (action.type) {\n        case 'failed':\n          return { ...state,\n            failureCount: action.failureCount,\n            failureReason: action.error\n          };\n\n        case 'pause':\n          return { ...state,\n            isPaused: true\n          };\n\n        case 'continue':\n          return { ...state,\n            isPaused: false\n          };\n\n        case 'loading':\n          return { ...state,\n            context: action.context,\n            data: undefined,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            isPaused: !canFetch(this.options.networkMode),\n            status: 'loading',\n            variables: action.variables\n          };\n\n        case 'success':\n          return { ...state,\n            data: action.data,\n            failureCount: 0,\n            failureReason: null,\n            error: null,\n            status: 'success',\n            isPaused: false\n          };\n\n        case 'error':\n          return { ...state,\n            data: undefined,\n            error: action.error,\n            failureCount: state.failureCount + 1,\n            failureReason: action.error,\n            isPaused: false,\n            status: 'error'\n          };\n\n        case 'setState':\n          return { ...state,\n            ...action.state\n          };\n      }\n    };\n\n    this.state = reducer(this.state);\n    notifyManager.batch(() => {\n      this.observers.forEach(observer => {\n        observer.onMutationUpdate(action);\n      });\n      this.mutationCache.notify({\n        mutation: this,\n        type: 'updated',\n        action\n      });\n    });\n  }\n\n}\nfunction getDefaultState() {\n  return {\n    context: undefined,\n    data: undefined,\n    error: null,\n    failureCount: 0,\n    failureReason: null,\n    isPaused: false,\n    status: 'idle',\n    variables: undefined\n  };\n}\n\nexport { Mutation, getDefaultState };\n//# sourceMappingURL=mutation.mjs.map\n","import { notifyManager } from './notifyManager.mjs';\nimport { Mutation } from './mutation.mjs';\nimport { matchMutation, noop } from './utils.mjs';\nimport { Subscribable } from './subscribable.mjs';\n\n// CLASS\nclass MutationCache extends Subscribable {\n  constructor(config) {\n    super();\n    this.config = config || {};\n    this.mutations = [];\n    this.mutationId = 0;\n  }\n\n  build(client, options, state) {\n    const mutation = new Mutation({\n      mutationCache: this,\n      logger: client.getLogger(),\n      mutationId: ++this.mutationId,\n      options: client.defaultMutationOptions(options),\n      state,\n      defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined\n    });\n    this.add(mutation);\n    return mutation;\n  }\n\n  add(mutation) {\n    this.mutations.push(mutation);\n    this.notify({\n      type: 'added',\n      mutation\n    });\n  }\n\n  remove(mutation) {\n    this.mutations = this.mutations.filter(x => x !== mutation);\n    this.notify({\n      type: 'removed',\n      mutation\n    });\n  }\n\n  clear() {\n    notifyManager.batch(() => {\n      this.mutations.forEach(mutation => {\n        this.remove(mutation);\n      });\n    });\n  }\n\n  getAll() {\n    return this.mutations;\n  }\n\n  find(filters) {\n    if (typeof filters.exact === 'undefined') {\n      filters.exact = true;\n    }\n\n    return this.mutations.find(mutation => matchMutation(filters, mutation));\n  }\n\n  findAll(filters) {\n    return this.mutations.filter(mutation => matchMutation(filters, mutation));\n  }\n\n  notify(event) {\n    notifyManager.batch(() => {\n      this.listeners.forEach(({\n        listener\n      }) => {\n        listener(event);\n      });\n    });\n  }\n\n  resumePausedMutations() {\n    var _this$resuming;\n\n    this.resuming = ((_this$resuming = this.resuming) != null ? _this$resuming : Promise.resolve()).then(() => {\n      const pausedMutations = this.mutations.filter(x => x.state.isPaused);\n      return notifyManager.batch(() => pausedMutations.reduce((promise, mutation) => promise.then(() => mutation.continue().catch(noop)), Promise.resolve()));\n    }).then(() => {\n      this.resuming = undefined;\n    });\n    return this.resuming;\n  }\n\n}\n\nexport { MutationCache };\n//# sourceMappingURL=mutationCache.mjs.map\n","function infiniteQueryBehavior() {\n  return {\n    onFetch: context => {\n      context.fetchFn = () => {\n        var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;\n\n        const refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;\n        const fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;\n        const pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;\n        const isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';\n        const isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';\n        const oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];\n        const oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];\n        let newPageParams = oldPageParams;\n        let cancelled = false;\n\n        const addSignalProperty = object => {\n          Object.defineProperty(object, 'signal', {\n            enumerable: true,\n            get: () => {\n              var _context$signal;\n\n              if ((_context$signal = context.signal) != null && _context$signal.aborted) {\n                cancelled = true;\n              } else {\n                var _context$signal2;\n\n                (_context$signal2 = context.signal) == null ? void 0 : _context$signal2.addEventListener('abort', () => {\n                  cancelled = true;\n                });\n              }\n\n              return context.signal;\n            }\n          });\n        }; // Get query function\n\n\n        const queryFn = context.options.queryFn || (() => Promise.reject(\"Missing queryFn for queryKey '\" + context.options.queryHash + \"'\"));\n\n        const buildNewPages = (pages, param, page, previous) => {\n          newPageParams = previous ? [param, ...newPageParams] : [...newPageParams, param];\n          return previous ? [page, ...pages] : [...pages, page];\n        }; // Create function to fetch a page\n\n\n        const fetchPage = (pages, manual, param, previous) => {\n          if (cancelled) {\n            return Promise.reject('Cancelled');\n          }\n\n          if (typeof param === 'undefined' && !manual && pages.length) {\n            return Promise.resolve(pages);\n          }\n\n          const queryFnContext = {\n            queryKey: context.queryKey,\n            pageParam: param,\n            meta: context.options.meta\n          };\n          addSignalProperty(queryFnContext);\n          const queryFnResult = queryFn(queryFnContext);\n          const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));\n          return promise;\n        };\n\n        let promise; // Fetch first page?\n\n        if (!oldPages.length) {\n          promise = fetchPage([]);\n        } // Fetch next page?\n        else if (isFetchingNextPage) {\n          const manual = typeof pageParam !== 'undefined';\n          const param = manual ? pageParam : getNextPageParam(context.options, oldPages);\n          promise = fetchPage(oldPages, manual, param);\n        } // Fetch previous page?\n        else if (isFetchingPreviousPage) {\n          const manual = typeof pageParam !== 'undefined';\n          const param = manual ? pageParam : getPreviousPageParam(context.options, oldPages);\n          promise = fetchPage(oldPages, manual, param, true);\n        } // Refetch pages\n        else {\n          newPageParams = [];\n          const manual = typeof context.options.getNextPageParam === 'undefined';\n          const shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true; // Fetch first page\n\n          promise = shouldFetchFirstPage ? fetchPage([], manual, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0])); // Fetch remaining pages\n\n          for (let i = 1; i < oldPages.length; i++) {\n            promise = promise.then(pages => {\n              const shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;\n\n              if (shouldFetchNextPage) {\n                const param = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);\n                return fetchPage(pages, manual, param);\n              }\n\n              return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));\n            });\n          }\n        }\n\n        const finalPromise = promise.then(pages => ({\n          pages,\n          pageParams: newPageParams\n        }));\n        return finalPromise;\n      };\n    }\n  };\n}\nfunction getNextPageParam(options, pages) {\n  return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);\n}\nfunction getPreviousPageParam(options, pages) {\n  return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);\n}\n/**\n * Checks if there is a next page.\n * Returns `undefined` if it cannot be determined.\n */\n\nfunction hasNextPage(options, pages) {\n  if (options.getNextPageParam && Array.isArray(pages)) {\n    const nextPageParam = getNextPageParam(options, pages);\n    return typeof nextPageParam !== 'undefined' && nextPageParam !== null && nextPageParam !== false;\n  }\n\n  return;\n}\n/**\n * Checks if there is a previous page.\n * Returns `undefined` if it cannot be determined.\n */\n\nfunction hasPreviousPage(options, pages) {\n  if (options.getPreviousPageParam && Array.isArray(pages)) {\n    const previousPageParam = getPreviousPageParam(options, pages);\n    return typeof previousPageParam !== 'undefined' && previousPageParam !== null && previousPageParam !== false;\n  }\n\n  return;\n}\n\nexport { getNextPageParam, getPreviousPageParam, hasNextPage, hasPreviousPage, infiniteQueryBehavior };\n//# sourceMappingURL=infiniteQueryBehavior.mjs.map\n","'use client';\nimport { ReactQueryDevtools as ReactQueryDevtools$1, ReactQueryDevtoolsPanel as ReactQueryDevtoolsPanel$1 } from './devtools.mjs';\n\nconst ReactQueryDevtools = process.env.NODE_ENV !== 'development' ? function () {\n  return null;\n} : ReactQueryDevtools$1;\nconst ReactQueryDevtoolsPanel = process.env.NODE_ENV !== 'development' ? function () {\n  return null;\n} : ReactQueryDevtoolsPanel$1;\n\nexport { ReactQueryDevtools, ReactQueryDevtoolsPanel };\n//# sourceMappingURL=index.mjs.map\n","/* eslint-disable local-rules/disallow-side-effects */\n/**\n * Keep references on console methods to avoid triggering patched behaviors\n *\n * NB: in some setup, console could already be patched by another SDK.\n * In this case, some display messages can be sent by the other SDK\n * but we should be safe from infinite loop nonetheless.\n */\nexport var ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\n/**\n * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove\n * \"console.*\" references. This causes some issue as we expect `console.*` to be defined.\n * As a workaround, let's use a variable alias, so those expressions won't be taken into account by\n * simple static analysis.\n *\n * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/\n * [2]: https://github.com/terser/terser#compress-options (look for drop_console)\n */\nexport var globalConsole = console;\nexport var originalConsoleMethods = {};\nObject.keys(ConsoleApiName).forEach(function (name) {\n    originalConsoleMethods[name] = globalConsole[name];\n});\nvar PREFIX = 'Datadog Browser SDK:';\nexport var display = {\n    debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),\n    log: originalConsoleMethods.log.bind(globalConsole, PREFIX),\n    info: originalConsoleMethods.info.bind(globalConsole, PREFIX),\n    warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),\n    error: originalConsoleMethods.error.bind(globalConsole, PREFIX),\n};\n//# sourceMappingURL=display.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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { display } from './display';\nvar onMonitorErrorCollected;\nvar debugMode = false;\nexport function startMonitorErrorCollection(newOnMonitorErrorCollected) {\n    onMonitorErrorCollected = newOnMonitorErrorCollected;\n}\nexport function setDebugMode(newDebugMode) {\n    debugMode = newDebugMode;\n}\nexport function resetMonitor() {\n    onMonitorErrorCollected = undefined;\n    debugMode = false;\n}\nexport function monitored(_, __, descriptor) {\n    var originalMethod = descriptor.value;\n    descriptor.value = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod;\n        return decorated.apply(this, args);\n    };\n}\nexport function monitor(fn) {\n    return function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return callMonitored(fn, this, arguments);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return fn.apply(context, args);\n    }\n    catch (e) {\n        displayIfDebugEnabled(e);\n        if (onMonitorErrorCollected) {\n            try {\n                onMonitorErrorCollected(e);\n            }\n            catch (e) {\n                displayIfDebugEnabled(e);\n            }\n        }\n    }\n}\nexport function displayIfDebugEnabled() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    if (debugMode) {\n        display.error.apply(display, __spreadArray(['[MONITOR]'], args, false));\n    }\n}\n//# sourceMappingURL=monitor.js.map","export function includes(candidate, search) {\n    return candidate.indexOf(search) !== -1;\n}\nexport function arrayFrom(arrayLike) {\n    if (Array.from) {\n        return Array.from(arrayLike);\n    }\n    var array = [];\n    if (arrayLike instanceof Set) {\n        arrayLike.forEach(function (item) { return array.push(item); });\n    }\n    else {\n        for (var i = 0; i < arrayLike.length; i++) {\n            array.push(arrayLike[i]);\n        }\n    }\n    return array;\n}\nexport function find(array, predicate) {\n    for (var i = 0; i < array.length; i += 1) {\n        var item = array[i];\n        if (predicate(item, i)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function findLast(array, predicate) {\n    for (var i = array.length - 1; i >= 0; i -= 1) {\n        var item = array[i];\n        if (predicate(item, i, array)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\nexport function objectValues(object) {\n    return Object.keys(object).map(function (key) { return object[key]; });\n}\nexport function objectEntries(object) {\n    return Object.keys(object).map(function (key) { return [key, object[key]]; });\n}\nexport function startsWith(candidate, search) {\n    return candidate.slice(0, search.length) === search;\n}\nexport function endsWith(candidate, search) {\n    return candidate.slice(-search.length) === search;\n}\nexport function elementMatches(element, selector) {\n    if (element.matches) {\n        return element.matches(selector);\n    }\n    // IE11 support\n    if (element.msMatchesSelector) {\n        return element.msMatchesSelector(selector);\n    }\n    return false;\n}\n// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js\nexport function cssEscape(str) {\n    if (window.CSS && window.CSS.escape) {\n        return window.CSS.escape(str);\n    }\n    // eslint-disable-next-line no-control-regex\n    return str.replace(/([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g, function (ch, asCodePoint) {\n        if (asCodePoint) {\n            // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n            if (ch === '\\0') {\n                return '\\uFFFD';\n            }\n            // Control characters and (dependent upon position) numbers get escaped as code points\n            return \"\".concat(ch.slice(0, -1), \"\\\\\").concat(ch.charCodeAt(ch.length - 1).toString(16), \" \");\n        }\n        // Other potentially-special ASCII characters get backslash-escaped\n        return \"\\\\\".concat(ch);\n    });\n}\nexport function assign(target) {\n    var toAssign = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        toAssign[_i - 1] = arguments[_i];\n    }\n    toAssign.forEach(function (source) {\n        for (var key in source) {\n            if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n            }\n        }\n    });\n    return target;\n}\n//# sourceMappingURL=polyfills.js.map","/**\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}\n//# sourceMappingURL=getGlobalObject.js.map","export var ONE_KIBI_BYTE = 1024;\nexport var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;\n// eslint-disable-next-line no-control-regex\nvar HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nexport function computeBytesCount(candidate) {\n    // Accurate bytes count computations can degrade performances when there is a lot of events to process\n    if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n        return candidate.length;\n    }\n    if (window.TextEncoder !== undefined) {\n        return new TextEncoder().encode(candidate).length;\n    }\n    return new Blob([candidate]).size;\n}\nexport function concatBuffers(buffers) {\n    var length = buffers.reduce(function (total, buffer) { return total + buffer.length; }, 0);\n    var result = new Uint8Array(length);\n    var offset = 0;\n    for (var _i = 0, buffers_1 = buffers; _i < buffers_1.length; _i++) {\n        var buffer = buffers_1[_i];\n        result.set(buffer, offset);\n        offset += buffer.length;\n    }\n    return result;\n}\n//# sourceMappingURL=byteUtils.js.map","import { getGlobalObject } from './getGlobalObject';\n/**\n * Gets the original value for a DOM API that was potentially patched by Zone.js.\n *\n * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original\n * value of the patched functions/constructors/methods in a hidden property prefixed by\n * __zone_symbol__.\n *\n * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to\n * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to\n * use the original DOM API instead of the one patched by Zone.js.\n *\n * [1]: https://github.com/angular/angular/tree/main/packages/zone.js\n */\nexport function getZoneJsOriginalValue(target, name) {\n    var browserWindow = getGlobalObject();\n    var original;\n    if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {\n        original = target[browserWindow.Zone.__symbol__(name)];\n    }\n    if (!original) {\n        original = target[name];\n    }\n    return original;\n}\n//# sourceMappingURL=getZoneJsOriginalValue.js.map","import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';\nimport { monitor } from './monitor';\nimport { getGlobalObject } from './getGlobalObject';\nexport function setTimeout(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay);\n}\nexport function clearTimeout(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId);\n}\nexport function setInterval(callback, delay) {\n    return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay);\n}\nexport function clearInterval(timeoutId) {\n    getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId);\n}\n//# sourceMappingURL=timer.js.map","import { setTimeout, clearTimeout } from '../timer';\n// use lodash API\nexport function throttle(fn, wait, options) {\n    var needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n    var needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n    var inWaitPeriod = false;\n    var pendingExecutionWithParameters;\n    var pendingTimeoutId;\n    return {\n        throttled: function () {\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}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() { }\n//# sourceMappingURL=functionUtils.js.map","/**\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}\n//# sourceMappingURL=typeUtils.js.map","import { getType } from './utils/typeUtils';\n/**\n * Iterate over source and affect its sub values into destination, recursively.\n * If the source and destination can't be merged, return source.\n */\nexport function mergeInto(destination, source, circularReferenceChecker) {\n    if (circularReferenceChecker === void 0) { 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}\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//# sourceMappingURL=mergeInto.js.map","import { noop } from '../utils/functionUtils';\n/**\n * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(value, replacer, space) {\n    if (typeof value !== 'object' || value === null) {\n        return JSON.stringify(value);\n    }\n    // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n    // subclasses.\n    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));\n    var restoreValueToJson = detachToJsonMethod(value);\n    try {\n        return JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        return '<error: unable to serialize object>';\n    }\n    finally {\n        restoreObjectPrototypeToJson();\n        restoreArrayPrototypeToJson();\n        restoreValuePrototypeToJson();\n        restoreValueToJson();\n    }\n}\nexport function detachToJsonMethod(value) {\n    var object = value;\n    var objectToJson = object.toJSON;\n    if (objectToJson) {\n        delete object.toJSON;\n        return function () {\n            object.toJSON = objectToJson;\n        };\n    }\n    return noop;\n}\n//# sourceMappingURL=jsonStringify.js.map","import { display } from '../display';\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils';\nimport { detachToJsonMethod } from './jsonStringify';\n// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data\n// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...\nvar SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;\n// Symbol for the root element of the JSONPath used for visited objects\nvar JSON_PATH_ROOT_ELEMENT = '$';\n// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as \"key\".\n// With the separator (:), we need to add 3 characters to the count.\nvar KEY_DECORATION_LENGTH = 3;\nexport function sanitize(source, maxCharacterCount) {\n    var _a;\n    if (maxCharacterCount === void 0) { maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT; }\n    // Unbind any toJSON function we may have on [] or {} prototypes\n    var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);\n    var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);\n    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n    var containerQueue = [];\n    var visitedObjectsWithPath = new WeakMap();\n    var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);\n    var accumulatedCharacterCount = ((_a = JSON.stringify(sanitizedData)) === null || _a === void 0 ? void 0 : _a.length) || 0;\n    if (accumulatedCharacterCount > maxCharacterCount) {\n        warnOverCharacterLimit(maxCharacterCount, 'discarded', source);\n        return undefined;\n    }\n    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n        var containerToProcess = containerQueue.shift();\n        var separatorLength = 0; // 0 for the first element, 1 for subsequent elements\n        // Arrays and Objects have to be handled distinctly to ensure\n        // we do not pick up non-numerical properties from Arrays\n        if (Array.isArray(containerToProcess.source)) {\n            for (var key = 0; key < containerToProcess.source.length; key++) {\n                var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                if (targetData !== undefined) {\n                    accumulatedCharacterCount += JSON.stringify(targetData).length;\n                }\n                else {\n                    // When an element of an Array (targetData) is undefined, it is serialized as null:\n                    // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters\n                    accumulatedCharacterCount += 4;\n                }\n                accumulatedCharacterCount += separatorLength;\n                separatorLength = 1;\n                if (accumulatedCharacterCount > maxCharacterCount) {\n                    warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                    break;\n                }\n                ;\n                containerToProcess.target[key] = targetData;\n            }\n        }\n        else {\n            for (var key in containerToProcess.source) {\n                if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n                    var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);\n                    // When a property of an object has an undefined value, it will be dropped during serialization:\n                    // JSON.stringify({a:undefined}) => '{}'\n                    if (targetData !== undefined) {\n                        accumulatedCharacterCount +=\n                            JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;\n                        separatorLength = 1;\n                    }\n                    if (accumulatedCharacterCount > maxCharacterCount) {\n                        warnOverCharacterLimit(maxCharacterCount, 'truncated', source);\n                        break;\n                    }\n                    ;\n                    containerToProcess.target[key] = targetData;\n                }\n            }\n        }\n    }\n    // Rebind detached toJSON functions\n    restoreObjectPrototypeToJson();\n    restoreArrayPrototypeToJson();\n    return sanitizedData;\n}\n/**\n * Internal function to factorize the process common to the\n * initial call to sanitize, and iterations for Arrays and Objects\n *\n */\nfunction sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {\n    // Start by handling toJSON, as we want to sanitize its output\n    var sourceToSanitize = tryToApplyToJSON(source);\n    if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n        return sanitizePrimitivesAndFunctions(sourceToSanitize);\n    }\n    var sanitizedSource = sanitizeObjects(sourceToSanitize);\n    if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n        return sanitizedSource;\n    }\n    // Handle potential cyclic references\n    // We need to use source as sourceToSanitize could be a reference to a new object\n    // At this stage, we know the source is an object type\n    var sourceAsObject = source;\n    if (visitedObjectsWithPath.has(sourceAsObject)) {\n        return \"[Reference seen at \".concat(visitedObjectsWithPath.get(sourceAsObject), \"]\");\n    }\n    // Add processed source to queue\n    var currentPath = key !== undefined ? \"\".concat(parentPath, \".\").concat(key) : parentPath;\n    var target = Array.isArray(sourceToSanitize) ? [] : {};\n    visitedObjectsWithPath.set(sourceAsObject, currentPath);\n    queue.push({ source: sourceToSanitize, target: target, path: currentPath });\n    return target;\n}\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value) {\n    // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n    if (typeof value === 'bigint') {\n        return \"[BigInt] \".concat(value.toString());\n    }\n    // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted\n    // so it won't prevent stringify from serializing later\n    if (typeof value === 'function') {\n        return \"[Function] \".concat(value.name || 'unknown');\n    }\n    // JSON.stringify() does not serialize symbols.\n    if (typeof value === 'symbol') {\n        return \"[Symbol] \".concat(value.description || value.toString());\n    }\n    return value;\n}\n/**\n * Handles sanitization of object types\n *\n * LIMITATIONS\n * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.\n * To avoid this, a toJSON method can be defined.\n * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their\n * properties enumerated if any.\n *\n */\nfunction sanitizeObjects(value) {\n    try {\n        // Handle events - Keep a simple implementation to avoid breaking changes\n        if (value instanceof Event) {\n            return {\n                isTrusted: value.isTrusted,\n            };\n        }\n        // Handle all remaining object types in a generic way\n        var result = Object.prototype.toString.call(value);\n        var match = result.match(/\\[object (.*)\\]/);\n        if (match && match[1]) {\n            return \"[\".concat(match[1], \"]\");\n        }\n    }\n    catch (_a) {\n        // If the previous serialization attempts failed, and we cannot convert using\n        // Object.prototype.toString, declare the value unserializable\n    }\n    return '[Unserializable]';\n}\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value) {\n    var object = value;\n    if (object && typeof object.toJSON === 'function') {\n        try {\n            return object.toJSON();\n        }\n        catch (_a) {\n            // If toJSON fails, we continue by trying to serialize the value manually\n        }\n    }\n    return value;\n}\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount, changeType, source) {\n    display.warn(\"The data provided has been \".concat(changeType, \" as it is over the limit of \").concat(maxCharacterCount, \" characters:\"), source);\n}\n//# sourceMappingURL=sanitize.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","var _a;\nimport { ONE_KIBI_BYTE } from '../../tools/utils/byteUtils';\nimport { display } from '../../tools/display';\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;\nvar CustomerDataLabel = (_a = {},\n    _a[0 /* CustomerDataType.FeatureFlag */] = 'feature flag evaluation',\n    _a[1 /* CustomerDataType.User */] = 'user',\n    _a[2 /* CustomerDataType.GlobalContext */] = 'global context',\n    _a[3 /* CustomerDataType.LoggerContext */] = 'logger context',\n    _a);\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n    if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n        display.warn(\"The \".concat(CustomerDataLabel[customerDataType], \" data exceeds the recommended \").concat(CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE, \"KiB threshold. More details: https://docs.datadoghq.com/real_user_monitoring/browser/troubleshooting/#customer-data-exceeds-the-recommended-3kib-warning\"));\n        return true;\n    }\n    return false;\n}\n//# sourceMappingURL=heavyCustomerDataWarning.js.map","import { computeBytesCount } from '../../tools/utils/byteUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { deepClone } from '../../tools/mergeInto';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { Observable } from '../../tools/observable';\nimport { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning';\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\nexport function createContextManager(customerDataType, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    var context = {};\n    var bytesCountCache;\n    var alreadyWarned = false;\n    var changeObservable = new Observable();\n    // Throttle the bytes computation to minimize the impact on performance.\n    // Especially useful if the user call context APIs synchronously multiple times in a row\n    var computeBytesCountThrottled = throttle(function (context) {\n        bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n        if (!alreadyWarned) {\n            alreadyWarned = warnIfCustomerDataLimitReached(bytesCountCache, customerDataType);\n        }\n    }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled;\n    var contextManager = {\n        getBytesCount: function () { return bytesCountCache; },\n        /** @deprecated use getContext instead */\n        get: function () { return context; },\n        /** @deprecated use setContextProperty instead */\n        add: function (key, value) {\n            context[key] = value;\n            computeBytesCountThrottled(context);\n            changeObservable.notify();\n        },\n        /** @deprecated renamed to removeContextProperty */\n        remove: function (key) {\n            delete context[key];\n            computeBytesCountThrottled(context);\n            changeObservable.notify();\n        },\n        /** @deprecated use setContext instead */\n        set: function (newContext) {\n            context = newContext;\n            computeBytesCountThrottled(context);\n            changeObservable.notify();\n        },\n        getContext: function () { return deepClone(context); },\n        setContext: function (newContext) {\n            if (getType(newContext) === 'object') {\n                context = sanitize(newContext);\n                computeBytesCountThrottled(context);\n            }\n            else {\n                contextManager.clearContext();\n            }\n            changeObservable.notify();\n        },\n        setContextProperty: function (key, property) {\n            context[key] = sanitize(property);\n            computeBytesCountThrottled(context);\n            changeObservable.notify();\n        },\n        removeContextProperty: function (key) {\n            delete context[key];\n            computeBytesCountThrottled(context);\n            changeObservable.notify();\n        },\n        clearContext: function () {\n            context = {};\n            bytesCountCache = 0;\n            changeObservable.notify();\n        },\n        changeObservable: changeObservable,\n    };\n    return contextManager;\n}\n//# sourceMappingURL=contextManager.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","/**\n * Return true if the draw is successful\n * @param threshold between 0 and 100\n */\nexport function performDraw(threshold) {\n    return threshold !== 0 && Math.random() * 100 <= threshold;\n}\nexport function round(num, decimals) {\n    return +num.toFixed(decimals);\n}\nexport function isPercentage(value) {\n    return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n    return typeof value === 'number';\n}\n//# sourceMappingURL=numberUtils.js.map","import { isNumber, round } from './numberUtils';\nexport var ONE_SECOND = 1000;\nexport var ONE_MINUTE = 60 * ONE_SECOND;\nexport var ONE_HOUR = 60 * ONE_MINUTE;\nexport var ONE_DAY = 24 * ONE_HOUR;\nexport var ONE_YEAR = 365 * ONE_DAY;\nexport function relativeToClocks(relative) {\n    return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    var correctedOrigin = (dateNow() - performance.now());\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        return Math.round(addDuration(correctedOrigin, relativeTime));\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now()));\n}\nexport function toServerDuration(duration) {\n    if (!isNumber(duration)) {\n        return duration;\n    }\n    return round(duration * 1e6, 0);\n}\nexport function dateNow() {\n    // Do not use `Date.now` because sometimes websites are wrongly \"polyfilling\" it. For example, we\n    // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date\n    // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this\n    // case ourselves.\n    // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16\n    return new Date().getTime();\n}\nexport function timeStampNow() {\n    return dateNow();\n}\nexport function relativeNow() {\n    return performance.now();\n}\nexport function clocksNow() {\n    return { 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}\nexport function addDuration(a, b) {\n    return a + b;\n}\n/**\n * Get the time since the navigation was started.\n *\n * Note: this does not use `performance.timeOrigin` because it doesn't seem to reflect the actual\n * time on which the navigation has started: it may be much farther in the past, at least in Firefox 71.\n * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926\n */\nexport function getRelativeTime(timestamp) {\n    return (timestamp - getNavigationStart());\n}\nexport function getTimeStamp(relativeTime) {\n    return Math.round(addDuration(getNavigationStart(), relativeTime));\n}\nexport function looksLikeRelativeTime(time) {\n    return time < ONE_YEAR;\n}\n/**\n * Navigation start slightly change on some rare cases\n */\nvar navigationStart;\nfunction getNavigationStart() {\n    if (navigationStart === undefined) {\n        navigationStart = performance.timing.navigationStart;\n    }\n    return navigationStart;\n}\nexport function resetNavigationStart() {\n    navigationStart = undefined;\n}\n//# sourceMappingURL=timeUtils.js.map","import { display } from '../tools/display';\nimport { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { findCommaSeparatedValue, generateUUID } from '../tools/utils/stringUtils';\nexport function setCookie(name, value, expireDelay, options) {\n    var date = new Date();\n    date.setTime(date.getTime() + expireDelay);\n    var expires = \"expires=\".concat(date.toUTCString());\n    var sameSite = options && options.crossSite ? 'none' : 'strict';\n    var domain = options && options.domain ? \";domain=\".concat(options.domain) : '';\n    var secure = options && options.secure ? ';secure' : '';\n    document.cookie = \"\".concat(name, \"=\").concat(value, \";\").concat(expires, \";path=/;samesite=\").concat(sameSite).concat(domain).concat(secure);\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\nexport function deleteCookie(name, options) {\n    setCookie(name, '', 0, options);\n}\nexport function areCookiesAuthorized(options) {\n    if (document.cookie === undefined || document.cookie === null) {\n        return false;\n    }\n    try {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        var testCookieName = \"dd_cookie_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        setCookie(testCookieName, testCookieValue, ONE_MINUTE, options);\n        var isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;\n        deleteCookie(testCookieName, options);\n        return isCookieCorrectlySet;\n    }\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","/**\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}\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    }\n    return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}\n//# sourceMappingURL=stringUtils.js.map","import { getCookie } from '../../browser/cookie';\nexport var SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum';\nexport function willSyntheticsInjectRum() {\n    return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\nexport function getSyntheticsTestId() {\n    var value = window._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\nexport function getSyntheticsResultId() {\n    var value = window._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=syntheticsWorkerValues.js.map","import { endsWith } from '../tools/utils/polyfills';\nimport { getGlobalObject } from '../tools/getGlobalObject';\nexport function getEventBridge() {\n    var eventBridgeGlobal = getEventBridgeGlobal();\n    if (!eventBridgeGlobal) {\n        return;\n    }\n    return {\n        getAllowedWebViewHosts: function () {\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(currentHost) {\n    var _a;\n    if (currentHost === void 0) { currentHost = (_a = getGlobalObject().location) === null || _a === void 0 ? void 0 : _a.hostname; }\n    var bridge = getEventBridge();\n    return (!!bridge &&\n        bridge\n            .getAllowedWebViewHosts()\n            .some(function (allowedHost) { return currentHost === allowedHost || endsWith(currentHost, \".\".concat(allowedHost)); }));\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","import { monitor } from '../tools/monitor';\nimport { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue';\n/**\n * Add an event listener to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n */\nexport function addEventListener(configuration, eventTarget, eventName, listener, options) {\n    return addEventListeners(configuration, eventTarget, [eventName], listener, options);\n}\n/**\n * Add event listeners to an event target object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n *\n * * with `once: true`, the listener will be called at most once, even if different events are listened\n */\nexport function addEventListeners(_, eventTarget, eventNames, listener, _a) {\n    var _b = _a === void 0 ? {} : _a, once = _b.once, capture = _b.capture, passive = _b.passive;\n    var listenerWithMonitor = monitor(once\n        ? function (event) {\n            stop();\n            listener(event);\n        }\n        : listener);\n    var options = passive ? { capture: capture, passive: passive } : capture;\n    var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');\n    eventNames.forEach(function (eventName) { return add.call(eventTarget, eventName, listenerWithMonitor, options); });\n    function stop() {\n        var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');\n        eventNames.forEach(function (eventName) { return remove.call(eventTarget, eventName, listenerWithMonitor, options); });\n    }\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=addEventListener.js.map","import { computeBytesCount } from '../../tools/utils/byteUtils';\nimport { addEventListener } from '../../browser/addEventListener';\nimport { createContextManager } from './contextManager';\nvar CONTEXT_STORE_KEY_PREFIX = '_dd_c';\nvar storageListeners = [];\nexport function createStoredContextManager(configuration, productKey, customerDataType, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    var storageKey = buildStorageKey(productKey, customerDataType);\n    var contextManager = createContextManager(customerDataType, computeBytesCountImpl);\n    synchronizeWithStorage();\n    storageListeners.push(addEventListener(configuration, window, \"storage\" /* DOM_EVENT.STORAGE */, function (_a) {\n        var key = _a.key;\n        if (storageKey === key) {\n            synchronizeWithStorage();\n        }\n    }));\n    contextManager.changeObservable.subscribe(dumpToStorage);\n    return contextManager;\n    function synchronizeWithStorage() {\n        var rawContext = localStorage.getItem(storageKey);\n        var context = rawContext !== null ? JSON.parse(rawContext) : {};\n        contextManager.setContext(context);\n    }\n    function dumpToStorage() {\n        localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()));\n    }\n}\nexport function buildStorageKey(productKey, customerDataType) {\n    return \"\".concat(CONTEXT_STORE_KEY_PREFIX, \"_\").concat(productKey, \"_\").concat(customerDataType);\n}\nexport function removeStorageListeners() {\n    storageListeners.map(function (listener) { return listener.stop(); });\n}\n//# sourceMappingURL=storedContextManager.js.map","import { startsWith } from '../../tools/utils/polyfills';\nvar UNKNOWN_FUNCTION = '?';\n/**\n * Computes a stack trace for an exception.\n */\nexport function computeStackTrace(ex) {\n    var stack = [];\n    var stackProperty = tryToGetString(ex, 'stack');\n    var exString = String(ex);\n    if (stackProperty && startsWith(stackProperty, exString)) {\n        stackProperty = stackProperty.slice(exString.length);\n    }\n    if (stackProperty) {\n        stackProperty.split('\\n').forEach(function (line) {\n            var stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line);\n            if (stackFrame) {\n                if (!stackFrame.func && stackFrame.line) {\n                    stackFrame.func = UNKNOWN_FUNCTION;\n                }\n                stack.push(stackFrame);\n            }\n        });\n    }\n    return {\n        message: tryToGetString(ex, 'message'),\n        name: tryToGetString(ex, 'name'),\n        stack: stack,\n    };\n}\nvar fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)';\nvar filePosition = '(?::(\\\\d+))';\nvar CHROME_LINE_RE = new RegExp(\"^\\\\s*at (.*?) ?\\\\(\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"?\\\\)?\\\\s*$\"), 'i');\nvar CHROME_EVAL_RE = new RegExp(\"\\\\((\\\\S*)\".concat(filePosition).concat(filePosition, \"\\\\)\"));\nfunction parseChromeLine(line) {\n    var parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    var submatch = CHROME_EVAL_RE.exec(parts[2]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = submatch[1]; // url\n        parts[3] = submatch[2]; // line\n        parts[4] = submatch[3]; // column\n    }\n    return {\n        args: isNative ? [parts[2]] : [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: !isNative ? parts[2] : undefined,\n    };\n}\nvar CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(\"^\\\\s*at ?\".concat(fileUrl).concat(filePosition, \"?\").concat(filePosition, \"??\\\\s*$\"), 'i');\nfunction parseChromeAnonymousLine(line) {\n    var parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[3] ? +parts[3] : undefined,\n        func: UNKNOWN_FUNCTION,\n        line: parts[2] ? +parts[2] : undefined,\n        url: parts[1],\n    };\n}\nvar WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n    var parts = WINJS_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: +parts[3],\n        url: parts[2],\n    };\n}\nvar GECKO_LINE_RE = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    var parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    var submatch = GECKO_EVAL_RE.exec(parts[3]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line number\n        parts[3] = submatch[1];\n        parts[4] = submatch[2];\n        parts[5] = undefined; // no column when eval\n    }\n    return {\n        args: parts[2] ? parts[2].split(',') : [],\n        column: parts[5] ? +parts[5] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[4] ? +parts[4] : undefined,\n        url: parts[3],\n    };\n}\nfunction tryToGetString(candidate, property) {\n    if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n        return undefined;\n    }\n    var value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=computeStackTrace.js.map","import { computeStackTrace } from '../tracekit';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { noop } from '../../tools/utils/functionUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nexport var NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error';\nexport function computeRawError(_a) {\n    var stackTrace = _a.stackTrace, originalError = _a.originalError, handlingStack = _a.handlingStack, startClocks = _a.startClocks, nonErrorPrefix = _a.nonErrorPrefix, source = _a.source, handling = _a.handling;\n    var isErrorInstance = originalError instanceof Error;\n    var message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError);\n    var stack = hasUsableStack(isErrorInstance, stackTrace)\n        ? toStackTraceString(stackTrace)\n        : NO_ERROR_STACK_PRESENT_MESSAGE;\n    var causes = isErrorInstance ? flattenErrorCauses(originalError, source) : undefined;\n    var type = stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name;\n    var fingerprint = tryToGetFingerprint(originalError);\n    return {\n        startClocks: startClocks,\n        source: source,\n        handling: handling,\n        handlingStack: handlingStack,\n        originalError: originalError,\n        type: type,\n        message: message,\n        stack: stack,\n        causes: causes,\n        fingerprint: fingerprint,\n    };\n}\nfunction computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError) {\n    // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)\n    // TODO rework tracekit integration to avoid scattering error building logic\n    return (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.message) && (stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name)\n        ? stackTrace.message\n        : !isErrorInstance\n            ? \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(sanitize(originalError)))\n            : 'Empty message';\n}\nfunction hasUsableStack(isErrorInstance, stackTrace) {\n    if (stackTrace === undefined) {\n        return false;\n    }\n    if (isErrorInstance) {\n        return true;\n    }\n    // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]\n    // TODO rework tracekit integration to avoid generating those unusable stack\n    return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined);\n}\nexport function tryToGetFingerprint(originalError) {\n    return originalError instanceof Error && 'dd_fingerprint' in originalError\n        ? String(originalError.dd_fingerprint)\n        : undefined;\n}\nexport function toStackTraceString(stack) {\n    var result = formatErrorMessage(stack);\n    stack.stack.forEach(function (frame) {\n        var func = frame.func === '?' ? '<anonymous>' : frame.func;\n        var args = frame.args && frame.args.length > 0 ? \"(\".concat(frame.args.join(', '), \")\") : '';\n        var line = frame.line ? \":\".concat(frame.line) : '';\n        var column = frame.line && frame.column ? \":\".concat(frame.column) : '';\n        result += \"\\n  at \".concat(func).concat(args, \" @ \").concat(frame.url).concat(line).concat(column);\n    });\n    return result;\n}\nexport function getFileFromStackTraceString(stack) {\n    var _a;\n    return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function formatErrorMessage(stack) {\n    return \"\".concat(stack.name || 'Error', \": \").concat(stack.message);\n}\n/**\n Creates a stacktrace without SDK internal frames.\n \n Constraints:\n - Has to be called at the utmost position of the call stack.\n - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack() {\n    /**\n     * Skip the two internal frames:\n     * - SDK API (console.error, ...)\n     * - this function\n     * in order to keep only the user calls\n     */\n    var internalFramesToSkip = 2;\n    var error = new Error();\n    var formattedStack;\n    // IE needs to throw the error to fill in the stack trace\n    if (!error.stack) {\n        try {\n            throw error;\n        }\n        catch (e) {\n            noop();\n        }\n    }\n    callMonitored(function () {\n        var stackTrace = computeStackTrace(error);\n        stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n        formattedStack = toStackTraceString(stackTrace);\n    });\n    return formattedStack;\n}\nexport function flattenErrorCauses(error, parentSource) {\n    var currentError = error;\n    var causes = [];\n    while ((currentError === null || currentError === void 0 ? void 0 : currentError.cause) instanceof Error && causes.length < 10) {\n        var stackTrace = computeStackTrace(currentError.cause);\n        causes.push({\n            message: currentError.cause.message,\n            source: parentSource,\n            type: stackTrace === null || stackTrace === void 0 ? void 0 : stackTrace.name,\n            stack: stackTrace && toStackTraceString(stackTrace),\n        });\n        currentError = currentError.cause;\n    }\n    return causes.length ? causes : undefined;\n}\n//# sourceMappingURL=error.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 *\n * FORMAT:\n * All feature flags should be snake_cased\n */\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected feature flag\n// eslint-disable-next-line no-restricted-syntax\nexport var ExperimentalFeature;\n(function (ExperimentalFeature) {\n    ExperimentalFeature[\"PAGEHIDE\"] = \"pagehide\";\n    ExperimentalFeature[\"FEATURE_FLAGS\"] = \"feature_flags\";\n    ExperimentalFeature[\"RESOURCE_PAGE_STATES\"] = \"resource_page_states\";\n    ExperimentalFeature[\"PAGE_STATES\"] = \"page_states\";\n    ExperimentalFeature[\"COLLECT_FLUSH_REASON\"] = \"collect_flush_reason\";\n    ExperimentalFeature[\"NO_RESOURCE_DURATION_FROZEN_STATE\"] = \"no_resource_duration_frozen_state\";\n    ExperimentalFeature[\"SCROLLMAP\"] = \"scrollmap\";\n    ExperimentalFeature[\"INTERACTION_TO_NEXT_PAINT\"] = \"interaction_to_next_paint\";\n    ExperimentalFeature[\"WEB_VITALS_ATTRIBUTION\"] = \"web_vitals_attribution\";\n    ExperimentalFeature[\"DISABLE_REPLAY_INLINE_CSS\"] = \"disable_replay_inline_css\";\n})(ExperimentalFeature || (ExperimentalFeature = {}));\nvar enabledExperimentalFeatures = new Set();\nexport function addExperimentalFeatures(enabledFeatures) {\n    enabledFeatures.forEach(function (flag) {\n        enabledExperimentalFeatures.add(flag);\n    });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n    return enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n    enabledExperimentalFeatures.clear();\n}\nexport function getExperimentalFeatures() {\n    return enabledExperimentalFeatures;\n}\n//# sourceMappingURL=experimentalFeatures.js.map","import { display } from '../../tools/display';\nimport { getType } from '../../tools/utils/typeUtils';\nimport { assign } from '../../tools/utils/polyfills';\n/**\n * Clone input data and ensure known user properties (id, name, email)\n * are strings, as defined here:\n * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n */\nexport function sanitizeUser(newUser) {\n    // We shallow clone only to prevent mutation of user data.\n    var user = assign({}, newUser);\n    var keys = ['id', 'name', 'email'];\n    keys.forEach(function (key) {\n        if (key in user) {\n            user[key] = String(user[key]);\n        }\n    });\n    return user;\n}\n/**\n * Simple check to ensure user is valid\n */\nexport function checkUser(newUser) {\n    var isValid = getType(newUser) === 'object';\n    if (!isValid) {\n        display.error('Unsupported user:', newUser);\n    }\n    return isValid;\n}\n//# sourceMappingURL=user.js.map","import { assign } from './polyfills';\nexport function shallowClone(object) {\n    return assign({}, object);\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some(function (key) { return object[key] === value; });\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//# sourceMappingURL=objectUtils.js.map","import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils/timeUtils';\nexport var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR;\nexport var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE;\n//# sourceMappingURL=sessionConstants.js.map","var browserIsIE;\nexport function isIE() {\n    return browserIsIE !== null && browserIsIE !== void 0 ? browserIsIE : (browserIsIE = Boolean(document.documentMode));\n}\nvar browserIsChromium;\nexport function isChromium() {\n    return (browserIsChromium !== null && browserIsChromium !== void 0 ? browserIsChromium : (browserIsChromium = !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent)));\n}\nvar browserIsSafari;\nexport function isSafari() {\n    return browserIsSafari !== null && browserIsSafari !== void 0 ? browserIsSafari : (browserIsSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent));\n}\n//# sourceMappingURL=browserDetection.js.map","export var SESSION_STORE_KEY = '_dd_s';\n//# sourceMappingURL=sessionStoreStrategy.js.map","import { isEmptyObject } from '../../tools/utils/objectUtils';\nimport { objectEntries } from '../../tools/utils/polyfills';\nimport { dateNow } from '../../tools/utils/timeUtils';\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants';\nvar SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;\nvar SESSION_ENTRY_SEPARATOR = '&';\nexport function isSessionInExpiredState(session) {\n    return isEmptyObject(session);\n}\nexport function expandSessionState(session) {\n    session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);\n}\nexport function toSessionString(session) {\n    return objectEntries(session)\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 toSessionState(sessionString) {\n    var session = {};\n    if (isValidSessionString(sessionString)) {\n        sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {\n            var matches = SESSION_ENTRY_REGEXP.exec(entry);\n            if (matches !== null) {\n                var key = matches[1], value = matches[2];\n                session[key] = value;\n            }\n        });\n    }\n    return session;\n}\nfunction isValidSessionString(sessionString) {\n    return (!!sessionString &&\n        (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString)));\n}\n//# sourceMappingURL=sessionState.js.map","import { isChromium } from '../../../tools/utils/browserDetection';\nimport { getCurrentSite, areCookiesAuthorized, deleteCookie, getCookie, setCookie } from '../../../browser/cookie';\nimport { tryOldCookiesMigration } from '../oldCookiesMigration';\nimport { SESSION_EXPIRATION_DELAY } from '../sessionConstants';\nimport { toSessionString, toSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nexport function selectCookieStrategy(initConfiguration) {\n    var cookieOptions = buildCookieOptions(initConfiguration);\n    return areCookiesAuthorized(cookieOptions) ? { type: 'Cookie', cookieOptions: cookieOptions } : undefined;\n}\nexport function initCookieStrategy(cookieOptions) {\n    var cookieStore = {\n        /**\n         * Lock strategy allows mitigating issues due to concurrent access to cookie.\n         * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.\n         */\n        isLockEnabled: isChromium(),\n        persistSession: persistSessionCookie(cookieOptions),\n        retrieveSession: retrieveSessionCookie,\n        clearSession: deleteSessionCookie(cookieOptions),\n    };\n    tryOldCookiesMigration(cookieStore);\n    return cookieStore;\n}\nfunction persistSessionCookie(options) {\n    return function (session) {\n        setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n    };\n}\nfunction retrieveSessionCookie() {\n    var sessionString = getCookie(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction deleteSessionCookie(options) {\n    return function () {\n        deleteCookie(SESSION_STORE_KEY, options);\n    };\n}\nexport function buildCookieOptions(initConfiguration) {\n    var cookieOptions = {};\n    cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n    cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        cookieOptions.domain = getCurrentSite();\n    }\n    return cookieOptions;\n}\n//# sourceMappingURL=sessionInCookie.js.map","import { getCookie } from '../../browser/cookie';\nimport { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport var OLD_SESSION_COOKIE_NAME = '_dd';\nexport var OLD_RUM_COOKIE_NAME = '_dd_r';\nexport var OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport var RUM_SESSION_KEY = 'rum';\nexport var LOGS_SESSION_KEY = 'logs';\n/**\n * This migration should remain in the codebase as long as older versions are available/live\n * to allow older sdk versions to be upgraded to newer versions without compatibility issues.\n */\nexport function tryOldCookiesMigration(cookieStoreStrategy) {\n    var sessionString = getCookie(SESSION_STORE_KEY);\n    if (!sessionString) {\n        var oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME);\n        var oldRumType = getCookie(OLD_RUM_COOKIE_NAME);\n        var oldLogsType = getCookie(OLD_LOGS_COOKIE_NAME);\n        var session = {};\n        if (oldSessionId) {\n            session.id = oldSessionId;\n        }\n        if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n            session[LOGS_SESSION_KEY] = oldLogsType;\n        }\n        if (oldRumType && /^[012]$/.test(oldRumType)) {\n            session[RUM_SESSION_KEY] = oldRumType;\n        }\n        if (!isSessionInExpiredState(session)) {\n            expandSessionState(session);\n            cookieStoreStrategy.persistSession(session);\n        }\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { generateUUID } from '../../../tools/utils/stringUtils';\nimport { toSessionString, toSessionState } from '../sessionState';\nimport { SESSION_STORE_KEY } from './sessionStoreStrategy';\nvar LOCAL_STORAGE_TEST_KEY = '_dd_test_';\nexport function selectLocalStorageStrategy() {\n    try {\n        var id = generateUUID();\n        var testKey = \"\".concat(LOCAL_STORAGE_TEST_KEY).concat(id);\n        localStorage.setItem(testKey, id);\n        var retrievedId = localStorage.getItem(testKey);\n        localStorage.removeItem(testKey);\n        return id === retrievedId ? { type: 'LocalStorage' } : undefined;\n    }\n    catch (e) {\n        return undefined;\n    }\n}\nexport function initLocalStorageStrategy() {\n    return {\n        isLockEnabled: false,\n        persistSession: persistInLocalStorage,\n        retrieveSession: retrieveSessionFromLocalStorage,\n        clearSession: clearSessionFromLocalStorage,\n    };\n}\nfunction persistInLocalStorage(sessionState) {\n    localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState));\n}\nfunction retrieveSessionFromLocalStorage() {\n    var sessionString = localStorage.getItem(SESSION_STORE_KEY);\n    return toSessionState(sessionString);\n}\nfunction clearSessionFromLocalStorage() {\n    localStorage.removeItem(SESSION_STORE_KEY);\n}\n//# sourceMappingURL=sessionInLocalStorage.js.map","import { setTimeout } from '../../tools/timer';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { expandSessionState, isSessionInExpiredState } from './sessionState';\nexport var LOCK_RETRY_DELAY = 10;\nexport var LOCK_MAX_TRIES = 100;\nvar bufferedOperations = [];\nvar ongoingOperations;\nexport function processSessionStoreOperations(operations, sessionStoreStrategy, numberOfRetries) {\n    var _a;\n    if (numberOfRetries === void 0) { numberOfRetries = 0; }\n    var isLockEnabled = sessionStoreStrategy.isLockEnabled, retrieveSession = sessionStoreStrategy.retrieveSession, persistSession = sessionStoreStrategy.persistSession, clearSession = sessionStoreStrategy.clearSession;\n    if (!ongoingOperations) {\n        ongoingOperations = operations;\n    }\n    if (operations !== ongoingOperations) {\n        bufferedOperations.push(operations);\n        return;\n    }\n    if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {\n        next(sessionStoreStrategy);\n        return;\n    }\n    var currentLock;\n    var currentSession = retrieveSession();\n    if (isLockEnabled) {\n        // if someone has lock, retry later\n        if (currentSession.lock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n        // acquire lock\n        currentLock = generateUUID();\n        currentSession.lock = currentLock;\n        persistSession(currentSession);\n        // if lock is not acquired, retry later\n        currentSession = retrieveSession();\n        if (currentSession.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    var processedSession = operations.process(currentSession);\n    if (isLockEnabled) {\n        // if lock corrupted after process, retry later\n        currentSession = retrieveSession();\n        if (currentSession.lock !== currentLock) {\n            retryLater(operations, sessionStoreStrategy, numberOfRetries);\n            return;\n        }\n    }\n    if (processedSession) {\n        if (isSessionInExpiredState(processedSession)) {\n            clearSession();\n        }\n        else {\n            expandSessionState(processedSession);\n            persistSession(processedSession);\n        }\n    }\n    if (isLockEnabled) {\n        // correctly handle lock around expiration would require to handle this case properly at several levels\n        // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n        if (!(processedSession && isSessionInExpiredState(processedSession))) {\n            // if lock corrupted after persist, retry later\n            currentSession = retrieveSession();\n            if (currentSession.lock !== currentLock) {\n                retryLater(operations, sessionStoreStrategy, numberOfRetries);\n                return;\n            }\n            delete currentSession.lock;\n            persistSession(currentSession);\n            processedSession = currentSession;\n        }\n    }\n    // call after even if session is not persisted in order to perform operations on\n    // up-to-date session state value => the value could have been modified by another tab\n    (_a = operations.after) === null || _a === void 0 ? void 0 : _a.call(operations, processedSession || currentSession);\n    next(sessionStoreStrategy);\n}\nfunction retryLater(operations, sessionStore, currentNumberOfRetries) {\n    setTimeout(function () {\n        processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1);\n    }, LOCK_RETRY_DELAY);\n}\nfunction next(sessionStore) {\n    ongoingOperations = undefined;\n    var nextOperations = bufferedOperations.shift();\n    if (nextOperations) {\n        processSessionStoreOperations(nextOperations, sessionStore);\n    }\n}\n//# sourceMappingURL=sessionStoreOperations.js.map","import { clearInterval, setInterval } from '../../tools/timer';\nimport { Observable } from '../../tools/observable';\nimport { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils';\nimport { throttle } from '../../tools/utils/functionUtils';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie';\nimport { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage';\nimport { processSessionStoreOperations } from './sessionStoreOperations';\n/**\n * Every second, the storage will be polled to check for any change that can occur\n * to the session state in another browser tab, or another window.\n * This value has been determined from our previous cookie-only implementation.\n */\nexport var STORAGE_POLL_DELAY = ONE_SECOND;\n/**\n * Checks if cookies are available as the preferred storage\n * Else, checks if LocalStorage is allowed and available\n */\nexport function selectSessionStoreStrategyType(initConfiguration) {\n    var sessionStoreStrategyType = selectCookieStrategy(initConfiguration);\n    if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {\n        sessionStoreStrategyType = selectLocalStorageStrategy();\n    }\n    return sessionStoreStrategyType;\n}\n/**\n * Different session concepts:\n * - tracked, the session has an id and is updated along the user navigation\n * - not tracked, the session does not have an id but it is updated along the user navigation\n * - inactive, no session in store or session expired, waiting for a renew session\n */\nexport function startSessionStore(sessionStoreStrategyType, productKey, computeSessionState) {\n    var renewObservable = new Observable();\n    var expireObservable = new Observable();\n    var sessionStoreStrategy = sessionStoreStrategyType.type === 'Cookie'\n        ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)\n        : initLocalStorageStrategy();\n    var clearSession = sessionStoreStrategy.clearSession, retrieveSession = sessionStoreStrategy.retrieveSession;\n    var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY);\n    var sessionCache = retrieveActiveSession();\n    function expandOrRenewSession() {\n        var isTracked;\n        processSessionStoreOperations({\n            process: function (sessionState) {\n                var synchronizedSession = synchronizeSession(sessionState);\n                isTracked = expandOrRenewSessionState(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: function (sessionState) {\n                if (isTracked && !hasSessionInCache()) {\n                    renewSessionInCache(sessionState);\n                }\n                sessionCache = sessionState;\n            },\n        }, sessionStoreStrategy);\n    }\n    function expandSession() {\n        processSessionStoreOperations({\n            process: function (sessionState) { return (hasSessionInCache() ? synchronizeSession(sessionState) : undefined); },\n        }, sessionStoreStrategy);\n    }\n    /**\n     * allows two behaviors:\n     * - if the session is active, synchronize the session cache without updating the session store\n     * - if the session is not active, clear the session store and expire the session cache\n     */\n    function watchSession() {\n        processSessionStoreOperations({\n            process: function (sessionState) { return (!isActiveSession(sessionState) ? {} : undefined); },\n            after: synchronizeSession,\n        }, sessionStoreStrategy);\n    }\n    function synchronizeSession(sessionState) {\n        if (!isActiveSession(sessionState)) {\n            sessionState = {};\n        }\n        if (hasSessionInCache()) {\n            if (isSessionInCacheOutdated(sessionState)) {\n                expireSessionInCache();\n            }\n            else {\n                sessionCache = sessionState;\n            }\n        }\n        return sessionState;\n    }\n    function expandOrRenewSessionState(sessionState) {\n        var _a = computeSessionState(sessionState[productKey]), trackingType = _a.trackingType, isTracked = _a.isTracked;\n        sessionState[productKey] = trackingType;\n        if (isTracked && !sessionState.id) {\n            sessionState.id = generateUUID();\n            sessionState.created = String(dateNow());\n        }\n        return isTracked;\n    }\n    function hasSessionInCache() {\n        return sessionCache[productKey] !== undefined;\n    }\n    function isSessionInCacheOutdated(sessionState) {\n        return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey];\n    }\n    function expireSessionInCache() {\n        sessionCache = {};\n        expireObservable.notify();\n    }\n    function renewSessionInCache(sessionState) {\n        sessionCache = sessionState;\n        renewObservable.notify();\n    }\n    function retrieveActiveSession() {\n        var session = retrieveSession();\n        if (isActiveSession(session)) {\n            return session;\n        }\n        return {};\n    }\n    function isActiveSession(sessionState) {\n        // created and expire can be undefined for versions which was not storing them\n        // these checks could be removed when older versions will not be available/live anymore\n        return ((sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&\n            (sessionState.expire === undefined || dateNow() < Number(sessionState.expire)));\n    }\n    return {\n        expandOrRenewSession: throttle(expandOrRenewSession, STORAGE_POLL_DELAY).throttled,\n        expandSession: expandSession,\n        getSession: function () { return sessionCache; },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        expire: function () {\n            clearSession();\n            synchronizeSession({});\n        },\n        stop: function () {\n            clearInterval(watchSessionTimeoutId);\n        },\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { jsonStringify } from '../serialisation/jsonStringify';\nexport function normalizeUrl(url) {\n    return buildUrl(url, getLocationOrigin()).href;\n}\nexport function isValidUrl(url) {\n    try {\n        return !!buildUrl(url);\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getOrigin(url) {\n    return getLinkElementOrigin(buildUrl(url));\n}\nexport function getPathName(url) {\n    var pathname = buildUrl(url).pathname;\n    return pathname[0] === '/' ? pathname : \"/\".concat(pathname);\n}\nexport function getSearch(url) {\n    return buildUrl(url).search;\n}\nexport function getHash(url) {\n    return buildUrl(url).hash;\n}\nexport function buildUrl(url, base) {\n    var supportedURL = getSupportedUrl();\n    if (supportedURL) {\n        try {\n            return base !== undefined ? new supportedURL(url, base) : new supportedURL(url);\n        }\n        catch (error) {\n            throw new Error(\"Failed to construct URL: \".concat(String(error), \" \").concat(jsonStringify({ url: url, base: base })));\n        }\n    }\n    if (base === undefined && !/:/.test(url)) {\n        throw new Error(\"Invalid URL: '\".concat(url, \"'\"));\n    }\n    var doc = document;\n    var anchorElement = doc.createElement('a');\n    if (base !== undefined) {\n        doc = document.implementation.createHTMLDocument('');\n        var baseElement = doc.createElement('base');\n        baseElement.href = base;\n        doc.head.appendChild(baseElement);\n        doc.body.appendChild(anchorElement);\n    }\n    anchorElement.href = url;\n    return anchorElement;\n}\nvar originalURL = URL;\nvar isURLSupported;\nfunction getSupportedUrl() {\n    if (isURLSupported === undefined) {\n        try {\n            var url = new originalURL('http://test/path');\n            isURLSupported = url.href === 'http://test/path';\n        }\n        catch (_a) {\n            isURLSupported = false;\n        }\n    }\n    return isURLSupported ? originalURL : undefined;\n}\nexport function getLocationOrigin() {\n    return getLinkElementOrigin(window.location);\n}\n/**\n * Fallback\n * On IE HTMLAnchorElement origin is not supported: https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin\n * On Firefox window.location.origin is \"null\" for file: URIs: https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n */\nexport function getLinkElementOrigin(element) {\n    if (element.origin && element.origin !== 'null') {\n        return element.origin;\n    }\n    var sanitizedHost = element.host.replace(/(:80|:443)$/, '');\n    return \"\".concat(element.protocol, \"//\").concat(sanitizedHost);\n}\n//# sourceMappingURL=urlPolyfill.js.map","export var INTAKE_SITE_STAGING = 'datad0g.com';\nexport var INTAKE_SITE_US1 = 'datadoghq.com';\nexport var INTAKE_SITE_EU1 = 'datadoghq.eu';\nexport var INTAKE_SITE_AP1 = 'ap1.datadoghq.com';\nexport var INTAKE_SITE_US1_FED = 'ddog-gov.com';\n//# sourceMappingURL=intakeSites.js.map","import { timeStampNow } from '../../tools/utils/timeUtils';\nimport { normalizeUrl } from '../../tools/utils/urlPolyfill';\nimport { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures';\nimport { generateUUID } from '../../tools/utils/stringUtils';\nimport { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites';\nexport var ENDPOINTS = {\n    logs: 'logs',\n    rum: 'rum',\n    sessionReplay: 'session-replay',\n};\nvar INTAKE_TRACKS = {\n    logs: 'logs',\n    rum: 'rum',\n    sessionReplay: 'replay',\n};\nexport function createEndpointBuilder(initConfiguration, endpointType, configurationTags) {\n    var buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, endpointType);\n    return {\n        build: function (api, payload) {\n            var parameters = buildEndpointParameters(initConfiguration, endpointType, configurationTags, api, payload);\n            return buildUrlWithParameters(parameters);\n        },\n        urlPrefix: buildUrlWithParameters(''),\n        endpointType: endpointType,\n    };\n}\n/**\n * Create a function used to build a full endpoint url from provided parameters. The goal of this\n * function is to pre-compute some parts of the URL to avoid re-computing everything on every\n * request, as only parameters are changing.\n */\nfunction createEndpointUrlWithParametersBuilder(initConfiguration, endpointType) {\n    var path = \"/api/v2/\".concat(INTAKE_TRACKS[endpointType]);\n    var proxy = initConfiguration.proxy, proxyUrl = initConfiguration.proxyUrl;\n    if (proxy) {\n        var normalizedProxyUrl_1 = normalizeUrl(proxy);\n        return function (parameters) { return \"\".concat(normalizedProxyUrl_1, \"?ddforward=\").concat(encodeURIComponent(\"\".concat(path, \"?\").concat(parameters))); };\n    }\n    var host = buildEndpointHost(initConfiguration, endpointType);\n    if (proxy === undefined && proxyUrl) {\n        // TODO: remove this in a future major.\n        var normalizedProxyUrl_2 = normalizeUrl(proxyUrl);\n        return function (parameters) {\n            return \"\".concat(normalizedProxyUrl_2, \"?ddforward=\").concat(encodeURIComponent(\"https://\".concat(host).concat(path, \"?\").concat(parameters)));\n        };\n    }\n    return function (parameters) { return \"https://\".concat(host).concat(path, \"?\").concat(parameters); };\n}\nfunction buildEndpointHost(initConfiguration, endpointType) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US1 : _a, internalAnalyticsSubdomain = initConfiguration.internalAnalyticsSubdomain;\n    if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {\n        return \"\".concat(internalAnalyticsSubdomain, \".\").concat(INTAKE_SITE_US1);\n    }\n    var domainParts = site.split('.');\n    var extension = domainParts.pop();\n    var subdomain = site !== INTAKE_SITE_AP1 ? \"\".concat(ENDPOINTS[endpointType], \".\") : '';\n    return \"\".concat(subdomain, \"browser-intake-\").concat(domainParts.join('-'), \".\").concat(extension);\n}\n/**\n * Build parameters to be used for an intake request. Parameters should be re-built for each\n * request, as they change randomly.\n */\nfunction buildEndpointParameters(_a, endpointType, configurationTags, api, _b) {\n    var clientToken = _a.clientToken, internalAnalyticsSubdomain = _a.internalAnalyticsSubdomain;\n    var retry = _b.retry, flushReason = _b.flushReason, encoding = _b.encoding;\n    var tags = [\"sdk_version:\".concat(\"4.50.1\"), \"api:\".concat(api)].concat(configurationTags);\n    if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {\n        tags.push(\"flush_reason:\".concat(flushReason));\n    }\n    if (retry) {\n        tags.push(\"retry_count:\".concat(retry.count), \"retry_after:\".concat(retry.lastFailureStatus));\n    }\n    var parameters = [\n        'ddsource=browser',\n        \"ddtags=\".concat(encodeURIComponent(tags.join(','))),\n        \"dd-api-key=\".concat(clientToken),\n        \"dd-evp-origin-version=\".concat(encodeURIComponent(\"4.50.1\")),\n        'dd-evp-origin=browser',\n        \"dd-request-id=\".concat(generateUUID()),\n    ];\n    if (encoding) {\n        parameters.push(\"dd-evp-encoding=\".concat(encoding));\n    }\n    if (endpointType === 'rum') {\n        parameters.push(\"batch_time=\".concat(timeStampNow()));\n    }\n    if (internalAnalyticsSubdomain) {\n        parameters.reverse();\n    }\n    return parameters.join('&');\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 { objectValues, assign } from '../../tools/utils/polyfills';\nimport { createEndpointBuilder } from './endpointBuilder';\nimport { buildTags } from './tags';\nimport { INTAKE_SITE_US1 } from './intakeSites';\nexport function computeTransportConfiguration(initConfiguration) {\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var intakeUrlPrefixes = objectValues(endpointBuilders).map(function (builder) { return builder.urlPrefix; });\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags);\n    return assign({\n        isIntakeUrl: function (url) { return intakeUrlPrefixes.some(function (intakeEndpoint) { return url.indexOf(intakeEndpoint) === 0; }); },\n        replica: replicaConfiguration,\n        site: initConfiguration.site || INTAKE_SITE_US1,\n    }, endpointBuilders);\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n    return {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),\n    };\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeUrlPrefixes, tags) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    var replicaConfiguration = assign({}, initConfiguration, {\n        site: INTAKE_SITE_US1,\n        clientToken: initConfiguration.replica.clientToken,\n    });\n    var replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n    };\n    intakeUrlPrefixes.push.apply(intakeUrlPrefixes, objectValues(replicaEndpointBuilders).map(function (builder) { return builder.urlPrefix; }));\n    return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { ExperimentalFeature, addExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { ONE_SECOND } from '../../tools/utils/timeUtils';\nimport { isPercentage } from '../../tools/utils/numberUtils';\nimport { ONE_KIBI_BYTE } from '../../tools/utils/byteUtils';\nimport { objectHasValue } from '../../tools/utils/objectUtils';\nimport { assign } from '../../tools/utils/polyfills';\nimport { selectSessionStoreStrategyType } from '../session/sessionStore';\nimport { computeTransportConfiguration } from './transportConfiguration';\nexport var DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\n};\nexport function validateAndBuildConfiguration(initConfiguration) {\n    var _a, _b, _c;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\n        return;\n    }\n    var sessionSampleRate = (_a = initConfiguration.sessionSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.sampleRate;\n    if (sessionSampleRate !== undefined && !isPercentage(sessionSampleRate)) {\n        display.error('Session Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetrySampleRate !== undefined && !isPercentage(initConfiguration.telemetrySampleRate)) {\n        display.error('Telemetry Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetryConfigurationSampleRate !== undefined &&\n        !isPercentage(initConfiguration.telemetryConfigurationSampleRate)) {\n        display.error('Telemetry Configuration Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // Set the experimental feature flags as early as possible, so we can use them in most places\n    if (Array.isArray(initConfiguration.enableExperimentalFeatures)) {\n        addExperimentalFeatures(initConfiguration.enableExperimentalFeatures.filter(function (flag) {\n            return objectHasValue(ExperimentalFeature, flag);\n        }));\n    }\n    return assign({\n        beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n        sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),\n        sessionSampleRate: sessionSampleRate !== null && sessionSampleRate !== void 0 ? sessionSampleRate : 100,\n        telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n        telemetryConfigurationSampleRate: (_c = initConfiguration.telemetryConfigurationSampleRate) !== null && _c !== void 0 ? _c : 5,\n        service: initConfiguration.service,\n        silentMultipleInit: !!initConfiguration.silentMultipleInit,\n        /**\n         * beacon payload max queue size implementation is 64kb\n         * ensure that we leave room for logs, rum and potential other users\n         */\n        batchBytesLimit: 16 * ONE_KIBI_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxTelemetryEventsPerPage: 15,\n        /**\n         * flush automatically, aim to be lower than ALB connection timeout\n         * to maximize connection reuse.\n         */\n        flushTimeout: (30 * ONE_SECOND),\n        /**\n         * Logs intake limit\n         */\n        batchMessagesLimit: 50,\n        messageBytesLimit: 256 * ONE_KIBI_BYTE,\n    }, computeTransportConfiguration(initConfiguration));\n}\nexport function serializeConfiguration(initConfiguration) {\n    var _a, _b;\n    var proxy = (_a = initConfiguration.proxy) !== null && _a !== void 0 ? _a : initConfiguration.proxyUrl;\n    return {\n        session_sample_rate: (_b = initConfiguration.sessionSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.sampleRate,\n        telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n        telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n        use_before_send: !!initConfiguration.beforeSend,\n        use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,\n        use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n        use_proxy: proxy !== undefined ? !!proxy : undefined,\n        silent_multiple_init: initConfiguration.silentMultipleInit,\n        track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n        track_resources: initConfiguration.trackResources,\n        track_long_task: initConfiguration.trackLongTasks,\n        allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,\n        store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,\n    };\n}\n//# sourceMappingURL=configuration.js.map","import { startsWith } from './utils/polyfills';\nimport { display } from './display';\nimport { getType } from './utils/typeUtils';\nexport function isMatchOption(item) {\n    var itemType = getType(item);\n    return itemType === 'string' || itemType === 'function' || item instanceof RegExp;\n}\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list, value, useStartsWith) {\n    if (useStartsWith === void 0) { useStartsWith = false; }\n    return list.some(function (item) {\n        try {\n            if (typeof item === 'function') {\n                return item(value);\n            }\n            else if (item instanceof RegExp) {\n                return item.test(value);\n            }\n            else if (typeof item === 'string') {\n                return useStartsWith ? startsWith(value, item) : item === value;\n            }\n        }\n        catch (e) {\n            display.error(e);\n        }\n        return false;\n    });\n}\n//# sourceMappingURL=matchOption.js.map","import { objectEntries, shallowClone, performDraw, isNumber, assign, find, getType, isMatchOption, matchList, } from '@datadog/browser-core';\nexport function isTracingOption(item) {\n    var expectedItem = item;\n    return (getType(expectedItem) === 'object' &&\n        isMatchOption(expectedItem.match) &&\n        Array.isArray(expectedItem.propagatorTypes));\n}\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the\n * request did not reach the server, but 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        context.traceSampled = 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() || !sessionManager.findTrackedSession()) {\n        return;\n    }\n    var tracingOption = find(configuration.allowedTracingUrls, function (tracingOption) {\n        return matchList([tracingOption.match], context.url, true);\n    });\n    if (!tracingOption) {\n        return;\n    }\n    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\n    context.traceSampled = !isNumber(configuration.traceSampleRate) || performDraw(configuration.traceSampleRate);\n    inject(makeTracingHeaders(context.traceId, context.spanId, context.traceSampled, tracingOption.propagatorTypes));\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\n}\nfunction getCrypto() {\n    return window.crypto || window.msCrypto;\n}\n/**\n * When trace is not sampled, set priority to '0' instead of not adding the tracing headers\n * to prepare the implementation for sampling delegation.\n */\nfunction makeTracingHeaders(traceId, spanId, traceSampled, propagatorTypes) {\n    var tracingHeaders = {};\n    propagatorTypes.forEach(function (propagatorType) {\n        switch (propagatorType) {\n            case 'datadog': {\n                assign(tracingHeaders, {\n                    'x-datadog-origin': 'rum',\n                    'x-datadog-parent-id': spanId.toDecimalString(),\n                    'x-datadog-sampling-priority': traceSampled ? '1' : '0',\n                    'x-datadog-trace-id': traceId.toDecimalString(),\n                });\n                break;\n            }\n            // https://www.w3.org/TR/trace-context/\n            case 'tracecontext': {\n                assign(tracingHeaders, {\n                    traceparent: \"00-0000000000000000\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-0\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            // https://github.com/openzipkin/b3-propagation\n            case 'b3': {\n                assign(tracingHeaders, {\n                    b3: \"\".concat(traceId.toPaddedHexadecimalString(), \"-\").concat(spanId.toPaddedHexadecimalString(), \"-\").concat(traceSampled ? '1' : '0'),\n                });\n                break;\n            }\n            case 'b3multi': {\n                assign(tracingHeaders, {\n                    'X-B3-TraceId': traceId.toPaddedHexadecimalString(),\n                    'X-B3-SpanId': spanId.toPaddedHexadecimalString(),\n                    'X-B3-Sampled': traceSampled ? '1' : '0',\n                });\n                break;\n            }\n        }\n    });\n    return tracingHeaders;\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    /**\n     * Format used by OTel headers\n     */\n    TraceIdentifier.prototype.toPaddedHexadecimalString = function () {\n        var traceId = this.toString(16);\n        return Array(17 - traceId.length).join('0') + traceId;\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 { getType, arrayFrom, getOrigin, isMatchOption, serializeConfiguration, assign, DefaultPrivacyLevel, display, isPercentage, objectHasValue, validateAndBuildConfiguration, } from '@datadog/browser-core';\nimport { isTracingOption } from './tracing/tracer';\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b, _c, _d, _e, _f;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (initConfiguration.sessionReplaySampleRate !== undefined &&\n        !isPercentage(initConfiguration.sessionReplaySampleRate)) {\n        display.error('Session Replay Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // TODO remove fallback in next major\n    var premiumSampleRate = (_a = initConfiguration.premiumSampleRate) !== null && _a !== void 0 ? _a : initConfiguration.replaySampleRate;\n    if (premiumSampleRate !== undefined && initConfiguration.sessionReplaySampleRate !== undefined) {\n        display.warn('Ignoring Premium Sample Rate because Session Replay Sample Rate is set');\n        premiumSampleRate = undefined;\n    }\n    if (premiumSampleRate !== undefined && !isPercentage(premiumSampleRate)) {\n        display.error('Premium Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    var traceSampleRate = (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : initConfiguration.tracingSampleRate;\n    if (traceSampleRate !== undefined && !isPercentage(traceSampleRate)) {\n        display.error('Trace Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.excludedActivityUrls !== undefined && !Array.isArray(initConfiguration.excludedActivityUrls)) {\n        display.error('Excluded Activity Urls should be an array');\n        return;\n    }\n    var allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration);\n    if (!allowedTracingUrls) {\n        return;\n    }\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    var trackUserInteractions = !!((_c = initConfiguration.trackUserInteractions) !== null && _c !== void 0 ? _c : initConfiguration.trackInteractions);\n    var trackFrustrations = !!initConfiguration.trackFrustrations;\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        sessionReplaySampleRate: (_e = (_d = initConfiguration.sessionReplaySampleRate) !== null && _d !== void 0 ? _d : premiumSampleRate) !== null && _e !== void 0 ? _e : 100,\n        oldPlansBehavior: initConfiguration.sessionReplaySampleRate === undefined,\n        traceSampleRate: traceSampleRate,\n        allowedTracingUrls: allowedTracingUrls,\n        excludedActivityUrls: (_f = initConfiguration.excludedActivityUrls) !== null && _f !== void 0 ? _f : [],\n        workerUrl: initConfiguration.workerUrl,\n        trackUserInteractions: trackUserInteractions || trackFrustrations,\n        trackFrustrations: trackFrustrations,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        trackResources: initConfiguration.trackResources,\n        trackLongTasks: initConfiguration.trackLongTasks,\n        subdomain: initConfiguration.subdomain,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK_USER_INPUT,\n        customerDataTelemetrySampleRate: 1,\n    }, baseConfiguration);\n}\n/**\n * Handles allowedTracingUrls and processes legacy allowedTracingOrigins\n */\nfunction validateAndBuildTracingOptions(initConfiguration) {\n    // Advise about parameters precedence.\n    if (initConfiguration.allowedTracingUrls !== undefined && initConfiguration.allowedTracingOrigins !== undefined) {\n        display.warn('Both allowedTracingUrls and allowedTracingOrigins (deprecated) have been defined. The parameter allowedTracingUrls will override allowedTracingOrigins.');\n    }\n    // Handle allowedTracingUrls first\n    if (initConfiguration.allowedTracingUrls !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingUrls)) {\n            display.error('Allowed Tracing URLs should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service needs to be configured when tracing is enabled');\n            return;\n        }\n        // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties\n        var tracingOptions_1 = [];\n        initConfiguration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                tracingOptions_1.push({ match: option, propagatorTypes: ['datadog'] });\n            }\n            else if (isTracingOption(option)) {\n                tracingOptions_1.push(option);\n            }\n            else {\n                display.warn('Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter', option);\n            }\n        });\n        return tracingOptions_1;\n    }\n    // Handle conversion of allowedTracingOrigins to allowedTracingUrls\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 needs to be configured when tracing is enabled');\n            return;\n        }\n        var tracingOptions_2 = [];\n        initConfiguration.allowedTracingOrigins.forEach(function (legacyMatchOption) {\n            var tracingOption = convertLegacyMatchOptionToTracingOption(legacyMatchOption);\n            if (tracingOption) {\n                tracingOptions_2.push(tracingOption);\n            }\n        });\n        return tracingOptions_2;\n    }\n    return [];\n}\n/**\n * Converts parameters from the deprecated allowedTracingOrigins\n * to allowedTracingUrls. Handles the change from origin to full URLs.\n */\nfunction convertLegacyMatchOptionToTracingOption(item) {\n    var match;\n    if (typeof item === 'string') {\n        match = item;\n    }\n    else if (item instanceof RegExp) {\n        match = function (url) { return item.test(getOrigin(url)); };\n    }\n    else if (typeof item === 'function') {\n        match = function (url) { return item(getOrigin(url)); };\n    }\n    if (match === undefined) {\n        display.warn('Allowed Tracing Origins parameters should be a string, RegExp or function. Ignoring parameter', item);\n        return undefined;\n    }\n    return { match: match, propagatorTypes: ['datadog'] };\n}\n/**\n * Combines the selected tracing propagators from the different options in allowedTracingUrls,\n * and assumes 'datadog' has been selected when using allowedTracingOrigins\n */\nfunction getSelectedTracingPropagators(configuration) {\n    var usedTracingPropagators = new Set();\n    if (Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0) {\n        configuration.allowedTracingUrls.forEach(function (option) {\n            if (isMatchOption(option)) {\n                usedTracingPropagators.add('datadog');\n            }\n            else if (getType(option) === 'object' && Array.isArray(option.propagatorTypes)) {\n                // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)\n                option.propagatorTypes.forEach(function (propagatorType) { return usedTracingPropagators.add(propagatorType); });\n            }\n        });\n    }\n    if (Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0) {\n        usedTracingPropagators.add('datadog');\n    }\n    return arrayFrom(usedTracingPropagators);\n}\nexport function serializeRumConfiguration(configuration) {\n    var _a, _b;\n    var baseSerializedConfiguration = serializeConfiguration(configuration);\n    return assign({\n        premium_sample_rate: configuration.premiumSampleRate,\n        replay_sample_rate: configuration.replaySampleRate,\n        session_replay_sample_rate: configuration.sessionReplaySampleRate,\n        trace_sample_rate: (_a = configuration.traceSampleRate) !== null && _a !== void 0 ? _a : configuration.tracingSampleRate,\n        action_name_attribute: configuration.actionNameAttribute,\n        use_allowed_tracing_origins: Array.isArray(configuration.allowedTracingOrigins) && configuration.allowedTracingOrigins.length > 0,\n        use_allowed_tracing_urls: Array.isArray(configuration.allowedTracingUrls) && configuration.allowedTracingUrls.length > 0,\n        selected_tracing_propagators: getSelectedTracingPropagators(configuration),\n        default_privacy_level: configuration.defaultPrivacyLevel,\n        use_excluded_activity_urls: Array.isArray(configuration.excludedActivityUrls) && configuration.excludedActivityUrls.length > 0,\n        use_worker_url: !!configuration.workerUrl,\n        track_frustrations: configuration.trackFrustrations,\n        track_views_manually: configuration.trackViewsManually,\n        track_user_interactions: (_b = configuration.trackUserInteractions) !== null && _b !== void 0 ? _b : configuration.trackInteractions,\n    }, baseSerializedConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","export function buildCommonContext(globalContextManager, userContextManager, recorderApi) {\n    return {\n        context: globalContextManager.getContext(),\n        user: userContextManager.getContext(),\n        hasReplay: recorderApi.isRecording() ? true : undefined,\n    };\n}\n//# sourceMappingURL=commonContext.js.map","export function sendToExtension(type, payload) {\n    var callback = window.__ddBrowserSdkExtensionCallback;\n    if (callback) {\n        callback({ type: type, payload: payload });\n    }\n}\n//# sourceMappingURL=sendToExtension.js.map","export var TelemetryType = {\n    log: 'log',\n    configuration: 'configuration',\n};\n//# sourceMappingURL=rawTelemetryEvent.types.js.map","import { ConsoleApiName } from '../../tools/display';\nimport { toStackTraceString, NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/error';\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures';\nimport { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration';\nimport { computeStackTrace } from '../tracekit';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/utils/timeUtils';\nimport { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor';\nimport { sendToExtension } from '../../tools/sendToExtension';\nimport { startsWith, arrayFrom, includes, assign } from '../../tools/utils/polyfills';\nimport { performDraw } from '../../tools/utils/numberUtils';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nimport { combine } from '../../tools/mergeInto';\nimport { TelemetryType } from './rawTelemetryEvent.types';\nvar ALLOWED_FRAME_URLS = [\n    'https://www.datadoghq-browser-agent.com',\n    'https://www.datad0g-browser-agent.com',\n    'https://d3uc069fcn7uxw.cloudfront.net',\n    'https://d20xtzwzcl0ceb.cloudfront.net',\n    'http://localhost',\n    '<anonymous>',\n];\nvar TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_US1_FED];\nvar telemetryConfiguration = { maxEventsPerPage: 0, sentEventCount: 0, telemetryEnabled: false, telemetryConfigurationEnabled: false };\nvar onRawTelemetryEventCollected;\nexport function startTelemetry(telemetryService, configuration) {\n    var contextProvider;\n    var observable = new Observable();\n    telemetryConfiguration.telemetryEnabled =\n        !includes(TELEMETRY_EXCLUDED_SITES, configuration.site) && performDraw(configuration.telemetrySampleRate);\n    telemetryConfiguration.telemetryConfigurationEnabled =\n        telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate);\n    var runtimeEnvInfo = getRuntimeEnvInfo();\n    onRawTelemetryEventCollected = function (rawEvent) {\n        if (telemetryConfiguration.telemetryEnabled) {\n            var event_1 = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo);\n            observable.notify(event_1);\n            sendToExtension('telemetry', event_1);\n        }\n    };\n    startMonitorErrorCollection(addTelemetryError);\n    assign(telemetryConfiguration, {\n        maxEventsPerPage: configuration.maxTelemetryEventsPerPage,\n        sentEventCount: 0,\n    });\n    function toTelemetryEvent(telemetryService, event, runtimeEnvInfo) {\n        return combine({\n            type: 'telemetry',\n            date: timeStampNow(),\n            service: telemetryService,\n            version: \"4.50.1\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: combine(event, {\n                runtime_env: runtimeEnvInfo,\n            }),\n            experimental_features: arrayFrom(getExperimentalFeatures()),\n        }, contextProvider !== undefined ? contextProvider() : {});\n    }\n    return {\n        setContextProvider: function (provider) {\n            contextProvider = provider;\n        },\n        observable: observable,\n        enabled: telemetryConfiguration.telemetryEnabled,\n    };\n}\nfunction getRuntimeEnvInfo() {\n    return {\n        is_local_file: window.location.protocol === 'file:',\n        is_worker: 'WorkerGlobalScope' in self,\n    };\n}\nexport function startFakeTelemetry() {\n    var events = [];\n    assign(telemetryConfiguration, {\n        maxEventsPerPage: Infinity,\n        sentEventCount: 0,\n    });\n    onRawTelemetryEventCollected = function (event) {\n        events.push(event);\n    };\n    return events;\n}\nexport function resetTelemetry() {\n    onRawTelemetryEventCollected = undefined;\n}\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nexport function isTelemetryReplicationAllowed(configuration) {\n    return configuration.site === INTAKE_SITE_STAGING;\n}\nexport function addTelemetryDebug(message, context) {\n    displayIfDebugEnabled(ConsoleApiName.debug, message, context);\n    addTelemetry(assign({\n        type: TelemetryType.log,\n        message: message,\n        status: \"debug\" /* StatusType.debug */,\n    }, context));\n}\nexport function addTelemetryError(e, context) {\n    addTelemetry(assign({\n        type: TelemetryType.log,\n        status: \"error\" /* StatusType.error */,\n    }, formatError(e), context));\n}\nexport function addTelemetryConfiguration(configuration) {\n    if (telemetryConfiguration.telemetryConfigurationEnabled) {\n        addTelemetry({\n            type: TelemetryType.configuration,\n            configuration: configuration,\n        });\n    }\n}\nfunction addTelemetry(event) {\n    if (onRawTelemetryEventCollected && telemetryConfiguration.sentEventCount < telemetryConfiguration.maxEventsPerPage) {\n        telemetryConfiguration.sentEventCount += 1;\n        onRawTelemetryEventCollected(event);\n    }\n}\nexport function formatError(e) {\n    if (e instanceof Error) {\n        var stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(scrubCustomerFrames(stackTrace)),\n            },\n            message: stackTrace.message,\n        };\n    }\n    return {\n        error: {\n            stack: NO_ERROR_STACK_PRESENT_MESSAGE,\n        },\n        message: \"\".concat(\"Uncaught\" /* NonErrorPrefix.UNCAUGHT */, \" \").concat(jsonStringify(e)),\n    };\n}\nexport function scrubCustomerFrames(stackTrace) {\n    stackTrace.stack = stackTrace.stack.filter(function (frame) { return !frame.url || ALLOWED_FRAME_URLS.some(function (allowedFrameUrl) { return startsWith(frame.url, allowedFrameUrl); }); });\n    return stackTrace;\n}\n//# sourceMappingURL=telemetry.js.map","import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../tools/experimentalFeatures';\nimport { Observable } from '../tools/observable';\nimport { objectValues, includes } from '../tools/utils/polyfills';\nimport { noop } from '../tools/utils/functionUtils';\nimport { addEventListeners, addEventListener } from './addEventListener';\nexport var PageExitReason = {\n    HIDDEN: 'visibility_hidden',\n    UNLOADING: 'before_unload',\n    PAGEHIDE: 'page_hide',\n    FROZEN: 'page_frozen',\n};\nexport function createPageExitObservable(configuration) {\n    var observable = new Observable(function () {\n        var pagehideEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGEHIDE);\n        var stopListeners = addEventListeners(configuration, window, [\"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, \"freeze\" /* DOM_EVENT.FREEZE */, \"pagehide\" /* DOM_EVENT.PAGE_HIDE */], function (event) {\n            if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */ && pagehideEnabled) {\n                /**\n                 * Only event that detect page unload events while being compatible with the back/forward cache (bfcache)\n                 */\n                observable.notify({ reason: PageExitReason.PAGEHIDE });\n            }\n            else if (event.type === \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */ && document.visibilityState === 'hidden') {\n                /**\n                 * Only event that guarantee to fire on mobile devices when the page transitions to background state\n                 * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n                 */\n                observable.notify({ reason: PageExitReason.HIDDEN });\n            }\n            else if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n                /**\n                 * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)\n                 * Allow to collect events happening between hidden and frozen state.\n                 */\n                observable.notify({ reason: PageExitReason.FROZEN });\n            }\n        }, { capture: true }).stop;\n        var stopBeforeUnloadListener = noop;\n        if (!pagehideEnabled) {\n            stopBeforeUnloadListener = addEventListener(configuration, window, \"beforeunload\" /* DOM_EVENT.BEFORE_UNLOAD */, function () {\n                observable.notify({ reason: PageExitReason.UNLOADING });\n            }).stop;\n        }\n        return function () {\n            stopListeners();\n            stopBeforeUnloadListener();\n        };\n    });\n    return observable;\n}\nexport function isPageExitReason(reason) {\n    return includes(objectValues(PageExitReason), reason);\n}\n//# sourceMappingURL=pageExitObservable.js.map","import { monitor, noop, Observable, getZoneJsOriginalValue } 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 try to get the original MutationObserver constructor stored by\n    // Zone.js.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        // Zone.js 0.8.6+ is storing original class constructors into the browser 'window' object[3].\n        //\n        // [3] https://github.com/angular/angular/blob/6375fa79875c0fe7b815efc45940a6e6f5c9c9eb/packages/zone.js/lib/common/utils.ts#L288\n        constructor = getZoneJsOriginalValue(browserWindow, 'MutationObserver');\n        if (browserWindow.MutationObserver && constructor === browserWindow.MutationObserver) {\n            // Anterior Zone.js versions (used in Angular 2) does not expose the original MutationObserver\n            // in the 'window' object. Luckily, the patched MutationObserver class is storing an original\n            // instance in its properties[4]. Let's get the original MutationObserver constructor from\n            // there.\n            //\n            // [4] https://github.com/angular/zone.js/blob/v0.8.5/lib/common/utils.ts#L412\n            var patchedInstance = new browserWindow.MutationObserver(noop);\n            var originalInstance = getZoneJsOriginalValue(patchedInstance, 'originalInstance');\n            constructor = originalInstance && originalInstance.constructor;\n        }\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { addEventListener } from './addEventListener';\nexport function runOnReadyState(configuration, expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n    }\n    else {\n        var eventName = expectedReadyState === 'complete' ? \"load\" /* DOM_EVENT.LOAD */ : \"DOMContentLoaded\" /* DOM_EVENT.DOM_CONTENT_LOADED */;\n        addEventListener(configuration, window, eventName, callback, { once: true });\n    }\n}\n//# sourceMappingURL=runOnReadyState.js.map","import { assign, addTelemetryDebug, elapsed, getPathName, includes, isValidUrl, toServerDuration, } from '@datadog/browser-core';\nexport var FAKE_INITIAL_DOCUMENT = 'initial_document';\nvar RESOURCE_TYPES = [\n    [\"document\" /* ResourceType.DOCUMENT */, function (initiatorType) { return FAKE_INITIAL_DOCUMENT === initiatorType; }],\n    [\"xhr\" /* ResourceType.XHR */, function (initiatorType) { return 'xmlhttprequest' === initiatorType; }],\n    [\"fetch\" /* ResourceType.FETCH */, function (initiatorType) { return 'fetch' === initiatorType; }],\n    [\"beacon\" /* ResourceType.BEACON */, function (initiatorType) { return 'beacon' === initiatorType; }],\n    [\"css\" /* ResourceType.CSS */, function (_, path) { return /\\.css$/i.test(path); }],\n    [\"js\" /* ResourceType.JS */, function (_, path) { return /\\.js$/i.test(path); }],\n    [\n        \"image\" /* ResourceType.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\" /* ResourceType.FONT */, function (_, path) { return /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null; }],\n    [\n        \"media\" /* ResourceType.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        addTelemetryDebug(\"Failed to construct URL for \\\"\".concat(timing.name, \"\\\"\"));\n        return \"other\" /* ResourceType.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\" /* ResourceType.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","export function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE;\n}\nexport function isCommentNode(node) {\n    return node.nodeType === Node.COMMENT_NODE;\n}\nexport function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n}\nexport function isNodeShadowHost(node) {\n    return isElementNode(node) && Boolean(node.shadowRoot);\n}\nexport function isNodeShadowRoot(node) {\n    var shadowRoot = node;\n    return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host);\n}\nexport function hasChildNodes(node) {\n    return node.childNodes.length > 0 || isNodeShadowHost(node);\n}\nexport function forEachChildNodes(node, callback) {\n    node.childNodes.forEach(callback);\n    if (isNodeShadowHost(node)) {\n        callback(node.shadowRoot);\n    }\n}\n/**\n * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`\n */\nexport function getParentNode(node) {\n    return isNodeShadowRoot(node) ? node.host : node.parentNode;\n}\n//# sourceMappingURL=htmlDomUtils.js.map","import { dateNow, findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nimport { isCommentNode, isTextNode } from '../../browser/htmlDomUtils';\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 <= dateNow() - 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    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}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { dateNow, assign, addEventListeners, getRelativeTime, isNumber, monitor, setTimeout, relativeNow, runOnReadyState, addEventListener, objectHasValue, } from '@datadog/browser-core';\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/resource/resourceUtils';\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId';\n// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary\n// string is an expected performance entry\n// eslint-disable-next-line no-restricted-syntax\nexport var RumPerformanceEntryType;\n(function (RumPerformanceEntryType) {\n    RumPerformanceEntryType[\"EVENT\"] = \"event\";\n    RumPerformanceEntryType[\"FIRST_INPUT\"] = \"first-input\";\n    RumPerformanceEntryType[\"LARGEST_CONTENTFUL_PAINT\"] = \"largest-contentful-paint\";\n    RumPerformanceEntryType[\"LAYOUT_SHIFT\"] = \"layout-shift\";\n    RumPerformanceEntryType[\"LONG_TASK\"] = \"longtask\";\n    RumPerformanceEntryType[\"NAVIGATION\"] = \"navigation\";\n    RumPerformanceEntryType[\"PAINT\"] = \"paint\";\n    RumPerformanceEntryType[\"RESOURCE\"] = \"resource\";\n})(RumPerformanceEntryType || (RumPerformanceEntryType = {}));\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 startPerformanceCollection(lifeCycle, configuration) {\n    retrieveInitialDocumentResourceTiming(configuration, 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(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 = [\n            RumPerformanceEntryType.RESOURCE,\n            RumPerformanceEntryType.NAVIGATION,\n            RumPerformanceEntryType.LONG_TASK,\n            RumPerformanceEntryType.PAINT,\n        ];\n        var experimentalEntries = [\n            RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT,\n            RumPerformanceEntryType.FIRST_INPUT,\n            RumPerformanceEntryType.LAYOUT_SHIFT,\n            RumPerformanceEntryType.EVENT,\n        ];\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 window.PerformanceObserver(handlePerformanceEntryList_1);\n                observer.observe({\n                    type: type,\n                    buffered: true,\n                    // durationThreshold only impact PerformanceEventTiming entries used for INP computation which requires a threshold at 40 (default is 104ms)\n                    // cf: https://github.com/GoogleChrome/web-vitals/blob/3806160ffbc93c3c4abf210a167b81228172b31c/src/onINP.ts#L209\n                    durationThreshold: 40,\n                });\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            addEventListener(configuration, performance, 'resourcetimingbufferfull', function () {\n                performance.clearResourceTimings();\n            });\n        }\n    }\n    if (!supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION)) {\n        retrieveNavigationTiming(configuration, function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n    if (!supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT)) {\n        retrieveFirstInputTiming(configuration, function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n}\nexport function retrieveInitialDocumentResourceTiming(configuration, callback) {\n    runOnReadyState(configuration, 'interactive', function () {\n        var timing;\n        var forcedAttributes = {\n            entryType: RumPerformanceEntryType.RESOURCE,\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n            toJSON: function () { return assign({}, timing, { toJSON: undefined }); },\n        };\n        if (supportPerformanceTimingEvent(RumPerformanceEntryType.NAVIGATION) &&\n            performance.getEntriesByType(RumPerformanceEntryType.NAVIGATION).length > 0) {\n            var navigationEntry = performance.getEntriesByType(RumPerformanceEntryType.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(configuration, callback) {\n    function sendFakeTiming() {\n        callback(assign(computeRelativePerformanceTiming(), {\n            entryType: RumPerformanceEntryType.NAVIGATION,\n        }));\n    }\n    runOnReadyState(configuration, 'complete', function () {\n        // Send it a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        setTimeout(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(configuration, callback) {\n    var startTimeStamp = dateNow();\n    var timingSent = false;\n    var removeEventListeners = addEventListeners(configuration, window, [\"click\" /* DOM_EVENT.CLICK */, \"mousedown\" /* DOM_EVENT.MOUSE_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"pointerdown\" /* DOM_EVENT.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: RumPerformanceEntryType.FIRST_INPUT,\n            processingStart: relativeNow(),\n            processingEnd: relativeNow(),\n            startTime: evt.timeStamp,\n            duration: 0,\n            name: '',\n        };\n        if (evt.type === \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(configuration, 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(configuration, timing) {\n        addEventListeners(configuration, window, [\"pointerup\" /* DOM_EVENT.POINTER_UP */, \"pointercancel\" /* DOM_EVENT.POINTER_CANCEL */], function (event) {\n            if (event.type === \"pointerup\" /* DOM_EVENT.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 < dateNow() - 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            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 objectHasValue(RumPerformanceEntryType, entry.entryType);\n    });\n    var rumAllowedPerformanceEntries = rumPerformanceEntries.filter(function (entry) { return !isIncompleteNavigation(entry) && !isForbiddenResource(configuration, entry); });\n    if (rumAllowedPerformanceEntries.length) {\n        lifeCycle.notify(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, rumAllowedPerformanceEntries);\n    }\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.entryType === RumPerformanceEntryType.NAVIGATION && entry.loadEventEnd <= 0;\n}\nfunction isForbiddenResource(configuration, entry) {\n    return entry.entryType === RumPerformanceEntryType.RESOURCE && !isAllowedRequestUrl(configuration, entry.name);\n}\n//# sourceMappingURL=performanceCollection.js.map","export var ErrorSource = {\n    AGENT: 'agent',\n    CONSOLE: 'console',\n    CUSTOM: 'custom',\n    LOGGER: 'logger',\n    NETWORK: 'network',\n    SOURCE: 'source',\n    REPORT: 'report',\n};\n//# sourceMappingURL=error.types.js.map","import { setTimeout } from '../../tools/timer';\nimport { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { ErrorSource } from '../error/error.types';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n    var eventCount = 0;\n    var allowNextEvent = false;\n    return {\n        isLimitReached: function () {\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 { getSyntheticsResultId, getSyntheticsTestId, willSyntheticsInjectRum } from '@datadog/browser-core';\nexport function getSyntheticsContext() {\n    var testId = getSyntheticsTestId();\n    var resultId = getSyntheticsResultId();\n    if (testId && resultId) {\n        return {\n            test_id: testId,\n            result_id: resultId,\n            injected: willSyntheticsInjectRum(),\n        };\n    }\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { sanitize, deepClone, getType, objectEntries } from '@datadog/browser-core';\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    objectEntries(modifiableFieldPaths).forEach(function (_a) {\n        var fieldPath = _a[0], fieldType = _a[1];\n        var newValue = get(clone, fieldPath);\n        var newType = getType(newValue);\n        if (newType === fieldType) {\n            set(object, fieldPath, sanitize(newValue));\n        }\n        else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {\n            set(object, fieldPath, {});\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 (!isValidObject(current)) {\n            return;\n        }\n        if (i !== fields.length - 1) {\n            current = current[field];\n        }\n        else {\n            current[field] = value;\n        }\n    }\n}\nfunction isValidObject(object) {\n    return getType(object) === 'object';\n}\nfunction isValidObjectContaining(object, field) {\n    return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field);\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, assign, round, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './contexts/syntheticsContext';\nimport { getCiTestContext } from './contexts/ciTestContext';\nimport { limitModification } from './limitModification';\nvar VIEW_MODIFIABLE_FIELD_PATHS = {\n    'view.name': 'string',\n    'view.url': 'string',\n    'view.referrer': 'string',\n};\nvar USER_CUSTOMIZABLE_FIELD_PATHS = {\n    context: 'object',\n};\nvar modifiableFieldPathsByEvent;\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, displayContext, buildCommonContext, reportError) {\n    var _a, _b;\n    modifiableFieldPathsByEvent = (_a = {},\n        _a[\"view\" /* RumEventType.VIEW */] = VIEW_MODIFIABLE_FIELD_PATHS,\n        _a[\"error\" /* RumEventType.ERROR */] = assign({\n            'error.message': 'string',\n            'error.stack': 'string',\n            'error.resource.url': 'string',\n            'error.fingerprint': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"resource\" /* RumEventType.RESOURCE */] = assign({\n            'resource.url': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"action\" /* RumEventType.ACTION */] = assign({\n            'action.target.name': 'string',\n        }, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a[\"long_task\" /* RumEventType.LONG_TASK */] = assign({}, USER_CUSTOMIZABLE_FIELD_PATHS, VIEW_MODIFIABLE_FIELD_PATHS),\n        _a);\n    var eventRateLimiters = (_b = {},\n        _b[\"error\" /* RumEventType.ERROR */] = createEventRateLimiter(\"error\" /* RumEventType.ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        _b[\"action\" /* RumEventType.ACTION */] = createEventRateLimiter(\"action\" /* RumEventType.ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        _b);\n    var syntheticsContext = getSyntheticsContext();\n    var ciTestContext = getCiTestContext();\n    lifeCycle.subscribe(10 /* LifeCycleEventType.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 = viewContexts.findView(startTime);\n        var urlContext = urlContexts.findUrl(startTime);\n        var session = sessionManager.findTrackedSession(startTime);\n        if (session && viewContext && urlContext) {\n            var commonContext = savedCommonContext || buildCommonContext();\n            var actionId = actionContexts.findActionId(startTime);\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    session: {\n                        plan: session.plan,\n                    },\n                    configuration: {\n                        session_sample_rate: round(configuration.sessionSampleRate, 3),\n                        session_replay_sample_rate: round(configuration.sessionReplaySampleRate, 3),\n                    },\n                    browser_sdk_version: canUseEventBridge() ? \"4.50.1\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: viewContext.service || configuration.service,\n                version: viewContext.version || configuration.version,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext ? \"synthetics\" /* SessionType.SYNTHETICS */ : ciTestContext ? \"ci_test\" /* SessionType.CI_TEST */ : \"user\" /* SessionType.USER */,\n                },\n                view: {\n                    id: viewContext.id,\n                    name: viewContext.name,\n                    url: urlContext.url,\n                    referrer: urlContext.referrer,\n                },\n                action: needToAssembleWithAction(rawRumEvent) && actionId ? { id: actionId } : undefined,\n                synthetics: syntheticsContext,\n                ci_test: ciTestContext,\n                display: displayContext.get(),\n            };\n            var serverRumEvent = combine(rumContext, 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(11 /* LifeCycleEventType.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, modifiableFieldPathsByEvent[event.type], function (event) {\n            return beforeSend(event, domainContext);\n        });\n        if (result === false && event.type !== \"view\" /* RumEventType.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\" /* RumEventType.ERROR */, \"resource\" /* RumEventType.RESOURCE */, \"long_task\" /* RumEventType.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","var AbstractLifeCycle = /** @class */ (function () {\n    function AbstractLifeCycle() {\n        this.callbacks = {};\n    }\n    AbstractLifeCycle.prototype.notify = function (eventType, data) {\n        var eventCallbacks = this.callbacks[eventType];\n        if (eventCallbacks) {\n            eventCallbacks.forEach(function (callback) { return callback(data); });\n        }\n    };\n    AbstractLifeCycle.prototype.subscribe = function (eventType, callback) {\n        var _this = this;\n        if (!this.callbacks[eventType]) {\n            this.callbacks[eventType] = [];\n        }\n        this.callbacks[eventType].push(callback);\n        return {\n            unsubscribe: function () {\n                _this.callbacks[eventType] = _this.callbacks[eventType].filter(function (other) { return callback !== other; });\n            },\n        };\n    };\n    return AbstractLifeCycle;\n}());\nexport { AbstractLifeCycle };\n//# sourceMappingURL=abstractLifeCycle.js.map","import { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nimport { shallowClone } from '../tools/utils/objectUtils';\nimport { addEventListener } from './addEventListener';\nvar xhrObservable;\nvar xhrContexts = new WeakMap();\nexport function initXhrObservable(configuration) {\n    if (!xhrObservable) {\n        xhrObservable = createXhrObservable(configuration);\n    }\n    return xhrObservable;\n}\nfunction createXhrObservable(configuration) {\n    var observable = new Observable(function () {\n        var stopInstrumentingStart = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {\n            before: openXhr,\n        }).stop;\n        var stopInstrumentingSend = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {\n            before: function () {\n                sendXhr.call(this, configuration, observable);\n            },\n        }).stop;\n        var stopInstrumentingAbort = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {\n            before: abortXhr,\n        }).stop;\n        return function () {\n            stopInstrumentingStart();\n            stopInstrumentingSend();\n            stopInstrumentingAbort();\n        };\n    });\n    return observable;\n}\nfunction openXhr(method, url) {\n    xhrContexts.set(this, {\n        state: 'open',\n        method: method,\n        url: normalizeUrl(String(url)),\n    });\n}\nfunction sendXhr(configuration, observable) {\n    var _this = this;\n    var context = xhrContexts.get(this);\n    if (!context) {\n        return;\n    }\n    var startContext = context;\n    startContext.state = 'start';\n    startContext.startTime = relativeNow();\n    startContext.startClocks = clocksNow();\n    startContext.isAborted = false;\n    startContext.xhr = this;\n    var hasBeenReported = false;\n    var stopInstrumentingOnReadyStateChange = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {\n        before: function () {\n            if (this.readyState === XMLHttpRequest.DONE) {\n                // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n                // application during a future event. For example, Angular is calling .abort() on\n                // completed requests during a onreadystatechange event, so the status becomes '0'\n                // before the request is collected.\n                onEnd();\n            }\n        },\n    }).stop;\n    var onEnd = function () {\n        unsubscribeLoadEndListener();\n        stopInstrumentingOnReadyStateChange();\n        if (hasBeenReported) {\n            return;\n        }\n        hasBeenReported = true;\n        var completeContext = context;\n        completeContext.state = 'complete';\n        completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\n        completeContext.status = _this.status;\n        observable.notify(shallowClone(completeContext));\n    };\n    var unsubscribeLoadEndListener = addEventListener(configuration, this, 'loadend', onEnd).stop;\n    observable.notify(startContext);\n}\nfunction abortXhr() {\n    var context = xhrContexts.get(this);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","import { setInterval, clearInterval } from './timer';\nimport { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE;\n/**\n * Store and keep track of values spans. This whole class assumes that values are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nvar ValueHistory = /** @class */ (function () {\n    function ValueHistory(expireDelay, maxEntries) {\n        var _this = this;\n        this.expireDelay = expireDelay;\n        this.maxEntries = maxEntries;\n        this.entries = [];\n        this.clearOldValuesInterval = setInterval(function () { return _this.clearOldValues(); }, CLEAR_OLD_VALUES_INTERVAL);\n    }\n    /**\n     * Add a value to the history associated with a start time. Returns a reference to this newly\n     * added entry that can be removed or closed.\n     */\n    ValueHistory.prototype.add = function (value, startTime) {\n        var _this = this;\n        var entry = {\n            value: value,\n            startTime: startTime,\n            endTime: END_OF_TIMES,\n            remove: function () {\n                var index = _this.entries.indexOf(entry);\n                if (index >= 0) {\n                    _this.entries.splice(index, 1);\n                }\n            },\n            close: function (endTime) {\n                entry.endTime = endTime;\n            },\n        };\n        if (this.maxEntries && this.entries.length >= this.maxEntries) {\n            this.entries.pop();\n        }\n        this.entries.unshift(entry);\n        return entry;\n    };\n    /**\n     * Return the latest value that was active during `startTime`, or the currently active value\n     * if no `startTime` is provided. This method assumes that entries are not overlapping.\n     */\n    ValueHistory.prototype.find = function (startTime) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        for (var _i = 0, _a = this.entries; _i < _a.length; _i++) {\n            var entry = _a[_i];\n            if (entry.startTime <= startTime) {\n                if (startTime <= entry.endTime) {\n                    return entry.value;\n                }\n                break;\n            }\n        }\n    };\n    /**\n     * Helper function to close the currently active value, if any. This method assumes that entries\n     * are not overlapping.\n     */\n    ValueHistory.prototype.closeActive = function (endTime) {\n        var latestEntry = this.entries[0];\n        if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n            latestEntry.close(endTime);\n        }\n    };\n    /**\n     * Return all values with an active period overlapping with the duration,\n     * or all values that were active during `startTime` if no duration is provided,\n     * or all currently active values if no `startTime` is provided.\n     */\n    ValueHistory.prototype.findAll = function (startTime, duration) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        if (duration === void 0) { duration = 0; }\n        var endTime = addDuration(startTime, duration);\n        return this.entries\n            .filter(function (entry) { return entry.startTime <= endTime && startTime <= entry.endTime; })\n            .map(function (entry) { return entry.value; });\n    };\n    /**\n     * Remove all entries from this collection.\n     */\n    ValueHistory.prototype.reset = function () {\n        this.entries = [];\n    };\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    ValueHistory.prototype.stop = function () {\n        clearInterval(this.clearOldValuesInterval);\n    };\n    ValueHistory.prototype.clearOldValues = function () {\n        var oldTimeThreshold = relativeNow() - this.expireDelay;\n        while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {\n            this.entries.pop();\n        }\n    };\n    return ValueHistory;\n}());\nexport { ValueHistory };\n//# sourceMappingURL=valueHistory.js.map","import { setTimeout } from './timer';\nimport { callMonitored } from './monitor';\nimport { noop } from './utils/functionUtils';\nexport function instrumentMethod(object, method, instrumentationFactory) {\n    var original = object[method];\n    var instrumentation = instrumentationFactory(original);\n    var instrumentationWrapper = function () {\n        if (typeof instrumentation !== 'function') {\n            return undefined;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return instrumentation.apply(this, arguments);\n    };\n    object[method] = instrumentationWrapper;\n    return {\n        stop: function () {\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(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 { instrumentMethod } from '../tools/instrumentMethod';\nimport { callMonitored, monitor } from '../tools/monitor';\nimport { Observable } from '../tools/observable';\nimport { clocksNow } from '../tools/utils/timeUtils';\nimport { normalizeUrl } from '../tools/utils/urlPolyfill';\nvar fetchObservable;\nexport function initFetchObservable() {\n    if (!fetchObservable) {\n        fetchObservable = createFetchObservable();\n    }\n    return fetchObservable;\n}\nfunction createFetchObservable() {\n    var observable = new Observable(function () {\n        if (!window.fetch) {\n            return;\n        }\n        var stop = instrumentMethod(window, 'fetch', function (originalFetch) {\n            return function (input, init) {\n                var responsePromise;\n                var context = callMonitored(beforeSend, null, [observable, input, init]);\n                if (context) {\n                    responsePromise = originalFetch.call(this, context.input, context.init);\n                    callMonitored(afterSend, null, [observable, responsePromise, context]);\n                }\n                else {\n                    responsePromise = originalFetch.call(this, input, init);\n                }\n                return responsePromise;\n            };\n        }).stop;\n        return stop;\n    });\n    return observable;\n}\nfunction beforeSend(observable, input, init) {\n    var method = (init && init.method) || (input instanceof Request && input.method) || 'GET';\n    var url = input instanceof Request ? input.url : normalizeUrl(String(input));\n    var startClocks = clocksNow();\n    var context = {\n        state: 'start',\n        init: init,\n        input: input,\n        method: method,\n        startClocks: startClocks,\n        url: url,\n    };\n    observable.notify(context);\n    return context;\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    var reportFetch = function (response) {\n        var context = startContext;\n        context.state = 'resolve';\n        if ('stack' in response || response instanceof Error) {\n            context.status = 0;\n            context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR;\n            context.error = response;\n        }\n        else if ('status' in response) {\n            context.response = response;\n            context.responseType = response.type;\n            context.status = response.status;\n            context.isAborted = false;\n        }\n        observable.notify(context);\n    };\n    responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { initFetchObservable, initXhrObservable, readBytesFromStream, elapsed, timeStampNow, tryToClone, } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './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(configuration).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(5 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(6 /* LifeCycleEventType.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                    traceSampled: context.traceSampled,\n                    type: \"xhr\" /* RequestType.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(5 /* LifeCycleEventType.REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                    url: context.url,\n                });\n                break;\n            case 'resolve':\n                waitForResponseToComplete(context, function (duration) {\n                    tracer.clearTracingIfNeeded(context);\n                    lifeCycle.notify(6 /* LifeCycleEventType.REQUEST_COMPLETED */, {\n                        duration: 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                        traceSampled: context.traceSampled,\n                        type: \"fetch\" /* RequestType.FETCH */,\n                        url: context.url,\n                        response: context.response,\n                        init: context.init,\n                        input: context.input,\n                    });\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}\nfunction waitForResponseToComplete(context, callback) {\n    var clonedResponse = context.response && tryToClone(context.response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // do not try to wait for the response if the clone failed, fetch error or null body\n        callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n    }\n    else {\n        readBytesFromStream(clonedResponse.body, function () {\n            callback(elapsed(context.startClocks.timeStamp, timeStampNow()));\n        }, {\n            bytesLimit: Number.POSITIVE_INFINITY,\n            collectStreamBody: false,\n        });\n    }\n}\n//# sourceMappingURL=requestCollection.js.map","export function isServerError(status) {\n    return status >= 500;\n}\nexport function tryToClone(response) {\n    try {\n        return response.clone();\n    }\n    catch (e) {\n        // clone can throw if the response has already been used by another instrumentation or is disturbed\n        return;\n    }\n}\n//# sourceMappingURL=responseUtils.js.map","import { monitor } from './monitor';\nimport { noop } from './utils/functionUtils';\n/**\n * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of\n * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit\n * has been exceeded if more bytes were available.\n */\nexport function readBytesFromStream(stream, callback, options) {\n    var reader = stream.getReader();\n    var chunks = [];\n    var readBytesCount = 0;\n    readMore();\n    function readMore() {\n        reader.read().then(monitor(function (result) {\n            if (result.done) {\n                onDone();\n                return;\n            }\n            if (options.collectStreamBody) {\n                chunks.push(result.value);\n            }\n            readBytesCount += result.value.length;\n            if (readBytesCount > options.bytesLimit) {\n                onDone();\n            }\n            else {\n                readMore();\n            }\n        }), monitor(function (error) { return callback(error); }));\n    }\n    function onDone() {\n        reader.cancel().catch(\n        // we don't care if cancel fails, but we still need to catch the error to avoid reporting it\n        // as an unhandled rejection\n        noop);\n        var bytes;\n        var limitExceeded;\n        if (options.collectStreamBody) {\n            var completeBuffer_1;\n            if (chunks.length === 1) {\n                // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just\n                // use it directly.\n                completeBuffer_1 = chunks[0];\n            }\n            else {\n                // else, we need to copy buffers into a larger buffer to concatenate them.\n                completeBuffer_1 = new Uint8Array(readBytesCount);\n                var offset_1 = 0;\n                chunks.forEach(function (chunk) {\n                    completeBuffer_1.set(chunk, offset_1);\n                    offset_1 += chunk.length;\n                });\n            }\n            bytes = completeBuffer_1.slice(0, options.bytesLimit);\n            limitExceeded = completeBuffer_1.length > options.bytesLimit;\n        }\n        callback(undefined, bytes, limitExceeded);\n    }\n}\n//# sourceMappingURL=readBytesFromStream.js.map","import { noop } from '@datadog/browser-core';\nexport function trackEventCounts(_a) {\n    var lifeCycle = _a.lifeCycle, isChildEvent = _a.isChildEvent, _b = _a.onChange, callback = _b === void 0 ? noop : _b;\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        actionCount: 0,\n        frustrationCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        var _a;\n        if (event.type === 'view' || !isChildEvent(event)) {\n            return;\n        }\n        switch (event.type) {\n            case \"error\" /* RumEventType.ERROR */:\n                eventCounts.errorCount += 1;\n                callback();\n                break;\n            case \"action\" /* RumEventType.ACTION */:\n                eventCounts.actionCount += 1;\n                if (event.action.frustration) {\n                    eventCounts.frustrationCount += event.action.frustration.type.length;\n                }\n                callback();\n                break;\n            case \"long_task\" /* RumEventType.LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback();\n                break;\n            case \"resource\" /* RumEventType.RESOURCE */:\n                if (!((_a = event._dd) === null || _a === void 0 ? void 0 : _a.discarded)) {\n                    eventCounts.resourceCount += 1;\n                    callback();\n                }\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { instrumentMethodAndCallOriginal, matchList, monitor, Observable, timeStampNow, setTimeout, clearTimeout, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../browser/performanceCollection';\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 page activity end\n *\n * Detection lifecycle:\n * ```\n *                        Wait page activity end\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 waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, pageActivityEndCallback, maxDuration) {\n    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable, configuration);\n    return doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration);\n}\nexport function doWaitPageActivityEnd(pageActivityObservable, pageActivityEndCallback, maxDuration) {\n    var pageActivityEndTimeoutId;\n    var hasCompleted = false;\n    var validationTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: false }); }), PAGE_ACTIVITY_VALIDATION_DELAY);\n    var maxDurationTimeoutId = maxDuration !== undefined\n        ? setTimeout(monitor(function () { return complete({ hadActivity: true, end: timeStampNow() }); }), maxDuration)\n        : undefined;\n    var pageActivitySubscription = pageActivityObservable.subscribe(function (_a) {\n        var isBusy = _a.isBusy;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(pageActivityEndTimeoutId);\n        var lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            pageActivityEndTimeoutId = 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(pageActivityEndTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        pageActivityEndCallback(event);\n    }\n    return { stop: stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable, configuration) {\n    var observable = new Observable(function () {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(notifyPageActivity), lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n            if (entries.some(function (entry) { return entry.entryType === RumPerformanceEntryType.RESOURCE && !isExcludedUrl(configuration, entry.name); })) {\n                notifyPageActivity();\n            }\n        }), lifeCycle.subscribe(5 /* LifeCycleEventType.REQUEST_STARTED */, function (startEvent) {\n            if (isExcludedUrl(configuration, startEvent.url)) {\n                return;\n            }\n            if (firstRequestIndex === undefined) {\n                firstRequestIndex = startEvent.requestIndex;\n            }\n            pendingRequestsCount += 1;\n            notifyPageActivity();\n        }), lifeCycle.subscribe(6 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n            if (isExcludedUrl(configuration, request.url) ||\n                firstRequestIndex === undefined ||\n                // If the request started before the tracking start, ignore it\n                request.requestIndex < firstRequestIndex) {\n                return;\n            }\n            pendingRequestsCount -= 1;\n            notifyPageActivity();\n        }));\n        var stopTrackingWindowOpen = trackWindowOpen(notifyPageActivity).stop;\n        return function () {\n            stopTrackingWindowOpen();\n            subscriptions.forEach(function (s) { return s.unsubscribe(); });\n        };\n        function notifyPageActivity() {\n            observable.notify({ isBusy: pendingRequestsCount > 0 });\n        }\n    });\n    return observable;\n}\nfunction isExcludedUrl(configuration, requestUrl) {\n    return matchList(configuration.excludedActivityUrls, requestUrl);\n}\nfunction trackWindowOpen(callback) {\n    return instrumentMethodAndCallOriginal(window, 'open', { before: callback });\n}\n//# sourceMappingURL=waitPageActivityEnd.js.map","import { safeTruncate, isIE, find } 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 */\nexport var DEFAULT_PROGRAMMATIC_ACTION_NAME_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_ACTION_NAME_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 &&\n                find(element.ownerDocument.querySelectorAll('label'), function (label) { return label.htmlFor === element.id; });\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_ACTION_NAME_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 { cssEscape } from '@datadog/browser-core';\nimport { DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE } from './action/getActionNameFromElement';\n/**\n * Stable attributes are attributes that are commonly used to identify parts of a UI (ex:\n * component). Those attribute values should not be generated randomly (hardcoded most of the time)\n * and stay the same across deploys. They are not necessarily unique across the document.\n */\nexport var STABLE_ATTRIBUTES = [\n    DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,\n    // Common test attributes (list provided by google recorder)\n    'data-testid',\n    'data-test',\n    'data-qa',\n    'data-cy',\n    'data-test-id',\n    'data-qa-id',\n    'data-testing',\n    // FullStory decorator attributes:\n    'data-component',\n    'data-element',\n    'data-source-file',\n];\n// Selectors to use if they target a single element on the whole document. Those selectors are\n// considered as \"stable\" and uniquely identify an element regardless of the page state. If we find\n// one, we should consider the selector \"complete\" and stop iterating over ancestors.\nvar GLOBALLY_UNIQUE_SELECTOR_GETTERS = [getStableAttributeSelector, getIDSelector];\n// Selectors to use if they target a single element among an element descendants. Those selectors\n// are more brittle than \"globally unique\" selectors and should be combined with ancestor selectors\n// to improve specificity.\nvar UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS = [\n    getStableAttributeSelector,\n    getClassSelector,\n    getTagNameSelector,\n];\nexport function getSelectorFromElement(targetElement, actionNameAttribute) {\n    var targetElementSelector = '';\n    var element = targetElement;\n    while (element && element.nodeName !== 'HTML') {\n        var globallyUniqueSelector = findSelector(element, GLOBALLY_UNIQUE_SELECTOR_GETTERS, isSelectorUniqueGlobally, actionNameAttribute, targetElementSelector);\n        if (globallyUniqueSelector) {\n            return globallyUniqueSelector;\n        }\n        var uniqueSelectorAmongChildren = findSelector(element, UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS, isSelectorUniqueAmongSiblings, actionNameAttribute, targetElementSelector);\n        targetElementSelector =\n            uniqueSelectorAmongChildren || combineSelector(getPositionSelector(element), targetElementSelector);\n        element = element.parentElement;\n    }\n    return targetElementSelector;\n}\nfunction isGeneratedValue(value) {\n    // To compute the \"URL path group\", the backend replaces every URL path parts as a question mark\n    // if it thinks the part is an identifier. The condition it uses is to checks whether a digit is\n    // present.\n    //\n    // Here, we use the same strategy: if a the value contains a digit, we consider it generated. This\n    // strategy might be a bit naive and fail in some cases, but there are many fallbacks to generate\n    // CSS selectors so it should be fine most of the time. We might want to allow customers to\n    // provide their own `isGeneratedValue` at some point.\n    return /[0-9]/.test(value);\n}\nfunction getIDSelector(element) {\n    if (element.id && !isGeneratedValue(element.id)) {\n        return \"#\".concat(cssEscape(element.id));\n    }\n}\nfunction getClassSelector(element) {\n    if (element.tagName === 'BODY') {\n        return;\n    }\n    if (element.classList.length > 0) {\n        for (var i = 0; i < element.classList.length; i += 1) {\n            var className = element.classList[i];\n            if (isGeneratedValue(className)) {\n                continue;\n            }\n            return \"\".concat(cssEscape(element.tagName), \".\").concat(cssEscape(className));\n        }\n    }\n}\nfunction getTagNameSelector(element) {\n    return cssEscape(element.tagName);\n}\nfunction getStableAttributeSelector(element, actionNameAttribute) {\n    if (actionNameAttribute) {\n        var selector = getAttributeSelector(actionNameAttribute);\n        if (selector) {\n            return selector;\n        }\n    }\n    for (var _i = 0, STABLE_ATTRIBUTES_1 = STABLE_ATTRIBUTES; _i < STABLE_ATTRIBUTES_1.length; _i++) {\n        var attributeName = STABLE_ATTRIBUTES_1[_i];\n        var selector = getAttributeSelector(attributeName);\n        if (selector) {\n            return selector;\n        }\n    }\n    function getAttributeSelector(attributeName) {\n        if (element.hasAttribute(attributeName)) {\n            return \"\".concat(cssEscape(element.tagName), \"[\").concat(attributeName, \"=\\\"\").concat(cssEscape(element.getAttribute(attributeName)), \"\\\"]\");\n        }\n    }\n}\nfunction getPositionSelector(element) {\n    var sibling = element.parentElement.firstElementChild;\n    var elementIndex = 1;\n    while (sibling && sibling !== element) {\n        if (sibling.tagName === element.tagName) {\n            elementIndex += 1;\n        }\n        sibling = sibling.nextElementSibling;\n    }\n    return \"\".concat(cssEscape(element.tagName), \":nth-of-type(\").concat(elementIndex, \")\");\n}\nfunction findSelector(element, selectorGetters, predicate, actionNameAttribute, childSelector) {\n    for (var _i = 0, selectorGetters_1 = selectorGetters; _i < selectorGetters_1.length; _i++) {\n        var selectorGetter = selectorGetters_1[_i];\n        var elementSelector = selectorGetter(element, actionNameAttribute);\n        if (!elementSelector) {\n            continue;\n        }\n        var fullSelector = combineSelector(elementSelector, childSelector);\n        if (predicate(element, fullSelector)) {\n            return fullSelector;\n        }\n    }\n}\n/**\n * Check whether the selector is unique among the whole document.\n */\nfunction isSelectorUniqueGlobally(element, selector) {\n    return element.ownerDocument.querySelectorAll(selector).length === 1;\n}\n/**\n * Check whether the selector is unique among the element siblings. In other words, it returns true\n * if \"ELEMENT_PARENT > SELECTOR\" returns a single element.\n *\n * The result will be less accurate on browsers that don't support :scope (i. e. IE): it will check\n * for any element matching the selector contained in the parent (in other words,\n * \"ELEMENT_PARENT SELECTOR\" returns a single element), regardless of whether the selector is a\n * direct descendent of the element parent. This should not impact results too much: if it\n * inaccurately returns false, we'll just fall back to another strategy.\n */\nfunction isSelectorUniqueAmongSiblings(element, selector) {\n    return (element.parentElement.querySelectorAll(supportScopeSelector() ? combineSelector(':scope', selector) : selector)\n        .length === 1);\n}\nfunction combineSelector(parent, child) {\n    return child ? \"\".concat(parent, \">\").concat(child) : parent;\n}\nvar supportScopeSelectorCache;\nexport function supportScopeSelector() {\n    if (supportScopeSelectorCache === undefined) {\n        try {\n            document.querySelector(':scope');\n            supportScopeSelectorCache = true;\n        }\n        catch (_a) {\n            supportScopeSelectorCache = false;\n        }\n    }\n    return supportScopeSelectorCache;\n}\n//# sourceMappingURL=getSelectorFromElement.js.map","import { ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nexport var MAX_DURATION_BETWEEN_CLICKS = ONE_SECOND;\nexport var MAX_DISTANCE_BETWEEN_CLICKS = 100;\nexport function createClickChain(firstClick, onFinalize) {\n    var bufferedClicks = [];\n    var status = 0 /* ClickChainStatus.WaitingForMoreClicks */;\n    var maxDurationBetweenClicksTimeoutId;\n    appendClick(firstClick);\n    function appendClick(click) {\n        click.stopObservable.subscribe(tryFinalize);\n        bufferedClicks.push(click);\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        maxDurationBetweenClicksTimeoutId = setTimeout(dontAcceptMoreClick, MAX_DURATION_BETWEEN_CLICKS);\n    }\n    function tryFinalize() {\n        if (status === 1 /* ClickChainStatus.WaitingForClicksToStop */ && bufferedClicks.every(function (click) { return click.isStopped(); })) {\n            status = 2 /* ClickChainStatus.Finalized */;\n            onFinalize(bufferedClicks);\n        }\n    }\n    function dontAcceptMoreClick() {\n        clearTimeout(maxDurationBetweenClicksTimeoutId);\n        if (status === 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n            status = 1 /* ClickChainStatus.WaitingForClicksToStop */;\n            tryFinalize();\n        }\n    }\n    return {\n        tryAppend: function (click) {\n            if (status !== 0 /* ClickChainStatus.WaitingForMoreClicks */) {\n                return false;\n            }\n            if (bufferedClicks.length > 0 &&\n                !areEventsSimilar(bufferedClicks[bufferedClicks.length - 1].event, click.event)) {\n                dontAcceptMoreClick();\n                return false;\n            }\n            appendClick(click);\n            return true;\n        },\n        stop: function () {\n            dontAcceptMoreClick();\n        },\n    };\n}\n/**\n * Checks whether two events are similar by comparing their target, position and timestamp\n */\nfunction areEventsSimilar(first, second) {\n    return (first.target === second.target &&\n        mouseEventDistance(first, second) <= MAX_DISTANCE_BETWEEN_CLICKS &&\n        first.timeStamp - second.timeStamp <= MAX_DURATION_BETWEEN_CLICKS);\n}\nfunction mouseEventDistance(origin, other) {\n    return Math.sqrt(Math.pow(origin.clientX - other.clientX, 2) + Math.pow(origin.clientY - other.clientY, 2));\n}\n//# sourceMappingURL=clickChain.js.map","import { addEventListener } from '@datadog/browser-core';\nexport function listenActionEvents(configuration, _a) {\n    var onPointerDown = _a.onPointerDown, onPointerUp = _a.onPointerUp;\n    var selectionEmptyAtPointerDown;\n    var userActivity = {\n        selection: false,\n        input: false,\n    };\n    var clickContext;\n    var listeners = [\n        addEventListener(configuration, window, \"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, function (event) {\n            if (isValidPointerEvent(event)) {\n                selectionEmptyAtPointerDown = isSelectionEmpty();\n                userActivity = {\n                    selection: false,\n                    input: false,\n                };\n                clickContext = onPointerDown(event);\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"selectionchange\" /* DOM_EVENT.SELECTION_CHANGE */, function () {\n            if (!selectionEmptyAtPointerDown || !isSelectionEmpty()) {\n                userActivity.selection = true;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"pointerup\" /* DOM_EVENT.POINTER_UP */, function (event) {\n            if (isValidPointerEvent(event) && clickContext) {\n                // Use a scoped variable to make sure the value is not changed by other clicks\n                var localUserActivity_1 = userActivity;\n                onPointerUp(clickContext, event, function () { return localUserActivity_1; });\n                clickContext = undefined;\n            }\n        }, { capture: true }),\n        addEventListener(configuration, window, \"input\" /* DOM_EVENT.INPUT */, function () {\n            userActivity.input = true;\n        }, { capture: true }),\n    ];\n    return {\n        stop: function () {\n            listeners.forEach(function (listener) { return listener.stop(); });\n        },\n    };\n}\nfunction isSelectionEmpty() {\n    var selection = window.getSelection();\n    return !selection || selection.isCollapsed;\n}\nfunction isValidPointerEvent(event) {\n    return (event.target instanceof Element &&\n        // Only consider 'primary' pointer events for now. Multi-touch support could be implemented in\n        // the future.\n        event.isPrimary !== false);\n}\n//# sourceMappingURL=listenActionEvents.js.map","import { elementMatches, ONE_SECOND } from '@datadog/browser-core';\nvar MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE = 3;\nexport function computeFrustration(clicks, rageClick) {\n    if (isRage(clicks)) {\n        rageClick.addFrustration(\"rage_click\" /* FrustrationType.RAGE_CLICK */);\n        if (clicks.some(isDead)) {\n            rageClick.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n        if (rageClick.hasError) {\n            rageClick.addFrustration(\"error_click\" /* FrustrationType.ERROR_CLICK */);\n        }\n        return { isRage: true };\n    }\n    var hasSelectionChanged = clicks.some(function (click) { return click.getUserActivity().selection; });\n    clicks.forEach(function (click) {\n        if (click.hasError) {\n            click.addFrustration(\"error_click\" /* FrustrationType.ERROR_CLICK */);\n        }\n        if (isDead(click) &&\n            // Avoid considering clicks part of a double-click or triple-click selections as dead clicks\n            !hasSelectionChanged) {\n            click.addFrustration(\"dead_click\" /* FrustrationType.DEAD_CLICK */);\n        }\n    });\n    return { isRage: false };\n}\nexport function isRage(clicks) {\n    if (clicks.some(function (click) { return click.getUserActivity().selection; })) {\n        return false;\n    }\n    for (var i = 0; i < clicks.length - (MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1); i += 1) {\n        if (clicks[i + MIN_CLICKS_PER_SECOND_TO_CONSIDER_RAGE - 1].event.timeStamp - clicks[i].event.timeStamp <=\n            ONE_SECOND) {\n            return true;\n        }\n    }\n    return false;\n}\nvar DEAD_CLICK_EXCLUDE_SELECTOR = \n// inputs that don't trigger a meaningful event like \"input\" when clicked, including textual\n// inputs (using a negative selector is shorter here)\n'input:not([type=\"checkbox\"]):not([type=\"radio\"]):not([type=\"button\"]):not([type=\"submit\"]):not([type=\"reset\"]):not([type=\"range\"]),' +\n    'textarea,' +\n    'select,' +\n    // contenteditable and their descendants don't always trigger meaningful changes when manipulated\n    '[contenteditable],' +\n    '[contenteditable] *,' +\n    // canvas, as there is no good way to detect activity occurring on them\n    'canvas,' +\n    // links that are interactive (have an href attribute) or any of their descendants, as they can\n    // open a new tab or navigate to a hash without triggering a meaningful event\n    'a[href],' +\n    'a[href] *';\nexport function isDead(click) {\n    if (click.hasPageActivity || click.getUserActivity().input) {\n        return false;\n    }\n    return !elementMatches(click.event.target, DEAD_CLICK_EXCLUDE_SELECTOR);\n}\n//# sourceMappingURL=computeFrustration.js.map","import { includes, timeStampNow, Observable, assign, getRelativeTime, ONE_MINUTE, ValueHistory, generateUUID, clocksNow, ONE_SECOND, elapsed, } from '@datadog/browser-core';\nimport { trackEventCounts } from '../trackEventCounts';\nimport { PAGE_ACTIVITY_VALIDATION_DELAY, waitPageActivityEnd } from '../waitPageActivityEnd';\nimport { getSelectorFromElement } from '../getSelectorFromElement';\nimport { createClickChain } from './clickChain';\nimport { getActionNameFromElement } from './getActionNameFromElement';\nimport { listenActionEvents } from './listenActionEvents';\nimport { computeFrustration } from './computeFrustration';\n// Maximum duration for click actions\nexport var CLICK_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackClickActions(lifeCycle, domMutationObservable, configuration) {\n    var history = new ValueHistory(ACTION_CONTEXT_TIME_OUT_DELAY);\n    var stopObservable = new Observable();\n    var currentClickChain;\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, stopClickChain);\n    var stopActionEventsListener = listenActionEvents(configuration, {\n        onPointerDown: function (pointerDownEvent) {\n            return processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent);\n        },\n        onPointerUp: function (_a, startEvent, getUserActivity) {\n            var clickActionBase = _a.clickActionBase, hadActivityOnPointerDown = _a.hadActivityOnPointerDown;\n            return startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown);\n        },\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) {\n            return configuration.trackFrustrations ? history.findAll(startTime) : history.find(startTime);\n        },\n    };\n    return {\n        stop: function () {\n            stopClickChain();\n            stopObservable.notify();\n            stopActionEventsListener();\n        },\n        actionContexts: actionContexts,\n    };\n    function appendClickToClickChain(click) {\n        if (!currentClickChain || !currentClickChain.tryAppend(click)) {\n            var rageClick_1 = click.clone();\n            currentClickChain = createClickChain(click, function (clicks) {\n                finalizeClicks(clicks, rageClick_1);\n            });\n        }\n    }\n    function stopClickChain() {\n        if (currentClickChain) {\n            currentClickChain.stop();\n        }\n    }\n}\nfunction processPointerDown(configuration, lifeCycle, domMutationObservable, history, pointerDownEvent) {\n    if (!configuration.trackFrustrations && history.find()) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any new\n        // action if another one is already occurring.\n        return;\n    }\n    var clickActionBase = computeClickActionBase(pointerDownEvent, configuration.actionNameAttribute);\n    if (!configuration.trackFrustrations && !clickActionBase.name) {\n        // TODO: remove this in a future major version. To keep retrocompatibility, ignore any action\n        // with a blank name\n        return;\n    }\n    var hadActivityOnPointerDown = false;\n    waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (pageActivityEndEvent) {\n        hadActivityOnPointerDown = pageActivityEndEvent.hadActivity;\n    }, \n    // We don't care about the activity duration, we just want to know whether an activity did happen\n    // within the \"validation delay\" or not. Limit the duration so the callback is called sooner.\n    PAGE_ACTIVITY_VALIDATION_DELAY);\n    return { clickActionBase: clickActionBase, hadActivityOnPointerDown: function () { return hadActivityOnPointerDown; } };\n}\nfunction startClickAction(configuration, lifeCycle, domMutationObservable, history, stopObservable, appendClickToClickChain, clickActionBase, startEvent, getUserActivity, hadActivityOnPointerDown) {\n    var click = newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent);\n    if (configuration.trackFrustrations) {\n        appendClickToClickChain(click);\n    }\n    var stopWaitPageActivityEnd = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, function (pageActivityEndEvent) {\n        if (pageActivityEndEvent.hadActivity && pageActivityEndEvent.end < click.startClocks.timeStamp) {\n            // If the clock is looking weird, just discard the click\n            click.discard();\n        }\n        else {\n            if (pageActivityEndEvent.hadActivity) {\n                click.stop(pageActivityEndEvent.end);\n            }\n            else if (hadActivityOnPointerDown()) {\n                click.stop(\n                // using the click start as activity end, so the click will have some activity but its\n                // duration will be 0 (as the activity started before the click start)\n                click.startClocks.timeStamp);\n            }\n            else {\n                click.stop();\n            }\n            // Validate or discard the click only if we don't track frustrations. It'll be done when\n            // the click chain is finalized.\n            if (!configuration.trackFrustrations) {\n                if (!pageActivityEndEvent.hadActivity) {\n                    // If we are not tracking frustrations, we should discard the click to keep backward\n                    // compatibility.\n                    click.discard();\n                }\n                else {\n                    click.validate();\n                }\n            }\n        }\n    }, CLICK_ACTION_MAX_DURATION).stop;\n    var viewEndedSubscription = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        click.stop(endClocks.timeStamp);\n    });\n    var stopSubscription = stopObservable.subscribe(function () {\n        click.stop();\n    });\n    click.stopObservable.subscribe(function () {\n        viewEndedSubscription.unsubscribe();\n        stopWaitPageActivityEnd();\n        stopSubscription.unsubscribe();\n    });\n}\nfunction computeClickActionBase(event, actionNameAttribute) {\n    var rect = event.target.getBoundingClientRect();\n    return {\n        type: \"click\" /* ActionType.CLICK */,\n        target: {\n            width: Math.round(rect.width),\n            height: Math.round(rect.height),\n            selector: getSelectorFromElement(event.target, actionNameAttribute),\n        },\n        position: {\n            // Use clientX and Y because for SVG element offsetX and Y are relatives to the <svg> element\n            x: Math.round(event.clientX - rect.left),\n            y: Math.round(event.clientY - rect.top),\n        },\n        name: getActionNameFromElement(event.target, actionNameAttribute),\n    };\n}\nfunction newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent) {\n    var id = generateUUID();\n    var startClocks = clocksNow();\n    var historyEntry = history.add(id, startClocks.relative);\n    var eventCountsSubscription = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) {\n            return event.action !== undefined &&\n                (Array.isArray(event.action.id) ? includes(event.action.id, id) : event.action.id === id);\n        },\n    });\n    var status = 0 /* ClickStatus.ONGOING */;\n    var activityEndTime;\n    var frustrationTypes = [];\n    var stopObservable = new Observable();\n    function stop(newActivityEndTime) {\n        if (status !== 0 /* ClickStatus.ONGOING */) {\n            return;\n        }\n        activityEndTime = newActivityEndTime;\n        status = 1 /* ClickStatus.STOPPED */;\n        if (activityEndTime) {\n            historyEntry.close(getRelativeTime(activityEndTime));\n        }\n        else {\n            historyEntry.remove();\n        }\n        eventCountsSubscription.stop();\n        stopObservable.notify();\n    }\n    return {\n        event: startEvent,\n        stop: stop,\n        stopObservable: stopObservable,\n        get hasError() {\n            return eventCountsSubscription.eventCounts.errorCount > 0;\n        },\n        get hasPageActivity() {\n            return activityEndTime !== undefined;\n        },\n        getUserActivity: getUserActivity,\n        addFrustration: function (frustrationType) {\n            frustrationTypes.push(frustrationType);\n        },\n        startClocks: startClocks,\n        isStopped: function () { return status === 1 /* ClickStatus.STOPPED */ || status === 2 /* ClickStatus.FINALIZED */; },\n        clone: function () { return newClick(lifeCycle, history, getUserActivity, clickActionBase, startEvent); },\n        validate: function (domEvents) {\n            stop();\n            if (status !== 1 /* ClickStatus.STOPPED */) {\n                return;\n            }\n            var _a = eventCountsSubscription.eventCounts, resourceCount = _a.resourceCount, errorCount = _a.errorCount, longTaskCount = _a.longTaskCount;\n            var clickAction = assign({\n                type: \"click\" /* ActionType.CLICK */,\n                duration: activityEndTime && elapsed(startClocks.timeStamp, activityEndTime),\n                startClocks: startClocks,\n                id: id,\n                frustrationTypes: frustrationTypes,\n                counts: {\n                    resourceCount: resourceCount,\n                    errorCount: errorCount,\n                    longTaskCount: longTaskCount,\n                },\n                events: domEvents !== null && domEvents !== void 0 ? domEvents : [startEvent],\n                event: startEvent,\n            }, clickActionBase);\n            lifeCycle.notify(1 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, clickAction);\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n        discard: function () {\n            stop();\n            status = 2 /* ClickStatus.FINALIZED */;\n        },\n    };\n}\nexport function finalizeClicks(clicks, rageClick) {\n    var isRage = computeFrustration(clicks, rageClick).isRage;\n    if (isRage) {\n        clicks.forEach(function (click) { return click.discard(); });\n        rageClick.stop(timeStampNow());\n        rageClick.validate(clicks.map(function (click) { return click.event; }));\n    }\n    else {\n        rageClick.discard();\n        clicks.forEach(function (click) { return click.validate(); });\n    }\n}\n//# sourceMappingURL=trackClickActions.js.map","import { noop, assign, combine, toServerDuration, generateUUID } from '@datadog/browser-core';\nimport { trackClickActions } from './trackClickActions';\nexport function startActionCollection(lifeCycle, domMutationObservable, configuration, pageStateHistory) {\n    lifeCycle.subscribe(1 /* LifeCycleEventType.AUTO_ACTION_COMPLETED */, function (action) {\n        return lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processAction(action, pageStateHistory));\n    });\n    var actionContexts = { findActionId: noop };\n    if (configuration.trackUserInteractions) {\n        actionContexts = trackClickActions(lifeCycle, domMutationObservable, configuration).actionContexts;\n    }\n    return {\n        addAction: function (action, savedCommonContext) {\n            lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n                savedCommonContext: savedCommonContext,\n            }, processAction(action, pageStateHistory)));\n        },\n        actionContexts: actionContexts,\n    };\n}\nfunction processAction(action, pageStateHistory) {\n    var autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                id: action.id,\n                loading_time: toServerDuration(action.duration),\n                frustration: {\n                    type: action.frustrationTypes,\n                },\n                error: {\n                    count: action.counts.errorCount,\n                },\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n            _dd: {\n                action: {\n                    target: action.target,\n                    position: action.position,\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\" /* RumEventType.ACTION */,\n        view: { in_foreground: pageStateHistory.isInActivePageStateAt(action.startClocks.relative) },\n    }, autoActionProperties);\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: isAutoAction(action) ? { event: action.event, events: action.events } : {},\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* ActionType.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): )?([\\s\\S]*)$/;\n/**\n * Cross-browser collection of unhandled errors\n *\n * Supports:\n * - Firefox: full stack trace with line numbers, plus column number\n * on top frame; column number is not guaranteed\n * - Opera: full stack trace with line and column numbers\n * - Chrome: full stack trace with line and column numbers\n * - Safari: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n * - IE: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n * - IE5.5+ (only 8.0 tested)\n * - Firefox 0.9+ (only 3.5+ tested)\n * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n * Exceptions Have Stacktrace to be enabled in opera:config)\n * - Safari 3+ (only 4+ tested)\n * - Chrome 1+ (only 5+ tested)\n * - Konqueror 3.5+ (untested)\n *\n * Tries to catch all unhandled errors and report them to the\n * callback.\n *\n * Callbacks receive a StackTrace object as described in the\n * computeStackTrace docs.\n *\n * @memberof TraceKit\n * @namespace\n */\nexport function startUnhandledErrorCollection(callback) {\n    var stopInstrumentingOnError = instrumentOnError(callback).stop;\n    var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(callback).stop;\n    return {\n        stop: function () {\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 (messageObj, url, line, column, errorObj) {\n            var stackTrace;\n            if (errorObj instanceof Error) {\n                stackTrace = computeStackTrace(errorObj);\n            }\n            else {\n                var stack = [{ url: url, column: column, line: line }];\n                var _a = tryToParseMessage(messageObj), name_1 = _a.name, message = _a.message;\n                stackTrace = {\n                    name: name_1,\n                    message: message,\n                    stack: stack,\n                };\n            }\n            callback(stackTrace, errorObj !== null && errorObj !== void 0 ? errorObj : messageObj);\n        },\n    });\n}\nfunction tryToParseMessage(messageObj) {\n    var _a;\n    var name;\n    var message;\n    if ({}.toString.call(messageObj) === '[object String]') {\n        ;\n        _a = ERROR_TYPES_RE.exec(messageObj), name = _a[1], message = _a[2];\n    }\n    return { name: name, message: message };\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 { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString, tryToGetFingerprint } from '../error/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { ConsoleApiName, globalConsole } from '../../tools/display';\nimport { callMonitored } from '../../tools/monitor';\nimport { sanitize } from '../../tools/serialisation/sanitize';\nimport { find } from '../../tools/utils/polyfills';\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify';\nvar consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n    var consoleObservables = apis.map(function (api) {\n        if (!consoleObservablesByApi[api]) {\n            consoleObservablesByApi[api] = createConsoleObservable(api);\n        }\n        return consoleObservablesByApi[api];\n    });\n    return mergeObservables.apply(void 0, consoleObservables);\n}\nexport function resetConsoleObservable() {\n    consoleObservablesByApi = {};\n}\nfunction createConsoleObservable(api) {\n    var observable = new Observable(function () {\n        var originalConsoleApi = globalConsole[api];\n        globalConsole[api] = function () {\n            var params = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                params[_i] = arguments[_i];\n            }\n            originalConsoleApi.apply(console, params);\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                observable.notify(buildConsoleLog(params, api, handlingStack));\n            });\n        };\n        return function () {\n            globalConsole[api] = originalConsoleApi;\n        };\n    });\n    return observable;\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n    // Todo: remove console error prefix in the next major version\n    var message = params.map(function (param) { return formatConsoleParameters(param); }).join(' ');\n    var stack;\n    var fingerprint;\n    if (api === ConsoleApiName.error) {\n        var firstErrorParam = find(params, function (param) { return param instanceof Error; });\n        stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;\n        fingerprint = tryToGetFingerprint(firstErrorParam);\n        message = \"console error: \".concat(message);\n    }\n    return {\n        api: api,\n        message: message,\n        stack: stack,\n        handlingStack: handlingStack,\n        fingerprint: fingerprint,\n    };\n}\nfunction formatConsoleParameters(param) {\n    if (typeof param === 'string') {\n        return sanitize(param);\n    }\n    if (param instanceof Error) {\n        return formatErrorMessage(computeStackTrace(param));\n    }\n    return jsonStringify(sanitize(param), undefined, 2);\n}\n//# sourceMappingURL=consoleObservable.js.map","import { toStackTraceString } from '../error/error';\nimport { monitor } from '../../tools/monitor';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { addEventListener } from '../../browser/addEventListener';\nimport { includes } from '../../tools/utils/polyfills';\nimport { safeTruncate } from '../../tools/utils/stringUtils';\nexport var RawReportType = {\n    intervention: 'intervention',\n    deprecation: 'deprecation',\n    cspViolation: 'csp_violation',\n};\nexport function initReportObservable(configuration, apis) {\n    var observables = [];\n    if (includes(apis, RawReportType.cspViolation)) {\n        observables.push(createCspViolationReportObservable(configuration));\n    }\n    var reportTypes = apis.filter(function (api) { 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(configuration) {\n    var observable = new Observable(function () {\n        var stop = addEventListener(configuration, document, \"securitypolicyviolation\" /* DOM_EVENT.SECURITY_POLICY_VIOLATION */, function (event) {\n            observable.notify(buildRawReportFromCspViolation(event));\n        }).stop;\n        return stop;\n    });\n    return observable;\n}\nfunction buildRawReportFromReport(_a) {\n    var type = _a.type, body = _a.body;\n    return {\n        type: type,\n        subtype: body.id,\n        message: \"\".concat(type, \": \").concat(body.message),\n        stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n    };\n}\nfunction buildRawReportFromCspViolation(event) {\n    var type = RawReportType.cspViolation;\n    var message = \"'\".concat(event.blockedURI, \"' blocked by '\").concat(event.effectiveDirective, \"' directive\");\n    return {\n        type: RawReportType.cspViolation,\n        subtype: event.effectiveDirective,\n        message: \"\".concat(type, \": \").concat(message),\n        stack: buildStack(event.effectiveDirective, event.originalPolicy\n            ? \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\")\n            : 'no policy', 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 !== null && lineNumber !== void 0 ? lineNumber : undefined,\n                    column: columnNumber !== null && columnNumber !== void 0 ? columnNumber : undefined,\n                },\n            ],\n        })\n        : undefined;\n}\n//# sourceMappingURL=reportObservable.js.map","import { isEmptyObject, assign, ErrorSource, generateUUID, computeRawError, computeStackTrace, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, configuration, pageStateHistory, featureFlagContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(configuration, errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts);\n}\nexport function doStartErrorCollection(lifeCycle, pageStateHistory, featureFlagContexts) {\n    lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, assign({\n            customerContext: customerContext,\n            savedCommonContext: savedCommonContext,\n        }, processError(error, pageStateHistory, featureFlagContexts)));\n    });\n    return {\n        addError: function (_a, savedCommonContext) {\n            var error = _a.error, handlingStack = _a.handlingStack, startClocks = _a.startClocks, customerContext = _a.context;\n            var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n            var rawError = computeRawError({\n                stackTrace: stackTrace,\n                originalError: error,\n                handlingStack: handlingStack,\n                startClocks: startClocks,\n                nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n                source: ErrorSource.CUSTOM,\n                handling: \"handled\" /* ErrorHandling.HANDLED */,\n            });\n            lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction processError(error, pageStateHistory, featureFlagContexts) {\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            causes: error.causes,\n            source_type: 'browser',\n            fingerprint: error.fingerprint,\n        },\n        type: \"error\" /* RumEventType.ERROR */,\n        view: { in_foreground: pageStateHistory.isInActivePageStateAt(error.startClocks.relative) },\n    };\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(error.startClocks.relative);\n    if (featureFlagContext && !isEmptyObject(featureFlagContext)) {\n        rawRumEvent.feature_flags = featureFlagContext;\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            fingerprint: consoleError.fingerprint,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* ErrorHandling.HANDLED */,\n            handlingStack: consoleError.handlingStack,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { clocksNow } from '../../tools/utils/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\nimport { computeRawError } from './error';\nimport { ErrorSource } from './error.types';\nexport function trackRuntimeError(errorObservable) {\n    return startUnhandledErrorCollection(function (stackTrace, originalError) {\n        errorObservable.notify(computeRawError({\n            stackTrace: stackTrace,\n            originalError: originalError,\n            startClocks: clocksNow(),\n            nonErrorPrefix: \"Uncaught\" /* NonErrorPrefix.UNCAUGHT */,\n            source: ErrorSource.SOURCE,\n            handling: \"unhandled\" /* ErrorHandling.UNHANDLED */,\n        }));\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { clocksNow, ErrorSource, initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(configuration, errorObservable) {\n    var subscription = initReportObservable(configuration, [\n        RawReportType.cspViolation,\n        RawReportType.intervention,\n    ]).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\" /* ErrorHandling.UNHANDLED */,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { addDuration } from '@datadog/browser-core';\nimport { 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 *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - if a single timing match, return the timing\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    return;\n}\nfunction endTime(timing) {\n    return addDuration(timing.startTime, timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    var errorMargin = 1;\n    return timing.startTime >= start - errorMargin && endTime(timing) <= addDuration(end, errorMargin);\n}\n//# sourceMappingURL=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, isNumber, isExperimentalFeatureEnabled, ExperimentalFeature, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceCollection';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle, configuration, sessionManager, pageStateHistory) {\n    lifeCycle.subscribe(6 /* LifeCycleEventType.REQUEST_COMPLETED */, function (request) {\n        lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processRequest(request, configuration, sessionManager, pageStateHistory));\n    });\n    lifeCycle.subscribe(0 /* LifeCycleEventType.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 === RumPerformanceEntryType.RESOURCE && !isRequestKind(entry)) {\n                lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processResourceEntry(entry, configuration, sessionManager, pageStateHistory));\n            }\n        }\n    });\n}\nfunction processRequest(request, configuration, sessionManager, pageStateHistory) {\n    var _a;\n    var type = request.type === \"xhr\" /* RequestType.XHR */ ? \"xhr\" /* ResourceType.XHR */ : \"fetch\" /* ResourceType.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, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var duration = computeRequestDuration(pageStateHistory, startClocks, request.duration);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, (_a = matchingTiming === null || matchingTiming === void 0 ? void 0 : matchingTiming.duration) !== null && _a !== void 0 ? _a : request.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: duration,\n            method: request.method,\n            status_code: request.status,\n            url: request.url,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n    }, tracingInfo, correspondingTimingOverrides, indexingInfo, pageStateInfo);\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, configuration, sessionManager, pageStateHistory) {\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var startClocks = relativeToClocks(entry.startTime);\n    var tracingInfo = computeEntryTracingInfo(entry, configuration);\n    var indexingInfo = computeIndexingInfo(sessionManager, startClocks);\n    var pageStateInfo = computePageStateInfo(pageStateHistory, startClocks, entry.duration);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            url: entry.name,\n        },\n        type: \"resource\" /* RumEventType.RESOURCE */,\n    }, tracingInfo, entryMetrics, indexingInfo, pageStateInfo);\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, configuration) {\n    var hasBeenTraced = request.traceSampled && 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            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\nfunction computeEntryTracingInfo(entry, configuration) {\n    var hasBeenTraced = entry.traceId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            trace_id: entry.traceId,\n            rule_psr: getRulePsr(configuration),\n        },\n    };\n}\n// TODO next major: use directly PerformanceEntry type in domain context\nfunction toPerformanceEntryRepresentation(entry) {\n    return entry;\n}\n/**\n * @returns number between 0 and 1 which represents trace sample rate\n */\nfunction getRulePsr(configuration) {\n    return isNumber(configuration.traceSampleRate) ? configuration.traceSampleRate / 100 : undefined;\n}\nfunction computeIndexingInfo(sessionManager, resourceStart) {\n    var session = sessionManager.findTrackedSession(resourceStart.relative);\n    return {\n        _dd: {\n            discarded: !session || !session.resourceAllowed,\n        },\n    };\n}\nfunction computePageStateInfo(pageStateHistory, startClocks, duration) {\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.RESOURCE_PAGE_STATES)) {\n        return;\n    }\n    return {\n        _dd: {\n            page_states: pageStateHistory.findAll(startClocks.relative, duration),\n            page_was_discarded: String(document.wasDiscarded),\n        },\n    };\n}\nfunction computeRequestDuration(pageStateHistory, startClocks, duration) {\n    var _a;\n    // TODO remove FF in next major\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.NO_RESOURCE_DURATION_FROZEN_STATE)) {\n        return toServerDuration(duration);\n    }\n    var requestCrossedFrozenState = (_a = pageStateHistory\n        .findAll(startClocks.relative, duration)) === null || _a === void 0 ? void 0 : _a.some(function (pageState) { return pageState.state === \"frozen\" /* PageState.FROZEN */; });\n    return !requestCrossedFrozenState ? toServerDuration(duration) : undefined;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { toServerDuration } from '@datadog/browser-core';\n// Todo: Remove in the next major release\nexport function mapToForegroundPeriods(pageStateServerEntries, duration) {\n    var foregroundPeriods = [];\n    for (var i = 0; i < pageStateServerEntries.length; i++) {\n        var current = pageStateServerEntries[i];\n        var next = pageStateServerEntries[i + 1];\n        if (current.state === \"active\" /* PageState.ACTIVE */) {\n            var start = current.start >= 0 ? current.start : 0;\n            var end = next ? next.start : toServerDuration(duration);\n            foregroundPeriods.push({\n                start: start,\n                duration: (end - start),\n            });\n        }\n    }\n    return foregroundPeriods;\n}\n//# sourceMappingURL=foregroundContexts.js.map","import { ExperimentalFeature, ONE_MINUTE, addEventListeners, findLast, isExperimentalFeatureEnabled, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\n// Discard LCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport var LCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\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/onLCP.ts\n */\nexport function trackLargestContentfulPaint(lifeCycle, configuration, firstHidden, eventTarget, callback) {\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(configuration, eventTarget, [\"pointerdown\" /* DOM_EVENT.POINTER_DOWN */, \"keydown\" /* DOM_EVENT.KEY_DOWN */], function (event) {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true }).stop;\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return entry.entryType === RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT &&\n                entry.startTime < firstInteractionTimestamp &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < LCP_MAXIMUM_DELAY;\n        });\n        if (lcpEntry) {\n            var lcpTargetSelector = void 0;\n            if (isExperimentalFeatureEnabled(ExperimentalFeature.WEB_VITALS_ATTRIBUTION) && lcpEntry.element) {\n                lcpTargetSelector = getSelectorFromElement(lcpEntry.element, configuration.actionNameAttribute);\n            }\n            callback({\n                value: lcpEntry.startTime,\n                targetSelector: lcpTargetSelector,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: function () {\n            stopEventListener();\n            unsubscribeLifeCycle();\n        },\n    };\n}\n//# sourceMappingURL=trackLargestContentfulPaint.js.map","/**\n * performance.interactionCount polyfill\n *\n * The interactionCount is an integer which counts the total number of distinct user interactions,\n * for which there was a unique interactionId.\n *\n * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213\n * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.\n * Hopefully when/if other browsers will support INP, they will also implement performance.interactionCount at the same time, so we won't need that polyfill.\n *\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts\n */\nimport { monitor } from '@datadog/browser-core';\nvar observer;\nvar interactionCountEstimate = 0;\nvar minKnownInteractionId = Infinity;\nvar maxKnownInteractionId = 0;\nexport function initInteractionCountPolyfill() {\n    if ('interactionCount' in performance || observer) {\n        return;\n    }\n    observer = new window.PerformanceObserver(monitor(function (entries) {\n        entries.getEntries().forEach(function (e) {\n            var entry = e;\n            if (entry.interactionId) {\n                minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);\n                maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);\n                interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1;\n            }\n        });\n    }));\n    observer.observe({ type: 'event', buffered: true, durationThreshold: 0 });\n}\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport var getInteractionCount = function () {\n    return observer ? interactionCountEstimate : window.performance.interactionCount || 0;\n};\n//# sourceMappingURL=interactionCountPolyfill.js.map","import { trackFirstContentfulPaint } from './trackFirstContentfulPaint';\nimport { trackFirstInput } from './trackFirstInput';\nimport { trackNavigationTimings } from './trackNavigationTimings';\nimport { trackLargestContentfulPaint } from './trackLargestContentfulPaint';\nimport { trackFirstHidden } from './trackFirstHidden';\nexport function trackInitialViewMetrics(lifeCycle, configuration, setLoadEvent, scheduleViewUpdate) {\n    var initialViewMetrics = {};\n    var stopNavigationTracking = trackNavigationTimings(lifeCycle, function (navigationTimings) {\n        setLoadEvent(navigationTimings.loadEvent);\n        initialViewMetrics.navigationTimings = navigationTimings;\n        scheduleViewUpdate();\n    }).stop;\n    var firstHidden = trackFirstHidden(configuration);\n    var stopFCPTracking = trackFirstContentfulPaint(lifeCycle, firstHidden, function (firstContentfulPaint) {\n        initialViewMetrics.firstContentfulPaint = firstContentfulPaint;\n        scheduleViewUpdate();\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaint(lifeCycle, configuration, firstHidden, window, function (largestContentfulPaint) {\n        initialViewMetrics.largestContentfulPaint = largestContentfulPaint;\n        scheduleViewUpdate();\n    }).stop;\n    var stopFIDTracking = trackFirstInput(lifeCycle, configuration, firstHidden, function (firstInput) {\n        initialViewMetrics.firstInput = firstInput;\n        scheduleViewUpdate();\n    }).stop;\n    function stop() {\n        stopNavigationTracking();\n        stopFCPTracking();\n        stopLCPTracking();\n        stopFIDTracking();\n        firstHidden.stop();\n    }\n    return {\n        stop: stop,\n        initialViewMetrics: initialViewMetrics,\n    };\n}\n//# sourceMappingURL=trackInitialViewMetrics.js.map","import { relativeNow } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\nexport function trackNavigationTimings(lifeCycle, callback) {\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.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 === RumPerformanceEntryType.NAVIGATION) {\n                callback({\n                    domComplete: entry.domComplete,\n                    domContentLoaded: entry.domContentLoadedEventEnd,\n                    domInteractive: entry.domInteractive,\n                    loadEvent: entry.loadEventEnd,\n                    // In some cases the value reported is negative or is larger\n                    // than the current page time. Ignore these cases:\n                    // https://github.com/GoogleChrome/web-vitals/issues/137\n                    // https://github.com/GoogleChrome/web-vitals/issues/162\n                    firstByte: entry.responseStart >= 0 && entry.responseStart <= relativeNow() ? entry.responseStart : undefined,\n                });\n            }\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\n//# sourceMappingURL=trackNavigationTimings.js.map","import { addEventListeners } from '@datadog/browser-core';\nexport function trackFirstHidden(configuration, eventTarget) {\n    if (eventTarget === void 0) { eventTarget = window; }\n    var timeStamp;\n    var stopListeners;\n    if (document.visibilityState === 'hidden') {\n        timeStamp = 0;\n    }\n    else {\n        timeStamp = Infinity;\n        (stopListeners = addEventListeners(configuration, eventTarget, [\"pagehide\" /* DOM_EVENT.PAGE_HIDE */, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */], function (event) {\n            if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */ || document.visibilityState === 'hidden') {\n                timeStamp = event.timeStamp;\n                stopListeners();\n            }\n        }, { capture: true }).stop);\n    }\n    return {\n        get timeStamp() {\n            return timeStamp;\n        },\n        stop: function () {\n            stopListeners === null || stopListeners === void 0 ? void 0 : stopListeners();\n        },\n    };\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { ONE_MINUTE, find } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\n// Discard 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 FCP_MAXIMUM_DELAY = 10 * ONE_MINUTE;\nexport function trackFirstContentfulPaint(lifeCycle, firstHidden, callback) {\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.entryType === RumPerformanceEntryType.PAINT &&\n                entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < FCP_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return {\n        stop: unsubscribeLifeCycle,\n    };\n}\n//# sourceMappingURL=trackFirstContentfulPaint.js.map","import { elapsed, find, ExperimentalFeature, isExperimentalFeatureEnabled } from '@datadog/browser-core';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { RumPerformanceEntryType } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\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 trackFirstInput(lifeCycle, configuration, firstHidden, callback) {\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var firstInputEntry = find(entries, function (entry) {\n            return entry.entryType === RumPerformanceEntryType.FIRST_INPUT && entry.startTime < firstHidden.timeStamp;\n        });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            var firstInputTargetSelector = void 0;\n            if (isExperimentalFeatureEnabled(ExperimentalFeature.WEB_VITALS_ATTRIBUTION) &&\n                firstInputEntry.target &&\n                isElementNode(firstInputEntry.target)) {\n                firstInputTargetSelector = getSelectorFromElement(firstInputEntry.target, configuration.actionNameAttribute);\n            }\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                delay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                time: firstInputEntry.startTime,\n                targetSelector: firstInputTargetSelector,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: unsubscribeLifeCycle,\n    };\n}\n//# sourceMappingURL=trackFirstInput.js.map","import { round, find, ONE_SECOND, isExperimentalFeatureEnabled, ExperimentalFeature, noop, } from '@datadog/browser-core';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\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 */\nexport function trackCumulativeLayoutShift(configuration, lifeCycle, callback) {\n    if (!isLayoutShiftSupported()) {\n        return {\n            stop: noop,\n        };\n    }\n    var maxClsValue = 0;\n    // if no layout shift happen the value should be reported as 0\n    callback({\n        value: 0,\n    });\n    var window = slidingSessionWindow();\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.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 === RumPerformanceEntryType.LAYOUT_SHIFT && !entry.hadRecentInput) {\n                window.update(entry);\n                if (window.value() > maxClsValue) {\n                    maxClsValue = window.value();\n                    var cls = round(maxClsValue, 4);\n                    var clsTarget = window.largestLayoutShiftTarget();\n                    var cslTargetSelector = void 0;\n                    if (isExperimentalFeatureEnabled(ExperimentalFeature.WEB_VITALS_ATTRIBUTION) && clsTarget) {\n                        cslTargetSelector = getSelectorFromElement(clsTarget, configuration.actionNameAttribute);\n                    }\n                    callback({\n                        value: cls,\n                        targetSelector: cslTargetSelector,\n                    });\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    var largestLayoutShift = 0;\n    var largestLayoutShiftTarget;\n    var largestLayoutShiftTime;\n    return {\n        update: function (entry) {\n            var _a, _b;\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                largestLayoutShift = 0;\n                largestLayoutShiftTarget = undefined;\n            }\n            else {\n                value += entry.value;\n                endTime = entry.startTime;\n            }\n            if (entry.value > largestLayoutShift) {\n                largestLayoutShift = entry.value;\n                largestLayoutShiftTime = entry.startTime;\n                if ((_a = entry.sources) === null || _a === void 0 ? void 0 : _a.length) {\n                    largestLayoutShiftTarget = (_b = find(entry.sources, function (s) { return !!s.node && isElementNode(s.node); })) === null || _b === void 0 ? void 0 : _b.node;\n                }\n                else {\n                    largestLayoutShiftTarget = undefined;\n                }\n            }\n        },\n        value: function () { return value; },\n        largestLayoutShiftTarget: function () { return largestLayoutShiftTarget; },\n        largestLayoutShiftTime: function () { return largestLayoutShiftTime; },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nexport function isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent(RumPerformanceEntryType.LAYOUT_SHIFT);\n}\n//# sourceMappingURL=trackCumulativeLayoutShift.js.map","import { Observable, throttle, addEventListener } from '@datadog/browser-core';\nvar viewportObservable;\nexport function initViewportObservable(configuration) {\n    if (!viewportObservable) {\n        viewportObservable = createViewportObservable(configuration);\n    }\n    return viewportObservable;\n}\nexport function createViewportObservable(configuration) {\n    var observable = new Observable(function () {\n        var updateDimension = throttle(function () {\n            observable.notify(getViewportDimension());\n        }, 200).throttled;\n        return addEventListener(configuration, window, \"resize\" /* DOM_EVENT.RESIZE */, updateDimension, { capture: true, passive: true })\n            .stop;\n    });\n    return observable;\n}\n// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getViewportDimension() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return {\n            width: Number(visual.width * visual.scale),\n            height: Number(visual.height * visual.scale),\n        };\n    }\n    return {\n        width: Number(window.innerWidth || 0),\n        height: Number(window.innerHeight || 0),\n    };\n}\n//# sourceMappingURL=viewportObservable.js.map","import { noop, isExperimentalFeatureEnabled, ExperimentalFeature, ONE_MINUTE, addTelemetryDebug, elapsed, } from '@datadog/browser-core';\nimport { RumPerformanceEntryType, supportPerformanceTimingEvent } from '../../../browser/performanceCollection';\nimport { getSelectorFromElement } from '../../getSelectorFromElement';\nimport { isElementNode } from '../../../browser/htmlDomUtils';\nimport { getInteractionCount, initInteractionCountPolyfill } from './interactionCountPolyfill';\n// Arbitrary value to prevent unnecessary memory usage on views with lots of interactions.\nvar MAX_INTERACTION_ENTRIES = 10;\n/**\n * Track the interaction to next paint (INP).\n * To avoid outliers, return the p98 worst interaction of the view.\n * Documentation: https://web.dev/inp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/onINP.ts\n */\nexport function trackInteractionToNextPaint(configuration, viewStart, viewLoadingType, lifeCycle) {\n    if (!isInteractionToNextPaintSupported() ||\n        !isExperimentalFeatureEnabled(ExperimentalFeature.INTERACTION_TO_NEXT_PAINT)) {\n        return {\n            getInteractionToNextPaint: function () { return undefined; },\n            stop: noop,\n        };\n    }\n    var getViewInteractionCount = trackViewInteractionCount(viewLoadingType).getViewInteractionCount;\n    var longestInteractions = trackLongestInteractions(getViewInteractionCount);\n    var interactionToNextPaint = -1;\n    var interactionToNextPaintTargetSelector;\n    var telemetryCollected = false;\n    var stop = lifeCycle.subscribe(0 /* LifeCycleEventType.PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var _a;\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if ((entry.entryType === RumPerformanceEntryType.EVENT ||\n                entry.entryType === RumPerformanceEntryType.FIRST_INPUT) &&\n                entry.interactionId) {\n                longestInteractions.process(entry);\n            }\n        }\n        var newInteraction = longestInteractions.estimateP98Interaction();\n        if (newInteraction) {\n            interactionToNextPaint = newInteraction.duration;\n            if (interactionToNextPaint > 10 * ONE_MINUTE && !telemetryCollected) {\n                telemetryCollected = true;\n                addTelemetryDebug('INP outlier', {\n                    inp: interactionToNextPaint,\n                    interaction: {\n                        timeFromViewStart: elapsed(viewStart.relative, newInteraction.startTime),\n                        duration: newInteraction.duration,\n                        startTime: newInteraction.startTime,\n                        processingStart: newInteraction.processingStart,\n                        processingEnd: newInteraction.processingEnd,\n                        interactionId: newInteraction.interactionId,\n                        name: newInteraction.name,\n                        targetNodeName: (_a = newInteraction.target) === null || _a === void 0 ? void 0 : _a.nodeName,\n                    },\n                });\n            }\n            if (isExperimentalFeatureEnabled(ExperimentalFeature.WEB_VITALS_ATTRIBUTION) &&\n                newInteraction.target &&\n                isElementNode(newInteraction.target)) {\n                interactionToNextPaintTargetSelector = getSelectorFromElement(newInteraction.target, configuration.actionNameAttribute);\n            }\n            else {\n                interactionToNextPaintTargetSelector = undefined;\n            }\n        }\n    }).unsubscribe;\n    return {\n        getInteractionToNextPaint: function () {\n            // If no INP duration where captured because of the performanceObserver 40ms threshold\n            // but the view interaction count > 0 then report 0\n            if (interactionToNextPaint >= 0) {\n                return {\n                    value: interactionToNextPaint,\n                    targetSelector: interactionToNextPaintTargetSelector,\n                };\n            }\n            else if (getViewInteractionCount()) {\n                return {\n                    value: 0,\n                };\n            }\n        },\n        stop: stop,\n    };\n}\nfunction trackLongestInteractions(getViewInteractionCount) {\n    var longestInteractions = [];\n    function sortAndTrimLongestInteractions() {\n        longestInteractions.sort(function (a, b) { return b.duration - a.duration; }).splice(MAX_INTERACTION_ENTRIES);\n    }\n    return {\n        /**\n         * Process the performance entry:\n         * - if its duration is long enough, add the performance entry to the list of worst interactions\n         * - if an entry with the same interaction id exists and its duration is lower than the new one, then replace it in the list of worst interactions\n         */\n        process: function (entry) {\n            var interactionIndex = longestInteractions.findIndex(function (interaction) { return entry.interactionId === interaction.interactionId; });\n            var minLongestInteraction = longestInteractions[longestInteractions.length - 1];\n            if (interactionIndex !== -1) {\n                if (entry.duration > longestInteractions[interactionIndex].duration) {\n                    longestInteractions[interactionIndex] = entry;\n                    sortAndTrimLongestInteractions();\n                }\n            }\n            else if (longestInteractions.length < MAX_INTERACTION_ENTRIES ||\n                entry.duration > minLongestInteraction.duration) {\n                longestInteractions.push(entry);\n                sortAndTrimLongestInteractions();\n            }\n        },\n        /**\n         * Compute the p98 longest interaction.\n         * For better performance the computation is based on 10 longest interactions and the interaction count of the current view.\n         */\n        estimateP98Interaction: function () {\n            var interactionIndex = Math.min(longestInteractions.length - 1, Math.floor(getViewInteractionCount() / 50));\n            return longestInteractions[interactionIndex];\n        },\n    };\n}\nexport function trackViewInteractionCount(viewLoadingType) {\n    initInteractionCountPolyfill();\n    var previousInteractionCount = viewLoadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */ ? 0 : getInteractionCount();\n    return {\n        getViewInteractionCount: function () { return getInteractionCount() - previousInteractionCount; },\n    };\n}\nexport function isInteractionToNextPaintSupported() {\n    return (supportPerformanceTimingEvent(RumPerformanceEntryType.EVENT) &&\n        window.PerformanceEventTiming &&\n        'interactionId' in PerformanceEventTiming.prototype);\n}\n//# sourceMappingURL=trackInteractionToNextPaint.js.map","export function getScrollX() {\n    var scrollX;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollX = visual.pageLeft - visual.offsetLeft;\n    }\n    else if (window.scrollX !== undefined) {\n        scrollX = window.scrollX;\n    }\n    else {\n        scrollX = window.pageXOffset || 0;\n    }\n    return Math.round(scrollX);\n}\nexport function getScrollY() {\n    var scrollY;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollY = visual.pageTop - visual.offsetTop;\n    }\n    else if (window.scrollY !== undefined) {\n        scrollY = window.scrollY;\n    }\n    else {\n        scrollY = window.pageYOffset || 0;\n    }\n    return Math.round(scrollY);\n}\n//# sourceMappingURL=scroll.js.map","import { Observable, ONE_SECOND, elapsed, relativeNow, throttle, addEventListener, monitor, } from '@datadog/browser-core';\nimport { getScrollY } from '../../../browser/scroll';\nimport { getViewportDimension } from '../../../browser/viewportObservable';\n/** Arbitrary scroll throttle duration */\nexport var THROTTLE_SCROLL_DURATION = ONE_SECOND;\nexport function trackScrollMetrics(configuration, viewStart, callback, scrollValues) {\n    if (scrollValues === void 0) { scrollValues = createScrollValuesObservable(configuration); }\n    var maxScrollDepth = 0;\n    var maxScrollHeight = 0;\n    var maxScrollHeightTime = 0;\n    var subscription = scrollValues.subscribe(function (_a) {\n        var scrollDepth = _a.scrollDepth, scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight;\n        var shouldUpdate = false;\n        if (scrollDepth > maxScrollDepth) {\n            maxScrollDepth = scrollDepth;\n            shouldUpdate = true;\n        }\n        if (scrollHeight > maxScrollHeight) {\n            maxScrollHeight = scrollHeight;\n            var now = relativeNow();\n            maxScrollHeightTime = elapsed(viewStart.relative, now);\n            shouldUpdate = true;\n        }\n        if (shouldUpdate) {\n            callback({\n                maxDepth: Math.min(maxScrollDepth, maxScrollHeight),\n                maxDepthScrollTop: scrollTop,\n                maxScrollHeight: maxScrollHeight,\n                maxScrollHeightTime: maxScrollHeightTime,\n            });\n        }\n    });\n    return {\n        stop: function () { return subscription.unsubscribe(); },\n    };\n}\nexport function computeScrollValues() {\n    var scrollTop = getScrollY();\n    var height = getViewportDimension().height;\n    var scrollHeight = Math.round((document.scrollingElement || document.documentElement).scrollHeight);\n    var scrollDepth = Math.round(height + scrollTop);\n    return {\n        scrollHeight: scrollHeight,\n        scrollDepth: scrollDepth,\n        scrollTop: scrollTop,\n    };\n}\nexport function createScrollValuesObservable(configuration, throttleDuration) {\n    if (throttleDuration === void 0) { throttleDuration = THROTTLE_SCROLL_DURATION; }\n    var observable = new Observable(function () {\n        function notify() {\n            observable.notify(computeScrollValues());\n        }\n        if (window.ResizeObserver) {\n            var throttledNotify_1 = throttle(notify, throttleDuration, {\n                leading: false,\n                trailing: true,\n            });\n            var observerTarget_1 = document.scrollingElement || document.documentElement;\n            var resizeObserver_1 = new ResizeObserver(monitor(throttledNotify_1.throttled));\n            resizeObserver_1.observe(observerTarget_1);\n            var eventListener_1 = addEventListener(configuration, window, \"scroll\" /* DOM_EVENT.SCROLL */, throttledNotify_1.throttled, {\n                passive: true,\n            });\n            return function () {\n                throttledNotify_1.cancel();\n                resizeObserver_1.unobserve(observerTarget_1);\n                eventListener_1.stop();\n            };\n        }\n    });\n    return observable;\n}\n//# sourceMappingURL=trackScrollMetrics.js.map","import { trackCumulativeLayoutShift } from './trackCumulativeLayoutShift';\nimport { trackInteractionToNextPaint } from './trackInteractionToNextPaint';\nimport { trackLoadingTime } from './trackLoadingTime';\nimport { trackScrollMetrics } from './trackScrollMetrics';\nexport function trackCommonViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {\n    var commonViewMetrics = {};\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadingType, viewStart, function (newLoadingTime) {\n        commonViewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopScrollMetricsTracking = trackScrollMetrics(configuration, viewStart, function (newScrollMetrics) {\n        commonViewMetrics.scroll = newScrollMetrics;\n    }).stop;\n    var stopCLSTracking = trackCumulativeLayoutShift(configuration, lifeCycle, function (cumulativeLayoutShift) {\n        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n        scheduleViewUpdate();\n    }).stop;\n    var _b = trackInteractionToNextPaint(configuration, viewStart, loadingType, lifeCycle), stopINPTracking = _b.stop, getInteractionToNextPaint = _b.getInteractionToNextPaint;\n    return {\n        stop: function () {\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n            stopScrollMetricsTracking();\n            stopINPTracking();\n        },\n        setLoadEvent: setLoadEvent,\n        getCommonViewMetrics: function () {\n            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();\n            return commonViewMetrics;\n        },\n    };\n}\n//# sourceMappingURL=trackCommonViewMetrics.js.map","import { elapsed } from '@datadog/browser-core';\nimport { waitPageActivityEnd } from '../../waitPageActivityEnd';\nexport function trackLoadingTime(lifeCycle, domMutationObservable, configuration, loadType, viewStart, callback) {\n    var isWaitingForLoadEvent = loadType === \"initial_load\" /* ViewLoadingType.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 = waitPageActivityEnd(lifeCycle, domMutationObservable, configuration, 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//# sourceMappingURL=trackLoadingTime.js.map","import { noop, PageExitReason, shallowClone, elapsed, generateUUID, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, setInterval, clearInterval, setTimeout, Observable, } from '@datadog/browser-core';\nimport { trackViewEventCounts } from './trackViewEventCounts';\nimport { trackInitialViewMetrics } from './viewMetrics/trackInitialViewMetrics';\nimport { trackCommonViewMetrics } from './viewMetrics/trackCommonViewMetrics';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\n// Some events or metrics can be captured after the end of the view. To avoid missing those;\n// an arbitrary delay is added for stopping their tracking after the view ends.\n//\n// Ideally, we would not stop and keep tracking events or metrics until the end of the session.\n// But this might have a small performance impact if there are many many views.\n// So let's have a fairly short delay improving the situation in most cases and avoid impacting performances too much.\nexport var KEEP_TRACKING_AFTER_VIEW_DELAY = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    var activeViews = new Set();\n    var currentView = startNewView(\"initial_load\" /* ViewLoadingType.INITIAL_LOAD */, clocksOrigin(), initialViewOptions);\n    startViewLifeCycle();\n    var locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function startNewView(loadingType, startClocks, viewOptions) {\n        var newlyCreatedView = newView(lifeCycle, domMutationObservable, configuration, location, loadingType, startClocks, viewOptions);\n        activeViews.add(newlyCreatedView);\n        newlyCreatedView.stopObservable.subscribe(function () {\n            activeViews.delete(newlyCreatedView);\n        });\n        return newlyCreatedView;\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n            // Renew view on session renewal\n            currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */, undefined, {\n                name: currentView.name,\n                service: currentView.service,\n                version: currentView.version,\n            });\n        });\n        lifeCycle.subscribe(7 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n            currentView.end({ sessionIsActive: false });\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(9 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n            if (pageExitEvent.reason === PageExitReason.UNLOADING || pageExitEvent.reason === PageExitReason.PAGEHIDE) {\n                currentView.end();\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 = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */);\n            }\n        });\n    }\n    return {\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            currentView.addTiming(name, time);\n        },\n        startView: function (options, startClocks) {\n            currentView.end({ endClocks: startClocks });\n            currentView = startNewView(\"route_change\" /* ViewLoadingType.ROUTE_CHANGE */, startClocks, options);\n        },\n        stop: function () {\n            locationChangeSubscription === null || locationChangeSubscription === void 0 ? void 0 : locationChangeSubscription.unsubscribe();\n            currentView.end();\n            activeViews.forEach(function (view) { return view.stop(); });\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, configuration, initialLocation, loadingType, startClocks, viewOptions) {\n    if (startClocks === void 0) { startClocks = clocksNow(); }\n    // Setup initial values\n    var id = generateUUID();\n    var stopObservable = new Observable();\n    var customTimings = {};\n    var documentVersion = 0;\n    var endClocks;\n    var location = shallowClone(initialLocation);\n    var sessionIsActive = true;\n    var name;\n    var service;\n    var version;\n    if (viewOptions) {\n        name = viewOptions.name;\n        service = viewOptions.service;\n        version = viewOptions.version;\n    }\n    lifeCycle.notify(2 /* LifeCycleEventType.VIEW_CREATED */, {\n        id: id,\n        name: name,\n        startClocks: startClocks,\n        service: service,\n        version: version,\n    });\n    // Update the view every time the measures are changing\n    var _a = throttle(triggerViewUpdate, THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    }), scheduleViewUpdate = _a.throttled, cancelScheduleViewUpdate = _a.cancel;\n    var _b = trackCommonViewMetrics(lifeCycle, domMutationObservable, configuration, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, stopCommonViewMetricsTracking = _b.stop, getCommonViewMetrics = _b.getCommonViewMetrics;\n    var _c = loadingType === \"initial_load\" /* ViewLoadingType.INITIAL_LOAD */\n        ? trackInitialViewMetrics(lifeCycle, configuration, setLoadEvent, scheduleViewUpdate)\n        : { stop: noop, initialViewMetrics: {} }, stopInitialViewMetricsTracking = _c.stop, initialViewMetrics = _c.initialViewMetrics;\n    var _d = trackViewEventCounts(lifeCycle, id, scheduleViewUpdate), stopEventCountsTracking = _d.stop, eventCounts = _d.eventCounts;\n    // Session keep alive\n    var keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL);\n    // Initial view update\n    triggerViewUpdate();\n    function triggerViewUpdate() {\n        cancelScheduleViewUpdate();\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(3 /* LifeCycleEventType.VIEW_UPDATED */, {\n            customTimings: customTimings,\n            documentVersion: documentVersion,\n            id: id,\n            name: name,\n            service: service,\n            version: version,\n            loadingType: loadingType,\n            location: location,\n            startClocks: startClocks,\n            commonViewMetrics: getCommonViewMetrics(),\n            initialViewMetrics: initialViewMetrics,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n            sessionIsActive: sessionIsActive,\n            eventCounts: eventCounts,\n        });\n    }\n    return {\n        name: name,\n        service: service,\n        version: version,\n        stopObservable: stopObservable,\n        end: function (options) {\n            var _this = this;\n            var _a, _b;\n            if (options === void 0) { options = {}; }\n            if (endClocks) {\n                // view already ended\n                return;\n            }\n            endClocks = (_a = options.endClocks) !== null && _a !== void 0 ? _a : clocksNow();\n            sessionIsActive = (_b = options.sessionIsActive) !== null && _b !== void 0 ? _b : true;\n            lifeCycle.notify(4 /* LifeCycleEventType.VIEW_ENDED */, { endClocks: endClocks });\n            clearInterval(keepAliveIntervalId);\n            stopCommonViewMetricsTracking();\n            triggerViewUpdate();\n            setTimeout(function () {\n                _this.stop();\n            }, KEEP_TRACKING_AFTER_VIEW_DELAY);\n        },\n        stop: function () {\n            stopInitialViewMetricsTracking();\n            stopEventCountsTracking();\n            stopObservable.notify();\n        },\n        addTiming: function (name, time) {\n            if (endClocks) {\n                return;\n            }\n            var relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n            scheduleViewUpdate();\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 { trackEventCounts } from '../trackEventCounts';\nexport function trackViewEventCounts(lifeCycle, viewId, onChange) {\n    var _a = trackEventCounts({\n        lifeCycle: lifeCycle,\n        isChildEvent: function (event) { return event.view.id === viewId; },\n        onChange: onChange,\n    }), stop = _a.stop, eventCounts = _a.eventCounts;\n    return {\n        stop: stop,\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackViewEventCounts.js.map","import { isExperimentalFeatureEnabled, ExperimentalFeature, isEmptyObject, mapValues, toServerDuration, isNumber, } from '@datadog/browser-core';\nimport { mapToForegroundPeriods } from '../contexts/foregroundContexts';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(3 /* LifeCycleEventType.VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory));\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, configuration, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, configuration, featureFlagContexts, recorderApi, pageStateHistory) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations(view.startClocks.relative);\n    var pageStatesEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGE_STATES);\n    var pageStates = pageStateHistory.findAll(view.startClocks.relative, view.duration);\n    var viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n            page_states: pageStatesEnabled ? pageStates : undefined,\n        },\n        date: view.startClocks.timeStamp,\n        type: \"view\" /* RumEventType.VIEW */,\n        view: {\n            action: {\n                count: view.eventCounts.actionCount,\n            },\n            frustration: {\n                count: view.eventCounts.frustrationCount,\n            },\n            cumulative_layout_shift: (_a = view.commonViewMetrics.cumulativeLayoutShift) === null || _a === void 0 ? void 0 : _a.value,\n            cumulative_layout_shift_target_selector: (_b = view.commonViewMetrics.cumulativeLayoutShift) === null || _b === void 0 ? void 0 : _b.targetSelector,\n            first_byte: toServerDuration((_c = view.initialViewMetrics.navigationTimings) === null || _c === void 0 ? void 0 : _c.firstByte),\n            dom_complete: toServerDuration((_d = view.initialViewMetrics.navigationTimings) === null || _d === void 0 ? void 0 : _d.domComplete),\n            dom_content_loaded: toServerDuration((_e = view.initialViewMetrics.navigationTimings) === null || _e === void 0 ? void 0 : _e.domContentLoaded),\n            dom_interactive: toServerDuration((_f = view.initialViewMetrics.navigationTimings) === null || _f === void 0 ? void 0 : _f.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.initialViewMetrics.firstContentfulPaint),\n            first_input_delay: toServerDuration((_g = view.initialViewMetrics.firstInput) === null || _g === void 0 ? void 0 : _g.delay),\n            first_input_time: toServerDuration((_h = view.initialViewMetrics.firstInput) === null || _h === void 0 ? void 0 : _h.time),\n            first_input_target_selector: (_j = view.initialViewMetrics.firstInput) === null || _j === void 0 ? void 0 : _j.targetSelector,\n            interaction_to_next_paint: toServerDuration((_k = view.commonViewMetrics.interactionToNextPaint) === null || _k === void 0 ? void 0 : _k.value),\n            interaction_to_next_paint_target_selector: (_l = view.commonViewMetrics.interactionToNextPaint) === null || _l === void 0 ? void 0 : _l.targetSelector,\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration((_m = view.initialViewMetrics.largestContentfulPaint) === null || _m === void 0 ? void 0 : _m.value),\n            largest_contentful_paint_target_selector: (_o = view.initialViewMetrics.largestContentfulPaint) === null || _o === void 0 ? void 0 : _o.targetSelector,\n            load_event: toServerDuration((_p = view.initialViewMetrics.navigationTimings) === null || _p === void 0 ? void 0 : _p.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.commonViewMetrics.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: !pageStatesEnabled && pageStates ? mapToForegroundPeriods(pageStates, view.duration) : undefined, // Todo: Remove in the next major release\n        },\n        feature_flags: featureFlagContext && !isEmptyObject(featureFlagContext) ? featureFlagContext : undefined,\n        display: view.commonViewMetrics.scroll\n            ? {\n                scroll: {\n                    max_depth: view.commonViewMetrics.scroll.maxDepth,\n                    max_depth_scroll_top: view.commonViewMetrics.scroll.maxDepthScrollTop,\n                    max_scroll_height: view.commonViewMetrics.scroll.maxScrollHeight,\n                    max_scroll_height_time: toServerDuration(view.commonViewMetrics.scroll.maxScrollHeightTime),\n                },\n            }\n            : undefined,\n        session: {\n            has_replay: replayStats ? true : undefined,\n            is_active: view.sessionIsActive ? undefined : false,\n        },\n        privacy: {\n            replay_level: configuration.defaultPrivacyLevel,\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 { ValueHistory } from '../../tools/valueHistory';\nimport { relativeNow, clocksOrigin, ONE_MINUTE } from '../../tools/utils/timeUtils';\nimport { addEventListener, addEventListeners } from '../../browser/addEventListener';\nimport { clearInterval, setInterval } from '../../tools/timer';\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants';\nimport { startSessionStore } from './sessionStore';\nexport var VISIBILITY_CHECK_DELAY = ONE_MINUTE;\nvar SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nvar stopCallbacks = [];\nexport function startSessionManager(configuration, productKey, computeSessionState) {\n    // TODO - Improve configuration type and remove assertion\n    var sessionStore = startSessionStore(configuration.sessionStoreStrategyType, productKey, computeSessionState);\n    stopCallbacks.push(function () { return sessionStore.stop(); });\n    var sessionContextHistory = new ValueHistory(SESSION_CONTEXT_TIMEOUT_DELAY);\n    stopCallbacks.push(function () { return sessionContextHistory.stop(); });\n    sessionStore.renewObservable.subscribe(function () {\n        sessionContextHistory.add(buildSessionContext(), relativeNow());\n    });\n    sessionStore.expireObservable.subscribe(function () {\n        sessionContextHistory.closeActive(relativeNow());\n    });\n    sessionStore.expandOrRenewSession();\n    sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);\n    trackActivity(configuration, function () { return sessionStore.expandOrRenewSession(); });\n    trackVisibility(configuration, 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        expire: sessionStore.expire,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach(function (e) { return e(); });\n    stopCallbacks = [];\n}\nfunction trackActivity(configuration, expandOrRenewSession) {\n    var stop = addEventListeners(configuration, window, [\"click\" /* DOM_EVENT.CLICK */, \"touchstart\" /* DOM_EVENT.TOUCH_START */, \"keydown\" /* DOM_EVENT.KEY_DOWN */, \"scroll\" /* DOM_EVENT.SCROLL */], expandOrRenewSession, { capture: true, passive: true }).stop;\n    stopCallbacks.push(stop);\n}\nfunction trackVisibility(configuration, expandSession) {\n    var expandSessionWhenVisible = function () {\n        if (document.visibilityState === 'visible') {\n            expandSession();\n        }\n    };\n    var stop = addEventListener(configuration, document, \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */, expandSessionWhenVisible).stop;\n    stopCallbacks.push(stop);\n    var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);\n    stopCallbacks.push(function () {\n        clearInterval(visibilityCheckInterval);\n    });\n}\n//# sourceMappingURL=sessionManager.js.map","import { Observable, noop, performDraw, startSessionManager } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle) {\n    var sessionManager = startSessionManager(configuration, RUM_SESSION_KEY, function (rawTrackingType) {\n        return computeSessionState(configuration, rawTrackingType);\n    });\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(7 /* LifeCycleEventType.SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(8 /* LifeCycleEventType.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            var plan = session.trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */\n                ? 2 /* RumSessionPlan.WITH_SESSION_REPLAY */\n                : 1 /* RumSessionPlan.WITHOUT_SESSION_REPLAY */;\n            return {\n                id: session.id,\n                plan: plan,\n                sessionReplayAllowed: plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n                longTaskAllowed: configuration.trackLongTasks !== undefined\n                    ? configuration.trackLongTasks\n                    : configuration.oldPlansBehavior && plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n                resourceAllowed: configuration.trackResources !== undefined\n                    ? configuration.trackResources\n                    : configuration.oldPlansBehavior && plan === 2 /* RumSessionPlan.WITH_SESSION_REPLAY */,\n            };\n        },\n        expire: sessionManager.expire,\n        expireObservable: sessionManager.expireObservable,\n    };\n}\n/**\n * Start a tracked replay session stub\n */\nexport function startRumSessionManagerStub() {\n    var session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        plan: 1 /* RumSessionPlan.WITHOUT_SESSION_REPLAY */,\n        sessionReplayAllowed: false,\n        longTaskAllowed: true,\n        resourceAllowed: true,\n    };\n    return {\n        findTrackedSession: function () { return session; },\n        expire: noop,\n        expireObservable: new Observable(),\n    };\n}\nfunction computeSessionState(configuration, rawTrackingType) {\n    var trackingType;\n    if (hasValidRumSession(rawTrackingType)) {\n        trackingType = rawTrackingType;\n    }\n    else if (!performDraw(configuration.sessionSampleRate)) {\n        trackingType = \"0\" /* RumTrackingType.NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.sessionReplaySampleRate)) {\n        trackingType = \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */;\n    }\n    else {\n        trackingType = \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */;\n    }\n    return {\n        trackingType: trackingType,\n        isTracked: isTypeTracked(trackingType),\n    };\n}\nfunction hasValidRumSession(trackingType) {\n    return (trackingType === \"0\" /* RumTrackingType.NOT_TRACKED */ ||\n        trackingType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */ ||\n        trackingType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */);\n}\nfunction isTypeTracked(rumSessionType) {\n    return (rumSessionType === \"2\" /* RumTrackingType.TRACKED_WITHOUT_SESSION_REPLAY */ ||\n        rumSessionType === \"1\" /* RumTrackingType.TRACKED_WITH_SESSION_REPLAY */);\n}\n//# sourceMappingURL=rumSessionManager.js.map","import { display } from '../tools/display';\nimport { objectValues } from '../tools/utils/polyfills';\nimport { isPageExitReason } from '../browser/pageExitObservable';\nimport { computeBytesCount } from '../tools/utils/byteUtils';\nimport { jsonStringify } from '../tools/serialisation/jsonStringify';\nvar Batch = /** @class */ (function () {\n    function Batch(request, flushController, messageBytesLimit) {\n        var _this = this;\n        this.request = request;\n        this.flushController = flushController;\n        this.messageBytesLimit = messageBytesLimit;\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        this.flushSubscription = this.flushController.flushObservable.subscribe(function (event) { return _this.flush(event); });\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.stop = function () {\n        this.flushSubscription.unsubscribe();\n    };\n    Batch.prototype.flush = function (event) {\n        var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        var payload = { data: messages.join('\\n'), bytesCount: event.bytesCount, flushReason: event.reason };\n        if (isPageExitReason(event.reason)) {\n            this.request.sendOnExit(payload);\n        }\n        else {\n            this.request.send(payload);\n        }\n    };\n    Batch.prototype.addOrUpdate = function (message, key) {\n        var _a = this.process(message), processedMessage = _a.processedMessage, messageBytesCount = _a.messageBytesCount;\n        if (messageBytesCount >= this.messageBytesLimit) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.messageBytesLimit, \"KB.\"));\n            return;\n        }\n        if (this.hasMessageFor(key)) {\n            this.remove(key);\n        }\n        this.push(processedMessage, messageBytesCount, key);\n    };\n    Batch.prototype.process = function (message) {\n        var processedMessage = jsonStringify(message);\n        var messageBytesCount = computeBytesCount(processedMessage);\n        return { processedMessage: processedMessage, messageBytesCount: messageBytesCount };\n    };\n    Batch.prototype.push = function (processedMessage, messageBytesCount, key) {\n        // If there are other messages, a '\\n' will be added at serialization\n        var separatorBytesCount = this.flushController.messagesCount > 0 ? 1 : 0;\n        this.flushController.notifyBeforeAddMessage(messageBytesCount + separatorBytesCount);\n        if (key !== undefined) {\n            this.upsertBuffer[key] = processedMessage;\n        }\n        else {\n            this.pushOnlyBuffer.push(processedMessage);\n        }\n        this.flushController.notifyAfterAddMessage();\n    };\n    Batch.prototype.remove = function (key) {\n        var removedMessage = this.upsertBuffer[key];\n        delete this.upsertBuffer[key];\n        var messageBytesCount = computeBytesCount(removedMessage);\n        // If there are other messages, a '\\n' will be added at serialization\n        var separatorBytesCount = this.flushController.messagesCount > 1 ? 1 : 0;\n        this.flushController.notifyAfterRemoveMessage(messageBytesCount + separatorBytesCount);\n    };\n    Batch.prototype.hasMessageFor = function (key) {\n        return key !== undefined && this.upsertBuffer[key] !== undefined;\n    };\n    return Batch;\n}());\nexport { Batch };\n//# sourceMappingURL=batch.js.map","import { setTimeout } from '../tools/timer';\nimport { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils';\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils';\nimport { isServerError } from '../tools/utils/responseUtils';\nimport { ErrorSource } from '../domain/error/error.types';\nexport var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;\nexport var MAX_ONGOING_REQUESTS = 32;\nexport var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;\nexport var MAX_BACKOFF_TIME = ONE_MINUTE;\nexport var INITIAL_BACKOFF_TIME = ONE_SECOND;\nexport function sendWithRetryStrategy(payload, state, sendStrategy, endpointType, reportError) {\n    if (state.transportStatus === 0 /* TransportStatus.UP */ &&\n        state.queuedPayloads.size() === 0 &&\n        state.bandwidthMonitor.canHandle(payload)) {\n        send(payload, state, sendStrategy, {\n            onSuccess: function () { return retryQueuedPayloads(0 /* RetryReason.AFTER_SUCCESS */, state, sendStrategy, endpointType, reportError); },\n            onFailure: function () {\n                state.queuedPayloads.enqueue(payload);\n                scheduleRetry(state, sendStrategy, endpointType, reportError);\n            },\n        });\n    }\n    else {\n        state.queuedPayloads.enqueue(payload);\n    }\n}\nfunction scheduleRetry(state, sendStrategy, endpointType, reportError) {\n    if (state.transportStatus !== 2 /* TransportStatus.DOWN */) {\n        return;\n    }\n    setTimeout(function () {\n        var payload = state.queuedPayloads.first();\n        send(payload, state, sendStrategy, {\n            onSuccess: function () {\n                state.queuedPayloads.dequeue();\n                state.currentBackoffTime = INITIAL_BACKOFF_TIME;\n                retryQueuedPayloads(1 /* RetryReason.AFTER_RESUME */, state, sendStrategy, endpointType, reportError);\n            },\n            onFailure: function () {\n                state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);\n                scheduleRetry(state, sendStrategy, endpointType, reportError);\n            },\n        });\n    }, state.currentBackoffTime);\n}\nfunction send(payload, state, sendStrategy, _a) {\n    var onSuccess = _a.onSuccess, onFailure = _a.onFailure;\n    state.bandwidthMonitor.add(payload);\n    sendStrategy(payload, function (response) {\n        state.bandwidthMonitor.remove(payload);\n        if (!shouldRetryRequest(response)) {\n            state.transportStatus = 0 /* TransportStatus.UP */;\n            onSuccess();\n        }\n        else {\n            // do not consider transport down if another ongoing request could succeed\n            state.transportStatus =\n                state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 /* TransportStatus.FAILURE_DETECTED */ : 2 /* TransportStatus.DOWN */;\n            payload.retry = {\n                count: payload.retry ? payload.retry.count + 1 : 1,\n                lastFailureStatus: response.status,\n            };\n            onFailure();\n        }\n    });\n}\nfunction retryQueuedPayloads(reason, state, sendStrategy, endpointType, reportError) {\n    if (reason === 0 /* RetryReason.AFTER_SUCCESS */ && state.queuedPayloads.isFull() && !state.queueFullReported) {\n        reportError({\n            message: \"Reached max \".concat(endpointType, \" events size queued for upload: \").concat(MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE, \"MiB\"),\n            source: ErrorSource.AGENT,\n            startClocks: clocksNow(),\n        });\n        state.queueFullReported = true;\n    }\n    var previousQueue = state.queuedPayloads;\n    state.queuedPayloads = newPayloadQueue();\n    while (previousQueue.size() > 0) {\n        sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, endpointType, reportError);\n    }\n}\nfunction shouldRetryRequest(response) {\n    return (response.type !== 'opaque' &&\n        ((response.status === 0 && !navigator.onLine) ||\n            response.status === 408 ||\n            response.status === 429 ||\n            isServerError(response.status)));\n}\nexport function newRetryState() {\n    return {\n        transportStatus: 0 /* TransportStatus.UP */,\n        currentBackoffTime: INITIAL_BACKOFF_TIME,\n        bandwidthMonitor: newBandwidthMonitor(),\n        queuedPayloads: newPayloadQueue(),\n        queueFullReported: false,\n    };\n}\nfunction newPayloadQueue() {\n    var queue = [];\n    return {\n        bytesCount: 0,\n        enqueue: function (payload) {\n            if (this.isFull()) {\n                return;\n            }\n            queue.push(payload);\n            this.bytesCount += payload.bytesCount;\n        },\n        first: function () {\n            return queue[0];\n        },\n        dequeue: function () {\n            var payload = queue.shift();\n            if (payload) {\n                this.bytesCount -= payload.bytesCount;\n            }\n            return payload;\n        },\n        size: function () {\n            return queue.length;\n        },\n        isFull: function () {\n            return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;\n        },\n    };\n}\nfunction newBandwidthMonitor() {\n    return {\n        ongoingRequestCount: 0,\n        ongoingByteCount: 0,\n        canHandle: function (payload) {\n            return (this.ongoingRequestCount === 0 ||\n                (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n                    this.ongoingRequestCount < MAX_ONGOING_REQUESTS));\n        },\n        add: function (payload) {\n            this.ongoingRequestCount += 1;\n            this.ongoingByteCount += payload.bytesCount;\n        },\n        remove: function (payload) {\n            this.ongoingRequestCount -= 1;\n            this.ongoingByteCount -= payload.bytesCount;\n        },\n    };\n}\n//# sourceMappingURL=sendWithRetryStrategy.js.map","import { addTelemetryError } from '../domain/telemetry';\nimport { monitor } from '../tools/monitor';\nimport { addEventListener } from '../browser/addEventListener';\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy';\nexport function createHttpRequest(configuration, endpointBuilder, bytesLimit, reportError) {\n    var retryState = newRetryState();\n    var sendStrategyForRetry = function (payload, onResponse) {\n        return fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse);\n    };\n    return {\n        send: function (payload) {\n            sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.endpointType, reportError);\n        },\n        /**\n         * Since fetch keepalive behaves like regular fetch on Firefox,\n         * keep using sendBeaconStrategy on exit\n         */\n        sendOnExit: function (payload) {\n            sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload);\n        },\n    };\n}\nfunction sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload) {\n    var canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit;\n    if (canUseBeacon) {\n        try {\n            var beaconUrl = endpointBuilder.build('beacon', payload);\n            var isQueued = navigator.sendBeacon(beaconUrl, payload.data);\n            if (isQueued) {\n                return;\n            }\n        }\n        catch (e) {\n            reportBeaconError(e);\n        }\n    }\n    var xhrUrl = endpointBuilder.build('xhr', payload);\n    sendXHR(configuration, xhrUrl, payload.data);\n}\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addTelemetryError(e);\n    }\n}\nexport function fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse) {\n    var canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit;\n    if (canUseKeepAlive) {\n        var fetchUrl = endpointBuilder.build('fetch', payload);\n        fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(monitor(function (response) { return onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: response.status, type: response.type }); }), monitor(function () {\n            var xhrUrl = endpointBuilder.build('xhr', payload);\n            // failed to queue the request\n            sendXHR(configuration, xhrUrl, payload.data, onResponse);\n        }));\n    }\n    else {\n        var xhrUrl = endpointBuilder.build('xhr', payload);\n        sendXHR(configuration, xhrUrl, payload.data, onResponse);\n    }\n}\nfunction isKeepAliveSupported() {\n    // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors\n    try {\n        return window.Request && 'keepalive' in new Request('http://a');\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function sendXHR(configuration, url, data, onResponse) {\n    var request = new XMLHttpRequest();\n    request.open('POST', url, true);\n    addEventListener(configuration, request, 'loadend', function () {\n        onResponse === null || onResponse === void 0 ? void 0 : onResponse({ status: request.status });\n    }, {\n        // prevent multiple onResponse callbacks\n        // if the xhr instance is reused by a third party\n        once: true,\n    });\n    request.send(data);\n}\n//# sourceMappingURL=httpRequest.js.map","import { Observable } from '../tools/observable';\nimport { clearTimeout, setTimeout } from '../tools/timer';\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController(_a) {\n    var messagesLimit = _a.messagesLimit, bytesLimit = _a.bytesLimit, durationLimit = _a.durationLimit, pageExitObservable = _a.pageExitObservable, sessionExpireObservable = _a.sessionExpireObservable;\n    var pageExitSubscription = pageExitObservable.subscribe(function (event) { return flush(event.reason); });\n    var sessionExpireSubscription = sessionExpireObservable.subscribe(function () { return flush('session_expire'); });\n    var flushObservable = new Observable(function () { return function () {\n        pageExitSubscription.unsubscribe();\n        sessionExpireSubscription.unsubscribe();\n    }; });\n    var currentBytesCount = 0;\n    var currentMessagesCount = 0;\n    function flush(flushReason) {\n        if (currentMessagesCount === 0) {\n            return;\n        }\n        var messagesCount = currentMessagesCount;\n        var bytesCount = currentBytesCount;\n        currentMessagesCount = 0;\n        currentBytesCount = 0;\n        cancelDurationLimitTimeout();\n        flushObservable.notify({\n            reason: flushReason,\n            messagesCount: messagesCount,\n            bytesCount: bytesCount,\n        });\n    }\n    var durationLimitTimeoutId;\n    function scheduleDurationLimitTimeout() {\n        if (durationLimitTimeoutId === undefined) {\n            durationLimitTimeoutId = setTimeout(function () {\n                flush('duration_limit');\n            }, durationLimit);\n        }\n    }\n    function cancelDurationLimitTimeout() {\n        clearTimeout(durationLimitTimeoutId);\n        durationLimitTimeoutId = undefined;\n    }\n    return {\n        flushObservable: flushObservable,\n        get messagesCount() {\n            return currentMessagesCount;\n        },\n        /**\n         * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right before adding the message, so no flush\n         * event can happen after `notifyBeforeAddMessage` and before adding the message.\n         */\n        notifyBeforeAddMessage: function (messageBytesCount) {\n            if (currentBytesCount + messageBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n            // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n            // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n            // to notify when a flush is needed (for example on page exit).\n            currentMessagesCount += 1;\n            currentBytesCount += messageBytesCount;\n            scheduleDurationLimitTimeout();\n        },\n        /**\n         * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n         *\n         * This function can be called asynchronously after the message was added, but in this case it\n         * should not be called if a flush event occurred in between.\n         */\n        notifyAfterAddMessage: function () {\n            if (currentMessagesCount >= messagesLimit) {\n                flush('messages_limit');\n            }\n            else if (currentBytesCount >= bytesLimit) {\n                flush('bytes_limit');\n            }\n        },\n        /**\n         * Notifies that a message was removed from a pool of pending messages waiting to be flushed.\n         *\n         * This function needs to be called synchronously, right after removing the message, so no flush\n         * event can happen after removing the message and before `notifyAfterRemoveMessage`.\n         */\n        notifyAfterRemoveMessage: function (messageBytesCount) {\n            currentBytesCount -= messageBytesCount;\n            currentMessagesCount -= 1;\n            if (currentMessagesCount === 0) {\n                cancelDurationLimitTimeout();\n            }\n        },\n    };\n}\n//# sourceMappingURL=flushController.js.map","import { combine, isTelemetryReplicationAllowed, startBatchWithReplica } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable, reportError, pageExitObservable, sessionExpireObservable) {\n    var replica = configuration.replica;\n    var batch = startBatchWithReplica(configuration, {\n        endpoint: configuration.rumEndpointBuilder,\n    }, replica && {\n        endpoint: replica.rumEndpointBuilder,\n        transformMessage: function (message) { return combine(message, { application: { id: replica.applicationId } }); },\n    }, reportError, pageExitObservable, sessionExpireObservable);\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        if (serverRumEvent.type === \"view\" /* RumEventType.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, isTelemetryReplicationAllowed(configuration)); });\n    return batch;\n}\n//# sourceMappingURL=startRumBatch.js.map","import { Batch } from './batch';\nimport { createHttpRequest } from './httpRequest';\nimport { createFlushController } from './flushController';\nexport function startBatchWithReplica(configuration, primary, replica, reportError, pageExitObservable, sessionExpireObservable) {\n    var primaryBatch = createBatch(configuration, primary.endpoint);\n    var replicaBatch = replica && createBatch(configuration, replica.endpoint);\n    function createBatch(configuration, endpointBuilder) {\n        return new Batch(createHttpRequest(configuration, endpointBuilder, configuration.batchBytesLimit, reportError), createFlushController({\n            messagesLimit: configuration.batchMessagesLimit,\n            bytesLimit: configuration.batchBytesLimit,\n            durationLimit: configuration.flushTimeout,\n            pageExitObservable: pageExitObservable,\n            sessionExpireObservable: sessionExpireObservable,\n        }), configuration.messageBytesLimit);\n    }\n    return {\n        flushObservable: primaryBatch.flushController.flushObservable,\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(replica.transformMessage ? replica.transformMessage(message) : message);\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key);\n            }\n        },\n        stop: function () {\n            primaryBatch.stop();\n            replicaBatch === null || replicaBatch === void 0 ? void 0 : replicaBatch.stop();\n        },\n    };\n}\n//# sourceMappingURL=startBatchWithReplica.js.map","import { addEventListener, instrumentMethodAndCallOriginal, Observable, shallowClone, } from '@datadog/browser-core';\nexport function createLocationChangeObservable(configuration, location) {\n    var currentLocation = shallowClone(location);\n    var observable = new Observable(function () {\n        var stopHistoryTracking = trackHistory(configuration, onLocationChange).stop;\n        var stopHashTracking = trackHash(configuration, 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(configuration, 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(configuration, window, \"popstate\" /* DOM_EVENT.POP_STATE */, onHistoryChange).stop;\n    return {\n        stop: function () {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(configuration, onHashChange) {\n    return addEventListener(configuration, window, \"hashchange\" /* DOM_EVENT.HASH_CHANGE */, onHashChange);\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { isEmptyObject, includes, performDraw, ONE_SECOND, addTelemetryDebug, setInterval } from '@datadog/browser-core';\nexport var MEASURES_PERIOD_DURATION = 10 * ONE_SECOND;\nvar currentPeriodMeasures;\nvar currentBatchMeasures;\nvar batchHasRumEvent;\nexport function startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batchFlushObservable) {\n    var customerDataTelemetryEnabled = telemetry.enabled && performDraw(configuration.customerDataTelemetrySampleRate);\n    if (!customerDataTelemetryEnabled) {\n        return;\n    }\n    initCurrentPeriodMeasures();\n    initCurrentBatchMeasures();\n    // We measure the data of every view updates even if there could only be one per batch due to the upsert\n    // It means that contexts bytes count sums can be higher than it really is\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) {\n        batchHasRumEvent = true;\n        updateMeasure(currentBatchMeasures.globalContextBytes, !isEmptyObject(globalContextManager.get()) ? globalContextManager.getBytesCount() : 0);\n        updateMeasure(currentBatchMeasures.userContextBytes, !isEmptyObject(userContextManager.get()) ? userContextManager.getBytesCount() : 0);\n        var featureFlagContext = featureFlagContexts.findFeatureFlagEvaluations();\n        var hasFeatureFlagContext = includes([\"view\" /* RumEventType.VIEW */, \"error\" /* RumEventType.ERROR */], event.type) &&\n            featureFlagContext &&\n            !isEmptyObject(featureFlagContext);\n        updateMeasure(currentBatchMeasures.featureFlagBytes, hasFeatureFlagContext ? featureFlagContexts.getFeatureFlagBytesCount() : 0);\n    });\n    batchFlushObservable.subscribe(function (_a) {\n        var bytesCount = _a.bytesCount, messagesCount = _a.messagesCount;\n        // Don't measure batch that only contains telemetry events to avoid batch sending loop\n        // It could happen because after each batch we are adding a customer data measures telemetry event to the next one\n        if (!batchHasRumEvent) {\n            return;\n        }\n        currentPeriodMeasures.batchCount += 1;\n        updateMeasure(currentPeriodMeasures.batchBytesCount, bytesCount);\n        updateMeasure(currentPeriodMeasures.batchMessagesCount, messagesCount);\n        mergeMeasure(currentPeriodMeasures.globalContextBytes, currentBatchMeasures.globalContextBytes);\n        mergeMeasure(currentPeriodMeasures.userContextBytes, currentBatchMeasures.userContextBytes);\n        mergeMeasure(currentPeriodMeasures.featureFlagBytes, currentBatchMeasures.featureFlagBytes);\n        initCurrentBatchMeasures();\n    });\n    setInterval(sendCurrentPeriodMeasures, MEASURES_PERIOD_DURATION);\n}\nfunction sendCurrentPeriodMeasures() {\n    if (currentPeriodMeasures.batchCount === 0) {\n        return;\n    }\n    addTelemetryDebug('Customer data measures', currentPeriodMeasures);\n    initCurrentPeriodMeasures();\n}\nfunction createMeasure() {\n    return { min: Infinity, max: 0, sum: 0 };\n}\nfunction updateMeasure(measure, value) {\n    measure.sum += value;\n    measure.min = Math.min(measure.min, value);\n    measure.max = Math.max(measure.max, value);\n}\nfunction mergeMeasure(target, source) {\n    target.sum += source.sum;\n    target.min = Math.min(target.min, source.min);\n    target.max = Math.max(target.max, source.max);\n}\nfunction initCurrentPeriodMeasures() {\n    currentPeriodMeasures = {\n        batchCount: 0,\n        batchBytesCount: createMeasure(),\n        batchMessagesCount: createMeasure(),\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\nfunction initCurrentBatchMeasures() {\n    batchHasRumEvent = false;\n    currentBatchMeasures = {\n        globalContextBytes: createMeasure(),\n        userContextBytes: createMeasure(),\n        featureFlagBytes: createMeasure(),\n    };\n}\n//# sourceMappingURL=startCustomerDataTelemetry.js.map","import { elapsed, ValueHistory, SESSION_TIME_OUT_DELAY, toServerDuration, addEventListeners, relativeNow, } from '@datadog/browser-core';\n// Arbitrary value to cap number of element for memory consumption in the browser\nexport var MAX_PAGE_STATE_ENTRIES = 4000;\n// Arbitrary value to cap number of element for backend & to save bandwidth\nexport var MAX_PAGE_STATE_ENTRIES_SELECTABLE = 500;\nexport var PAGE_STATE_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startPageStateHistory(configuration, maxPageStateEntriesSelectable) {\n    if (maxPageStateEntriesSelectable === void 0) { maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE; }\n    var pageStateHistory = new ValueHistory(PAGE_STATE_CONTEXT_TIME_OUT_DELAY, MAX_PAGE_STATE_ENTRIES);\n    var currentPageState;\n    addPageState(getPageState(), relativeNow());\n    var stopEventListeners = addEventListeners(configuration, window, [\n        \"pageshow\" /* DOM_EVENT.PAGE_SHOW */,\n        \"focus\" /* DOM_EVENT.FOCUS */,\n        \"blur\" /* DOM_EVENT.BLUR */,\n        \"visibilitychange\" /* DOM_EVENT.VISIBILITY_CHANGE */,\n        \"resume\" /* DOM_EVENT.RESUME */,\n        \"freeze\" /* DOM_EVENT.FREEZE */,\n        \"pagehide\" /* DOM_EVENT.PAGE_HIDE */,\n    ], function (event) {\n        // Only get events fired by the browser to avoid false currentPageState changes done with custom events\n        // cf: developer extension auto flush: https://github.com/DataDog/browser-sdk/blob/2f72bf05a672794c9e33965351964382a94c72ba/developer-extension/src/panel/flushEvents.ts#L11-L12\n        if (event.isTrusted) {\n            addPageState(computePageState(event), event.timeStamp);\n        }\n    }, { capture: true }).stop;\n    function addPageState(nextPageState, startTime) {\n        if (startTime === void 0) { startTime = relativeNow(); }\n        if (nextPageState === currentPageState) {\n            return;\n        }\n        currentPageState = nextPageState;\n        pageStateHistory.closeActive(startTime);\n        pageStateHistory.add({ state: currentPageState, startTime: startTime }, startTime);\n    }\n    return {\n        findAll: function (eventStartTime, duration) {\n            var pageStateEntries = pageStateHistory.findAll(eventStartTime, duration);\n            if (pageStateEntries.length === 0) {\n                return;\n            }\n            var pageStateServerEntries = [];\n            // limit the number of entries to return\n            var limit = Math.max(0, pageStateEntries.length - maxPageStateEntriesSelectable);\n            // loop page state entries backward to return the selected ones in desc order\n            for (var index = pageStateEntries.length - 1; index >= limit; index--) {\n                var pageState = pageStateEntries[index];\n                // compute the start time relative to the event start time (ex: to be relative to the view start time)\n                var relativeStartTime = elapsed(eventStartTime, pageState.startTime);\n                pageStateServerEntries.push({\n                    state: pageState.state,\n                    start: toServerDuration(relativeStartTime),\n                });\n            }\n            return pageStateServerEntries;\n        },\n        isInActivePageStateAt: function (startTime) {\n            var pageStateEntry = pageStateHistory.find(startTime);\n            return pageStateEntry !== undefined && pageStateEntry.state === \"active\" /* PageState.ACTIVE */;\n        },\n        addPageState: addPageState,\n        stop: function () {\n            stopEventListeners();\n            pageStateHistory.stop();\n        },\n    };\n}\nfunction computePageState(event) {\n    if (event.type === \"freeze\" /* DOM_EVENT.FREEZE */) {\n        return \"frozen\" /* PageState.FROZEN */;\n    }\n    else if (event.type === \"pagehide\" /* DOM_EVENT.PAGE_HIDE */) {\n        return event.persisted ? \"frozen\" /* PageState.FROZEN */ : \"terminated\" /* PageState.TERMINATED */;\n    }\n    return getPageState();\n}\nfunction getPageState() {\n    if (document.visibilityState === 'hidden') {\n        return \"hidden\" /* PageState.HIDDEN */;\n    }\n    if (document.hasFocus()) {\n        return \"active\" /* PageState.ACTIVE */;\n    }\n    return \"passive\" /* PageState.PASSIVE */;\n}\n//# sourceMappingURL=pageStateHistory.js.map","import { INTAKE_SITE_STAGING, INTAKE_SITE_US1, INTAKE_SITE_EU1 } from '@datadog/browser-core';\nexport function getSessionReplayUrl(configuration, _a) {\n    var session = _a.session, viewContext = _a.viewContext, errorType = _a.errorType;\n    var sessionId = session ? session.id : 'no-session-id';\n    var parameters = [];\n    if (errorType !== undefined) {\n        parameters.push(\"error-type=\".concat(errorType));\n    }\n    if (viewContext) {\n        parameters.push(\"seed=\".concat(viewContext.id));\n        parameters.push(\"from=\".concat(viewContext.startClocks.timeStamp));\n    }\n    var origin = getDatadogSiteUrl(configuration);\n    var path = \"/rum/replay/sessions/\".concat(sessionId);\n    return \"\".concat(origin).concat(path, \"?\").concat(parameters.join('&'));\n}\nexport function getDatadogSiteUrl(rumConfiguration) {\n    var site = rumConfiguration.site;\n    var subdomain = rumConfiguration.subdomain || getSiteDefaultSubdomain(rumConfiguration);\n    return \"https://\".concat(subdomain ? \"\".concat(subdomain, \".\") : '').concat(site);\n}\nfunction getSiteDefaultSubdomain(configuration) {\n    switch (configuration.site) {\n        case INTAKE_SITE_US1:\n        case INTAKE_SITE_EU1:\n            return 'app';\n        case INTAKE_SITE_STAGING:\n            return 'dd';\n        default:\n            return undefined;\n    }\n}\n//# sourceMappingURL=getSessionReplayUrl.js.map","export var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport var NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport 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 MouseInteractionType = {\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 MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","import { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=assembly.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 { isElementNode, getParentNode, isTextNode } from '@datadog/browser-rum-core';\nimport { 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;\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 parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel) : 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 (!isElementNode(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 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 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        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/**\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        // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n        (/preload|prefetch/i.test(relAttribute) && 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//# sourceMappingURL=privacy.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot } from '@datadog/browser-rum-core';\nimport { 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) && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\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}\nexport var URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport var ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport var DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, function (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) {\n        var url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        var quote = singleQuote || doubleQuote || '';\n        return \"url(\".concat(quote).concat(makeUrlAbsolute(url, cssHref)).concat(quote, \")\");\n    });\n}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_) {\n        return url;\n    }\n}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function 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}\n//# sourceMappingURL=serializationUtils.js.map","export function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map(function (cssStyleSheet) {\n        var rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        var cssRules = Array.from(rules, function (cssRule) { return cssRule.cssText; });\n        var styleSheet = {\n            cssRules: cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializeStyleSheets.js.map","import { startsWith } from '@datadog/browser-core';\nimport { STABLE_ATTRIBUTES } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK } from '../../../constants';\nimport { MAX_ATTRIBUTE_VALUE_CHAR_LENGTH } from '../privacy';\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\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        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\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 && startsWith(attributeName, 'data-')) {\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}\n//# sourceMappingURL=serializeAttribute.js.map","import { ExperimentalFeature, isExperimentalFeatureEnabled, isSafari } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { shouldMaskNode } from '../privacy';\nimport { getElementInputValue, switchToAbsoluteUrl, getValidTagName } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeAttributes(element, nodePrivacyLevel, options) {\n    var _a;\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, options.configuration);\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 && !isExperimentalFeatureEnabled(ExperimentalFeature.DISABLE_REPLAY_INLINE_CSS)) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\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            delete safeAttrs.checked;\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 only for full snapshot\n     */\n    var scrollTop;\n    var scrollLeft;\n    var serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop: scrollTop, scrollLeft: scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                (_a = serializationContext.elementsScrollPositions.get(element), scrollTop = _a.scrollTop, scrollLeft = _a.scrollLeft);\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\nexport function getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    var rules;\n    try {\n        rules = cssStyleSheet.rules || cssStyleSheet.cssRules;\n    }\n    catch (_a) {\n        // if css is protected by CORS we cannot access cssRules see: https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface\n    }\n    if (!rules) {\n        return null;\n    }\n    var styleSheetCssText = Array.from(rules, isSafari() ? getCssRuleStringForSafari : getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleStringForSafari(rule) {\n    // Safari does not escape attribute selectors containing : properly\n    // https://bugs.webkit.org/show_bug.cgi?id=184604\n    if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\n        // This regex replaces [foo:bar] by [foo\\\\:bar]\n        var escapeColon = /(\\[[\\w-]+[^\\\\])(:[^\\]]+\\])/g;\n        return rule.cssText.replace(escapeColon, '$1\\\\$2');\n    }\n    return getCssRuleString(rule);\n}\nfunction getCssRuleString(rule) {\n    // If it's an @import rule, try to inline sub-rules recursively with `getCssRulesString`. This\n    // operation can fail if the imported stylesheet is protected by CORS, in which case we fallback\n    // to the @import rule CSS text.\n    return (isCSSImportRule(rule) && getCssRulesString(rule.styleSheet)) || rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { isNodeShadowRoot, hasChildNodes, forEachChildNodes } from '@datadog/browser-rum-core';\nimport { assign } from '@datadog/browser-core';\nimport { NodeType } from '../../../types';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN } from '../../../constants';\nimport { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent } from '../privacy';\nimport { getSerializedNodeId, getValidTagName, setSerializedNodeId } from './serializationUtils';\nimport { serializeStyleSheets } from './serializeStyleSheets';\nimport { serializeAttributes } from './serializeAttributes';\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}\nvar _nextId = 1;\nexport function generateNextId() {\n    return _nextId++;\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    forEachChildNodes(node, function (childNode) {\n        var serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(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: NodeType.Document,\n        childNodes: serializeChildNodes(document, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentFragmentNode(element, options) {\n    var isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: serializeChildNodes(element, options),\n        isShadowRoot: isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option 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 */\nfunction 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: NodeType.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 = serializeAttributes(element, nodePrivacyLevel, options);\n    var childNodes = [];\n    if (hasChildNodes(element) &&\n        // Do not serialize style children as the css rules are already in the _cssText attribute\n        tagName !== 'style') {\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: NodeType.Element,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\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 textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent: textContent,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.js.map","import { serializeNodeWithId } from './serializeNode';\nexport function serializeDocument(document, configuration, serializationContext) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        serializationContext: serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration: configuration,\n    });\n}\n//# sourceMappingURL=serializeDocument.js.map","import { isNodeShadowHost } from '@datadog/browser-rum-core';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=eventsUtils.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(visualViewport) {\n    return (Math.abs(visualViewport.pageTop - visualViewport.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visualViewport.pageLeft - visualViewport.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visualViewport = window.visualViewport;\n    var normalized = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visualViewport) {\n        // On old browsers, we cannot normalize, so fallback to clientX/Y\n        return normalized;\n    }\n    else if (isVisualViewportFactoredIn(visualViewport)) {\n        // Typically Mobile Devices\n        normalized.layoutViewportX = Math.round(clientX + visualViewport.offsetLeft);\n        normalized.layoutViewportY = Math.round(clientY + visualViewport.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalized.visualViewportX = Math.round(clientX - visualViewport.offsetLeft);\n        normalized.visualViewportY = Math.round(clientY - visualViewport.offsetTop);\n    }\n    return normalized;\n};\nexport var getVisualViewport = function (visualViewport) { return ({\n    scale: visualViewport.scale,\n    offsetLeft: visualViewport.offsetLeft,\n    offsetTop: visualViewport.offsetTop,\n    pageLeft: visualViewport.pageLeft,\n    pageTop: visualViewport.pageTop,\n    height: visualViewport.height,\n    width: visualViewport.width,\n}); };\n//# sourceMappingURL=viewports.js.map","import { addEventListeners, addTelemetryDebug, throttle } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget, isTouchEvent } from '../eventsUtils';\nimport { convertMouseEventToLayoutCoordinates } from '../viewports';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function initMoveObserver(configuration, cb) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\n            };\n            cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove);\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }).throttled;\n    return addEventListeners(configuration, document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nexport function tryToComputeCoordinates(event) {\n    var _a = isTouchEvent(event) ? event.changedTouches[0] : event, x = _a.clientX, y = _a.clientY;\n    if (window.visualViewport) {\n        var _b = convertMouseEventToLayoutCoordinates(x, y), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        if (event.isTrusted) {\n            addTelemetryDebug('mouse/touch event without x/y');\n        }\n        return undefined;\n    }\n    return { x: x, y: y };\n}\n//# sourceMappingURL=moveObserver.js.map","import { throttle, addEventListener } from '@datadog/browser-core';\nimport { getScrollX, getScrollY } from '@datadog/browser-rum-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { NodePrivacyLevel } from '../../../constants';\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nexport function initScrollObserver(configuration, cb, defaultPrivacyLevel, elementsScrollPositions) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        cb({\n            id: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        });\n    }, SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(configuration, document, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, { capture: true, passive: true })\n        .stop;\n}\n//# sourceMappingURL=scrollObserver.js.map","var _a;\nimport { assign, addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { IncrementalSource, MouseInteractionType } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { tryToComputeCoordinates } from './moveObserver';\nvar eventTypeToMouseInteraction = (_a = {},\n    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    _a[\"pointerup\" /* DOM_EVENT.POINTER_UP */] = MouseInteractionType.MouseUp,\n    _a[\"mousedown\" /* DOM_EVENT.MOUSE_DOWN */] = MouseInteractionType.MouseDown,\n    _a[\"click\" /* DOM_EVENT.CLICK */] = MouseInteractionType.Click,\n    _a[\"contextmenu\" /* DOM_EVENT.CONTEXT_MENU */] = MouseInteractionType.ContextMenu,\n    _a[\"dblclick\" /* DOM_EVENT.DBL_CLICK */] = MouseInteractionType.DblClick,\n    _a[\"focus\" /* DOM_EVENT.FOCUS */] = MouseInteractionType.Focus,\n    _a[\"blur\" /* DOM_EVENT.BLUR */] = MouseInteractionType.Blur,\n    _a[\"touchstart\" /* DOM_EVENT.TOUCH_START */] = MouseInteractionType.TouchStart,\n    _a[\"touchend\" /* DOM_EVENT.TOUCH_END */] = MouseInteractionType.TouchEnd,\n    _a);\nexport function initMouseInteractionObserver(configuration, cb, recordIds) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var type = eventTypeToMouseInteraction[event.type];\n        var interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id: id, type: type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id: id, type: type };\n        }\n        var record = assign({ id: recordIds.getIdForEvent(event) }, assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction));\n        cb(record);\n    };\n    return addEventListeners(configuration, document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\n//# sourceMappingURL=mouseInteractionObserver.js.map","import { instrumentSetter, assign, addEventListeners, forEach, noop, cssEscape } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel, shouldMaskNode } from '../privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initInputObserver(configuration, cb, target) {\n    if (target === void 0) { target = document; }\n    var defaultPrivacyLevel = configuration.defaultPrivacyLevel;\n    var lastInputStateMap = new WeakMap();\n    var isShadowRoot = target !== document;\n    var stopEventListeners = addEventListeners(configuration, target, \n    // The 'input' event bubbles across shadow roots, so we don't have to listen for it on shadow\n    // roots since it will be handled by the event listener that we did add to the document. Only\n    // the 'change' event is blocked and needs to be handled on shadow roots.\n    isShadowRoot ? [\"change\" /* DOM_EVENT.CHANGE */] : [\"input\" /* DOM_EVENT.INPUT */, \"change\" /* DOM_EVENT.CHANGE */], function (event) {\n        var target = getEventTarget(event);\n        if (target instanceof HTMLInputElement ||\n            target instanceof HTMLTextAreaElement ||\n            target instanceof HTMLSelectElement) {\n            onElementChange(target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    }).stop;\n    var stopPropertySetterInstrumentation;\n    if (!isShadowRoot) {\n        var instrumentationStoppers_1 = [\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        stopPropertySetterInstrumentation = function () {\n            instrumentationStoppers_1.forEach(function (stopper) { return stopper.stop(); });\n        };\n    }\n    else {\n        stopPropertySetterInstrumentation = noop;\n    }\n    return function () {\n        stopPropertySetterInstrumentation();\n        stopEventListeners();\n    };\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(cssEscape(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}\n//# sourceMappingURL=inputObserver.js.map","import { instrumentMethodAndCallOriginal } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initStyleSheetObserver(cb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    var instrumentationStoppers = [\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n            before: function (rule, index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, adds: [{ rule: rule, index: index }] }); });\n            },\n        }),\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n            before: function (index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, removes: [{ index: index }] }); });\n            },\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethodAndCallOriginal(cls.prototype, 'insertRule', {\n            before: function (rule, index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index || 0);\n                        cb({ id: id, adds: [{ rule: rule, index: path }] });\n                    }\n                });\n            },\n        }), instrumentMethodAndCallOriginal(cls.prototype, 'deleteRule', {\n            before: function (index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index);\n                        cb({ id: id, removes: [{ index: path }] });\n                    }\n                });\n            },\n        }));\n    }\n    return function () { return instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); }); };\n}\nexport function getPathToNestedCSSRule(rule) {\n    var path = [];\n    var currentRule = rule;\n    while (currentRule.parentRule) {\n        var rules_1 = Array.from(currentRule.parentRule.cssRules);\n        var index_1 = rules_1.indexOf(currentRule);\n        path.unshift(index_1);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    var rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    var index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=styleSheetObserver.js.map","import { noop, monitor } 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/**\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 efficiently.\n *\n * Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.\n */\nfunction requestIdleCallback(callback, opts) {\n    if (window.requestIdleCallback && window.cancelIdleCallback) {\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}\n//# sourceMappingURL=mutationBatch.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { isNodeShadowHost, getMutationObserverConstructor, getParentNode, forEachChildNodes, } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { getNodePrivacyLevel, getTextContent } from '../privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, serializeNodeWithId, serializeAttribute, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function initMutationObserver(mutationCallback, configuration, shadowRootsController, target) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: function () {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController) {\n    mutations\n        .filter(function (mutation) { return mutation.type === 'childList'; })\n        .forEach(function (mutation) {\n        mutation.removedNodes.forEach(function (removedNode) {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\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 mutation.target.isConnected &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController), 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    }), configuration);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration);\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, configuration, shadowRootsController) {\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        mutation.addedNodes.forEach(function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach(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, configuration.defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* SerializationContextStatus.MUTATION */, shadowRootsController: shadowRootsController },\n            configuration: configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        var parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(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, configuration) {\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(getParentNode(mutation.target), configuration.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, configuration) {\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, configuration.defaultPrivacyLevel);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\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 (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}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    forEachChildNodes(removedNode, function (childNode) { return traverseRemovedShadowDom(childNode, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=mutationObserver.js.map","import { initMoveObserver } from './moveObserver';\nimport { initScrollObserver } from './scrollObserver';\nimport { initMouseInteractionObserver } from './mouseInteractionObserver';\nimport { initInputObserver } from './inputObserver';\nimport { initStyleSheetObserver } from './styleSheetObserver';\nimport { initMediaInteractionObserver } from './mediaInteractionObserver';\nimport { initFrustrationObserver } from './frustrationObserver';\nimport { initViewportResizeObserver, initVisualViewportResizeObserver } from './viewportResizeObserver';\nimport { initMutationObserver } from './mutationObserver';\nimport { initFocusObserver } from './focusObserver';\nimport { initRecordIds } from './recordIds';\nexport function initObservers(configuration, o) {\n    var recordIds = initRecordIds();\n    var mutationHandler = initMutationObserver(o.mutationCb, o.configuration, o.shadowRootsController, document);\n    var mousemoveHandler = initMoveObserver(configuration, o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(configuration, o.mouseInteractionCb, recordIds);\n    var scrollHandler = initScrollObserver(configuration, o.scrollCb, o.configuration.defaultPrivacyLevel, o.elementsScrollPositions);\n    var viewportResizeHandler = initViewportResizeObserver(configuration, o.viewportResizeCb);\n    var inputHandler = initInputObserver(configuration, o.inputCb);\n    var mediaInteractionHandler = initMediaInteractionObserver(configuration, o.mediaInteractionCb, o.configuration.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetCb);\n    var focusHandler = initFocusObserver(configuration, o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(configuration, o.visualViewportResizeCb);\n    var frustrationHandler = initFrustrationObserver(o.lifeCycle, o.frustrationCb, recordIds);\n    return {\n        flush: function () {\n            mutationHandler.flush();\n        },\n        stop: function () {\n            mutationHandler.stop();\n            mousemoveHandler();\n            mouseInteractionHandler();\n            scrollHandler();\n            viewportResizeHandler();\n            inputHandler();\n            mediaInteractionHandler();\n            styleSheetObserver();\n            focusHandler();\n            visualViewportResizeHandler();\n            frustrationHandler();\n        },\n    };\n}\n//# sourceMappingURL=observers.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../../constants';\nimport { MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getNodePrivacyLevel } from '../privacy';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nexport function initMediaInteractionObserver(configuration, mediaInteractionCb, defaultPrivacyLevel) {\n    return addEventListeners(configuration, document, [\"play\" /* DOM_EVENT.PLAY */, \"pause\" /* DOM_EVENT.PAUSE */], function (event) {\n        var target = getEventTarget(event);\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\" /* DOM_EVENT.PLAY */ ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        });\n    }, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\n//# sourceMappingURL=mediaInteractionObserver.js.map","import { addEventListeners } from '@datadog/browser-core';\nexport function initFocusObserver(configuration, focusCb) {\n    return addEventListeners(configuration, window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], function () {\n        focusCb({ has_focus: document.hasFocus() });\n    }).stop;\n}\n//# sourceMappingURL=focusObserver.js.map","export function initRecordIds() {\n    var recordIds = new WeakMap();\n    var nextId = 1;\n    return {\n        getIdForEvent: function (event) {\n            if (!recordIds.has(event)) {\n                recordIds.set(event, nextId++);\n            }\n            return recordIds.get(event);\n        },\n    };\n}\n//# sourceMappingURL=recordIds.js.map","import { throttle, addEventListeners, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { getVisualViewport } from '../viewports';\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function initViewportResizeObserver(configuration, cb) {\n    return initViewportObservable(configuration).subscribe(cb).unsubscribe;\n}\nexport function initVisualViewportResizeObserver(configuration, cb) {\n    var visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return noop;\n    }\n    var _a = throttle(function () {\n        cb(getVisualViewport(visualViewport));\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(configuration, visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return function stop() {\n        removeListener();\n        cancelThrottle();\n    };\n}\n//# sourceMappingURL=viewportResizeObserver.js.map","import { RecordType } from '../../../types';\nexport function initFrustrationObserver(lifeCycle, frustrationCb, recordIds) {\n    return lifeCycle.subscribe(10 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, function (data) {\n        var _a, _b, _c;\n        if (data.rawRumEvent.type === \"action\" /* RumEventType.ACTION */ &&\n            data.rawRumEvent.action.type === \"click\" /* ActionType.CLICK */ &&\n            ((_b = (_a = data.rawRumEvent.action.frustration) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.length) &&\n            'events' in data.domainContext &&\n            ((_c = data.domainContext.events) === null || _c === void 0 ? void 0 : _c.length)) {\n            frustrationCb({\n                timestamp: data.rawRumEvent.date,\n                type: RecordType.FrustrationRecord,\n                data: {\n                    frustrationTypes: data.rawRumEvent.action.frustration.type,\n                    recordIds: data.domainContext.events.map(function (e) { return recordIds.getIdForEvent(e); }),\n                },\n            });\n        }\n    }).unsubscribe;\n}\n//# sourceMappingURL=frustrationObserver.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { getViewportDimension, getScrollX, getScrollY } from '@datadog/browser-rum-core';\nimport { RecordType, IncrementalSource } from '../../types';\nimport { assembleIncrementalSnapshot } from './assembly';\nimport { serializeDocument } from './serialization';\nimport { initObservers } from './observers';\nimport { getVisualViewport } from './viewports';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nexport function record(options) {\n    var emit = options.emit, configuration = options.configuration;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var elementsScrollPositions = createElementsScrollPositions();\n    var mutationCb = function (mutation) {\n        emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, mutation));\n    };\n    var inputCb = function (s) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, s)); };\n    var shadowRootsController = initShadowRootsController(configuration, { mutationCb: mutationCb, inputCb: inputCb });\n    var takeFullSnapshot = function (timestamp, serializationContext) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        if (serializationContext === void 0) { serializationContext = {\n            status: 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n            shadowRootsController: shadowRootsController,\n        }; }\n        var _a = getViewportDimension(), width = _a.width, height = _a.height;\n        emit({\n            data: {\n                height: height,\n                href: window.location.href,\n                width: width,\n            },\n            type: RecordType.Meta,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                node: serializeDocument(document, configuration, serializationContext),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n            timestamp: timestamp,\n        });\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n    };\n    takeFullSnapshot();\n    var _a = initObservers(configuration, {\n        lifeCycle: options.lifeCycle,\n        configuration: configuration,\n        elementsScrollPositions: elementsScrollPositions,\n        inputCb: inputCb,\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (mouseInteractionRecord) { return emit(mouseInteractionRecord); },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: mutationCb,\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        frustrationCb: function (frustrationRecord) { return emit(frustrationRecord); },\n        focusCb: function (data) {\n            return emit({\n                data: data,\n                type: RecordType.Focus,\n                timestamp: timeStampNow(),\n            });\n        },\n        visualViewportResizeCb: function (data) {\n            emit({\n                data: data,\n                type: RecordType.VisualViewport,\n                timestamp: timeStampNow(),\n            });\n        },\n        shadowRootsController: shadowRootsController,\n    }), stopObservers = _a.stop, flushMutationsFromObservers = _a.flush;\n    function flushMutations() {\n        shadowRootsController.flush();\n        flushMutationsFromObservers();\n    }\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            stopObservers();\n        },\n        takeSubsequentFullSnapshot: function (timestamp) {\n            flushMutations();\n            takeFullSnapshot(timestamp, {\n                shadowRootsController: shadowRootsController,\n                status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n                elementsScrollPositions: elementsScrollPositions,\n            });\n        },\n        flushMutations: flushMutations,\n        shadowRootsController: shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    var scrollPositionsByElement = new WeakMap();\n    return {\n        set: function (element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get: function (element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has: function (element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { initInputObserver, initMutationObserver } from './observers';\nexport var initShadowRootsController = function (configuration, _a) {\n    var mutationCb = _a.mutationCb, inputCb = _a.inputCb;\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            var _a = initMutationObserver(mutationCb, configuration, shadowRootsController, shadowRoot), stopMutationObserver = _a.stop, flush = _a.flush;\n            // the change event no do bubble up across the shadow root, we have to listen on the shadow root\n            var stopInputObserver = initInputObserver(configuration, inputCb, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: flush,\n                stop: function () {\n                    stopMutationObserver();\n                    stopInputObserver();\n                },\n            });\n        },\n        removeShadowRoot: function (shadowRoot) {\n            var entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                // unidentified root cause: observed in some cases with shadow DOM added by browser extensions\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var stop = _a.stop;\n                return stop();\n            });\n        },\n        flush: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var flush = _a.flush;\n                return flush();\n            });\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.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, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\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 { assign, sendToExtension } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nvar Segment = /** @class */ (function () {\n    function Segment(encoder, context, creationReason) {\n        this.encoder = encoder;\n        var viewId = context.view.id;\n        this.metadata = assign({\n            start: Infinity,\n            end: -Infinity,\n            creation_reason: creationReason,\n            records_count: 0,\n            has_full_snapshot: false,\n            index_in_view: replayStats.getSegmentsCount(viewId),\n            source: 'browser',\n        }, context);\n        replayStats.addSegment(viewId);\n    }\n    Segment.prototype.addRecord = function (record, callback) {\n        var _a;\n        this.metadata.start = Math.min(this.metadata.start, record.timestamp);\n        this.metadata.end = Math.max(this.metadata.end, record.timestamp);\n        this.metadata.records_count += 1;\n        (_a = this.metadata).has_full_snapshot || (_a.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        sendToExtension('record', { record: record, segment: this.metadata });\n        replayStats.addRecord(this.metadata.view.id);\n        var prefix = this.metadata.records_count === 1 ? '{\"records\":[' : ',';\n        this.encoder.write(prefix + JSON.stringify(record), callback);\n    };\n    Segment.prototype.flush = function (callback) {\n        var _this = this;\n        if (this.metadata.records_count === 0) {\n            throw new Error('Empty segment flushed');\n        }\n        this.encoder.write(\"],\".concat(JSON.stringify(this.metadata).slice(1), \"\\n\"), function () {\n            replayStats.addWroteData(_this.metadata.view.id, _this.encoder.rawBytesCount);\n            callback(_this.metadata);\n        });\n        this.encoder.reset();\n    };\n    return Segment;\n}());\nexport { Segment };\n//# sourceMappingURL=segment.js.map","import { isPageExitReason, ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { Segment } from './segment';\nexport var SEGMENT_DURATION_LIMIT = 30 * ONE_SECOND;\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport var SEGMENT_BYTES_LIMIT = 60000;\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 many 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 bytes count 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, configuration, sessionManager, viewContexts, httpRequest, encoder) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(configuration.applicationId, sessionManager, viewContexts); }, httpRequest, encoder);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, encoder) {\n    var state = {\n        status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function () {\n        flushSegment('view_change');\n    }).unsubscribe;\n    var unsubscribePageExited = lifeCycle.subscribe(9 /* LifeCycleEventType.PAGE_EXITED */, function (pageExitEvent) {\n        flushSegment(pageExitEvent.reason);\n    }).unsubscribe;\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush(function (metadata) {\n                var payload = buildReplayPayload(encoder.encodedBytes, metadata, encoder.rawBytesCount);\n                if (isPageExitReason(flushReason)) {\n                    httpRequest.sendOnExit(payload);\n                }\n                else {\n                    httpRequest.send(payload);\n                }\n            });\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (flushReason !== 'stop') {\n            state = {\n                status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n                nextSegmentCreationReason: flushReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* SegmentCollectionStatus.Stopped */,\n            };\n        }\n    }\n    return {\n        addRecord: function (record) {\n            if (state.status === 2 /* SegmentCollectionStatus.Stopped */) {\n                return;\n            }\n            if (state.status === 0 /* SegmentCollectionStatus.WaitingForInitialRecord */) {\n                var context = getSegmentContext();\n                if (!context) {\n                    return;\n                }\n                state = {\n                    status: 1 /* SegmentCollectionStatus.SegmentPending */,\n                    segment: new Segment(encoder, context, state.nextSegmentCreationReason),\n                    expirationTimeoutId: setTimeout(function () {\n                        flushSegment('segment_duration_limit');\n                    }, SEGMENT_DURATION_LIMIT),\n                };\n            }\n            var segment = state.segment;\n            segment.addRecord(record, function () {\n                if (\n                // the written segment is still pending\n                state.status === 1 /* SegmentCollectionStatus.SegmentPending */ &&\n                    state.segment === segment &&\n                    encoder.encodedBytesCount > SEGMENT_BYTES_LIMIT) {\n                    flushSegment('segment_bytes_limit');\n                }\n            });\n        },\n        stop: function () {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewContexts) {\n    var session = sessionManager.findTrackedSession();\n    var viewContext = viewContexts.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.id,\n        },\n    };\n}\nexport function setSegmentBytesLimit(newSegmentBytesLimit) {\n    if (newSegmentBytesLimit === void 0) { newSegmentBytesLimit = 60000; }\n    SEGMENT_BYTES_LIMIT = newSegmentBytesLimit;\n}\n//# sourceMappingURL=segmentCollection.js.map","import { assign } from '@datadog/browser-core';\nexport function buildReplayPayload(data, metadata, rawSegmentBytesCount) {\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    var metadataAndSegmentSizes = assign({\n        raw_segment_size: rawSegmentBytesCount,\n        compressed_segment_size: data.byteLength,\n    }, metadata);\n    var serializedMetadataAndSegmentSizes = JSON.stringify(metadataAndSegmentSizes);\n    formData.append('event', new Blob([serializedMetadataAndSegmentSizes], { type: 'application/json' }));\n    return { data: formData, bytesCount: data.byteLength };\n}\n//# sourceMappingURL=buildReplayPayload.js.map","/**\n * Test for Browser features used while recording\n */\nexport function isBrowserSupported() {\n    return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' &&\n        typeof CSSSupportsRule === 'function' &&\n        typeof URL.createObjectURL === 'function' &&\n        'forEach' in NodeList.prototype);\n}\n//# sourceMappingURL=isBrowserSupported.js.map","import { getSessionReplayUrl } from '@datadog/browser-rum-core';\nimport { isBrowserSupported } from '../boot/isBrowserSupported';\nexport function getSessionReplayLink(configuration, sessionManager, viewContexts, isRecordingStarted) {\n    var session = sessionManager.findTrackedSession();\n    var errorType = getErrorType(session, isRecordingStarted);\n    var viewContext = viewContexts.findView();\n    return getSessionReplayUrl(configuration, {\n        viewContext: viewContext,\n        errorType: errorType,\n        session: session,\n    });\n}\nfunction getErrorType(session, isRecordingStarted) {\n    if (!isBrowserSupported()) {\n        return 'browser-not-supported';\n    }\n    if (!session) {\n        // possibilities:\n        // - rum sampled out\n        // - session expired (edge case)\n        return 'rum-not-tracked';\n    }\n    if (!session.sessionReplayAllowed) {\n        // possibilities\n        // - replay sampled out\n        return 'incorrect-session-plan';\n    }\n    if (!isRecordingStarted) {\n        return 'replay-not-started';\n    }\n}\n//# sourceMappingURL=getSessionReplayLink.js.map","import { addEventListener, addTelemetryDebug, concatBuffers } from '@datadog/browser-core';\nexport function createDeflateEncoder(configuration, worker, streamId) {\n    var rawBytesCount = 0;\n    var compressedData = [];\n    var compressedDataTrailer;\n    var nextWriteActionId = 0;\n    var pendingWriteActions = [];\n    var removeMessageListener = addEventListener(configuration, worker, 'message', function (_a) {\n        var data = _a.data;\n        if (data.type !== 'wrote' || data.streamId !== streamId) {\n            return;\n        }\n        var nextPendingAction = pendingWriteActions.shift();\n        if (nextPendingAction && nextPendingAction.id === data.id) {\n            if (data.id === 0) {\n                // Initial state\n                rawBytesCount = data.additionalBytesCount;\n                compressedData = [data.result];\n            }\n            else {\n                rawBytesCount += data.additionalBytesCount;\n                compressedData.push(data.result);\n            }\n            compressedDataTrailer = data.trailer;\n            nextPendingAction.callback();\n        }\n        else {\n            removeMessageListener();\n            addTelemetryDebug('Worker responses received out of order.');\n        }\n    }).stop;\n    return {\n        get encodedBytes() {\n            if (!compressedData.length) {\n                return new Uint8Array(0);\n            }\n            return concatBuffers(compressedData.concat(compressedDataTrailer));\n        },\n        get encodedBytesCount() {\n            if (!compressedData.length) {\n                return 0;\n            }\n            return compressedData.reduce(function (total, buffer) { return total + buffer.length; }, 0) + compressedDataTrailer.length;\n        },\n        get rawBytesCount() {\n            return rawBytesCount;\n        },\n        write: function (data, callback) {\n            worker.postMessage({\n                action: 'write',\n                id: nextWriteActionId,\n                data: data,\n                streamId: streamId,\n            });\n            pendingWriteActions.push({\n                id: nextWriteActionId,\n                callback: callback,\n            });\n            nextWriteActionId += 1;\n        },\n        reset: function () {\n            worker.postMessage({\n                action: 'reset',\n                streamId: streamId,\n            });\n            nextWriteActionId = 0;\n        },\n        stop: function () {\n            removeMessageListener();\n        },\n    };\n}\n//# sourceMappingURL=deflateEncoder.js.map","import { addTelemetryError, display, includes, addEventListener, setTimeout, ONE_SECOND } from '@datadog/browser-core';\nexport var INITIALIZATION_TIME_OUT_DELAY = 10 * ONE_SECOND;\nfunction createDeflateWorker(configuration) {\n    return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([\"!function(){\\\"use strict\\\";function t(t){for(var e=t.reduce((function(t,e){return t+e.length}),0),a=new Uint8Array(e),n=0,r=0,i=t;r<i.length;r++){var s=i[r];a.set(s,n),n+=s.length}return a}function e(t){for(var e=t.length;--e>=0;)t[e]=0}var a=256,n=286,r=30,i=15,s=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]),_=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]),h=new Uint8Array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]),l=new Uint8Array([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),o=new Array(576);e(o);var d=new Array(60);e(d);var u=new Array(512);e(u);var f=new Array(256);e(f);var c=new Array(29);e(c);var p,g,w,v=new Array(r);function b(t,e,a,n,r){this.static_tree=t,this.extra_bits=e,this.extra_base=a,this.elems=n,this.max_length=r,this.has_stree=t&&t.length}function m(t,e){this.dyn_tree=t,this.max_code=0,this.stat_desc=e}e(v);var y=function(t){return t<256?u[t]:u[256+(t>>>7)]},k=function(t,e){t.pending_buf[t.pending++]=255&e,t.pending_buf[t.pending++]=e>>>8&255},z=function(t,e,a){t.bi_valid>16-a?(t.bi_buf|=e<<t.bi_valid&65535,k(t,t.bi_buf),t.bi_buf=e>>16-t.bi_valid,t.bi_valid+=a-16):(t.bi_buf|=e<<t.bi_valid&65535,t.bi_valid+=a)},x=function(t,e,a){z(t,a[2*e],a[2*e+1])},A=function(t,e){var a=0;do{a|=1&t,t>>>=1,a<<=1}while(--e>0);return a>>>1},E=function(t,e,a){var n,r,s=new Array(16),_=0;for(n=1;n<=i;n++)s[n]=_=_+a[n-1]<<1;for(r=0;r<=e;r++){var h=t[2*r+1];0!==h&&(t[2*r]=A(s[h]++,h))}},Z=function(t){var e;for(e=0;e<n;e++)t.dyn_ltree[2*e]=0;for(e=0;e<r;e++)t.dyn_dtree[2*e]=0;for(e=0;e<19;e++)t.bl_tree[2*e]=0;t.dyn_ltree[512]=1,t.opt_len=t.static_len=0,t.last_lit=t.matches=0},U=function(t){t.bi_valid>8?k(t,t.bi_buf):t.bi_valid>0&&(t.pending_buf[t.pending++]=t.bi_buf),t.bi_buf=0,t.bi_valid=0},S=function(t,e,a,n){var r=2*e,i=2*a;return t[r]<t[i]||t[r]===t[i]&&n[e]<=n[a]},R=function(t,e,a){for(var n=t.heap[a],r=a<<1;r<=t.heap_len&&(r<t.heap_len&&S(e,t.heap[r+1],t.heap[r],t.depth)&&r++,!S(e,n,t.heap[r],t.depth));)t.heap[a]=t.heap[r],a=r,r<<=1;t.heap[a]=n},L=function(t,e,n){var r,i,h,l,o=0;if(0!==t.last_lit)do{r=t.pending_buf[t.d_buf+2*o]<<8|t.pending_buf[t.d_buf+2*o+1],i=t.pending_buf[t.l_buf+o],o++,0===r?x(t,i,e):(h=f[i],x(t,h+a+1,e),0!==(l=s[h])&&(i-=c[h],z(t,i,l)),r--,h=y(r),x(t,h,n),0!==(l=_[h])&&(r-=v[h],z(t,r,l)))}while(o<t.last_lit);x(t,256,e)},F=function(t,e){var a,n,r,s=e.dyn_tree,_=e.stat_desc.static_tree,h=e.stat_desc.has_stree,l=e.stat_desc.elems,o=-1;for(t.heap_len=0,t.heap_max=573,a=0;a<l;a++)0!==s[2*a]?(t.heap[++t.heap_len]=o=a,t.depth[a]=0):s[2*a+1]=0;for(;t.heap_len<2;)s[2*(r=t.heap[++t.heap_len]=o<2?++o:0)]=1,t.depth[r]=0,t.opt_len--,h&&(t.static_len-=_[2*r+1]);for(e.max_code=o,a=t.heap_len>>1;a>=1;a--)R(t,s,a);r=l;do{a=t.heap[1],t.heap[1]=t.heap[t.heap_len--],R(t,s,1),n=t.heap[1],t.heap[--t.heap_max]=a,t.heap[--t.heap_max]=n,s[2*r]=s[2*a]+s[2*n],t.depth[r]=(t.depth[a]>=t.depth[n]?t.depth[a]:t.depth[n])+1,s[2*a+1]=s[2*n+1]=r,t.heap[1]=r++,R(t,s,1)}while(t.heap_len>=2);t.heap[--t.heap_max]=t.heap[1],function(t,e){var a,n,r,s,_,h,l=e.dyn_tree,o=e.max_code,d=e.stat_desc.static_tree,u=e.stat_desc.has_stree,f=e.stat_desc.extra_bits,c=e.stat_desc.extra_base,p=e.stat_desc.max_length,g=0;for(s=0;s<=i;s++)t.bl_count[s]=0;for(l[2*t.heap[t.heap_max]+1]=0,a=t.heap_max+1;a<573;a++)(s=l[2*l[2*(n=t.heap[a])+1]+1]+1)>p&&(s=p,g++),l[2*n+1]=s,n>o||(t.bl_count[s]++,_=0,n>=c&&(_=f[n-c]),h=l[2*n],t.opt_len+=h*(s+_),u&&(t.static_len+=h*(d[2*n+1]+_)));if(0!==g){do{for(s=p-1;0===t.bl_count[s];)s--;t.bl_count[s]--,t.bl_count[s+1]+=2,t.bl_count[p]--,g-=2}while(g>0);for(s=p;0!==s;s--)for(n=t.bl_count[s];0!==n;)(r=t.heap[--a])>o||(l[2*r+1]!==s&&(t.opt_len+=(s-l[2*r+1])*l[2*r],l[2*r+1]=s),n--)}}(t,e),E(s,o,t.bl_count)},T=function(t,e,a){var n,r,i=-1,s=e[1],_=0,h=7,l=4;for(0===s&&(h=138,l=3),e[2*(a+1)+1]=65535,n=0;n<=a;n++)r=s,s=e[2*(n+1)+1],++_<h&&r===s||(_<l?t.bl_tree[2*r]+=_:0!==r?(r!==i&&t.bl_tree[2*r]++,t.bl_tree[32]++):_<=10?t.bl_tree[34]++:t.bl_tree[36]++,_=0,i=r,0===s?(h=138,l=3):r===s?(h=6,l=3):(h=7,l=4))},I=function(t,e,a){var n,r,i=-1,s=e[1],_=0,h=7,l=4;for(0===s&&(h=138,l=3),n=0;n<=a;n++)if(r=s,s=e[2*(n+1)+1],!(++_<h&&r===s)){if(_<l)do{x(t,r,t.bl_tree)}while(0!=--_);else 0!==r?(r!==i&&(x(t,r,t.bl_tree),_--),x(t,16,t.bl_tree),z(t,_-3,2)):_<=10?(x(t,17,t.bl_tree),z(t,_-3,3)):(x(t,18,t.bl_tree),z(t,_-11,7));_=0,i=r,0===s?(h=138,l=3):r===s?(h=6,l=3):(h=7,l=4)}},N=!1,O=function(t,e,a,n){z(t,0+(n?1:0),3),function(t,e,a,n){U(t),n&&(k(t,a),k(t,~a)),t.pending_buf.set(t.window.subarray(e,e+a),t.pending),t.pending+=a}(t,e,a,!0)},D=function(t,e,n,r){var i,s,_=0;t.level>0?(2===t.strm.data_type&&(t.strm.data_type=function(t){var e,n=4093624447;for(e=0;e<=31;e++,n>>>=1)if(1&n&&0!==t.dyn_ltree[2*e])return 0;if(0!==t.dyn_ltree[18]||0!==t.dyn_ltree[20]||0!==t.dyn_ltree[26])return 1;for(e=32;e<a;e++)if(0!==t.dyn_ltree[2*e])return 1;return 0}(t)),F(t,t.l_desc),F(t,t.d_desc),_=function(t){var e;for(T(t,t.dyn_ltree,t.l_desc.max_code),T(t,t.dyn_dtree,t.d_desc.max_code),F(t,t.bl_desc),e=18;e>=3&&0===t.bl_tree[2*l[e]+1];e--);return t.opt_len+=3*(e+1)+5+5+4,e}(t),i=t.opt_len+3+7>>>3,(s=t.static_len+3+7>>>3)<=i&&(i=s)):i=s=n+5,n+4<=i&&-1!==e?O(t,e,n,r):4===t.strategy||s===i?(z(t,2+(r?1:0),3),L(t,o,d)):(z(t,4+(r?1:0),3),function(t,e,a,n){var r;for(z(t,e-257,5),z(t,a-1,5),z(t,n-4,4),r=0;r<n;r++)z(t,t.bl_tree[2*l[r]+1],3);I(t,t.dyn_ltree,e-1),I(t,t.dyn_dtree,a-1)}(t,t.l_desc.max_code+1,t.d_desc.max_code+1,_+1),L(t,t.dyn_ltree,t.dyn_dtree)),Z(t),r&&U(t)},B={_tr_init:function(t){N||(!function(){var t,e,a,l,m,y=new Array(16);for(a=0,l=0;l<28;l++)for(c[l]=a,t=0;t<1<<s[l];t++)f[a++]=l;for(f[a-1]=l,m=0,l=0;l<16;l++)for(v[l]=m,t=0;t<1<<_[l];t++)u[m++]=l;for(m>>=7;l<r;l++)for(v[l]=m<<7,t=0;t<1<<_[l]-7;t++)u[256+m++]=l;for(e=0;e<=i;e++)y[e]=0;for(t=0;t<=143;)o[2*t+1]=8,t++,y[8]++;for(;t<=255;)o[2*t+1]=9,t++,y[9]++;for(;t<=279;)o[2*t+1]=7,t++,y[7]++;for(;t<=287;)o[2*t+1]=8,t++,y[8]++;for(E(o,287,y),t=0;t<r;t++)d[2*t+1]=5,d[2*t]=A(t,5);p=new b(o,s,257,n,i),g=new b(d,_,0,r,i),w=new b(new Array(0),h,0,19,7)}(),N=!0),t.l_desc=new m(t.dyn_ltree,p),t.d_desc=new m(t.dyn_dtree,g),t.bl_desc=new m(t.bl_tree,w),t.bi_buf=0,t.bi_valid=0,Z(t)},_tr_stored_block:O,_tr_flush_block:D,_tr_tally:function(t,e,n){return t.pending_buf[t.d_buf+2*t.last_lit]=e>>>8&255,t.pending_buf[t.d_buf+2*t.last_lit+1]=255&e,t.pending_buf[t.l_buf+t.last_lit]=255&n,t.last_lit++,0===e?t.dyn_ltree[2*n]++:(t.matches++,e--,t.dyn_ltree[2*(f[n]+a+1)]++,t.dyn_dtree[2*y(e)]++),t.last_lit===t.lit_bufsize-1},_tr_align:function(t){z(t,2,3),x(t,256,o),function(t){16===t.bi_valid?(k(t,t.bi_buf),t.bi_buf=0,t.bi_valid=0):t.bi_valid>=8&&(t.pending_buf[t.pending++]=255&t.bi_buf,t.bi_buf>>=8,t.bi_valid-=8)}(t)}},C=function(t,e,a,n){for(var r=65535&t|0,i=t>>>16&65535|0,s=0;0!==a;){a-=s=a>2e3?2e3:a;do{i=i+(r=r+e[n++]|0)|0}while(--s);r%=65521,i%=65521}return r|i<<16|0},H=new Uint32Array(function(){for(var t,e=[],a=0;a<256;a++){t=a;for(var n=0;n<8;n++)t=1&t?3988292384^t>>>1:t>>>1;e[a]=t}return e}()),M=function(t,e,a,n){var r=H,i=n+a;t^=-1;for(var s=n;s<i;s++)t=t>>>8^r[255&(t^e[s])];return-1^t},Y={2:\\\"need dictionary\\\",1:\\\"stream end\\\",0:\\\"\\\",\\\"-1\\\":\\\"file error\\\",\\\"-2\\\":\\\"stream error\\\",\\\"-3\\\":\\\"data error\\\",\\\"-4\\\":\\\"insufficient memory\\\",\\\"-5\\\":\\\"buffer error\\\",\\\"-6\\\":\\\"incompatible version\\\"},K={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8},P=B._tr_init,j=B._tr_stored_block,G=B._tr_flush_block,X=B._tr_tally,W=B._tr_align,q=K.Z_NO_FLUSH,J=K.Z_PARTIAL_FLUSH,Q=K.Z_FULL_FLUSH,V=K.Z_FINISH,$=K.Z_BLOCK,tt=K.Z_OK,et=K.Z_STREAM_END,at=K.Z_STREAM_ERROR,nt=K.Z_DATA_ERROR,rt=K.Z_BUF_ERROR,it=K.Z_DEFAULT_COMPRESSION,st=K.Z_FILTERED,_t=K.Z_HUFFMAN_ONLY,ht=K.Z_RLE,lt=K.Z_FIXED,ot=K.Z_DEFAULT_STRATEGY,dt=K.Z_UNKNOWN,ut=K.Z_DEFLATED,ft=258,ct=262,pt=103,gt=113,wt=666,vt=function(t,e){return t.msg=Y[e],e},bt=function(t){return(t<<1)-(t>4?9:0)},mt=function(t){for(var e=t.length;--e>=0;)t[e]=0},yt=function(t,e,a){return(e<<t.hash_shift^a)&t.hash_mask},kt=function(t){var e=t.state,a=e.pending;a>t.avail_out&&(a=t.avail_out),0!==a&&(t.output.set(e.pending_buf.subarray(e.pending_out,e.pending_out+a),t.next_out),t.next_out+=a,e.pending_out+=a,t.total_out+=a,t.avail_out-=a,e.pending-=a,0===e.pending&&(e.pending_out=0))},zt=function(t,e){G(t,t.block_start>=0?t.block_start:-1,t.strstart-t.block_start,e),t.block_start=t.strstart,kt(t.strm)},xt=function(t,e){t.pending_buf[t.pending++]=e},At=function(t,e){t.pending_buf[t.pending++]=e>>>8&255,t.pending_buf[t.pending++]=255&e},Et=function(t,e){var a,n,r=t.max_chain_length,i=t.strstart,s=t.prev_length,_=t.nice_match,h=t.strstart>t.w_size-ct?t.strstart-(t.w_size-ct):0,l=t.window,o=t.w_mask,d=t.prev,u=t.strstart+ft,f=l[i+s-1],c=l[i+s];t.prev_length>=t.good_match&&(r>>=2),_>t.lookahead&&(_=t.lookahead);do{if(l[(a=e)+s]===c&&l[a+s-1]===f&&l[a]===l[i]&&l[++a]===l[i+1]){i+=2,a++;do{}while(l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&l[++i]===l[++a]&&i<u);if(n=ft-(u-i),i=u-ft,n>s){if(t.match_start=e,s=n,n>=_)break;f=l[i+s-1],c=l[i+s]}}}while((e=d[e&o])>h&&0!=--r);return s<=t.lookahead?s:t.lookahead},Zt=function(t){var e,a,n,r,i,s,_,h,l,o,d=t.w_size;do{if(r=t.window_size-t.lookahead-t.strstart,t.strstart>=d+(d-ct)){t.window.set(t.window.subarray(d,d+d),0),t.match_start-=d,t.strstart-=d,t.block_start-=d,e=a=t.hash_size;do{n=t.head[--e],t.head[e]=n>=d?n-d:0}while(--a);e=a=d;do{n=t.prev[--e],t.prev[e]=n>=d?n-d:0}while(--a);r+=d}if(0===t.strm.avail_in)break;if(s=t.strm,_=t.window,h=t.strstart+t.lookahead,l=r,o=void 0,(o=s.avail_in)>l&&(o=l),a=0===o?0:(s.avail_in-=o,_.set(s.input.subarray(s.next_in,s.next_in+o),h),1===s.state.wrap?s.adler=C(s.adler,_,o,h):2===s.state.wrap&&(s.adler=M(s.adler,_,o,h)),s.next_in+=o,s.total_in+=o,o),t.lookahead+=a,t.lookahead+t.insert>=3)for(i=t.strstart-t.insert,t.ins_h=t.window[i],t.ins_h=yt(t,t.ins_h,t.window[i+1]);t.insert&&(t.ins_h=yt(t,t.ins_h,t.window[i+3-1]),t.prev[i&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=i,i++,t.insert--,!(t.lookahead+t.insert<3)););}while(t.lookahead<ct&&0!==t.strm.avail_in)},Ut=function(t,e){for(var a,n;;){if(t.lookahead<ct){if(Zt(t),t.lookahead<ct&&e===q)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=yt(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),0!==a&&t.strstart-a<=t.w_size-ct&&(t.match_length=Et(t,a)),t.match_length>=3)if(n=X(t,t.strstart-t.match_start,t.match_length-3),t.lookahead-=t.match_length,t.match_length<=t.max_lazy_match&&t.lookahead>=3){t.match_length--;do{t.strstart++,t.ins_h=yt(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart}while(0!=--t.match_length);t.strstart++}else t.strstart+=t.match_length,t.match_length=0,t.ins_h=t.window[t.strstart],t.ins_h=yt(t,t.ins_h,t.window[t.strstart+1]);else n=X(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++;if(n&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=t.strstart<2?t.strstart:2,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2},St=function(t,e){for(var a,n,r;;){if(t.lookahead<ct){if(Zt(t),t.lookahead<ct&&e===q)return 1;if(0===t.lookahead)break}if(a=0,t.lookahead>=3&&(t.ins_h=yt(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart),t.prev_length=t.match_length,t.prev_match=t.match_start,t.match_length=2,0!==a&&t.prev_length<t.max_lazy_match&&t.strstart-a<=t.w_size-ct&&(t.match_length=Et(t,a),t.match_length<=5&&(t.strategy===st||3===t.match_length&&t.strstart-t.match_start>4096)&&(t.match_length=2)),t.prev_length>=3&&t.match_length<=t.prev_length){r=t.strstart+t.lookahead-3,n=X(t,t.strstart-1-t.prev_match,t.prev_length-3),t.lookahead-=t.prev_length-1,t.prev_length-=2;do{++t.strstart<=r&&(t.ins_h=yt(t,t.ins_h,t.window[t.strstart+3-1]),a=t.prev[t.strstart&t.w_mask]=t.head[t.ins_h],t.head[t.ins_h]=t.strstart)}while(0!=--t.prev_length);if(t.match_available=0,t.match_length=2,t.strstart++,n&&(zt(t,!1),0===t.strm.avail_out))return 1}else if(t.match_available){if((n=X(t,0,t.window[t.strstart-1]))&&zt(t,!1),t.strstart++,t.lookahead--,0===t.strm.avail_out)return 1}else t.match_available=1,t.strstart++,t.lookahead--}return t.match_available&&(n=X(t,0,t.window[t.strstart-1]),t.match_available=0),t.insert=t.strstart<2?t.strstart:2,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2};function Rt(t,e,a,n,r){this.good_length=t,this.max_lazy=e,this.nice_length=a,this.max_chain=n,this.func=r}var Lt=[new Rt(0,0,0,0,(function(t,e){var a=65535;for(a>t.pending_buf_size-5&&(a=t.pending_buf_size-5);;){if(t.lookahead<=1){if(Zt(t),0===t.lookahead&&e===q)return 1;if(0===t.lookahead)break}t.strstart+=t.lookahead,t.lookahead=0;var n=t.block_start+a;if((0===t.strstart||t.strstart>=n)&&(t.lookahead=t.strstart-n,t.strstart=n,zt(t,!1),0===t.strm.avail_out))return 1;if(t.strstart-t.block_start>=t.w_size-ct&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):(t.strstart>t.block_start&&(zt(t,!1),t.strm.avail_out),1)})),new Rt(4,4,8,4,Ut),new Rt(4,5,16,8,Ut),new Rt(4,6,32,32,Ut),new Rt(4,4,16,16,St),new Rt(8,16,32,32,St),new Rt(8,16,128,128,St),new Rt(8,32,128,256,St),new Rt(32,128,258,1024,St),new Rt(32,258,258,4096,St)];function Ft(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=ut,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new Uint16Array(1146),this.dyn_dtree=new Uint16Array(122),this.bl_tree=new Uint16Array(78),mt(this.dyn_ltree),mt(this.dyn_dtree),mt(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new Uint16Array(16),this.heap=new Uint16Array(573),mt(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new Uint16Array(573),mt(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}var Tt=function(t){if(!t||!t.state)return vt(t,at);t.total_in=t.total_out=0,t.data_type=dt;var e=t.state;return e.pending=0,e.pending_out=0,e.wrap<0&&(e.wrap=-e.wrap),e.status=e.wrap?42:gt,t.adler=2===e.wrap?0:1,e.last_flush=q,P(e),tt},It=function(t){var e,a=Tt(t);return a===tt&&((e=t.state).window_size=2*e.w_size,mt(e.head),e.max_lazy_match=Lt[e.level].max_lazy,e.good_match=Lt[e.level].good_length,e.nice_match=Lt[e.level].nice_length,e.max_chain_length=Lt[e.level].max_chain,e.strstart=0,e.block_start=0,e.lookahead=0,e.insert=0,e.match_length=e.prev_length=2,e.match_available=0,e.ins_h=0),a},Nt=function(t,e,a,n,r,i){if(!t)return at;var s=1;if(e===it&&(e=6),n<0?(s=0,n=-n):n>15&&(s=2,n-=16),r<1||r>9||a!==ut||n<8||n>15||e<0||e>9||i<0||i>lt)return vt(t,at);8===n&&(n=9);var _=new Ft;return t.state=_,_.strm=t,_.wrap=s,_.gzhead=null,_.w_bits=n,_.w_size=1<<_.w_bits,_.w_mask=_.w_size-1,_.hash_bits=r+7,_.hash_size=1<<_.hash_bits,_.hash_mask=_.hash_size-1,_.hash_shift=~~((_.hash_bits+3-1)/3),_.window=new Uint8Array(2*_.w_size),_.head=new Uint16Array(_.hash_size),_.prev=new Uint16Array(_.w_size),_.lit_bufsize=1<<r+6,_.pending_buf_size=4*_.lit_bufsize,_.pending_buf=new Uint8Array(_.pending_buf_size),_.d_buf=1*_.lit_bufsize,_.l_buf=3*_.lit_bufsize,_.level=e,_.strategy=i,_.method=a,It(t)},Ot={deflateInit:function(t,e){return Nt(t,e,ut,15,8,ot)},deflateInit2:Nt,deflateReset:It,deflateResetKeep:Tt,deflateSetHeader:function(t,e){return t&&t.state?2!==t.state.wrap?at:(t.state.gzhead=e,tt):at},deflate:function(t,e){var a,n;if(!t||!t.state||e>$||e<0)return t?vt(t,at):at;var r=t.state;if(!t.output||!t.input&&0!==t.avail_in||r.status===wt&&e!==V)return vt(t,0===t.avail_out?rt:at);r.strm=t;var i=r.last_flush;if(r.last_flush=e,42===r.status)if(2===r.wrap)t.adler=0,xt(r,31),xt(r,139),xt(r,8),r.gzhead?(xt(r,(r.gzhead.text?1:0)+(r.gzhead.hcrc?2:0)+(r.gzhead.extra?4:0)+(r.gzhead.name?8:0)+(r.gzhead.comment?16:0)),xt(r,255&r.gzhead.time),xt(r,r.gzhead.time>>8&255),xt(r,r.gzhead.time>>16&255),xt(r,r.gzhead.time>>24&255),xt(r,9===r.level?2:r.strategy>=_t||r.level<2?4:0),xt(r,255&r.gzhead.os),r.gzhead.extra&&r.gzhead.extra.length&&(xt(r,255&r.gzhead.extra.length),xt(r,r.gzhead.extra.length>>8&255)),r.gzhead.hcrc&&(t.adler=M(t.adler,r.pending_buf,r.pending,0)),r.gzindex=0,r.status=69):(xt(r,0),xt(r,0),xt(r,0),xt(r,0),xt(r,0),xt(r,9===r.level?2:r.strategy>=_t||r.level<2?4:0),xt(r,3),r.status=gt);else{var s=ut+(r.w_bits-8<<4)<<8;s|=(r.strategy>=_t||r.level<2?0:r.level<6?1:6===r.level?2:3)<<6,0!==r.strstart&&(s|=32),s+=31-s%31,r.status=gt,At(r,s),0!==r.strstart&&(At(r,t.adler>>>16),At(r,65535&t.adler)),t.adler=1}if(69===r.status)if(r.gzhead.extra){for(a=r.pending;r.gzindex<(65535&r.gzhead.extra.length)&&(r.pending!==r.pending_buf_size||(r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),kt(t),a=r.pending,r.pending!==r.pending_buf_size));)xt(r,255&r.gzhead.extra[r.gzindex]),r.gzindex++;r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),r.gzindex===r.gzhead.extra.length&&(r.gzindex=0,r.status=73)}else r.status=73;if(73===r.status)if(r.gzhead.name){a=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),kt(t),a=r.pending,r.pending===r.pending_buf_size)){n=1;break}n=r.gzindex<r.gzhead.name.length?255&r.gzhead.name.charCodeAt(r.gzindex++):0,xt(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.gzindex=0,r.status=91)}else r.status=91;if(91===r.status)if(r.gzhead.comment){a=r.pending;do{if(r.pending===r.pending_buf_size&&(r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),kt(t),a=r.pending,r.pending===r.pending_buf_size)){n=1;break}n=r.gzindex<r.gzhead.comment.length?255&r.gzhead.comment.charCodeAt(r.gzindex++):0,xt(r,n)}while(0!==n);r.gzhead.hcrc&&r.pending>a&&(t.adler=M(t.adler,r.pending_buf,r.pending-a,a)),0===n&&(r.status=pt)}else r.status=pt;if(r.status===pt&&(r.gzhead.hcrc?(r.pending+2>r.pending_buf_size&&kt(t),r.pending+2<=r.pending_buf_size&&(xt(r,255&t.adler),xt(r,t.adler>>8&255),t.adler=0,r.status=gt)):r.status=gt),0!==r.pending){if(kt(t),0===t.avail_out)return r.last_flush=-1,tt}else if(0===t.avail_in&&bt(e)<=bt(i)&&e!==V)return vt(t,rt);if(r.status===wt&&0!==t.avail_in)return vt(t,rt);if(0!==t.avail_in||0!==r.lookahead||e!==q&&r.status!==wt){var _=r.strategy===_t?function(t,e){for(var a;;){if(0===t.lookahead&&(Zt(t),0===t.lookahead)){if(e===q)return 1;break}if(t.match_length=0,a=X(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++,a&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2}(r,e):r.strategy===ht?function(t,e){for(var a,n,r,i,s=t.window;;){if(t.lookahead<=ft){if(Zt(t),t.lookahead<=ft&&e===q)return 1;if(0===t.lookahead)break}if(t.match_length=0,t.lookahead>=3&&t.strstart>0&&(n=s[r=t.strstart-1])===s[++r]&&n===s[++r]&&n===s[++r]){i=t.strstart+ft;do{}while(n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&n===s[++r]&&r<i);t.match_length=ft-(i-r),t.match_length>t.lookahead&&(t.match_length=t.lookahead)}if(t.match_length>=3?(a=X(t,1,t.match_length-3),t.lookahead-=t.match_length,t.strstart+=t.match_length,t.match_length=0):(a=X(t,0,t.window[t.strstart]),t.lookahead--,t.strstart++),a&&(zt(t,!1),0===t.strm.avail_out))return 1}return t.insert=0,e===V?(zt(t,!0),0===t.strm.avail_out?3:4):t.last_lit&&(zt(t,!1),0===t.strm.avail_out)?1:2}(r,e):Lt[r.level].func(r,e);if(3!==_&&4!==_||(r.status=wt),1===_||3===_)return 0===t.avail_out&&(r.last_flush=-1),tt;if(2===_&&(e===J?W(r):e!==$&&(j(r,0,0,!1),e===Q&&(mt(r.head),0===r.lookahead&&(r.strstart=0,r.block_start=0,r.insert=0))),kt(t),0===t.avail_out))return r.last_flush=-1,tt}return e!==V?tt:r.wrap<=0?et:(2===r.wrap?(xt(r,255&t.adler),xt(r,t.adler>>8&255),xt(r,t.adler>>16&255),xt(r,t.adler>>24&255),xt(r,255&t.total_in),xt(r,t.total_in>>8&255),xt(r,t.total_in>>16&255),xt(r,t.total_in>>24&255)):(At(r,t.adler>>>16),At(r,65535&t.adler)),kt(t),r.wrap>0&&(r.wrap=-r.wrap),0!==r.pending?tt:et)},deflateEnd:function(t){if(!t||!t.state)return at;var e=t.state.status;return 42!==e&&69!==e&&73!==e&&91!==e&&e!==pt&&e!==gt&&e!==wt?vt(t,at):(t.state=null,e===gt?vt(t,nt):tt)},deflateSetDictionary:function(t,e){var a=e.length;if(!t||!t.state)return at;var n=t.state,r=n.wrap;if(2===r||1===r&&42!==n.status||n.lookahead)return at;if(1===r&&(t.adler=C(t.adler,e,a,0)),n.wrap=0,a>=n.w_size){0===r&&(mt(n.head),n.strstart=0,n.block_start=0,n.insert=0);var i=new Uint8Array(n.w_size);i.set(e.subarray(a-n.w_size,a),0),e=i,a=n.w_size}var s=t.avail_in,_=t.next_in,h=t.input;for(t.avail_in=a,t.next_in=0,t.input=e,Zt(n);n.lookahead>=3;){var l=n.strstart,o=n.lookahead-2;do{n.ins_h=yt(n,n.ins_h,n.window[l+3-1]),n.prev[l&n.w_mask]=n.head[n.ins_h],n.head[n.ins_h]=l,l++}while(--o);n.strstart=l,n.lookahead=2,Zt(n)}return n.strstart+=n.lookahead,n.block_start=n.strstart,n.insert=n.lookahead,n.lookahead=0,n.match_length=n.prev_length=2,n.match_available=0,t.next_in=_,t.input=h,t.avail_in=s,n.wrap=r,tt},deflateInfo:\\\"pako deflate (from Nodeca project)\\\"};for(var Dt=new Uint8Array(256),Bt=0;Bt<256;Bt++)Dt[Bt]=Bt>=252?6:Bt>=248?5:Bt>=240?4:Bt>=224?3:Bt>=192?2:1;Dt[254]=Dt[254]=1;var Ct=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg=\\\"\\\",this.state=null,this.data_type=2,this.adler=0},Ht=Object.prototype.toString,Mt=K.Z_NO_FLUSH,Yt=K.Z_SYNC_FLUSH,Kt=K.Z_FULL_FLUSH,Pt=K.Z_FINISH,jt=K.Z_OK,Gt=K.Z_STREAM_END,Xt=K.Z_DEFAULT_COMPRESSION,Wt=K.Z_DEFAULT_STRATEGY,qt=K.Z_DEFLATED;function Jt(){this.options={level:Xt,method:qt,chunkSize:16384,windowBits:15,memLevel:8,strategy:Wt};var t=this.options;t.raw&&t.windowBits>0?t.windowBits=-t.windowBits:t.gzip&&t.windowBits>0&&t.windowBits<16&&(t.windowBits+=16),this.err=0,this.msg=\\\"\\\",this.ended=!1,this.chunks=[],this.strm=new Ct,this.strm.avail_out=0;var e=Ot.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(e!==jt)throw new Error(Y[e]);if(t.header&&Ot.deflateSetHeader(this.strm,t.header),t.dictionary){var a;if(a=\\\"[object ArrayBuffer]\\\"===Ht.call(t.dictionary)?new Uint8Array(t.dictionary):t.dictionary,(e=Ot.deflateSetDictionary(this.strm,a))!==jt)throw new Error(Y[e]);this._dict_set=!0}}function Qt(t,e,a){try{t.postMessage({type:\\\"errored\\\",error:e,streamId:a})}catch(n){t.postMessage({type:\\\"errored\\\",error:String(e),streamId:a})}}function Vt(t){var e=t.strm.adler;return new Uint8Array([3,0,e>>>24&255,e>>>16&255,e>>>8&255,255&e])}Jt.prototype.push=function(t,e){var a,n,r=this.strm,i=this.options.chunkSize;if(this.ended)return!1;for(n=e===~~e?e:!0===e?Pt:Mt,\\\"[object ArrayBuffer]\\\"===Ht.call(t)?r.input=new Uint8Array(t):r.input=t,r.next_in=0,r.avail_in=r.input.length;;)if(0===r.avail_out&&(r.output=new Uint8Array(i),r.next_out=0,r.avail_out=i),(n===Yt||n===Kt)&&r.avail_out<=6)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else{if((a=Ot.deflate(r,n))===Gt)return r.next_out>0&&this.onData(r.output.subarray(0,r.next_out)),a=Ot.deflateEnd(this.strm),this.onEnd(a),this.ended=!0,a===jt;if(0!==r.avail_out){if(n>0&&r.next_out>0)this.onData(r.output.subarray(0,r.next_out)),r.avail_out=0;else if(0===r.avail_in)break}else this.onData(r.output)}return!0},Jt.prototype.onData=function(t){this.chunks.push(t)},Jt.prototype.onEnd=function(t){t===jt&&(this.result=function(t){for(var e=0,a=0,n=t.length;a<n;a++)e+=t[a].length;for(var r=new Uint8Array(e),i=0,s=0,_=t.length;i<_;i++){var h=t[i];r.set(h,s),s+=h.length}return r}(this.chunks)),this.chunks=[],this.err=t,this.msg=this.strm.msg},function(e){void 0===e&&(e=self);try{var a=new Map;e.addEventListener(\\\"message\\\",(function(n){try{var r=function(e,a){switch(a.action){case\\\"init\\\":return{type:\\\"initialized\\\",version:\\\"4.50.1\\\"};case\\\"write\\\":var n=e.get(a.streamId);n||(n=new Jt,e.set(a.streamId,n));var r=n.chunks.length,i=function(t){if(\\\"function\\\"==typeof TextEncoder&&TextEncoder.prototype.encode)return(new TextEncoder).encode(t);var e,a,n,r,i,s=t.length,_=0;for(r=0;r<s;r++)55296==(64512&(a=t.charCodeAt(r)))&&r+1<s&&56320==(64512&(n=t.charCodeAt(r+1)))&&(a=65536+(a-55296<<10)+(n-56320),r++),_+=a<128?1:a<2048?2:a<65536?3:4;for(e=new Uint8Array(_),i=0,r=0;i<_;r++)55296==(64512&(a=t.charCodeAt(r)))&&r+1<s&&56320==(64512&(n=t.charCodeAt(r+1)))&&(a=65536+(a-55296<<10)+(n-56320),r++),a<128?e[i++]=a:a<2048?(e[i++]=192|a>>>6,e[i++]=128|63&a):a<65536?(e[i++]=224|a>>>12,e[i++]=128|a>>>6&63,e[i++]=128|63&a):(e[i++]=240|a>>>18,e[i++]=128|a>>>12&63,e[i++]=128|a>>>6&63,e[i++]=128|63&a);return e}(a.data);return n.push(i,K.Z_SYNC_FLUSH),{type:\\\"wrote\\\",id:a.id,streamId:a.streamId,result:t(n.chunks.slice(r)),trailer:Vt(n),additionalBytesCount:i.length};case\\\"reset\\\":e.delete(a.streamId)}}(a,n.data);r&&e.postMessage(r)}catch(t){Qt(e,t,n.data&&\\\"streamId\\\"in n.data?n.data.streamId:void 0)}}))}catch(t){Qt(e,t)}}()}();\"])));\n}\nvar state = { status: 0 /* DeflateWorkerStatus.Nil */ };\nexport function startDeflateWorker(configuration, source, onInitializationFailure, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    if (state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        // doStartDeflateWorker updates the state to \"loading\" or \"error\"\n        doStartDeflateWorker(configuration, source, createDeflateWorkerImpl);\n    }\n    switch (state.status) {\n        case 1 /* DeflateWorkerStatus.Loading */:\n            state.initializationFailureCallbacks.push(onInitializationFailure);\n            return state.worker;\n        case 3 /* DeflateWorkerStatus.Initialized */:\n            return state.worker;\n    }\n}\nexport function resetDeflateWorkerState() {\n    if (state.status === 3 /* DeflateWorkerStatus.Initialized */ || state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state.stop();\n    }\n    state = { status: 0 /* DeflateWorkerStatus.Nil */ };\n}\nexport function getDeflateWorkerStatus() {\n    return state.status;\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(configuration, source, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker = createDeflateWorkerImpl(configuration);\n        var removeErrorListener_1 = addEventListener(configuration, worker, 'error', function (error) {\n            onError(configuration, source, error);\n        }).stop;\n        var removeMessageListener_1 = addEventListener(configuration, worker, 'message', function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored') {\n                onError(configuration, source, data.error, data.streamId);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(data.version);\n            }\n        }).stop;\n        worker.postMessage({ action: 'init' });\n        setTimeout(function () { return onTimeout(source); }, INITIALIZATION_TIME_OUT_DELAY);\n        var stop_1 = function () {\n            removeErrorListener_1();\n            removeMessageListener_1();\n        };\n        state = { status: 1 /* DeflateWorkerStatus.Loading */, worker: worker, stop: stop_1, initializationFailureCallbacks: [] };\n    }\n    catch (error) {\n        onError(configuration, source, error);\n    }\n}\nfunction onTimeout(source) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        display.error(\"\".concat(source, \" failed to start: a timeout occurred while initializing the Worker\"));\n        state.initializationFailureCallbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n}\nfunction onInitialized(version) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n        state = { status: 3 /* DeflateWorkerStatus.Initialized */, worker: state.worker, stop: state.stop, version: version };\n    }\n}\nfunction onError(configuration, source, error, streamId) {\n    if (state.status === 1 /* DeflateWorkerStatus.Loading */ || state.status === 0 /* DeflateWorkerStatus.Nil */) {\n        display.error(\"\".concat(source, \" failed to start: an error occurred while creating the Worker:\"), error);\n        if (error instanceof Event || (error instanceof Error && isMessageCspRelated(error.message))) {\n            var baseMessage = void 0;\n            if (configuration.workerUrl) {\n                baseMessage = \"Please make sure the Worker URL \".concat(configuration.workerUrl, \" is correct and CSP is correctly configured.\");\n            }\n            else {\n                baseMessage = 'Please make sure CSP is correctly configured.';\n            }\n            display.error(\"\".concat(baseMessage, \" See documentation at https://docs.datadoghq.com/integrations/content_security_policy_logs/#use-csp-with-real-user-monitoring-and-session-replay\"));\n        }\n        else {\n            addTelemetryError(error);\n        }\n        if (state.status === 1 /* DeflateWorkerStatus.Loading */) {\n            state.initializationFailureCallbacks.forEach(function (callback) { return callback(); });\n        }\n        state = { status: 2 /* DeflateWorkerStatus.Error */ };\n    }\n    else {\n        addTelemetryError(error, {\n            worker_version: state.status === 3 /* DeflateWorkerStatus.Initialized */ && state.version,\n            stream_id: streamId,\n        });\n    }\n}\nfunction isMessageCspRelated(message) {\n    return (includes(message, 'Content Security Policy') ||\n        // Related to `require-trusted-types-for` CSP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for\n        includes(message, \"requires 'TrustedScriptURL'\"));\n}\n//# sourceMappingURL=deflateWorker.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 { canUseEventBridge, noop, runOnReadyState } from '@datadog/browser-core';\nimport { getReplayStats as getReplayStatsImpl } from '../domain/replayStats';\nimport { getSessionReplayLink } from '../domain/getSessionReplayLink';\nimport { createDeflateEncoder, startDeflateWorker, getDeflateWorkerStatus, } from '../domain/deflate';\nimport { isBrowserSupported } from './isBrowserSupported';\nexport function makeRecorderApi(startRecordingImpl, createDeflateWorkerImpl) {\n    if (canUseEventBridge() || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n            getSessionReplayLink: function () { return undefined; },\n        };\n    }\n    var state = {\n        status: 0 /* RecorderStatus.Stopped */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* RecorderStatus.IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* RecorderStatus.Stopped */ };\n    };\n    return {\n        start: function () { return startStrategy(); },\n        stop: function () { return stopStrategy(); },\n        getSessionReplayLink: function (configuration, sessionManager, viewContexts) {\n            return getSessionReplayLink(configuration, sessionManager, viewContexts, state.status !== 0 /* RecorderStatus.Stopped */);\n        },\n        onRumStart: function (lifeCycle, configuration, sessionManager, viewContexts) {\n            lifeCycle.subscribe(7 /* LifeCycleEventType.SESSION_EXPIRED */, function () {\n                if (state.status === 2 /* RecorderStatus.Starting */ || state.status === 3 /* RecorderStatus.Started */) {\n                    stopStrategy();\n                    state = { status: 1 /* RecorderStatus.IntentToStart */ };\n                }\n            });\n            lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n                if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            startStrategy = function () {\n                var session = sessionManager.findTrackedSession();\n                if (!session || !session.sessionReplayAllowed) {\n                    state = { status: 1 /* RecorderStatus.IntentToStart */ };\n                    return;\n                }\n                if (state.status === 2 /* RecorderStatus.Starting */ || state.status === 3 /* RecorderStatus.Started */) {\n                    return;\n                }\n                state = { status: 2 /* RecorderStatus.Starting */ };\n                runOnReadyState(configuration, 'interactive', function () {\n                    if (state.status !== 2 /* RecorderStatus.Starting */) {\n                        return;\n                    }\n                    var worker = startDeflateWorker(configuration, 'Datadog Session Replay', function () {\n                        stopStrategy();\n                    }, createDeflateWorkerImpl);\n                    if (!worker) {\n                        state = {\n                            status: 0 /* RecorderStatus.Stopped */,\n                        };\n                        return;\n                    }\n                    var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewContexts, createDeflateEncoder(configuration, worker, 1 /* DeflateEncoderStreamId.REPLAY */)).stop;\n                    state = {\n                        status: 3 /* RecorderStatus.Started */,\n                        stopRecording: stopRecording,\n                    };\n                });\n            };\n            stopStrategy = function () {\n                if (state.status === 0 /* RecorderStatus.Stopped */) {\n                    return;\n                }\n                if (state.status === 3 /* RecorderStatus.Started */) {\n                    state.stopRecording();\n                }\n                state = {\n                    status: 0 /* RecorderStatus.Stopped */,\n                };\n            };\n            if (state.status === 1 /* RecorderStatus.IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () {\n            // The worker is started optimistically, meaning we could have started to record but its\n            // initialization fails a bit later. This could happen when:\n            // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari\n            // throw an exception when instantiating the worker, and IE doesn't care about CSP)\n            // * the browser fails to load the worker in case the workerUrl is used\n            // * an unexpected error occurs in the Worker before initialization, ex:\n            //   * a runtime exception collected by monitor()\n            //   * a syntax error notified by the browser via an error event\n            // * the worker is unresponsive for some reason and timeouts\n            //\n            // It is not expected to happen often. Nonetheless, the \"replayable\" status on RUM events is\n            // an important part of the Datadog App:\n            // * If we have a false positive (we set has_replay: true even if no replay data is present),\n            // we might display broken links to the Session Replay player.\n            // * If we have a false negative (we don't set has_replay: true even if replay data is\n            // available), it is less noticeable because no link will be displayed.\n            //\n            // Thus, it is better to have false negative, so let's make sure the worker is correctly\n            // initialized before advertizing that we are recording.\n            //\n            // In the future, when the compression worker will also be used for RUM data, this will be\n            // less important since no RUM event will be sent when the worker fails to initialize.\n            return getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ && state.status === 3 /* RecorderStatus.Started */;\n        },\n        getReplayStats: function (viewId) {\n            return getDeflateWorkerStatus() === 3 /* DeflateWorkerStatus.Initialized */ ? getReplayStatsImpl(viewId) : undefined;\n        },\n    };\n}\n//# sourceMappingURL=recorderApi.js.map","import { timeStampNow, createHttpRequest, addTelemetryDebug } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, encoder, httpRequest) {\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var replayRequest = httpRequest ||\n        createHttpRequest(configuration, configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    var _a = startSegmentCollection(lifeCycle, configuration, sessionManager, viewContexts, replayRequest, encoder), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    var _b = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n    }), stopRecording = _b.stop, takeSubsequentFullSnapshot = _b.takeSubsequentFullSnapshot, flushMutations = _b.flushMutations;\n    var unsubscribeViewEnded = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function () {\n        flushMutations();\n        addRecord({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    }).unsubscribe;\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        takeSubsequentFullSnapshot(view.startClocks.timeStamp);\n    }).unsubscribe;\n    return {\n        stop: function () {\n            unsubscribeViewEnded();\n            unsubscribeViewCreated();\n            stopRecording();\n            stopSegmentCollection();\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { noop, willSyntheticsInjectRum, assign, BoundedBuffer, createContextManager, deepClone, makePublicApi, monitor, clocksNow, timeStampNow, display, callMonitored, createHandlingStack, canUseEventBridge, checkUser, sanitizeUser, sanitize, createStoredContextManager, combine, } from '@datadog/browser-core';\nimport { validateAndBuildRumConfiguration } from '../domain/configuration';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nvar RUM_STORAGE_KEY = 'rum';\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(2 /* CustomerDataType.GlobalContext */);\n    var userContextManager = createContextManager(1 /* CustomerDataType.User */);\n    var getInternalContextStrategy = function () { return undefined; };\n    var getInitConfigurationStrategy = function () { return undefined; };\n    var stopSessionStrategy = noop;\n    var getSessionReplayLinkStrategy = 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 (options, startClocks) {\n        if (startClocks === void 0) { startClocks = clocksNow(); }\n        bufferApiCalls.add(function () { return startViewStrategy(options, startClocks); });\n    };\n    var addActionStrategy = function (action, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addActionStrategy(action, commonContext); });\n    };\n    var addErrorStrategy = function (providedError, commonContext) {\n        if (commonContext === void 0) { commonContext = buildCommonContext(globalContextManager, userContextManager, recorderApi); }\n        bufferApiCalls.add(function () { return addErrorStrategy(providedError, commonContext); });\n    };\n    var addFeatureFlagEvaluationStrategy = function (key, value) {\n        bufferApiCalls.add(function () { return addFeatureFlagEvaluationStrategy(key, value); });\n    };\n    function initRum(initConfiguration) {\n        if (!initConfiguration) {\n            display.error('Missing configuration');\n            return;\n        }\n        // This function should be available, regardless of initialization success.\n        getInitConfigurationStrategy = function () { return deepClone(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        var eventBridgeAvailable = canUseEventBridge();\n        if (eventBridgeAvailable) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        if (!canInitRum(initConfiguration)) {\n            return;\n        }\n        var configuration = validateAndBuildRumConfiguration(initConfiguration);\n        if (!configuration) {\n            return;\n        }\n        if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {\n            display.warn('No storage available for session. We will not send any data.');\n            return;\n        }\n        if (!configuration.trackViewsManually) {\n            doStartRum(initConfiguration, 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 (options) {\n                doStartRum(initConfiguration, configuration, options);\n            };\n            beforeInitCalls.drain();\n        }\n        isAlreadyInitialized = true;\n    }\n    function doStartRum(initConfiguration, configuration, initialViewOptions) {\n        if (initConfiguration.storeContextsAcrossPages) {\n            var beforeInitGlobalContext = globalContextManager.getContext();\n            globalContextManager = createStoredContextManager(configuration, RUM_STORAGE_KEY, 2 /* CustomerDataType.GlobalContext */);\n            globalContextManager.setContext(combine(globalContextManager.getContext(), beforeInitGlobalContext));\n            var beforeInitUserContext = userContextManager.getContext();\n            userContextManager = createStoredContextManager(configuration, RUM_STORAGE_KEY, 1 /* CustomerDataType.User */);\n            userContextManager.setContext(combine(userContextManager.getContext(), beforeInitUserContext));\n        }\n        var startRumResults = startRumImpl(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions);\n        getSessionReplayLinkStrategy = function () {\n            return recorderApi.getSessionReplayLink(configuration, startRumResults.session, startRumResults.viewContexts);\n        };\n        (startViewStrategy = startRumResults.startView, addActionStrategy = startRumResults.addAction, addErrorStrategy = startRumResults.addError, addTimingStrategy = startRumResults.addTiming, addFeatureFlagEvaluationStrategy = startRumResults.addFeatureFlagEvaluation, getInternalContextStrategy = startRumResults.getInternalContext, stopSessionStrategy = startRumResults.stopSession);\n        bufferApiCalls.drain();\n        recorderApi.onRumStart(startRumResults.lifeCycle, configuration, startRumResults.session, startRumResults.viewContexts);\n    }\n    var startView = monitor(function (options) {\n        var sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        startViewStrategy(sanitizedOptions);\n    });\n    var rumPublicApi = makePublicApi({\n        init: monitor(initRum),\n        /** @deprecated: use setGlobalContextProperty instead */\n        addRumGlobalContext: monitor(function (key, value) { return globalContextManager.add(key, value); }),\n        setGlobalContextProperty: monitor(function (key, value) { return globalContextManager.setContextProperty(key, value); }),\n        /** @deprecated: use removeGlobalContextProperty instead */\n        removeRumGlobalContext: monitor(function (key) { return globalContextManager.remove(key); }),\n        removeGlobalContextProperty: monitor(function (key) { return globalContextManager.removeContextProperty(key); }),\n        /** @deprecated: use getGlobalContext instead */\n        getRumGlobalContext: monitor(function () { return globalContextManager.get(); }),\n        getGlobalContext: monitor(function () { return globalContextManager.getContext(); }),\n        /** @deprecated: use setGlobalContext instead */\n        setRumGlobalContext: monitor(function (context) { return globalContextManager.set(context); }),\n        setGlobalContext: monitor(function (context) { return globalContextManager.setContext(context); }),\n        clearGlobalContext: monitor(function () { return globalContextManager.clearContext(); }),\n        getInternalContext: monitor(function (startTime) { return getInternalContextStrategy(startTime); }),\n        getInitConfiguration: monitor(function () { return getInitConfigurationStrategy(); }),\n        addAction: monitor(function (name, context) {\n            addActionStrategy({\n                name: sanitize(name),\n                context: sanitize(context),\n                startClocks: clocksNow(),\n                type: \"custom\" /* ActionType.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: sanitize(context),\n                    startClocks: clocksNow(),\n                });\n            });\n        },\n        addTiming: monitor(function (name, time) {\n            addTimingStrategy(sanitize(name), time);\n        }),\n        setUser: monitor(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n        }),\n        getUser: monitor(function () { return userContextManager.getContext(); }),\n        setUserProperty: monitor(function (key, property) {\n            var _a;\n            var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n            userContextManager.setContextProperty(key, sanitizedProperty);\n        }),\n        removeUserProperty: monitor(function (key) { return userContextManager.removeContextProperty(key); }),\n        /** @deprecated: renamed to clearUser */\n        removeUser: monitor(function () { return userContextManager.clearContext(); }),\n        clearUser: monitor(function () { return userContextManager.clearContext(); }),\n        startView: startView,\n        stopSession: monitor(function () {\n            stopSessionStrategy();\n        }),\n        startSessionReplayRecording: monitor(recorderApi.start),\n        stopSessionReplayRecording: monitor(recorderApi.stop),\n        /**\n         * This feature is currently in beta. For more information see the full [feature flag tracking guide](https://docs.datadoghq.com/real_user_monitoring/feature_flag_tracking/).\n         */\n        addFeatureFlagEvaluation: monitor(function (key, value) {\n            addFeatureFlagEvaluationStrategy(sanitize(key), sanitize(value));\n        }),\n        getSessionReplayLink: monitor(function () { return getSessionReplayLinkStrategy(); }),\n    });\n    return rumPublicApi;\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            sessionSampleRate: 100,\n        });\n    }\n}\n//# sourceMappingURL=rumPublicApi.js.map","import { catchUserErrors } from '../tools/catchUserErrors';\nimport { setDebugMode } from '../tools/monitor';\nimport { assign } from '../tools/utils/polyfills';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"4.50.1\",\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 { sendToExtension, createPageExitObservable, addTelemetryConfiguration, startTelemetry, canUseEventBridge, getEventBridge, addTelemetryDebug, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { startPerformanceCollection } from '../browser/performanceCollection';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewContexts } from '../domain/contexts/viewContexts';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/action/actionCollection';\nimport { startErrorCollection } from '../domain/error/errorCollection';\nimport { startLongTaskCollection } from '../domain/longTask/longTaskCollection';\nimport { startResourceCollection } from '../domain/resource/resourceCollection';\nimport { startViewCollection } from '../domain/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/contexts/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nimport { serializeRumConfiguration } from '../domain/configuration';\nimport { startFeatureFlagContexts } from '../domain/contexts/featureFlagContext';\nimport { startCustomerDataTelemetry } from '../domain/startCustomerDataTelemetry';\nimport { startPageStateHistory } from '../domain/contexts/pageStateHistory';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nimport { startDisplayContext } from '../domain/contexts/displayContext';\nexport function startRum(initConfiguration, configuration, recorderApi, globalContextManager, userContextManager, initialViewOptions) {\n    var cleanupTasks = [];\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (event) { return sendToExtension('rum', event); });\n    var telemetry = startRumTelemetry(configuration);\n    telemetry.setContextProvider(function () {\n        var _a, _b;\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 = viewContexts.findView()) === null || _b === void 0 ? void 0 : _b.id,\n            },\n            action: {\n                id: actionContexts.findActionId(),\n            },\n        });\n    });\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error: error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    var featureFlagContexts = startFeatureFlagContexts(lifeCycle);\n    var pageExitObservable = createPageExitObservable(configuration);\n    var pageExitSubscription = pageExitObservable.subscribe(function (event) {\n        lifeCycle.notify(9 /* LifeCycleEventType.PAGE_EXITED */, event);\n    });\n    cleanupTasks.push(function () { return pageExitSubscription.unsubscribe(); });\n    var session = !canUseEventBridge() ? startRumSessionManager(configuration, lifeCycle) : startRumSessionManagerStub();\n    if (!canUseEventBridge()) {\n        var batch_1 = startRumBatch(configuration, lifeCycle, telemetry.observable, reportError, pageExitObservable, session.expireObservable);\n        cleanupTasks.push(function () { return batch_1.stop(); });\n        startCustomerDataTelemetry(configuration, telemetry, lifeCycle, globalContextManager, userContextManager, featureFlagContexts, batch_1.flushObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(configuration, location);\n    var _a = startRumEventCollection(lifeCycle, configuration, location, session, locationChangeObservable, domMutationObservable, function () { return buildCommonContext(globalContextManager, userContextManager, recorderApi); }, reportError), viewContexts = _a.viewContexts, pageStateHistory = _a.pageStateHistory, urlContexts = _a.urlContexts, actionContexts = _a.actionContexts, addAction = _a.addAction, stopRumEventCollection = _a.stop;\n    cleanupTasks.push(stopRumEventCollection);\n    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration));\n    startLongTaskCollection(lifeCycle, session);\n    startResourceCollection(lifeCycle, configuration, session, pageStateHistory);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, featureFlagContexts, pageStateHistory, recorderApi, initialViewOptions), addTiming = _b.addTiming, startView = _b.startView, stopViewCollection = _b.stop;\n    cleanupTasks.push(stopViewCollection);\n    var addError = startErrorCollection(lifeCycle, configuration, pageStateHistory, featureFlagContexts).addError;\n    startRequestCollection(lifeCycle, configuration, session);\n    startPerformanceCollection(lifeCycle, configuration);\n    var internalContext = startInternalContext(configuration.applicationId, session, viewContexts, actionContexts, urlContexts);\n    return {\n        addAction: addAction,\n        addError: addError,\n        addTiming: addTiming,\n        addFeatureFlagEvaluation: featureFlagContexts.addFeatureFlagEvaluation,\n        startView: startView,\n        lifeCycle: lifeCycle,\n        viewContexts: viewContexts,\n        session: session,\n        stopSession: function () { return session.expire(); },\n        getInternalContext: internalContext.get,\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\nfunction startRumTelemetry(configuration) {\n    var telemetry = startTelemetry(\"browser-rum-sdk\" /* TelemetryService.RUM */, configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n    }\n    return telemetry;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, locationChangeObservable, domMutationObservable, buildCommonContext, reportError) {\n    var viewContexts = startViewContexts(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var pageStateHistory = startPageStateHistory(configuration);\n    var _a = startActionCollection(lifeCycle, domMutationObservable, configuration, pageStateHistory), addAction = _a.addAction, actionContexts = _a.actionContexts;\n    var displayContext = startDisplayContext(configuration);\n    startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, displayContext, buildCommonContext, reportError);\n    return {\n        viewContexts: viewContexts,\n        pageStateHistory: pageStateHistory,\n        urlContexts: urlContexts,\n        addAction: addAction,\n        actionContexts: actionContexts,\n        stop: function () {\n            displayContext.stop();\n            pageStateHistory.stop();\n            urlContexts.stop();\n            viewContexts.stop();\n            pageStateHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { warnIfCustomerDataLimitReached, throttle, jsonStringify, computeBytesCount, noop, isExperimentalFeatureEnabled, SESSION_TIME_OUT_DELAY, ValueHistory, ExperimentalFeature, } from '@datadog/browser-core';\nexport var FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport var BYTES_COMPUTATION_THROTTLING_DELAY = 200;\n/**\n * Start feature flag contexts\n *\n * Feature flag contexts follow the life of views.\n * A new context is added when a view is created and ended when the view is ended\n *\n * Note: we choose not to add a new context at each evaluation to save memory\n */\nexport function startFeatureFlagContexts(lifeCycle, computeBytesCountImpl) {\n    if (computeBytesCountImpl === void 0) { computeBytesCountImpl = computeBytesCount; }\n    if (!isExperimentalFeatureEnabled(ExperimentalFeature.FEATURE_FLAGS)) {\n        return {\n            findFeatureFlagEvaluations: function () { return undefined; },\n            getFeatureFlagBytesCount: function () { return 0; },\n            addFeatureFlagEvaluation: noop,\n            stop: noop,\n        };\n    }\n    var featureFlagContexts = new ValueHistory(FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY);\n    var bytesCountCache = 0;\n    var alreadyWarned = false;\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        featureFlagContexts.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        featureFlagContexts.add({}, startClocks.relative);\n        bytesCountCache = 0;\n    });\n    // Throttle the bytes computation to minimize the impact on performance.\n    // Especially useful if the user call addFeatureFlagEvaluation API synchronously multiple times in a row\n    var _a = throttle(function (context) {\n        bytesCountCache = computeBytesCountImpl(jsonStringify(context));\n        if (!alreadyWarned) {\n            alreadyWarned = warnIfCustomerDataLimitReached(bytesCountCache, 0 /* CustomerDataType.FeatureFlag */);\n        }\n    }, BYTES_COMPUTATION_THROTTLING_DELAY), computeBytesCountThrottled = _a.throttled, cancelPendingComputation = _a.cancel;\n    return {\n        findFeatureFlagEvaluations: function (startTime) { return featureFlagContexts.find(startTime); },\n        getFeatureFlagBytesCount: function () {\n            var currentContext = featureFlagContexts.find();\n            if (!currentContext) {\n                return 0;\n            }\n            return bytesCountCache;\n        },\n        addFeatureFlagEvaluation: function (key, value) {\n            var currentContext = featureFlagContexts.find();\n            if (currentContext) {\n                currentContext[key] = value;\n                computeBytesCountThrottled(currentContext);\n            }\n        },\n        stop: cancelPendingComputation,\n    };\n}\n//# sourceMappingURL=featureFlagContext.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRumEventBridge(lifeCycle) {\n    var bridge = getEventBridge();\n    lifeCycle.subscribe(11 /* LifeCycleEventType.RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { SESSION_TIME_OUT_DELAY, ValueHistory } from '@datadog/browser-core';\nexport var VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startViewContexts(lifeCycle) {\n    var viewContextHistory = new ValueHistory(VIEW_CONTEXT_TIME_OUT_DELAY);\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (view) {\n        viewContextHistory.add(buildViewContext(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(8 /* LifeCycleEventType.SESSION_RENEWED */, function () {\n        viewContextHistory.reset();\n    });\n    function buildViewContext(view) {\n        return {\n            service: view.service,\n            version: view.version,\n            id: view.id,\n            name: view.name,\n            startClocks: view.startClocks,\n        };\n    }\n    return {\n        findView: function (startTime) { return viewContextHistory.find(startTime); },\n        stop: function () {\n            viewContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=viewContexts.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, ValueHistory } 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 ValueHistory(URL_CONTEXT_TIME_OUT_DELAY);\n    var previousViewUrl;\n    lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        var viewUrl = location.href;\n        urlContextHistory.add(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.find();\n        if (current) {\n            var changeTime = relativeNow();\n            urlContextHistory.closeActive(changeTime);\n            urlContextHistory.add(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            url: url,\n            referrer: referrer,\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 { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable';\nexport function startDisplayContext(configuration) {\n    var viewport = getViewportDimension();\n    var unsubscribeViewport = initViewportObservable(configuration).subscribe(function (viewportDimension) {\n        viewport = viewportDimension;\n    }).unsubscribe;\n    return {\n        get: function () { return ({ viewport: viewport }); },\n        stop: unsubscribeViewport,\n    };\n}\n//# sourceMappingURL=displayContext.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nimport { RumPerformanceEntryType } from '../../browser/performanceCollection';\nexport function startLongTaskCollection(lifeCycle, sessionManager) {\n    lifeCycle.subscribe(0 /* LifeCycleEventType.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 !== RumPerformanceEntryType.LONG_TASK) {\n                break;\n            }\n            var session = sessionManager.findTrackedSession(entry.startTime);\n            if (!session || !session.longTaskAllowed) {\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\" /* RumEventType.LONG_TASK */,\n                _dd: {\n                    discarded: false,\n                },\n            };\n            lifeCycle.notify(10 /* LifeCycleEventType.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","/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(applicationId, sessionManager, viewContexts, actionContexts, urlContexts) {\n    return {\n        get: function (startTime) {\n            var viewContext = viewContexts.findView(startTime);\n            var urlContext = urlContexts.findUrl(startTime);\n            var session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                var actionId = actionContexts.findActionId(startTime);\n                return {\n                    application_id: applicationId,\n                    session_id: session.id,\n                    user_action: actionId ? { id: actionId } : undefined,\n                    view: { id: viewContext.id, name: viewContext.name, referrer: urlContext.referrer, url: urlContext.url },\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","import { datadogRum } from '@datadog/browser-rum';\nimport { isAxiosError } from 'axios';\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\n};\n\n// src/utils/isBrowser.ts\nfunction isBrowser() {\n  return typeof window !== \"undefined\";\n}\n\n// src/nextDatadogRumInit.ts\nvar nextConfig = (options) => {\n  var _a, _b;\n  return __spreadValues({\n    applicationId: process.env.NEXT_PUBLIC_DATADOG_APPLICATION_ID || \"Not Application Id\",\n    clientToken: process.env.NEXT_PUBLIC_DATADOG_CLIENT_TOKEN || \"Not Client Token\",\n    site: \"datadoghq.com\",\n    service: process.env.NEXT_PUBLIC_DATADOG_APPLICATION,\n    env: process.env.NEXT_PUBLIC_DATADOG_ENV,\n    version: options == null ? void 0 : options.packageVersion,\n    sessionSampleRate: (_a = options == null ? void 0 : options.sessionSampleRate) != null ? _a : 3,\n    sessionReplaySampleRate: (_b = options == null ? void 0 : options.sessionReplaySampleRate) != null ? _b : 20,\n    trackUserInteractions: true,\n    trackResources: true,\n    trackLongTasks: true,\n    defaultPrivacyLevel: \"mask-user-input\",\n    allowedTracingUrls: [\n      `${process.env.NEXT_PUBLIC_API_DOMAIN}`,\n      `${process.env.NEXT_PUBLIC_CDN_DOMAIN}`\n    ],\n    beforeSend: (options == null ? void 0 : options.beforeSend) ? options.beforeSend : (options == null ? void 0 : options.excludeAuthError) ? (event) => {\n      if (event.type === \"error\") {\n        const accessTokenExpired = event.error.message.includes(\"460\");\n        const accessTokenNotexist = event.error.message.includes(\"401\");\n        if (accessTokenExpired || accessTokenNotexist) {\n          return false;\n        }\n      }\n      return true;\n    } : void 0\n  }, options);\n};\nvar nextDatadogRumInit = (options) => {\n  if (isBrowser() && (options.applicationId || process.env.NEXT_PUBLIC_DATADOG_APPLICATION_ID)) {\n    if (process.env.NEXT_PUBLIC_MODE === \"development\" && process.env.NEXT_PUBLIC_LOCAL_MODE === \"true\") {\n      return;\n    }\n    const config = nextConfig(options);\n    datadogRum.init(config);\n    datadogRum.startSessionReplayRecording();\n  }\n};\nvar nextDatadogRumInit_default = nextDatadogRumInit;\nvar nuxtConfig = (options) => {\n  var _a, _b;\n  return __spreadValues({\n    applicationId: process.env.DATADOG_APPLICATION_ID || \"Not Application Id\",\n    clientToken: process.env.DATADOG_CLIENT_TOKEN || \"Not Client Token\",\n    site: \"datadoghq.com\",\n    service: process.env.DATADOG_APPLICATION,\n    env: process.env.DATADOG_ENV,\n    // Specify a version number to identify the deployed version of your application in Datadog\n    // version: '1.0.0',\n    version: options == null ? void 0 : options.packageVersion,\n    sessionSampleRate: (_a = options == null ? void 0 : options.sessionSampleRate) != null ? _a : 3,\n    sessionReplaySampleRate: (_b = options == null ? void 0 : options.sessionReplaySampleRate) != null ? _b : 20,\n    trackUserInteractions: true,\n    trackResources: true,\n    trackLongTasks: true,\n    allowedTracingUrls: [\n      `${process.env.API_DOMAIN}`,\n      `${process.env.VEHICLE_API_DOMAIN}`,\n      `${process.env.CDN_DOMAIN}`\n    ],\n    defaultPrivacyLevel: \"mask-user-input\",\n    traceSampleRate: 100\n  }, options);\n};\nvar nuxtDatadogRumInit = (options) => {\n  if (isBrowser() && process.env.DATADOG_APPLICATION_ID) {\n    if (process.env.BUILD === \"dev\" && process.env.LOCAL_MODE === \"true\") {\n      return;\n    }\n    const config = nuxtConfig(options);\n    datadogRum.init(config);\n    datadogRum.startSessionReplayRecording();\n  }\n};\nvar nuxtDatadogRumInit_default = nuxtDatadogRumInit;\nfunction logClientError(error, options) {\n  datadogRum.addError(error, __spreadValues({\n    type: \"client\",\n    path: window.location.pathname,\n    href: window.location.href\n  }, options));\n}\nfunction logNetworkError(error, options) {\n  var _a, _b, _c, _d, _e;\n  datadogRum.addError(error, __spreadValues({\n    type: \"network\",\n    statusCode: (_a = error == null ? void 0 : error.response) == null ? void 0 : _a.status,\n    resource: (_b = error == null ? void 0 : error.config) == null ? void 0 : _b.url,\n    method: (_c = error == null ? void 0 : error.config) == null ? void 0 : _c.method,\n    data: (_d = error == null ? void 0 : error.config) == null ? void 0 : _d.data,\n    response: (_e = error == null ? void 0 : error.response) == null ? void 0 : _e.data,\n    pathname: window.location.pathname,\n    href: window.location.href\n  }, options));\n}\n\n// src/useErrorLogger.ts\nfunction useErrorLogger() {\n  return (error, options) => {\n    if (!isAxiosError(error)) {\n      logClientError(error, options);\n    } else {\n      logNetworkError(error, options);\n    }\n  };\n}\nfunction setDatadogStaff(user) {\n  datadogRum.setUser(user);\n}\n\nexport { logClientError, logNetworkError, nextDatadogRumInit_default as nextDatadogRumInit, nuxtDatadogRumInit_default as nuxtDatadogRumInit, setDatadogStaff, useErrorLogger };\n//# sourceMappingURL=out.js.map\n//# sourceMappingURL=index.js.map","import * as React from 'react';\r\nimport Cookies from './Cookies';\r\nvar CookiesContext = React.createContext(new Cookies());\r\nexport var Provider = CookiesContext.Provider, Consumer = CookiesContext.Consumer;\r\nexport default CookiesContext;\r\n","var __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nimport * as React from 'react';\r\nimport Cookies from 'universal-cookie';\r\nimport { Provider } from './CookiesContext';\r\nvar CookiesProvider = /** @class */ (function (_super) {\r\n    __extends(CookiesProvider, _super);\r\n    function CookiesProvider(props) {\r\n        var _this = _super.call(this, props) || this;\r\n        if (props.cookies) {\r\n            _this.cookies = props.cookies;\r\n        }\r\n        else {\r\n            _this.cookies = new Cookies();\r\n        }\r\n        return _this;\r\n    }\r\n    CookiesProvider.prototype.render = function () {\r\n        return React.createElement(Provider, { value: this.cookies }, this.props.children);\r\n    };\r\n    return CookiesProvider;\r\n}(React.Component));\r\nexport default CookiesProvider;\r\n","import react from 'react';\nimport reactDom from 'react-dom';\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction err(message) {\n  const error = new Error(message); // In V8, Error objects keep the closure scope chain alive until the\n  // err.stack property is accessed.\n\n  if (error.stack === undefined) {\n    // IE sets the stack only if error is thrown\n    try {\n      throw error;\n    } catch (_) {} // eslint-disable-line fb-www/no-unused-catch-bindings, no-empty\n\n  }\n\n  return error;\n}\n\nvar err_1 = err;\n\n// @oss-only\n\n\nvar Recoil_err = err_1;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\n// Split declaration and implementation to allow this function to pretend to\n// check for actual instance of Promise instead of something with a `then`\n// method.\n// eslint-disable-next-line no-redeclare\nfunction isPromise(p) {\n  return !!p && typeof p.then === 'function';\n}\n\nvar Recoil_isPromise = isPromise;\n\nfunction nullthrows(x, message) {\n  if (x != null) {\n    return x;\n  }\n\n  throw Recoil_err(message !== null && message !== void 0 ? message : 'Got unexpected null or undefined');\n}\n\nvar Recoil_nullthrows = nullthrows;\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nclass BaseLoadable {\n  getValue() {\n    throw Recoil_err('BaseLoadable');\n  }\n\n  toPromise() {\n    throw Recoil_err('BaseLoadable');\n  }\n\n  valueMaybe() {\n    throw Recoil_err('BaseLoadable');\n  }\n\n  valueOrThrow() {\n    // $FlowFixMe[prop-missing]\n    throw Recoil_err(`Loadable expected value, but in \"${this.state}\" state`);\n  }\n\n  promiseMaybe() {\n    throw Recoil_err('BaseLoadable');\n  }\n\n  promiseOrThrow() {\n    // $FlowFixMe[prop-missing]\n    throw Recoil_err(`Loadable expected promise, but in \"${this.state}\" state`);\n  }\n\n  errorMaybe() {\n    throw Recoil_err('BaseLoadable');\n  }\n\n  errorOrThrow() {\n    // $FlowFixMe[prop-missing]\n    throw Recoil_err(`Loadable expected error, but in \"${this.state}\" state`);\n  }\n\n  is(other) {\n    // $FlowFixMe[prop-missing]\n    return other.state === this.state && other.contents === this.contents;\n  }\n\n  map(_map) {\n    throw Recoil_err('BaseLoadable');\n  }\n\n}\n\nclass ValueLoadable extends BaseLoadable {\n  constructor(value) {\n    super();\n\n    _defineProperty(this, \"state\", 'hasValue');\n\n    _defineProperty(this, \"contents\", void 0);\n\n    this.contents = value;\n  }\n\n  getValue() {\n    return this.contents;\n  }\n\n  toPromise() {\n    return Promise.resolve(this.contents);\n  }\n\n  valueMaybe() {\n    return this.contents;\n  }\n\n  valueOrThrow() {\n    return this.contents;\n  }\n\n  promiseMaybe() {\n    return undefined;\n  }\n\n  errorMaybe() {\n    return undefined;\n  }\n\n  map(map) {\n    try {\n      const next = map(this.contents);\n      return Recoil_isPromise(next) ? loadableWithPromise(next) : isLoadable(next) ? next : loadableWithValue(next);\n    } catch (e) {\n      return Recoil_isPromise(e) ? // If we \"suspended\", then try again.\n      // errors and subsequent retries will be handled in 'loading' case\n      // $FlowFixMe[prop-missing]\n      loadableWithPromise(e.next(() => this.map(map))) : loadableWithError(e);\n    }\n  }\n\n}\n\nclass ErrorLoadable extends BaseLoadable {\n  constructor(error) {\n    super();\n\n    _defineProperty(this, \"state\", 'hasError');\n\n    _defineProperty(this, \"contents\", void 0);\n\n    this.contents = error;\n  }\n\n  getValue() {\n    throw this.contents;\n  }\n\n  toPromise() {\n    return Promise.reject(this.contents);\n  }\n\n  valueMaybe() {\n    return undefined;\n  }\n\n  promiseMaybe() {\n    return undefined;\n  }\n\n  errorMaybe() {\n    return this.contents;\n  }\n\n  errorOrThrow() {\n    return this.contents;\n  }\n\n  map(_map) {\n    // $FlowIssue[incompatible-return]\n    return this;\n  }\n\n}\n\nclass LoadingLoadable extends BaseLoadable {\n  constructor(promise) {\n    super();\n\n    _defineProperty(this, \"state\", 'loading');\n\n    _defineProperty(this, \"contents\", void 0);\n\n    this.contents = promise;\n  }\n\n  getValue() {\n    throw this.contents;\n  }\n\n  toPromise() {\n    return this.contents;\n  }\n\n  valueMaybe() {\n    return undefined;\n  }\n\n  promiseMaybe() {\n    return this.contents;\n  }\n\n  promiseOrThrow() {\n    return this.contents;\n  }\n\n  errorMaybe() {\n    return undefined;\n  }\n\n  map(map) {\n    return loadableWithPromise(this.contents.then(value => {\n      const next = map(value);\n\n      if (isLoadable(next)) {\n        const nextLoadable = next;\n\n        switch (nextLoadable.state) {\n          case 'hasValue':\n            return nextLoadable.contents;\n\n          case 'hasError':\n            throw nextLoadable.contents;\n\n          case 'loading':\n            return nextLoadable.contents;\n        }\n      } // $FlowIssue[incompatible-return]\n\n\n      return next;\n    }).catch(e => {\n      if (Recoil_isPromise(e)) {\n        // we were \"suspended,\" try again\n        return e.then(() => this.map(map).contents);\n      }\n\n      throw e;\n    }));\n  }\n\n}\n\nfunction loadableWithValue(value) {\n  return Object.freeze(new ValueLoadable(value));\n}\n\nfunction loadableWithError(error) {\n  return Object.freeze(new ErrorLoadable(error));\n}\n\nfunction loadableWithPromise(promise) {\n  return Object.freeze(new LoadingLoadable(promise));\n}\n\nfunction loadableLoading() {\n  return Object.freeze(new LoadingLoadable(new Promise(() => {})));\n}\n\nfunction loadableAllArray(inputs) {\n  return inputs.every(i => i.state === 'hasValue') ? loadableWithValue(inputs.map(i => i.contents)) : inputs.some(i => i.state === 'hasError') ? loadableWithError(Recoil_nullthrows(inputs.find(i => i.state === 'hasError'), 'Invalid loadable passed to loadableAll').contents) : loadableWithPromise(Promise.all(inputs.map(i => i.contents)));\n}\n\nfunction loadableAll(inputs) {\n  const unwrapedInputs = Array.isArray(inputs) ? inputs : Object.getOwnPropertyNames(inputs).map(key => inputs[key]);\n  const normalizedInputs = unwrapedInputs.map(x => isLoadable(x) ? x : Recoil_isPromise(x) ? loadableWithPromise(x) : loadableWithValue(x));\n  const output = loadableAllArray(normalizedInputs);\n  return Array.isArray(inputs) ? // $FlowIssue[incompatible-return]\n  output : // Object.getOwnPropertyNames() has consistent key ordering with ES6\n  // $FlowIssue[incompatible-call]\n  output.map(outputs => Object.getOwnPropertyNames(inputs).reduce((out, key, idx) => ({ ...out,\n    [key]: outputs[idx]\n  }), {}));\n}\n\nfunction isLoadable(x) {\n  return x instanceof BaseLoadable;\n}\n\nconst LoadableStaticInterface = {\n  of: value => Recoil_isPromise(value) ? loadableWithPromise(value) : isLoadable(value) ? value : loadableWithValue(value),\n  error: error => loadableWithError(error),\n  // $FlowIssue[incompatible-return]\n  loading: () => loadableLoading(),\n  // $FlowIssue[unclear-type]\n  all: loadableAll,\n  isLoadable\n};\nvar Recoil_Loadable = {\n  loadableWithValue,\n  loadableWithError,\n  loadableWithPromise,\n  loadableLoading,\n  loadableAll,\n  isLoadable,\n  RecoilLoadable: LoadableStaticInterface\n};\n\nvar Recoil_Loadable_1 = Recoil_Loadable.loadableWithValue;\nvar Recoil_Loadable_2 = Recoil_Loadable.loadableWithError;\nvar Recoil_Loadable_3 = Recoil_Loadable.loadableWithPromise;\nvar Recoil_Loadable_4 = Recoil_Loadable.loadableLoading;\nvar Recoil_Loadable_5 = Recoil_Loadable.loadableAll;\nvar Recoil_Loadable_6 = Recoil_Loadable.isLoadable;\nvar Recoil_Loadable_7 = Recoil_Loadable.RecoilLoadable;\n\nvar Recoil_Loadable$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  loadableWithValue: Recoil_Loadable_1,\n  loadableWithError: Recoil_Loadable_2,\n  loadableWithPromise: Recoil_Loadable_3,\n  loadableLoading: Recoil_Loadable_4,\n  loadableAll: Recoil_Loadable_5,\n  isLoadable: Recoil_Loadable_6,\n  RecoilLoadable: Recoil_Loadable_7\n});\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nconst gks = new Map().set('recoil_hamt_2020', true).set('recoil_sync_external_store', true).set('recoil_suppress_rerender_in_callback', true).set('recoil_memory_managament_2020', true);\n\nfunction Recoil_gkx_OSS(gk) {\n  var _gks$get;\n\n  return (_gks$get = gks.get(gk)) !== null && _gks$get !== void 0 ? _gks$get : false;\n}\n\nRecoil_gkx_OSS.setPass = gk => {\n  gks.set(gk, true);\n};\n\nRecoil_gkx_OSS.setFail = gk => {\n  gks.set(gk, false);\n};\n\nRecoil_gkx_OSS.clear = () => {\n  gks.clear();\n};\n\nvar Recoil_gkx = Recoil_gkx_OSS; // @oss-only\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction recoverableViolation(message, _projectName, {\n  error\n} = {}) {\n  if (process.env.NODE_ENV !== \"production\") {\n    console.error(message, error);\n  }\n\n  return null;\n}\n\nvar recoverableViolation_1 = recoverableViolation;\n\n// @oss-only\n\n\nvar Recoil_recoverableViolation = recoverableViolation_1;\n\nvar _createMutableSource, _useMutableSource, _useSyncExternalStore;\n\n\n\n\n\n\n\nconst createMutableSource = // flowlint-next-line unclear-type:off\n(_createMutableSource = react.createMutableSource) !== null && _createMutableSource !== void 0 ? _createMutableSource : react.unstable_createMutableSource;\nconst useMutableSource = // flowlint-next-line unclear-type:off\n(_useMutableSource = react.useMutableSource) !== null && _useMutableSource !== void 0 ? _useMutableSource : react.unstable_useMutableSource; // https://github.com/reactwg/react-18/discussions/86\n\nconst useSyncExternalStore = // flowlint-next-line unclear-type:off\n(_useSyncExternalStore = react.useSyncExternalStore) !== null && _useSyncExternalStore !== void 0 ? _useSyncExternalStore : // flowlint-next-line unclear-type:off\nreact.unstable_useSyncExternalStore;\nlet ReactRendererVersionMismatchWarnOnce = false; // Check if the current renderer supports `useSyncExternalStore()`.\n// Since React goes through a proxy dispatcher and the current renderer can\n// change we can't simply check if `React.useSyncExternalStore()` is defined.\n\nfunction currentRendererSupportsUseSyncExternalStore() {\n  var _ReactCurrentDispatch;\n\n  // $FlowFixMe[incompatible-use]\n  const {\n    ReactCurrentDispatcher,\n    ReactCurrentOwner\n  } =\n  /* $FlowFixMe[prop-missing] This workaround was approved as a safer mechanism\n   * to detect if the current renderer supports useSyncExternalStore()\n   * https://fb.workplace.com/groups/reactjs/posts/9558682330846963/ */\n  react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  const dispatcher = (_ReactCurrentDispatch = ReactCurrentDispatcher === null || ReactCurrentDispatcher === void 0 ? void 0 : ReactCurrentDispatcher.current) !== null && _ReactCurrentDispatch !== void 0 ? _ReactCurrentDispatch : ReactCurrentOwner.currentDispatcher;\n  const isUseSyncExternalStoreSupported = dispatcher.useSyncExternalStore != null;\n\n  if (useSyncExternalStore && !isUseSyncExternalStoreSupported && !ReactRendererVersionMismatchWarnOnce) {\n    ReactRendererVersionMismatchWarnOnce = true;\n    Recoil_recoverableViolation('A React renderer without React 18+ API support is being used with React 18+.');\n  }\n\n  return isUseSyncExternalStoreSupported;\n}\n\n/**\n * mode: The React API and approach to use for syncing state with React\n * early: Re-renders from Recoil updates occur:\n *    1) earlier\n *    2) in sync with React updates in the same batch\n *    3) before transaction observers instead of after.\n * concurrent: Is the current mode compatible with Concurrent Mode and useTransition()\n */\nfunction reactMode() {\n  // NOTE: This mode is currently broken with some Suspense cases\n  // see Recoil_selector-test.js\n  if (Recoil_gkx('recoil_transition_support')) {\n    return {\n      mode: 'TRANSITION_SUPPORT',\n      early: true,\n      concurrent: true\n    };\n  }\n\n  if (Recoil_gkx('recoil_sync_external_store') && useSyncExternalStore != null) {\n    return {\n      mode: 'SYNC_EXTERNAL_STORE',\n      early: true,\n      concurrent: false\n    };\n  }\n\n  if (Recoil_gkx('recoil_mutable_source') && useMutableSource != null && typeof window !== 'undefined' && !window.$disableRecoilValueMutableSource_TEMP_HACK_DO_NOT_USE) {\n    return Recoil_gkx('recoil_suppress_rerender_in_callback') ? {\n      mode: 'MUTABLE_SOURCE',\n      early: true,\n      concurrent: true\n    } : {\n      mode: 'MUTABLE_SOURCE',\n      early: false,\n      concurrent: false\n    };\n  }\n\n  return Recoil_gkx('recoil_suppress_rerender_in_callback') ? {\n    mode: 'LEGACY',\n    early: true,\n    concurrent: false\n  } : {\n    mode: 'LEGACY',\n    early: false,\n    concurrent: false\n  };\n} // TODO Need to figure out if there is a standard/open-source equivalent to see if hot module replacement is happening:\n\n\nfunction isFastRefreshEnabled() {\n  // @fb-only: const {isAcceptingUpdate} = require('__debug');\n  // @fb-only: return typeof isAcceptingUpdate === 'function' && isAcceptingUpdate();\n  return false; // @oss-only\n}\n\nvar Recoil_ReactMode = {\n  createMutableSource,\n  useMutableSource,\n  useSyncExternalStore,\n  currentRendererSupportsUseSyncExternalStore,\n  reactMode,\n  isFastRefreshEnabled\n};\n\nconst env = {\n  RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED: true\n};\n/**\n * Allow NodeJS/NextJS/etc to set the initial state through process.env variable\n * Note:  we don't assume 'process' is available in all runtime environments\n *\n * @see https://github.com/facebookexperimental/Recoil/issues/733\n */\n\nfunction applyProcessEnvFlagOverrides() {\n  var _process, _process$env$RECOIL_D, _process$env$RECOIL_D2;\n\n  // note: this check is needed in addition to the check below, runtime error will occur without it!\n  // eslint-disable-next-line fb-www/typeof-undefined\n  if (typeof process === 'undefined') {\n    return;\n  }\n\n  if (((_process = process) === null || _process === void 0 ? void 0 : _process.env) == null) {\n    return;\n  }\n\n  const sanitizedValue = (_process$env$RECOIL_D = process.env.RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED) === null || _process$env$RECOIL_D === void 0 ? void 0 : (_process$env$RECOIL_D2 = _process$env$RECOIL_D.toLowerCase()) === null || _process$env$RECOIL_D2 === void 0 ? void 0 : _process$env$RECOIL_D2.trim();\n\n  if (sanitizedValue == null || sanitizedValue === '') {\n    return;\n  }\n\n  const allowedValues = ['true', 'false'];\n\n  if (!allowedValues.includes(sanitizedValue)) {\n    throw Recoil_err(`process.env.RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED value must be 'true', 'false', or empty: ${sanitizedValue}`);\n  }\n\n  env.RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED = sanitizedValue === 'true';\n}\n\napplyProcessEnvFlagOverrides();\nvar Recoil_RecoilEnv = env;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\n// eslint-disable-next-line no-unused-vars\nclass AbstractRecoilValue {\n  constructor(newKey) {\n    _defineProperty(this, \"key\", void 0);\n\n    this.key = newKey;\n  }\n\n  toJSON() {\n    return {\n      key: this.key\n    };\n  }\n\n}\n\nclass RecoilState extends AbstractRecoilValue {}\n\nclass RecoilValueReadOnly extends AbstractRecoilValue {}\n\nfunction isRecoilValue(x) {\n  return x instanceof RecoilState || x instanceof RecoilValueReadOnly;\n}\n\nvar Recoil_RecoilValue = {\n  AbstractRecoilValue,\n  RecoilState,\n  RecoilValueReadOnly,\n  isRecoilValue\n};\n\nvar Recoil_RecoilValue_1 = Recoil_RecoilValue.AbstractRecoilValue;\nvar Recoil_RecoilValue_2 = Recoil_RecoilValue.RecoilState;\nvar Recoil_RecoilValue_3 = Recoil_RecoilValue.RecoilValueReadOnly;\nvar Recoil_RecoilValue_4 = Recoil_RecoilValue.isRecoilValue;\n\nvar Recoil_RecoilValue$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  AbstractRecoilValue: Recoil_RecoilValue_1,\n  RecoilState: Recoil_RecoilValue_2,\n  RecoilValueReadOnly: Recoil_RecoilValue_3,\n  isRecoilValue: Recoil_RecoilValue_4\n});\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction sprintf(format, ...args) {\n  let index = 0;\n  return format.replace(/%s/g, () => String(args[index++]));\n}\n\nvar sprintf_1 = sprintf;\n\nfunction expectationViolation(format, ...args) {\n  if (process.env.NODE_ENV !== \"production\") {\n    const message = sprintf_1.call(null, format, ...args);\n    const error = new Error(message);\n    error.name = 'Expectation Violation';\n    console.error(error);\n  }\n}\n\nvar expectationViolation_1 = expectationViolation;\n\n// @oss-only\n\n\nvar Recoil_expectationViolation = expectationViolation_1;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Creates a new iterable whose output is generated by passing the input\n * iterable's values through the mapper function.\n */\n\nfunction mapIterable(iterable, callback) {\n  // Use generator to create iterable/iterator\n  return function* () {\n    let index = 0;\n\n    for (const value of iterable) {\n      yield callback(value, index++);\n    }\n  }();\n}\n\nvar Recoil_mapIterable = mapIterable;\n\nconst {\n  isFastRefreshEnabled: isFastRefreshEnabled$1\n} = Recoil_ReactMode;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nclass DefaultValue {}\n\nconst DEFAULT_VALUE = new DefaultValue();\n// flowlint-next-line unclear-type:off\nconst nodes = new Map(); // flowlint-next-line unclear-type:off\n\nconst recoilValues = new Map();\n/* eslint-disable no-redeclare */\n\nfunction recoilValuesForKeys(keys) {\n  return Recoil_mapIterable(keys, key => Recoil_nullthrows(recoilValues.get(key)));\n}\n\nfunction checkForDuplicateAtomKey(key) {\n  if (nodes.has(key)) {\n    const message = `Duplicate atom key \"${key}\". This is a FATAL ERROR in\n      production. But it is safe to ignore this warning if it occurred because of\n      hot module replacement.`;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      // TODO Figure this out for open-source\n      if (!isFastRefreshEnabled$1()) {\n        Recoil_expectationViolation(message, 'recoil');\n      }\n    } else {\n      // @fb-only: recoverableViolation(message, 'recoil');\n      console.warn(message); // @oss-only\n    }\n  }\n}\n\nfunction registerNode(node) {\n  if (Recoil_RecoilEnv.RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED) {\n    checkForDuplicateAtomKey(node.key);\n  }\n\n  nodes.set(node.key, node);\n  const recoilValue = node.set == null ? new Recoil_RecoilValue$1.RecoilValueReadOnly(node.key) : new Recoil_RecoilValue$1.RecoilState(node.key);\n  recoilValues.set(node.key, recoilValue);\n  return recoilValue;\n}\n/* eslint-enable no-redeclare */\n\n\nclass NodeMissingError extends Error {} // flowlint-next-line unclear-type:off\n\n\nfunction getNode(key) {\n  const node = nodes.get(key);\n\n  if (node == null) {\n    throw new NodeMissingError(`Missing definition for RecoilValue: \"${key}\"\"`);\n  }\n\n  return node;\n} // flowlint-next-line unclear-type:off\n\n\nfunction getNodeMaybe(key) {\n  return nodes.get(key);\n}\n\nconst configDeletionHandlers = new Map();\n\nfunction deleteNodeConfigIfPossible(key) {\n  var _node$shouldDeleteCon;\n\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  }\n\n  const node = nodes.get(key);\n\n  if (node !== null && node !== void 0 && (_node$shouldDeleteCon = node.shouldDeleteConfigOnRelease) !== null && _node$shouldDeleteCon !== void 0 && _node$shouldDeleteCon.call(node)) {\n    var _getConfigDeletionHan;\n\n    nodes.delete(key);\n    (_getConfigDeletionHan = getConfigDeletionHandler(key)) === null || _getConfigDeletionHan === void 0 ? void 0 : _getConfigDeletionHan();\n    configDeletionHandlers.delete(key);\n  }\n}\n\nfunction setConfigDeletionHandler(key, fn) {\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  }\n\n  if (fn === undefined) {\n    configDeletionHandlers.delete(key);\n  } else {\n    configDeletionHandlers.set(key, fn);\n  }\n}\n\nfunction getConfigDeletionHandler(key) {\n  return configDeletionHandlers.get(key);\n}\n\nvar Recoil_Node = {\n  nodes,\n  recoilValues,\n  registerNode,\n  getNode,\n  getNodeMaybe,\n  deleteNodeConfigIfPossible,\n  setConfigDeletionHandler,\n  getConfigDeletionHandler,\n  recoilValuesForKeys,\n  NodeMissingError,\n  DefaultValue,\n  DEFAULT_VALUE\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction enqueueExecution(s, f) {\n  f();\n}\n\nvar Recoil_Queue = {\n  enqueueExecution\n};\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar hamt_1 = createCommonjsModule(function (module) {\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n/**\n    @fileOverview Hash Array Mapped Trie.\n\n    Code based on: https://github.com/exclipy/pdata\n*/\n\n\nvar hamt = {}; // export\n\n/* Configuration\n ******************************************************************************/\n\nvar SIZE = 5;\nvar BUCKET_SIZE = Math.pow(2, SIZE);\nvar MASK = BUCKET_SIZE - 1;\nvar MAX_INDEX_NODE = BUCKET_SIZE / 2;\nvar MIN_ARRAY_NODE = BUCKET_SIZE / 4;\n/*\n ******************************************************************************/\n\nvar nothing = {};\n\nvar constant = function constant(x) {\n  return function () {\n    return x;\n  };\n};\n/**\n    Get 32 bit hash of string.\n\n    Based on:\n    http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery\n*/\n\n\nvar hash = hamt.hash = function (str) {\n  var type = typeof str === 'undefined' ? 'undefined' : _typeof(str);\n  if (type === 'number') return str;\n  if (type !== 'string') str += '';\n  var hash = 0;\n\n  for (var i = 0, len = str.length; i < len; ++i) {\n    var c = str.charCodeAt(i);\n    hash = (hash << 5) - hash + c | 0;\n  }\n\n  return hash;\n};\n/* Bit Ops\n ******************************************************************************/\n\n/**\n    Hamming weight.\n\n    Taken from: http://jsperf.com/hamming-weight\n*/\n\n\nvar popcount = function popcount(x) {\n  x -= x >> 1 & 0x55555555;\n  x = (x & 0x33333333) + (x >> 2 & 0x33333333);\n  x = x + (x >> 4) & 0x0f0f0f0f;\n  x += x >> 8;\n  x += x >> 16;\n  return x & 0x7f;\n};\n\nvar hashFragment = function hashFragment(shift, h) {\n  return h >>> shift & MASK;\n};\n\nvar toBitmap = function toBitmap(x) {\n  return 1 << x;\n};\n\nvar fromBitmap = function fromBitmap(bitmap, bit) {\n  return popcount(bitmap & bit - 1);\n};\n/* Array Ops\n ******************************************************************************/\n\n/**\n    Set a value in an array.\n\n    @param mutate Should the input array be mutated?\n    @param at Index to change.\n    @param v New value\n    @param arr Array.\n*/\n\n\nvar arrayUpdate = function arrayUpdate(mutate, at, v, arr) {\n  var out = arr;\n\n  if (!mutate) {\n    var len = arr.length;\n    out = new Array(len);\n\n    for (var i = 0; i < len; ++i) {\n      out[i] = arr[i];\n    }\n  }\n\n  out[at] = v;\n  return out;\n};\n/**\n    Remove a value from an array.\n\n    @param mutate Should the input array be mutated?\n    @param at Index to remove.\n    @param arr Array.\n*/\n\n\nvar arraySpliceOut = function arraySpliceOut(mutate, at, arr) {\n  var newLen = arr.length - 1;\n  var i = 0;\n  var g = 0;\n  var out = arr;\n\n  if (mutate) {\n    i = g = at;\n  } else {\n    out = new Array(newLen);\n\n    while (i < at) {\n      out[g++] = arr[i++];\n    }\n  }\n\n  ++i;\n\n  while (i <= newLen) {\n    out[g++] = arr[i++];\n  }\n\n  if (mutate) {\n    out.length = newLen;\n  }\n\n  return out;\n};\n/**\n    Insert a value into an array.\n\n    @param mutate Should the input array be mutated?\n    @param at Index to insert at.\n    @param v Value to insert,\n    @param arr Array.\n*/\n\n\nvar arraySpliceIn = function arraySpliceIn(mutate, at, v, arr) {\n  var len = arr.length;\n\n  if (mutate) {\n    var _i = len;\n\n    while (_i >= at) {\n      arr[_i--] = arr[_i];\n    }\n\n    arr[at] = v;\n    return arr;\n  }\n\n  var i = 0,\n      g = 0;\n  var out = new Array(len + 1);\n\n  while (i < at) {\n    out[g++] = arr[i++];\n  }\n\n  out[at] = v;\n\n  while (i < len) {\n    out[++g] = arr[i++];\n  }\n\n  return out;\n};\n/* Node Structures\n ******************************************************************************/\n\n\nvar LEAF = 1;\nvar COLLISION = 2;\nvar INDEX = 3;\nvar ARRAY = 4;\n/**\n    Empty node.\n*/\n\nvar empty = {\n  __hamt_isEmpty: true\n};\n\nvar isEmptyNode = function isEmptyNode(x) {\n  return x === empty || x && x.__hamt_isEmpty;\n};\n/**\n    Leaf holding a value.\n\n    @member edit Edit of the node.\n    @member hash Hash of key.\n    @member key Key.\n    @member value Value stored.\n*/\n\n\nvar Leaf = function Leaf(edit, hash, key, value) {\n  return {\n    type: LEAF,\n    edit: edit,\n    hash: hash,\n    key: key,\n    value: value,\n    _modify: Leaf__modify\n  };\n};\n/**\n    Leaf holding multiple values with the same hash but different keys.\n\n    @member edit Edit of the node.\n    @member hash Hash of key.\n    @member children Array of collision children node.\n*/\n\n\nvar Collision = function Collision(edit, hash, children) {\n  return {\n    type: COLLISION,\n    edit: edit,\n    hash: hash,\n    children: children,\n    _modify: Collision__modify\n  };\n};\n/**\n    Internal node with a sparse set of children.\n\n    Uses a bitmap and array to pack children.\n\n  @member edit Edit of the node.\n    @member mask Bitmap that encode the positions of children in the array.\n    @member children Array of child nodes.\n*/\n\n\nvar IndexedNode = function IndexedNode(edit, mask, children) {\n  return {\n    type: INDEX,\n    edit: edit,\n    mask: mask,\n    children: children,\n    _modify: IndexedNode__modify\n  };\n};\n/**\n    Internal node with many children.\n\n    @member edit Edit of the node.\n    @member size Number of children.\n    @member children Array of child nodes.\n*/\n\n\nvar ArrayNode = function ArrayNode(edit, size, children) {\n  return {\n    type: ARRAY,\n    edit: edit,\n    size: size,\n    children: children,\n    _modify: ArrayNode__modify\n  };\n};\n/**\n    Is `node` a leaf node?\n*/\n\n\nvar isLeaf = function isLeaf(node) {\n  return node === empty || node.type === LEAF || node.type === COLLISION;\n};\n/* Internal node operations.\n ******************************************************************************/\n\n/**\n    Expand an indexed node into an array node.\n\n  @param edit Current edit.\n    @param frag Index of added child.\n    @param child Added child.\n    @param mask Index node mask before child added.\n    @param subNodes Index node children before child added.\n*/\n\n\nvar expand = function expand(edit, frag, child, bitmap, subNodes) {\n  var arr = [];\n  var bit = bitmap;\n  var count = 0;\n\n  for (var i = 0; bit; ++i) {\n    if (bit & 1) arr[i] = subNodes[count++];\n    bit >>>= 1;\n  }\n\n  arr[frag] = child;\n  return ArrayNode(edit, count + 1, arr);\n};\n/**\n    Collapse an array node into a indexed node.\n\n  @param edit Current edit.\n    @param count Number of elements in new array.\n    @param removed Index of removed element.\n    @param elements Array node children before remove.\n*/\n\n\nvar pack = function pack(edit, count, removed, elements) {\n  var children = new Array(count - 1);\n  var g = 0;\n  var bitmap = 0;\n\n  for (var i = 0, len = elements.length; i < len; ++i) {\n    if (i !== removed) {\n      var elem = elements[i];\n\n      if (elem && !isEmptyNode(elem)) {\n        children[g++] = elem;\n        bitmap |= 1 << i;\n      }\n    }\n  }\n\n  return IndexedNode(edit, bitmap, children);\n};\n/**\n    Merge two leaf nodes.\n\n    @param shift Current shift.\n    @param h1 Node 1 hash.\n    @param n1 Node 1.\n    @param h2 Node 2 hash.\n    @param n2 Node 2.\n*/\n\n\nvar mergeLeaves = function mergeLeaves(edit, shift, h1, n1, h2, n2) {\n  if (h1 === h2) return Collision(edit, h1, [n2, n1]);\n  var subH1 = hashFragment(shift, h1);\n  var subH2 = hashFragment(shift, h2);\n  return IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), subH1 === subH2 ? [mergeLeaves(edit, shift + SIZE, h1, n1, h2, n2)] : subH1 < subH2 ? [n1, n2] : [n2, n1]);\n};\n/**\n    Update an entry in a collision list.\n\n    @param mutate Should mutation be used?\n    @param edit Current edit.\n    @param keyEq Key compare function.\n    @param hash Hash of collision.\n    @param list Collision list.\n    @param f Update function.\n    @param k Key to update.\n    @param size Size ref.\n*/\n\n\nvar updateCollisionList = function updateCollisionList(mutate, edit, keyEq, h, list, f, k, size) {\n  var len = list.length;\n\n  for (var i = 0; i < len; ++i) {\n    var child = list[i];\n\n    if (keyEq(k, child.key)) {\n      var value = child.value;\n\n      var _newValue = f(value);\n\n      if (_newValue === value) return list;\n\n      if (_newValue === nothing) {\n        --size.value;\n        return arraySpliceOut(mutate, i, list);\n      }\n\n      return arrayUpdate(mutate, i, Leaf(edit, h, k, _newValue), list);\n    }\n  }\n\n  var newValue = f();\n  if (newValue === nothing) return list;\n  ++size.value;\n  return arrayUpdate(mutate, len, Leaf(edit, h, k, newValue), list);\n};\n\nvar canEditNode = function canEditNode(edit, node) {\n  return edit === node.edit;\n};\n/* Editing\n ******************************************************************************/\n\n\nvar Leaf__modify = function Leaf__modify(edit, keyEq, shift, f, h, k, size) {\n  if (keyEq(k, this.key)) {\n    var _v = f(this.value);\n\n    if (_v === this.value) return this;else if (_v === nothing) {\n      --size.value;\n      return empty;\n    }\n\n    if (canEditNode(edit, this)) {\n      this.value = _v;\n      return this;\n    }\n\n    return Leaf(edit, h, k, _v);\n  }\n\n  var v = f();\n  if (v === nothing) return this;\n  ++size.value;\n  return mergeLeaves(edit, shift, this.hash, this, h, Leaf(edit, h, k, v));\n};\n\nvar Collision__modify = function Collision__modify(edit, keyEq, shift, f, h, k, size) {\n  if (h === this.hash) {\n    var canEdit = canEditNode(edit, this);\n    var list = updateCollisionList(canEdit, edit, keyEq, this.hash, this.children, f, k, size);\n    if (list === this.children) return this;\n    return list.length > 1 ? Collision(edit, this.hash, list) : list[0]; // collapse single element collision list\n  }\n\n  var v = f();\n  if (v === nothing) return this;\n  ++size.value;\n  return mergeLeaves(edit, shift, this.hash, this, h, Leaf(edit, h, k, v));\n};\n\nvar IndexedNode__modify = function IndexedNode__modify(edit, keyEq, shift, f, h, k, size) {\n  var mask = this.mask;\n  var children = this.children;\n  var frag = hashFragment(shift, h);\n  var bit = toBitmap(frag);\n  var indx = fromBitmap(mask, bit);\n  var exists = mask & bit;\n  var current = exists ? children[indx] : empty;\n\n  var child = current._modify(edit, keyEq, shift + SIZE, f, h, k, size);\n\n  if (current === child) return this;\n  var canEdit = canEditNode(edit, this);\n  var bitmap = mask;\n  var newChildren = void 0;\n\n  if (exists && isEmptyNode(child)) {\n    // remove\n    bitmap &= ~bit;\n    if (!bitmap) return empty;\n    if (children.length <= 2 && isLeaf(children[indx ^ 1])) return children[indx ^ 1]; // collapse\n\n    newChildren = arraySpliceOut(canEdit, indx, children);\n  } else if (!exists && !isEmptyNode(child)) {\n    // add\n    if (children.length >= MAX_INDEX_NODE) return expand(edit, frag, child, mask, children);\n    bitmap |= bit;\n    newChildren = arraySpliceIn(canEdit, indx, child, children);\n  } else {\n    // modify\n    newChildren = arrayUpdate(canEdit, indx, child, children);\n  }\n\n  if (canEdit) {\n    this.mask = bitmap;\n    this.children = newChildren;\n    return this;\n  }\n\n  return IndexedNode(edit, bitmap, newChildren);\n};\n\nvar ArrayNode__modify = function ArrayNode__modify(edit, keyEq, shift, f, h, k, size) {\n  var count = this.size;\n  var children = this.children;\n  var frag = hashFragment(shift, h);\n  var child = children[frag];\n\n  var newChild = (child || empty)._modify(edit, keyEq, shift + SIZE, f, h, k, size);\n\n  if (child === newChild) return this;\n  var canEdit = canEditNode(edit, this);\n  var newChildren = void 0;\n\n  if (isEmptyNode(child) && !isEmptyNode(newChild)) {\n    // add\n    ++count;\n    newChildren = arrayUpdate(canEdit, frag, newChild, children);\n  } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {\n    // remove\n    --count;\n    if (count <= MIN_ARRAY_NODE) return pack(edit, count, frag, children);\n    newChildren = arrayUpdate(canEdit, frag, empty, children);\n  } else {\n    // modify\n    newChildren = arrayUpdate(canEdit, frag, newChild, children);\n  }\n\n  if (canEdit) {\n    this.size = count;\n    this.children = newChildren;\n    return this;\n  }\n\n  return ArrayNode(edit, count, newChildren);\n};\n\nempty._modify = function (edit, keyEq, shift, f, h, k, size) {\n  var v = f();\n  if (v === nothing) return empty;\n  ++size.value;\n  return Leaf(edit, h, k, v);\n};\n/*\n ******************************************************************************/\n\n\nfunction Map(editable, edit, config, root, size) {\n  this._editable = editable;\n  this._edit = edit;\n  this._config = config;\n  this._root = root;\n  this._size = size;\n}\n\nMap.prototype.setTree = function (newRoot, newSize) {\n  if (this._editable) {\n    this._root = newRoot;\n    this._size = newSize;\n    return this;\n  }\n\n  return newRoot === this._root ? this : new Map(this._editable, this._edit, this._config, newRoot, newSize);\n};\n/* Queries\n ******************************************************************************/\n\n/**\n    Lookup the value for `key` in `map` using a custom `hash`.\n\n    Returns the value or `alt` if none.\n*/\n\n\nvar tryGetHash = hamt.tryGetHash = function (alt, hash, key, map) {\n  var node = map._root;\n  var shift = 0;\n  var keyEq = map._config.keyEq;\n\n  while (true) {\n    switch (node.type) {\n      case LEAF:\n        {\n          return keyEq(key, node.key) ? node.value : alt;\n        }\n\n      case COLLISION:\n        {\n          if (hash === node.hash) {\n            var children = node.children;\n\n            for (var i = 0, len = children.length; i < len; ++i) {\n              var child = children[i];\n              if (keyEq(key, child.key)) return child.value;\n            }\n          }\n\n          return alt;\n        }\n\n      case INDEX:\n        {\n          var frag = hashFragment(shift, hash);\n          var bit = toBitmap(frag);\n\n          if (node.mask & bit) {\n            node = node.children[fromBitmap(node.mask, bit)];\n            shift += SIZE;\n            break;\n          }\n\n          return alt;\n        }\n\n      case ARRAY:\n        {\n          node = node.children[hashFragment(shift, hash)];\n\n          if (node) {\n            shift += SIZE;\n            break;\n          }\n\n          return alt;\n        }\n\n      default:\n        return alt;\n    }\n  }\n};\n\nMap.prototype.tryGetHash = function (alt, hash, key) {\n  return tryGetHash(alt, hash, key, this);\n};\n/**\n    Lookup the value for `key` in `map` using internal hash function.\n\n    @see `tryGetHash`\n*/\n\n\nvar tryGet = hamt.tryGet = function (alt, key, map) {\n  return tryGetHash(alt, map._config.hash(key), key, map);\n};\n\nMap.prototype.tryGet = function (alt, key) {\n  return tryGet(alt, key, this);\n};\n/**\n    Lookup the value for `key` in `map` using a custom `hash`.\n\n    Returns the value or `undefined` if none.\n*/\n\n\nvar getHash = hamt.getHash = function (hash, key, map) {\n  return tryGetHash(undefined, hash, key, map);\n};\n\nMap.prototype.getHash = function (hash, key) {\n  return getHash(hash, key, this);\n};\n/**\n    Lookup the value for `key` in `map` using internal hash function.\n\n    @see `get`\n*/\n\n\nvar get = hamt.get = function (key, map) {\n  return tryGetHash(undefined, map._config.hash(key), key, map);\n};\n\nMap.prototype.get = function (key, alt) {\n  return tryGet(alt, key, this);\n};\n/**\n    Does an entry exist for `key` in `map`? Uses custom `hash`.\n*/\n\n\nvar hasHash = hamt.has = function (hash, key, map) {\n  return tryGetHash(nothing, hash, key, map) !== nothing;\n};\n\nMap.prototype.hasHash = function (hash, key) {\n  return hasHash(hash, key, this);\n};\n/**\n    Does an entry exist for `key` in `map`? Uses internal hash function.\n*/\n\n\nvar has = hamt.has = function (key, map) {\n  return hasHash(map._config.hash(key), key, map);\n};\n\nMap.prototype.has = function (key) {\n  return has(key, this);\n};\n\nvar defKeyCompare = function defKeyCompare(x, y) {\n  return x === y;\n};\n/**\n    Create an empty map.\n\n    @param config Configuration.\n*/\n\n\nhamt.make = function (config) {\n  return new Map(0, 0, {\n    keyEq: config && config.keyEq || defKeyCompare,\n    hash: config && config.hash || hash\n  }, empty, 0);\n};\n/**\n    Empty map.\n*/\n\n\nhamt.empty = hamt.make();\n/**\n    Does `map` contain any elements?\n*/\n\nvar isEmpty = hamt.isEmpty = function (map) {\n  return map && !!isEmptyNode(map._root);\n};\n\nMap.prototype.isEmpty = function () {\n  return isEmpty(this);\n};\n/* Updates\n ******************************************************************************/\n\n/**\n    Alter the value stored for `key` in `map` using function `f` using\n    custom hash.\n\n    `f` is invoked with the current value for `k` if it exists,\n    or no arguments if no such value exists. `modify` will always either\n    update or insert a value into the map.\n\n    Returns a map with the modified value. Does not alter `map`.\n*/\n\n\nvar modifyHash = hamt.modifyHash = function (f, hash, key, map) {\n  var size = {\n    value: map._size\n  };\n\n  var newRoot = map._root._modify(map._editable ? map._edit : NaN, map._config.keyEq, 0, f, hash, key, size);\n\n  return map.setTree(newRoot, size.value);\n};\n\nMap.prototype.modifyHash = function (hash, key, f) {\n  return modifyHash(f, hash, key, this);\n};\n/**\n    Alter the value stored for `key` in `map` using function `f` using\n    internal hash function.\n\n    @see `modifyHash`\n*/\n\n\nvar modify = hamt.modify = function (f, key, map) {\n  return modifyHash(f, map._config.hash(key), key, map);\n};\n\nMap.prototype.modify = function (key, f) {\n  return modify(f, key, this);\n};\n/**\n    Store `value` for `key` in `map` using custom `hash`.\n\n    Returns a map with the modified value. Does not alter `map`.\n*/\n\n\nvar setHash = hamt.setHash = function (hash, key, value, map) {\n  return modifyHash(constant(value), hash, key, map);\n};\n\nMap.prototype.setHash = function (hash, key, value) {\n  return setHash(hash, key, value, this);\n};\n/**\n    Store `value` for `key` in `map` using internal hash function.\n\n    @see `setHash`\n*/\n\n\nvar set = hamt.set = function (key, value, map) {\n  return setHash(map._config.hash(key), key, value, map);\n};\n\nMap.prototype.set = function (key, value) {\n  return set(key, value, this);\n};\n/**\n    Remove the entry for `key` in `map`.\n\n    Returns a map with the value removed. Does not alter `map`.\n*/\n\n\nvar del = constant(nothing);\n\nvar removeHash = hamt.removeHash = function (hash, key, map) {\n  return modifyHash(del, hash, key, map);\n};\n\nMap.prototype.removeHash = Map.prototype.deleteHash = function (hash, key) {\n  return removeHash(hash, key, this);\n};\n/**\n    Remove the entry for `key` in `map` using internal hash function.\n\n    @see `removeHash`\n*/\n\n\nvar remove = hamt.remove = function (key, map) {\n  return removeHash(map._config.hash(key), key, map);\n};\n\nMap.prototype.remove = Map.prototype.delete = function (key) {\n  return remove(key, this);\n};\n/* Mutation\n ******************************************************************************/\n\n/**\n    Mark `map` as mutable.\n */\n\n\nvar beginMutation = hamt.beginMutation = function (map) {\n  return new Map(map._editable + 1, map._edit + 1, map._config, map._root, map._size);\n};\n\nMap.prototype.beginMutation = function () {\n  return beginMutation(this);\n};\n/**\n    Mark `map` as immutable.\n */\n\n\nvar endMutation = hamt.endMutation = function (map) {\n  map._editable = map._editable && map._editable - 1;\n  return map;\n};\n\nMap.prototype.endMutation = function () {\n  return endMutation(this);\n};\n/**\n    Mutate `map` within the context of `f`.\n    @param f\n    @param map HAMT\n*/\n\n\nvar mutate = hamt.mutate = function (f, map) {\n  var transient = beginMutation(map);\n  f(transient);\n  return endMutation(transient);\n};\n\nMap.prototype.mutate = function (f) {\n  return mutate(f, this);\n};\n/* Traversal\n ******************************************************************************/\n\n/**\n    Apply a continuation.\n*/\n\n\nvar appk = function appk(k) {\n  return k && lazyVisitChildren(k[0], k[1], k[2], k[3], k[4]);\n};\n/**\n    Recursively visit all values stored in an array of nodes lazily.\n*/\n\n\nvar lazyVisitChildren = function lazyVisitChildren(len, children, i, f, k) {\n  while (i < len) {\n    var child = children[i++];\n    if (child && !isEmptyNode(child)) return lazyVisit(child, f, [len, children, i, f, k]);\n  }\n\n  return appk(k);\n};\n/**\n    Recursively visit all values stored in `node` lazily.\n*/\n\n\nvar lazyVisit = function lazyVisit(node, f, k) {\n  switch (node.type) {\n    case LEAF:\n      return {\n        value: f(node),\n        rest: k\n      };\n\n    case COLLISION:\n    case ARRAY:\n    case INDEX:\n      var children = node.children;\n      return lazyVisitChildren(children.length, children, 0, f, k);\n\n    default:\n      return appk(k);\n  }\n};\n\nvar DONE = {\n  done: true\n};\n/**\n    Javascript iterator over a map.\n*/\n\nfunction MapIterator(v) {\n  this.v = v;\n}\n\nMapIterator.prototype.next = function () {\n  if (!this.v) return DONE;\n  var v0 = this.v;\n  this.v = appk(v0.rest);\n  return v0;\n};\n\nMapIterator.prototype[Symbol.iterator] = function () {\n  return this;\n};\n/**\n    Lazily visit each value in map with function `f`.\n*/\n\n\nvar visit = function visit(map, f) {\n  return new MapIterator(lazyVisit(map._root, f));\n};\n/**\n    Get a Javascsript iterator of `map`.\n\n    Iterates over `[key, value]` arrays.\n*/\n\n\nvar buildPairs = function buildPairs(x) {\n  return [x.key, x.value];\n};\n\nvar entries = hamt.entries = function (map) {\n  return visit(map, buildPairs);\n};\n\nMap.prototype.entries = Map.prototype[Symbol.iterator] = function () {\n  return entries(this);\n};\n/**\n    Get array of all keys in `map`.\n\n    Order is not guaranteed.\n*/\n\n\nvar buildKeys = function buildKeys(x) {\n  return x.key;\n};\n\nvar keys = hamt.keys = function (map) {\n  return visit(map, buildKeys);\n};\n\nMap.prototype.keys = function () {\n  return keys(this);\n};\n/**\n    Get array of all values in `map`.\n\n    Order is not guaranteed, duplicates are preserved.\n*/\n\n\nvar buildValues = function buildValues(x) {\n  return x.value;\n};\n\nvar values = hamt.values = Map.prototype.values = function (map) {\n  return visit(map, buildValues);\n};\n\nMap.prototype.values = function () {\n  return values(this);\n};\n/* Fold\n ******************************************************************************/\n\n/**\n    Visit every entry in the map, aggregating data.\n\n    Order of nodes is not guaranteed.\n\n    @param f Function mapping accumulated value, value, and key to new value.\n    @param z Starting value.\n    @param m HAMT\n*/\n\n\nvar fold = hamt.fold = function (f, z, m) {\n  var root = m._root;\n  if (root.type === LEAF) return f(z, root.value, root.key);\n  var toVisit = [root.children];\n  var children = void 0;\n\n  while (children = toVisit.pop()) {\n    for (var i = 0, len = children.length; i < len;) {\n      var child = children[i++];\n\n      if (child && child.type) {\n        if (child.type === LEAF) z = f(z, child.value, child.key);else toVisit.push(child.children);\n      }\n    }\n  }\n\n  return z;\n};\n\nMap.prototype.fold = function (f, z) {\n  return fold(f, z, this);\n};\n/**\n    Visit every entry in the map, aggregating data.\n\n    Order of nodes is not guaranteed.\n\n    @param f Function invoked with value and key\n    @param map HAMT\n*/\n\n\nvar forEach = hamt.forEach = function (f, map) {\n  return fold(function (_, value, key) {\n    return f(value, key, map);\n  }, null, map);\n};\n\nMap.prototype.forEach = function (f) {\n  return forEach(f, this);\n};\n/* Aggregate\n ******************************************************************************/\n\n/**\n    Get the number of entries in `map`.\n*/\n\n\nvar count = hamt.count = function (map) {\n  return map._size;\n};\n\nMap.prototype.count = function () {\n  return count(this);\n};\n\nObject.defineProperty(Map.prototype, 'size', {\n  get: Map.prototype.count\n});\n/* Export\n ******************************************************************************/\n\nif ( module.exports) {\n  module.exports = hamt;\n} else {\n  undefined.hamt = hamt;\n}\n});\n\nclass BuiltInMap {\n  constructor(existing) {\n    _defineProperty(this, \"_map\", void 0);\n\n    this._map = new Map(existing === null || existing === void 0 ? void 0 : existing.entries());\n  }\n\n  keys() {\n    return this._map.keys();\n  }\n\n  entries() {\n    return this._map.entries();\n  }\n\n  get(k) {\n    return this._map.get(k);\n  }\n\n  has(k) {\n    return this._map.has(k);\n  }\n\n  set(k, v) {\n    this._map.set(k, v);\n\n    return this;\n  }\n\n  delete(k) {\n    this._map.delete(k);\n\n    return this;\n  }\n\n  clone() {\n    return persistentMap(this);\n  }\n\n  toMap() {\n    return new Map(this._map);\n  }\n\n}\n\nclass HashArrayMappedTrieMap {\n  // Because hamt.empty is not a function there is no way to introduce type\n  // parameters on it, so empty is typed as HAMTPlusMap<string, mixed>.\n  // $FlowIssue\n  constructor(existing) {\n    _defineProperty(this, \"_hamt\", hamt_1.empty.beginMutation());\n\n    if (existing instanceof HashArrayMappedTrieMap) {\n      const h = existing._hamt.endMutation();\n\n      existing._hamt = h.beginMutation();\n      this._hamt = h.beginMutation();\n    } else if (existing) {\n      for (const [k, v] of existing.entries()) {\n        this._hamt.set(k, v);\n      }\n    }\n  }\n\n  keys() {\n    return this._hamt.keys();\n  }\n\n  entries() {\n    return this._hamt.entries();\n  }\n\n  get(k) {\n    return this._hamt.get(k);\n  }\n\n  has(k) {\n    return this._hamt.has(k);\n  }\n\n  set(k, v) {\n    this._hamt.set(k, v);\n\n    return this;\n  }\n\n  delete(k) {\n    this._hamt.delete(k);\n\n    return this;\n  }\n\n  clone() {\n    return persistentMap(this);\n  }\n\n  toMap() {\n    return new Map(this._hamt);\n  }\n\n}\n\nfunction persistentMap(existing) {\n  if (Recoil_gkx('recoil_hamt_2020')) {\n    return new HashArrayMappedTrieMap(existing);\n  } else {\n    return new BuiltInMap(existing);\n  }\n}\n\nvar Recoil_PersistentMap = {\n  persistentMap\n};\n\nvar Recoil_PersistentMap_1 = Recoil_PersistentMap.persistentMap;\n\nvar Recoil_PersistentMap$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  persistentMap: Recoil_PersistentMap_1\n});\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Returns a set containing all of the values from the first set that are not\n * present in any of the subsequent sets.\n *\n * Note: this is written procedurally (i.e., without filterSet) for performant\n * use in tight loops.\n */\n\nfunction differenceSets(set, ...setsWithValuesToRemove) {\n  const ret = new Set();\n\n  FIRST: for (const value of set) {\n    for (const otherSet of setsWithValuesToRemove) {\n      if (otherSet.has(value)) {\n        continue FIRST;\n      }\n    }\n\n    ret.add(value);\n  }\n\n  return ret;\n}\n\nvar Recoil_differenceSets = differenceSets;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Returns a new Map object with the same keys as the original, but with the\n * values replaced with the output of the given callback function.\n */\n\nfunction mapMap(map, callback) {\n  const result = new Map();\n  map.forEach((value, key) => {\n    result.set(key, callback(value, key));\n  });\n  return result;\n}\n\nvar Recoil_mapMap = mapMap;\n\nfunction makeGraph() {\n  return {\n    nodeDeps: new Map(),\n    nodeToNodeSubscriptions: new Map()\n  };\n}\n\nfunction cloneGraph(graph) {\n  return {\n    nodeDeps: Recoil_mapMap(graph.nodeDeps, s => new Set(s)),\n    nodeToNodeSubscriptions: Recoil_mapMap(graph.nodeToNodeSubscriptions, s => new Set(s))\n  };\n} // Note that this overwrites the deps of existing nodes, rather than unioning\n// the new deps with the old deps.\n\n\nfunction mergeDepsIntoGraph(key, newDeps, graph, // If olderGraph is given then we will not overwrite changes made to the given\n// graph compared with olderGraph:\nolderGraph) {\n  const {\n    nodeDeps,\n    nodeToNodeSubscriptions\n  } = graph;\n  const oldDeps = nodeDeps.get(key);\n\n  if (oldDeps && olderGraph && oldDeps !== olderGraph.nodeDeps.get(key)) {\n    return;\n  } // Update nodeDeps:\n\n\n  nodeDeps.set(key, newDeps); // Add new deps to nodeToNodeSubscriptions:\n\n  const addedDeps = oldDeps == null ? newDeps : Recoil_differenceSets(newDeps, oldDeps);\n\n  for (const dep of addedDeps) {\n    if (!nodeToNodeSubscriptions.has(dep)) {\n      nodeToNodeSubscriptions.set(dep, new Set());\n    }\n\n    const existing = Recoil_nullthrows(nodeToNodeSubscriptions.get(dep));\n    existing.add(key);\n  } // Remove removed deps from nodeToNodeSubscriptions:\n\n\n  if (oldDeps) {\n    const removedDeps = Recoil_differenceSets(oldDeps, newDeps);\n\n    for (const dep of removedDeps) {\n      if (!nodeToNodeSubscriptions.has(dep)) {\n        return;\n      }\n\n      const existing = Recoil_nullthrows(nodeToNodeSubscriptions.get(dep));\n      existing.delete(key);\n\n      if (existing.size === 0) {\n        nodeToNodeSubscriptions.delete(dep);\n      }\n    }\n  }\n}\n\nfunction saveDepsToStore(key, deps, store, version) {\n  var _storeState$nextTree, _storeState$previousT, _storeState$previousT2, _storeState$previousT3;\n\n  const storeState = store.getState();\n\n  if (!(version === storeState.currentTree.version || version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version))) {\n    Recoil_recoverableViolation('Tried to save dependencies to a discarded tree');\n  } // Merge the dependencies discovered into the store's dependency map\n  // for the version that was read:\n\n\n  const graph = store.getGraph(version);\n  mergeDepsIntoGraph(key, deps, graph); // If this version is not the latest version, also write these dependencies\n  // into later versions if they don't already have their own:\n\n  if (version === ((_storeState$previousT2 = storeState.previousTree) === null || _storeState$previousT2 === void 0 ? void 0 : _storeState$previousT2.version)) {\n    const currentGraph = store.getGraph(storeState.currentTree.version);\n    mergeDepsIntoGraph(key, deps, currentGraph, graph);\n  }\n\n  if (version === ((_storeState$previousT3 = storeState.previousTree) === null || _storeState$previousT3 === void 0 ? void 0 : _storeState$previousT3.version) || version === storeState.currentTree.version) {\n    var _storeState$nextTree2;\n\n    const nextVersion = (_storeState$nextTree2 = storeState.nextTree) === null || _storeState$nextTree2 === void 0 ? void 0 : _storeState$nextTree2.version;\n\n    if (nextVersion !== undefined) {\n      const nextGraph = store.getGraph(nextVersion);\n      mergeDepsIntoGraph(key, deps, nextGraph, graph);\n    }\n  }\n}\n\nvar Recoil_Graph = {\n  cloneGraph,\n  graph: makeGraph,\n  saveDepsToStore\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nlet nextTreeStateVersion = 0;\n\nconst getNextTreeStateVersion = () => nextTreeStateVersion++;\n\nlet nextStoreID = 0;\n\nconst getNextStoreID = () => nextStoreID++;\n\nlet nextComponentID = 0;\n\nconst getNextComponentID = () => nextComponentID++;\n\nvar Recoil_Keys = {\n  getNextTreeStateVersion,\n  getNextStoreID,\n  getNextComponentID\n};\n\nconst {\n  persistentMap: persistentMap$1\n} = Recoil_PersistentMap$1;\n\nconst {\n  graph\n} = Recoil_Graph;\n\nconst {\n  getNextTreeStateVersion: getNextTreeStateVersion$1\n} = Recoil_Keys;\n\nfunction makeEmptyTreeState() {\n  const version = getNextTreeStateVersion$1();\n  return {\n    version,\n    stateID: version,\n    transactionMetadata: {},\n    dirtyAtoms: new Set(),\n    atomValues: persistentMap$1(),\n    nonvalidatedAtoms: persistentMap$1()\n  };\n}\n\nfunction makeEmptyStoreState() {\n  const currentTree = makeEmptyTreeState();\n  return {\n    currentTree,\n    nextTree: null,\n    previousTree: null,\n    commitDepth: 0,\n    knownAtoms: new Set(),\n    knownSelectors: new Set(),\n    transactionSubscriptions: new Map(),\n    nodeTransactionSubscriptions: new Map(),\n    nodeToComponentSubscriptions: new Map(),\n    queuedComponentCallbacks_DEPRECATED: [],\n    suspendedComponentResolvers: new Set(),\n    graphsByVersion: new Map().set(currentTree.version, graph()),\n    retention: {\n      referenceCounts: new Map(),\n      nodesRetainedByZone: new Map(),\n      retainablesToCheckForRelease: new Set()\n    },\n    nodeCleanupFunctions: new Map()\n  };\n}\n\nvar Recoil_State = {\n  makeEmptyTreeState,\n  makeEmptyStoreState,\n  getNextTreeStateVersion: getNextTreeStateVersion$1\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nclass RetentionZone {}\n\nfunction retentionZone() {\n  return new RetentionZone();\n}\n\nvar Recoil_RetentionZone = {\n  RetentionZone,\n  retentionZone\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * Utilities for working with built-in Maps and Sets without mutating them.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction setByAddingToSet(set, v) {\n  const next = new Set(set);\n  next.add(v);\n  return next;\n}\n\nfunction setByDeletingFromSet(set, v) {\n  const next = new Set(set);\n  next.delete(v);\n  return next;\n}\n\nfunction mapBySettingInMap(map, k, v) {\n  const next = new Map(map);\n  next.set(k, v);\n  return next;\n}\n\nfunction mapByUpdatingInMap(map, k, updater) {\n  const next = new Map(map);\n  next.set(k, updater(next.get(k)));\n  return next;\n}\n\nfunction mapByDeletingFromMap(map, k) {\n  const next = new Map(map);\n  next.delete(k);\n  return next;\n}\n\nfunction mapByDeletingMultipleFromMap(map, ks) {\n  const next = new Map(map);\n  ks.forEach(k => next.delete(k));\n  return next;\n}\n\nvar Recoil_CopyOnWrite = {\n  setByAddingToSet,\n  setByDeletingFromSet,\n  mapBySettingInMap,\n  mapByUpdatingInMap,\n  mapByDeletingFromMap,\n  mapByDeletingMultipleFromMap\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Creates a new iterable whose output is generated by passing the input\n * iterable's values through the filter function.\n */\n\nfunction* filterIterable(iterable, predicate) {\n  // Use generator to create iterable/iterator\n  let index = 0;\n\n  for (const value of iterable) {\n    if (predicate(value, index++)) {\n      yield value;\n    }\n  }\n}\n\nvar Recoil_filterIterable = filterIterable;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Return a proxy object based on the provided base and factories objects.\n * The proxy will include all properties of the base object as-is.\n * The factories object contains callbacks to obtain the values of the properies\n * for its keys.\n *\n * This is useful for providing users an object where some properties may be\n * lazily computed only on first access.\n */\n// $FlowIssue[unclear-type]\n\nfunction lazyProxy(base, factories) {\n  const proxy = new Proxy(base, {\n    // Compute and cache lazy property if not already done.\n    get: (target, prop) => {\n      if (!(prop in target) && prop in factories) {\n        target[prop] = factories[prop]();\n      }\n\n      return target[prop];\n    },\n    // This method allows user to iterate keys as normal\n    ownKeys: target => {\n\n      return Object.keys(target);\n    }\n  }); // $FlowIssue[incompatible-return]\n\n  return proxy;\n}\n\nvar Recoil_lazyProxy = lazyProxy;\n\nconst {\n  getNode: getNode$1,\n  getNodeMaybe: getNodeMaybe$1,\n  recoilValuesForKeys: recoilValuesForKeys$1\n} = Recoil_Node;\n\nconst {\n  RetentionZone: RetentionZone$1\n} = Recoil_RetentionZone;\n\nconst {\n  setByAddingToSet: setByAddingToSet$1\n} = Recoil_CopyOnWrite;\n\n\n\n\n\n\n\n // flowlint-next-line unclear-type:off\n\n\nconst emptySet = Object.freeze(new Set());\n\nclass ReadOnlyRecoilValueError extends Error {}\n\nfunction initializeRetentionForNode(store, nodeKey, retainedBy) {\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return () => undefined;\n  }\n\n  const {\n    nodesRetainedByZone\n  } = store.getState().retention;\n\n  function addToZone(zone) {\n    let set = nodesRetainedByZone.get(zone);\n\n    if (!set) {\n      nodesRetainedByZone.set(zone, set = new Set());\n    }\n\n    set.add(nodeKey);\n  }\n\n  if (retainedBy instanceof RetentionZone$1) {\n    addToZone(retainedBy);\n  } else if (Array.isArray(retainedBy)) {\n    for (const zone of retainedBy) {\n      addToZone(zone);\n    }\n  }\n\n  return () => {\n    if (!Recoil_gkx('recoil_memory_managament_2020')) {\n      return;\n    }\n\n    const {\n      retention\n    } = store.getState();\n\n    function deleteFromZone(zone) {\n      const set = retention.nodesRetainedByZone.get(zone);\n      set === null || set === void 0 ? void 0 : set.delete(nodeKey);\n\n      if (set && set.size === 0) {\n        retention.nodesRetainedByZone.delete(zone);\n      }\n    }\n\n    if (retainedBy instanceof RetentionZone$1) {\n      deleteFromZone(retainedBy);\n    } else if (Array.isArray(retainedBy)) {\n      for (const zone of retainedBy) {\n        deleteFromZone(zone);\n      }\n    }\n  };\n}\n\nfunction initializeNodeIfNewToStore(store, treeState, key, trigger) {\n  const storeState = store.getState();\n\n  if (storeState.nodeCleanupFunctions.has(key)) {\n    return;\n  }\n\n  const node = getNode$1(key);\n  const retentionCleanup = initializeRetentionForNode(store, key, node.retainedBy);\n  const nodeCleanup = node.init(store, treeState, trigger);\n  storeState.nodeCleanupFunctions.set(key, () => {\n    nodeCleanup();\n    retentionCleanup();\n  });\n}\n\nfunction initializeNode(store, key, trigger) {\n  initializeNodeIfNewToStore(store, store.getState().currentTree, key, trigger);\n}\n\nfunction cleanUpNode(store, key) {\n  var _state$nodeCleanupFun;\n\n  const state = store.getState();\n  (_state$nodeCleanupFun = state.nodeCleanupFunctions.get(key)) === null || _state$nodeCleanupFun === void 0 ? void 0 : _state$nodeCleanupFun();\n  state.nodeCleanupFunctions.delete(key);\n} // Get the current value loadable of a node and update the state.\n// Update dependencies and subscriptions for selectors.\n// Update saved value validation for atoms.\n\n\nfunction getNodeLoadable(store, state, key) {\n  initializeNodeIfNewToStore(store, state, key, 'get');\n  return getNode$1(key).get(store, state);\n} // Peek at the current value loadable for a node without any evaluation or state change\n\n\nfunction peekNodeLoadable(store, state, key) {\n  return getNode$1(key).peek(store, state);\n} // Write value directly to state bypassing the Node interface as the node\n// definitions may not have been loaded yet when processing the initial snapshot.\n\n\nfunction setUnvalidatedAtomValue_DEPRECATED(state, key, newValue) {\n  var _node$invalidate;\n\n  const node = getNodeMaybe$1(key);\n  node === null || node === void 0 ? void 0 : (_node$invalidate = node.invalidate) === null || _node$invalidate === void 0 ? void 0 : _node$invalidate.call(node, state);\n  return { ...state,\n    atomValues: state.atomValues.clone().delete(key),\n    nonvalidatedAtoms: state.nonvalidatedAtoms.clone().set(key, newValue),\n    dirtyAtoms: setByAddingToSet$1(state.dirtyAtoms, key)\n  };\n} // Return the discovered dependencies and values to be written by setting\n// a node value. (Multiple values may be written due to selectors getting to\n// set upstreams; deps may be discovered because of reads in updater functions.)\n\n\nfunction setNodeValue(store, state, key, newValue) {\n  const node = getNode$1(key);\n\n  if (node.set == null) {\n    throw new ReadOnlyRecoilValueError(`Attempt to set read-only RecoilValue: ${key}`);\n  }\n\n  const set = node.set; // so flow doesn't lose the above refinement.\n\n  initializeNodeIfNewToStore(store, state, key, 'set');\n  return set(store, state, newValue);\n}\n\nfunction peekNodeInfo(store, state, key) {\n  const storeState = store.getState();\n  const graph = store.getGraph(state.version);\n  const type = getNode$1(key).nodeType;\n  return Recoil_lazyProxy({\n    type\n  }, {\n    loadable: () => peekNodeLoadable(store, state, key),\n    isActive: () => storeState.knownAtoms.has(key) || storeState.knownSelectors.has(key),\n    isSet: () => type === 'selector' ? false : state.atomValues.has(key),\n    isModified: () => state.dirtyAtoms.has(key),\n    // Report current dependencies.  If the node hasn't been evaluated, then\n    // dependencies may be missing based on the current state.\n    deps: () => {\n      var _graph$nodeDeps$get;\n\n      return recoilValuesForKeys$1((_graph$nodeDeps$get = graph.nodeDeps.get(key)) !== null && _graph$nodeDeps$get !== void 0 ? _graph$nodeDeps$get : []);\n    },\n    // Reports all \"current\" subscribers.  Evaluating other nodes or\n    // previous in-progress async evaluations may introduce new subscribers.\n    subscribers: () => {\n      var _storeState$nodeToCom, _storeState$nodeToCom2;\n\n      return {\n        nodes: recoilValuesForKeys$1(Recoil_filterIterable(getDownstreamNodes(store, state, new Set([key])), nodeKey => nodeKey !== key)),\n        components: Recoil_mapIterable((_storeState$nodeToCom = (_storeState$nodeToCom2 = storeState.nodeToComponentSubscriptions.get(key)) === null || _storeState$nodeToCom2 === void 0 ? void 0 : _storeState$nodeToCom2.values()) !== null && _storeState$nodeToCom !== void 0 ? _storeState$nodeToCom : [], ([name]) => ({\n          name\n        }))\n      };\n    }\n  });\n} // Find all of the recursively dependent nodes\n\n\nfunction getDownstreamNodes(store, state, keys) {\n  const visitedNodes = new Set();\n  const visitingNodes = Array.from(keys);\n  const graph = store.getGraph(state.version);\n\n  for (let key = visitingNodes.pop(); key; key = visitingNodes.pop()) {\n    var _graph$nodeToNodeSubs;\n\n    visitedNodes.add(key);\n    const subscribedNodes = (_graph$nodeToNodeSubs = graph.nodeToNodeSubscriptions.get(key)) !== null && _graph$nodeToNodeSubs !== void 0 ? _graph$nodeToNodeSubs : emptySet;\n\n    for (const downstreamNode of subscribedNodes) {\n      if (!visitedNodes.has(downstreamNode)) {\n        visitingNodes.push(downstreamNode);\n      }\n    }\n  }\n\n  return visitedNodes;\n}\n\nvar Recoil_FunctionalCore = {\n  getNodeLoadable,\n  peekNodeLoadable,\n  setNodeValue,\n  initializeNode,\n  cleanUpNode,\n  setUnvalidatedAtomValue_DEPRECATED,\n  peekNodeInfo,\n  getDownstreamNodes\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nlet _invalidateMemoizedSnapshot = null;\n\nfunction setInvalidateMemoizedSnapshot(invalidate) {\n  _invalidateMemoizedSnapshot = invalidate;\n}\n\nfunction invalidateMemoizedSnapshot() {\n  var _invalidateMemoizedSn;\n\n  (_invalidateMemoizedSn = _invalidateMemoizedSnapshot) === null || _invalidateMemoizedSn === void 0 ? void 0 : _invalidateMemoizedSn();\n}\n\nvar Recoil_SnapshotCache = {\n  setInvalidateMemoizedSnapshot,\n  invalidateMemoizedSnapshot\n};\n\nconst {\n  getDownstreamNodes: getDownstreamNodes$1,\n  getNodeLoadable: getNodeLoadable$1,\n  setNodeValue: setNodeValue$1\n} = Recoil_FunctionalCore;\n\nconst {\n  getNextComponentID: getNextComponentID$1\n} = Recoil_Keys;\n\nconst {\n  getNode: getNode$2,\n  getNodeMaybe: getNodeMaybe$2\n} = Recoil_Node;\n\nconst {\n  DefaultValue: DefaultValue$1\n} = Recoil_Node;\n\nconst {\n  reactMode: reactMode$1\n} = Recoil_ReactMode;\n\nconst {\n  AbstractRecoilValue: AbstractRecoilValue$1,\n  RecoilState: RecoilState$1,\n  RecoilValueReadOnly: RecoilValueReadOnly$1,\n  isRecoilValue: isRecoilValue$1\n} = Recoil_RecoilValue$1;\n\nconst {\n  invalidateMemoizedSnapshot: invalidateMemoizedSnapshot$1\n} = Recoil_SnapshotCache;\n\n\n\n\n\n\n\nfunction getRecoilValueAsLoadable(store, {\n  key\n}, treeState = store.getState().currentTree) {\n  var _storeState$nextTree, _storeState$previousT;\n\n  // Reading from an older tree can cause bugs because the dependencies that we\n  // discover during the read are lost.\n  const storeState = store.getState();\n\n  if (!(treeState.version === storeState.currentTree.version || treeState.version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || treeState.version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version))) {\n    Recoil_recoverableViolation('Tried to read from a discarded tree');\n  }\n\n  const loadable = getNodeLoadable$1(store, treeState, key);\n\n  if (loadable.state === 'loading') {\n    loadable.contents.catch(() => {\n      /**\n       * HACK: intercept thrown error here to prevent an uncaught promise exception. Ideally this would happen closer to selector\n       * execution (perhaps introducing a new ERROR class to be resolved by async selectors that are in an error state)\n       */\n      return;\n    });\n  }\n\n  return loadable;\n}\n\nfunction applyAtomValueWrites(atomValues, writes) {\n  const result = atomValues.clone();\n  writes.forEach((v, k) => {\n    if (v.state === 'hasValue' && v.contents instanceof DefaultValue$1) {\n      result.delete(k);\n    } else {\n      result.set(k, v);\n    }\n  });\n  return result;\n}\n\nfunction valueFromValueOrUpdater(store, state, {\n  key\n}, valueOrUpdater) {\n  if (typeof valueOrUpdater === 'function') {\n    // Updater form: pass in the current value. Throw if the current value\n    // is unavailable (namely when updating an async selector that's\n    // pending or errored):\n    const current = getNodeLoadable$1(store, state, key);\n\n    if (current.state === 'loading') {\n      const msg = `Tried to set atom or selector \"${key}\" using an updater function while the current state is pending, this is not currently supported.`;\n      Recoil_recoverableViolation(msg);\n      throw Recoil_err(msg);\n    } else if (current.state === 'hasError') {\n      throw current.contents;\n    } // T itself may be a function, so our refinement is not sufficient:\n\n\n    return valueOrUpdater(current.contents); // flowlint-line unclear-type:off\n  } else {\n    return valueOrUpdater;\n  }\n}\n\nfunction applyAction(store, state, action) {\n  if (action.type === 'set') {\n    const {\n      recoilValue,\n      valueOrUpdater\n    } = action;\n    const newValue = valueFromValueOrUpdater(store, state, recoilValue, valueOrUpdater);\n    const writes = setNodeValue$1(store, state, recoilValue.key, newValue);\n\n    for (const [key, loadable] of writes.entries()) {\n      writeLoadableToTreeState(state, key, loadable);\n    }\n  } else if (action.type === 'setLoadable') {\n    const {\n      recoilValue: {\n        key\n      },\n      loadable\n    } = action;\n    writeLoadableToTreeState(state, key, loadable);\n  } else if (action.type === 'markModified') {\n    const {\n      recoilValue: {\n        key\n      }\n    } = action;\n    state.dirtyAtoms.add(key);\n  } else if (action.type === 'setUnvalidated') {\n    var _node$invalidate;\n\n    // Write value directly to state bypassing the Node interface as the node\n    // definitions may not have been loaded yet when processing the initial snapshot.\n    const {\n      recoilValue: {\n        key\n      },\n      unvalidatedValue\n    } = action;\n    const node = getNodeMaybe$2(key);\n    node === null || node === void 0 ? void 0 : (_node$invalidate = node.invalidate) === null || _node$invalidate === void 0 ? void 0 : _node$invalidate.call(node, state);\n    state.atomValues.delete(key);\n    state.nonvalidatedAtoms.set(key, unvalidatedValue);\n    state.dirtyAtoms.add(key);\n  } else {\n    Recoil_recoverableViolation(`Unknown action ${action.type}`);\n  }\n}\n\nfunction writeLoadableToTreeState(state, key, loadable) {\n  if (loadable.state === 'hasValue' && loadable.contents instanceof DefaultValue$1) {\n    state.atomValues.delete(key);\n  } else {\n    state.atomValues.set(key, loadable);\n  }\n\n  state.dirtyAtoms.add(key);\n  state.nonvalidatedAtoms.delete(key);\n}\n\nfunction applyActionsToStore(store, actions) {\n  store.replaceState(state => {\n    const newState = copyTreeState(state);\n\n    for (const action of actions) {\n      applyAction(store, newState, action);\n    }\n\n    invalidateDownstreams(store, newState);\n    invalidateMemoizedSnapshot$1();\n    return newState;\n  });\n}\n\nfunction queueOrPerformStateUpdate(store, action) {\n  if (batchStack.length) {\n    const actionsByStore = batchStack[batchStack.length - 1];\n    let actions = actionsByStore.get(store);\n\n    if (!actions) {\n      actionsByStore.set(store, actions = []);\n    }\n\n    actions.push(action);\n  } else {\n    applyActionsToStore(store, [action]);\n  }\n}\n\nconst batchStack = [];\n\nfunction batchStart() {\n  const actionsByStore = new Map();\n  batchStack.push(actionsByStore);\n  return () => {\n    for (const [store, actions] of actionsByStore) {\n      applyActionsToStore(store, actions);\n    }\n\n    const popped = batchStack.pop();\n\n    if (popped !== actionsByStore) {\n      Recoil_recoverableViolation('Incorrect order of batch popping');\n    }\n  };\n}\n\nfunction copyTreeState(state) {\n  return { ...state,\n    atomValues: state.atomValues.clone(),\n    nonvalidatedAtoms: state.nonvalidatedAtoms.clone(),\n    dirtyAtoms: new Set(state.dirtyAtoms)\n  };\n}\n\nfunction invalidateDownstreams(store, state) {\n  // Inform any nodes that were changed or downstream of changes so that they\n  // can clear out any caches as needed due to the update:\n  const downstreams = getDownstreamNodes$1(store, state, state.dirtyAtoms);\n\n  for (const key of downstreams) {\n    var _getNodeMaybe, _getNodeMaybe$invalid;\n\n    (_getNodeMaybe = getNodeMaybe$2(key)) === null || _getNodeMaybe === void 0 ? void 0 : (_getNodeMaybe$invalid = _getNodeMaybe.invalidate) === null || _getNodeMaybe$invalid === void 0 ? void 0 : _getNodeMaybe$invalid.call(_getNodeMaybe, state);\n  }\n}\n\nfunction setRecoilValue(store, recoilValue, valueOrUpdater) {\n  queueOrPerformStateUpdate(store, {\n    type: 'set',\n    recoilValue,\n    valueOrUpdater\n  });\n}\n\nfunction setRecoilValueLoadable(store, recoilValue, loadable) {\n  if (loadable instanceof DefaultValue$1) {\n    return setRecoilValue(store, recoilValue, loadable);\n  }\n\n  queueOrPerformStateUpdate(store, {\n    type: 'setLoadable',\n    recoilValue,\n    loadable: loadable\n  });\n}\n\nfunction markRecoilValueModified(store, recoilValue) {\n  queueOrPerformStateUpdate(store, {\n    type: 'markModified',\n    recoilValue\n  });\n}\n\nfunction setUnvalidatedRecoilValue(store, recoilValue, unvalidatedValue) {\n  queueOrPerformStateUpdate(store, {\n    type: 'setUnvalidated',\n    recoilValue,\n    unvalidatedValue\n  });\n}\n\nfunction subscribeToRecoilValue(store, {\n  key\n}, callback, componentDebugName = null) {\n  const subID = getNextComponentID$1();\n  const storeState = store.getState();\n\n  if (!storeState.nodeToComponentSubscriptions.has(key)) {\n    storeState.nodeToComponentSubscriptions.set(key, new Map());\n  }\n\n  Recoil_nullthrows(storeState.nodeToComponentSubscriptions.get(key)).set(subID, [componentDebugName !== null && componentDebugName !== void 0 ? componentDebugName : '<not captured>', callback]); // Handle the case that, during the same tick that we are subscribing, an atom\n  // has been updated by some effect handler. Otherwise we will miss the update.\n\n  const mode = reactMode$1();\n\n  if (mode.early && (mode.mode === 'LEGACY' || mode.mode === 'MUTABLE_SOURCE')) {\n    const nextTree = store.getState().nextTree;\n\n    if (nextTree && nextTree.dirtyAtoms.has(key)) {\n      callback(nextTree);\n    }\n  }\n\n  return {\n    release: () => {\n      const releaseStoreState = store.getState();\n      const subs = releaseStoreState.nodeToComponentSubscriptions.get(key);\n\n      if (subs === undefined || !subs.has(subID)) {\n        Recoil_recoverableViolation(`Subscription missing at release time for atom ${key}. This is a bug in Recoil.`);\n        return;\n      }\n\n      subs.delete(subID);\n\n      if (subs.size === 0) {\n        releaseStoreState.nodeToComponentSubscriptions.delete(key);\n      }\n    }\n  };\n}\n\nfunction refreshRecoilValue(store, recoilValue) {\n  var _node$clearCache;\n\n  const {\n    currentTree\n  } = store.getState();\n  const node = getNode$2(recoilValue.key);\n  (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, currentTree);\n}\n\nvar Recoil_RecoilValueInterface = {\n  RecoilValueReadOnly: RecoilValueReadOnly$1,\n  AbstractRecoilValue: AbstractRecoilValue$1,\n  RecoilState: RecoilState$1,\n  getRecoilValueAsLoadable,\n  setRecoilValue,\n  setRecoilValueLoadable,\n  markRecoilValueModified,\n  setUnvalidatedRecoilValue,\n  subscribeToRecoilValue,\n  isRecoilValue: isRecoilValue$1,\n  applyAtomValueWrites,\n  // TODO Remove export when deprecating initialStoreState_DEPRECATED in RecoilRoot\n  batchStart,\n  writeLoadableToTreeState,\n  invalidateDownstreams,\n  copyTreeState,\n  refreshRecoilValue\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * The someSet() method tests whether some elements in the given Set pass the\n * test implemented by the provided function.\n */\n\nfunction someSet(set, callback, context) {\n  const iterator = set.entries();\n  let current = iterator.next();\n\n  while (!current.done) {\n    const entry = current.value;\n\n    if (callback.call(context, entry[1], entry[0], set)) {\n      return true;\n    }\n\n    current = iterator.next();\n  }\n\n  return false;\n}\n\nvar Recoil_someSet = someSet;\n\nconst {\n  cleanUpNode: cleanUpNode$1\n} = Recoil_FunctionalCore;\n\nconst {\n  deleteNodeConfigIfPossible: deleteNodeConfigIfPossible$1,\n  getNode: getNode$3\n} = Recoil_Node;\n\nconst {\n  RetentionZone: RetentionZone$2\n} = Recoil_RetentionZone;\n\n\n\n\n\n\n\n // Components that aren't mounted after suspending for this long will be assumed\n// to be discarded and their resources released.\n\n\nconst SUSPENSE_TIMEOUT_MS = 120000;\nconst emptySet$1 = new Set();\n\nfunction releaseRetainablesNowOnCurrentTree(store, retainables) {\n  const storeState = store.getState();\n  const treeState = storeState.currentTree;\n\n  if (storeState.nextTree) {\n    Recoil_recoverableViolation('releaseNodesNowOnCurrentTree should only be called at the end of a batch');\n    return; // leak memory rather than erase something that's about to be used.\n  }\n\n  const nodes = new Set();\n\n  for (const r of retainables) {\n    if (r instanceof RetentionZone$2) {\n      for (const n of nodesRetainedByZone(storeState, r)) {\n        nodes.add(n);\n      }\n    } else {\n      nodes.add(r);\n    }\n  }\n\n  const releasableNodes = findReleasableNodes(store, nodes);\n\n  for (const node of releasableNodes) {\n    releaseNode(store, treeState, node);\n  }\n}\n\nfunction findReleasableNodes(store, searchFromNodes) {\n  const storeState = store.getState();\n  const treeState = storeState.currentTree;\n  const graph = store.getGraph(treeState.version);\n  const releasableNodes = new Set(); // mutated to collect answer\n\n  const nonReleasableNodes = new Set();\n  findReleasableNodesInner(searchFromNodes);\n  return releasableNodes;\n\n  function findReleasableNodesInner(searchFromNodes) {\n    const releasableNodesFoundThisIteration = new Set();\n    const downstreams = getDownstreamNodesInTopologicalOrder(store, treeState, searchFromNodes, releasableNodes, // don't descend into these\n    nonReleasableNodes // don't descend into these\n    ); // Find which of the downstream nodes are releasable and which are not:\n\n    for (const node of downstreams) {\n      var _storeState$retention;\n\n      // Not releasable if configured to be retained forever:\n      if (getNode$3(node).retainedBy === 'recoilRoot') {\n        nonReleasableNodes.add(node);\n        continue;\n      } // Not releasable if retained directly by a component:\n\n\n      if (((_storeState$retention = storeState.retention.referenceCounts.get(node)) !== null && _storeState$retention !== void 0 ? _storeState$retention : 0) > 0) {\n        nonReleasableNodes.add(node);\n        continue;\n      } // Not releasable if retained by a zone:\n\n\n      if (zonesThatCouldRetainNode(node).some(z => storeState.retention.referenceCounts.get(z))) {\n        nonReleasableNodes.add(node);\n        continue;\n      } // Not releasable if it has a non-releasable child (which will already be in\n      // nonReleasableNodes because we are going in topological order):\n\n\n      const nodeChildren = graph.nodeToNodeSubscriptions.get(node);\n\n      if (nodeChildren && Recoil_someSet(nodeChildren, child => nonReleasableNodes.has(child))) {\n        nonReleasableNodes.add(node);\n        continue;\n      }\n\n      releasableNodes.add(node);\n      releasableNodesFoundThisIteration.add(node);\n    } // If we found any releasable nodes, we need to walk UP from those nodes to\n    // find whether their parents can now be released as well:\n\n\n    const parents = new Set();\n\n    for (const node of releasableNodesFoundThisIteration) {\n      for (const parent of (_graph$nodeDeps$get = graph.nodeDeps.get(node)) !== null && _graph$nodeDeps$get !== void 0 ? _graph$nodeDeps$get : emptySet$1) {\n        var _graph$nodeDeps$get;\n\n        if (!releasableNodes.has(parent)) {\n          parents.add(parent);\n        }\n      }\n    }\n\n    if (parents.size) {\n      findReleasableNodesInner(parents);\n    }\n  }\n} // Children before parents\n\n\nfunction getDownstreamNodesInTopologicalOrder(store, treeState, nodes, // Mutable set is destroyed in place\ndoNotDescendInto1, doNotDescendInto2) {\n  const graph = store.getGraph(treeState.version);\n  const answer = [];\n  const visited = new Set();\n\n  while (nodes.size > 0) {\n    visit(Recoil_nullthrows(nodes.values().next().value));\n  }\n\n  return answer;\n\n  function visit(node) {\n    if (doNotDescendInto1.has(node) || doNotDescendInto2.has(node)) {\n      nodes.delete(node);\n      return;\n    }\n\n    if (visited.has(node)) {\n      return;\n    }\n\n    const children = graph.nodeToNodeSubscriptions.get(node);\n\n    if (children) {\n      for (const child of children) {\n        visit(child);\n      }\n    }\n\n    visited.add(node);\n    nodes.delete(node);\n    answer.push(node);\n  }\n}\n\nfunction releaseNode(store, treeState, node) {\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  } // Atom effects, in-closure caches, etc.:\n\n\n  cleanUpNode$1(store, node); // Delete from store state:\n\n  const storeState = store.getState();\n  storeState.knownAtoms.delete(node);\n  storeState.knownSelectors.delete(node);\n  storeState.nodeTransactionSubscriptions.delete(node);\n  storeState.retention.referenceCounts.delete(node);\n  const zones = zonesThatCouldRetainNode(node);\n\n  for (const zone of zones) {\n    var _storeState$retention2;\n\n    (_storeState$retention2 = storeState.retention.nodesRetainedByZone.get(zone)) === null || _storeState$retention2 === void 0 ? void 0 : _storeState$retention2.delete(node);\n  } // Note that we DO NOT delete from nodeToComponentSubscriptions because this\n  // already happens when the last component that was retaining the node unmounts,\n  // and this could happen either before or after that.\n  // Delete from TreeState and dep graph:\n\n\n  treeState.atomValues.delete(node);\n  treeState.dirtyAtoms.delete(node);\n  treeState.nonvalidatedAtoms.delete(node);\n  const graph = storeState.graphsByVersion.get(treeState.version);\n\n  if (graph) {\n    const deps = graph.nodeDeps.get(node);\n\n    if (deps !== undefined) {\n      graph.nodeDeps.delete(node);\n\n      for (const dep of deps) {\n        var _graph$nodeToNodeSubs;\n\n        (_graph$nodeToNodeSubs = graph.nodeToNodeSubscriptions.get(dep)) === null || _graph$nodeToNodeSubs === void 0 ? void 0 : _graph$nodeToNodeSubs.delete(node);\n      }\n    } // No need to delete sub's deps as there should be no subs at this point.\n    // But an invariant would require deleting nodes in topological order.\n\n\n    graph.nodeToNodeSubscriptions.delete(node);\n  } // Node config (for family members only as their configs can be recreated, and\n  // only if they are not retained within any other Stores):\n\n\n  deleteNodeConfigIfPossible$1(node);\n}\n\nfunction nodesRetainedByZone(storeState, zone) {\n  var _storeState$retention3;\n\n  return (_storeState$retention3 = storeState.retention.nodesRetainedByZone.get(zone)) !== null && _storeState$retention3 !== void 0 ? _storeState$retention3 : emptySet$1;\n}\n\nfunction zonesThatCouldRetainNode(node) {\n  const retainedBy = getNode$3(node).retainedBy;\n\n  if (retainedBy === undefined || retainedBy === 'components' || retainedBy === 'recoilRoot') {\n    return [];\n  } else if (retainedBy instanceof RetentionZone$2) {\n    return [retainedBy];\n  } else {\n    return retainedBy; // it's an array of zones\n  }\n}\n\nfunction scheduleOrPerformPossibleReleaseOfRetainable(store, retainable) {\n  const state = store.getState();\n\n  if (state.nextTree) {\n    state.retention.retainablesToCheckForRelease.add(retainable);\n  } else {\n    releaseRetainablesNowOnCurrentTree(store, new Set([retainable]));\n  }\n}\n\nfunction updateRetainCount(store, retainable, delta) {\n  var _map$get;\n\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  }\n\n  const map = store.getState().retention.referenceCounts;\n  const newCount = ((_map$get = map.get(retainable)) !== null && _map$get !== void 0 ? _map$get : 0) + delta;\n\n  if (newCount === 0) {\n    updateRetainCountToZero(store, retainable);\n  } else {\n    map.set(retainable, newCount);\n  }\n}\n\nfunction updateRetainCountToZero(store, retainable) {\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  }\n\n  const map = store.getState().retention.referenceCounts;\n  map.delete(retainable);\n  scheduleOrPerformPossibleReleaseOfRetainable(store, retainable);\n}\n\nfunction releaseScheduledRetainablesNow(store) {\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  }\n\n  const state = store.getState();\n  releaseRetainablesNowOnCurrentTree(store, state.retention.retainablesToCheckForRelease);\n  state.retention.retainablesToCheckForRelease.clear();\n}\n\nfunction retainedByOptionWithDefault(r) {\n  // The default will change from 'recoilRoot' to 'components' in the future.\n  return r === undefined ? 'recoilRoot' : r;\n}\n\nvar Recoil_Retention = {\n  SUSPENSE_TIMEOUT_MS,\n  updateRetainCount,\n  updateRetainCountToZero,\n  releaseScheduledRetainablesNow,\n  retainedByOptionWithDefault\n};\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * This is to export esstiential functions from react-dom\n * for our web build\n *\n * \n * @format\n * @oncall recoil\n */\nconst {\n  unstable_batchedUpdates\n} = reactDom;\n\nvar ReactBatchedUpdates = {\n  unstable_batchedUpdates\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * This is to export esstiential functions from react-dom\n * for our web build\n *\n * \n * @format\n * @oncall recoil\n */\n// @fb-only: const {unstable_batchedUpdates} = require('ReactDOMComet');\n// prettier-ignore\nconst {\n  unstable_batchedUpdates: unstable_batchedUpdates$1\n} = ReactBatchedUpdates; // @oss-only\n\n\nvar Recoil_ReactBatchedUpdates = {\n  unstable_batchedUpdates: unstable_batchedUpdates$1\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\nconst {\n  batchStart: batchStart$1\n} = Recoil_RecoilValueInterface;\n\nconst {\n  unstable_batchedUpdates: unstable_batchedUpdates$2\n} = Recoil_ReactBatchedUpdates;\n\nlet batcher = unstable_batchedUpdates$2; // flowlint-next-line unclear-type:off\n\n/**\n * Sets the provided batcher function as the batcher function used by Recoil.\n *\n * Set the batcher to a custom batcher for your renderer,\n * if you use a renderer other than React DOM or React Native.\n */\nconst setBatcher = newBatcher => {\n  batcher = newBatcher;\n};\n/**\n * Returns the current batcher function.\n */\n\n\nconst getBatcher = () => batcher;\n/**\n * Calls the current batcher function and passes the\n * provided callback function.\n */\n\n\nconst batchUpdates = callback => {\n  batcher(() => {\n    let batchEnd = () => undefined;\n\n    try {\n      batchEnd = batchStart$1();\n      callback();\n    } finally {\n      batchEnd();\n    }\n  });\n};\n\nvar Recoil_Batching = {\n  getBatcher,\n  setBatcher,\n  batchUpdates\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Combines multiple Iterables into a single Iterable.\n * Traverses the input Iterables in the order provided and maintains the order\n * of their elements.\n *\n * Example:\n * ```\n * const r = Array.from(concatIterables(['a', 'b'], ['c'], ['d', 'e', 'f']));\n * r == ['a', 'b', 'c', 'd', 'e', 'f'];\n * ```\n */\n\nfunction* concatIterables(iters) {\n  for (const iter of iters) {\n    for (const val of iter) {\n      yield val;\n    }\n  }\n}\n\nvar Recoil_concatIterables = concatIterables;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/* eslint-disable fb-www/typeof-undefined */\n\nconst isSSR = // $FlowFixMe(site=recoil) Window does not have a FlowType definition https://github.com/facebook/flow/issues/6709\ntypeof Window === 'undefined' || typeof window === 'undefined';\n/* eslint-enable fb-www/typeof-undefined */\n\nconst isWindow = value => !isSSR && ( // $FlowFixMe(site=recoil) Window does not have a FlowType definition https://github.com/facebook/flow/issues/6709\nvalue === window || value instanceof Window);\n\nconst isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative'; // eslint-disable-line fb-www/typeof-undefined\n\nvar Recoil_Environment = {\n  isSSR,\n  isReactNative,\n  isWindow\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Caches a function's results based on the key returned by the passed\n * hashFunction.\n */\n\nfunction memoizeWithArgsHash(fn, hashFunction) {\n  let cache;\n\n  const memoizedFn = (...args) => {\n    if (!cache) {\n      cache = {};\n    }\n\n    const key = hashFunction(...args);\n\n    if (!Object.hasOwnProperty.call(cache, key)) {\n      cache[key] = fn(...args);\n    }\n\n    return cache[key];\n  };\n\n  return memoizedFn;\n}\n/**\n * Caches a function's results based on a comparison of the arguments.\n * Only caches the last return of the function.\n * Defaults to reference equality\n */\n\n\nfunction memoizeOneWithArgsHash(fn, hashFunction) {\n  let lastKey;\n  let lastResult; // breaking cache when arguments change\n\n  const memoizedFn = (...args) => {\n    const key = hashFunction(...args);\n\n    if (lastKey === key) {\n      return lastResult;\n    }\n\n    lastKey = key;\n    lastResult = fn(...args);\n    return lastResult;\n  };\n\n  return memoizedFn;\n}\n/**\n * Caches a function's results based on a comparison of the arguments.\n * Only caches the last return of the function.\n * Defaults to reference equality\n */\n\n\nfunction memoizeOneWithArgsHashAndInvalidation(fn, hashFunction) {\n  let lastKey;\n  let lastResult; // breaking cache when arguments change\n\n  const memoizedFn = (...args) => {\n    const key = hashFunction(...args);\n\n    if (lastKey === key) {\n      return lastResult;\n    }\n\n    lastKey = key;\n    lastResult = fn(...args);\n    return lastResult;\n  };\n\n  const invalidate = () => {\n    lastKey = null;\n  };\n\n  return [memoizedFn, invalidate];\n}\n\nvar Recoil_Memoize = {\n  memoizeWithArgsHash,\n  memoizeOneWithArgsHash,\n  memoizeOneWithArgsHashAndInvalidation\n};\n\nconst {\n  batchUpdates: batchUpdates$1\n} = Recoil_Batching;\n\nconst {\n  initializeNode: initializeNode$1,\n  peekNodeInfo: peekNodeInfo$1\n} = Recoil_FunctionalCore;\n\nconst {\n  graph: graph$1\n} = Recoil_Graph;\n\nconst {\n  getNextStoreID: getNextStoreID$1\n} = Recoil_Keys;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$1,\n  recoilValues: recoilValues$1,\n  recoilValuesForKeys: recoilValuesForKeys$2\n} = Recoil_Node;\n\nconst {\n  AbstractRecoilValue: AbstractRecoilValue$2,\n  getRecoilValueAsLoadable: getRecoilValueAsLoadable$1,\n  setRecoilValue: setRecoilValue$1,\n  setUnvalidatedRecoilValue: setUnvalidatedRecoilValue$1\n} = Recoil_RecoilValueInterface;\n\nconst {\n  updateRetainCount: updateRetainCount$1\n} = Recoil_Retention;\n\nconst {\n  setInvalidateMemoizedSnapshot: setInvalidateMemoizedSnapshot$1\n} = Recoil_SnapshotCache;\n\nconst {\n  getNextTreeStateVersion: getNextTreeStateVersion$2,\n  makeEmptyStoreState: makeEmptyStoreState$1\n} = Recoil_State;\n\n\n\nconst {\n  isSSR: isSSR$1\n} = Recoil_Environment;\n\n\n\n\n\n\n\n\n\nconst {\n  memoizeOneWithArgsHashAndInvalidation: memoizeOneWithArgsHashAndInvalidation$1\n} = Recoil_Memoize;\n\n\n\n // Opaque at this surface because it's part of the public API from here.\n\n\nconst retainWarning = `\nRecoil Snapshots only last for the duration of the callback they are provided to. To keep a Snapshot longer, do this:\n\n  const release = snapshot.retain();\n  try {\n    await doSomethingWithSnapshot(snapshot);\n  } finally {\n    release();\n  }\n\nThis is currently a DEV-only warning but will become a thrown exception in the next release of Recoil.\n`; // A \"Snapshot\" is \"read-only\" and captures a specific set of values of atoms.\n// However, the data-flow-graph and selector values may evolve as selector\n// evaluation functions are executed and async selectors resolve.\n\nclass Snapshot {\n  // eslint-disable-next-line fb-www/no-uninitialized-properties\n  constructor(storeState, parentStoreID) {\n    _defineProperty(this, \"_store\", void 0);\n\n    _defineProperty(this, \"_refCount\", 1);\n\n    _defineProperty(this, \"getLoadable\", recoilValue => {\n      this.checkRefCount_INTERNAL();\n      return getRecoilValueAsLoadable$1(this._store, recoilValue);\n    });\n\n    _defineProperty(this, \"getPromise\", recoilValue => {\n      this.checkRefCount_INTERNAL();\n      return this.getLoadable(recoilValue).toPromise();\n    });\n\n    _defineProperty(this, \"getNodes_UNSTABLE\", opt => {\n      this.checkRefCount_INTERNAL(); // TODO Deal with modified selectors\n\n      if ((opt === null || opt === void 0 ? void 0 : opt.isModified) === true) {\n        if ((opt === null || opt === void 0 ? void 0 : opt.isInitialized) === false) {\n          return [];\n        }\n\n        const state = this._store.getState().currentTree;\n\n        return recoilValuesForKeys$2(state.dirtyAtoms);\n      }\n\n      const knownAtoms = this._store.getState().knownAtoms;\n\n      const knownSelectors = this._store.getState().knownSelectors;\n\n      return (opt === null || opt === void 0 ? void 0 : opt.isInitialized) == null ? recoilValues$1.values() : opt.isInitialized === true ? recoilValuesForKeys$2(Recoil_concatIterables([knownAtoms, knownSelectors])) : Recoil_filterIterable(recoilValues$1.values(), ({\n        key\n      }) => !knownAtoms.has(key) && !knownSelectors.has(key));\n    });\n\n    _defineProperty(this, \"getInfo_UNSTABLE\", ({\n      key\n    }) => {\n      this.checkRefCount_INTERNAL();\n      return peekNodeInfo$1(this._store, this._store.getState().currentTree, key);\n    });\n\n    _defineProperty(this, \"map\", mapper => {\n      this.checkRefCount_INTERNAL();\n      const mutableSnapshot = new MutableSnapshot(this, batchUpdates$1);\n      mapper(mutableSnapshot); // if removing batchUpdates from `set` add it here\n\n      return mutableSnapshot;\n    });\n\n    _defineProperty(this, \"asyncMap\", async mapper => {\n      this.checkRefCount_INTERNAL();\n      const mutableSnapshot = new MutableSnapshot(this, batchUpdates$1);\n      mutableSnapshot.retain(); // Retain new snapshot during async mapper\n\n      await mapper(mutableSnapshot); // Continue to retain the new snapshot for the user, but auto-release it\n      // after the next tick, the same as a new synchronous snapshot.\n\n      mutableSnapshot.autoRelease_INTERNAL();\n      return mutableSnapshot;\n    });\n\n    this._store = {\n      storeID: getNextStoreID$1(),\n      parentStoreID,\n      getState: () => storeState,\n      replaceState: replacer => {\n        // no batching, so nextTree is never active\n        storeState.currentTree = replacer(storeState.currentTree);\n      },\n      getGraph: version => {\n        const graphs = storeState.graphsByVersion;\n\n        if (graphs.has(version)) {\n          return Recoil_nullthrows(graphs.get(version));\n        }\n\n        const newGraph = graph$1();\n        graphs.set(version, newGraph);\n        return newGraph;\n      },\n      subscribeToTransactions: () => ({\n        release: () => {}\n      }),\n      addTransactionMetadata: () => {\n        throw Recoil_err('Cannot subscribe to Snapshots');\n      }\n    }; // Initialize any nodes that are live in the parent store (primarily so that\n    // this snapshot gets counted towards the node's live stores count).\n    // TODO Optimize this when cloning snapshots for callbacks\n\n    for (const nodeKey of this._store.getState().knownAtoms) {\n      initializeNode$1(this._store, nodeKey, 'get');\n      updateRetainCount$1(this._store, nodeKey, 1);\n    }\n\n    this.autoRelease_INTERNAL();\n  }\n\n  retain() {\n    if (this._refCount <= 0) {\n      if (process.env.NODE_ENV !== \"production\") {\n        throw Recoil_err('Snapshot has already been released.');\n      } else {\n        Recoil_recoverableViolation('Attempt to retain() Snapshot that was already released.');\n      }\n    }\n\n    this._refCount++;\n    let released = false;\n    return () => {\n      if (!released) {\n        released = true;\n\n        this._release();\n      }\n    };\n  }\n  /**\n   * Release the snapshot on the next tick.  This means the snapshot is retained\n   * during the execution of the current function using it.\n   */\n\n\n  autoRelease_INTERNAL() {\n    if (!isSSR$1) {\n      // Use timeout of 10 to workaround Firefox issue: https://github.com/facebookexperimental/Recoil/issues/1936\n      window.setTimeout(() => this._release(), 10);\n    }\n  }\n\n  _release() {\n    this._refCount--;\n\n    if (this._refCount === 0) {\n      this._store.getState().nodeCleanupFunctions.forEach(cleanup => cleanup());\n\n      this._store.getState().nodeCleanupFunctions.clear();\n\n      if (!Recoil_gkx('recoil_memory_managament_2020')) {\n        return;\n      } // Temporarily nerfing this to allow us to find broken call sites without\n      // actually breaking anybody yet.\n      // for (const k of this._store.getState().knownAtoms) {\n      //   updateRetainCountToZero(this._store, k);\n      // }\n\n    } else if (this._refCount < 0) {\n      if (process.env.NODE_ENV !== \"production\") {\n        Recoil_recoverableViolation('Snapshot released an extra time.');\n      }\n    }\n  }\n\n  isRetained() {\n    return this._refCount > 0;\n  }\n\n  checkRefCount_INTERNAL() {\n    if (Recoil_gkx('recoil_memory_managament_2020') && this._refCount <= 0) {\n      if (process.env.NODE_ENV !== \"production\") {\n        Recoil_recoverableViolation(retainWarning);\n      } // What we will ship later:\n      // throw err(retainWarning);\n\n    }\n  }\n\n  getStore_INTERNAL() {\n    this.checkRefCount_INTERNAL();\n    return this._store;\n  }\n\n  getID() {\n    this.checkRefCount_INTERNAL();\n    return this._store.getState().currentTree.stateID;\n  }\n\n  getStoreID() {\n    this.checkRefCount_INTERNAL();\n    return this._store.storeID;\n  } // We want to allow the methods to be destructured and used as accessors\n\n  /* eslint-disable fb-www/extra-arrow-initializer */\n\n  /* eslint-enable fb-www/extra-arrow-initializer */\n\n\n}\n\nfunction cloneStoreState(store, treeState, bumpVersion = false) {\n  const storeState = store.getState();\n  const version = bumpVersion ? getNextTreeStateVersion$2() : treeState.version;\n  return {\n    // Always clone the TreeState to isolate stores from accidental mutations.\n    // For example, reading a selector from a cloned snapshot shouldn't cache\n    // in the original treestate which may cause the original to skip\n    // initialization of upstream atoms.\n    currentTree: {\n      // TODO snapshots shouldn't really have versions because a new version number\n      // is always assigned when the snapshot is gone to.\n      version: bumpVersion ? version : treeState.version,\n      stateID: bumpVersion ? version : treeState.stateID,\n      transactionMetadata: { ...treeState.transactionMetadata\n      },\n      dirtyAtoms: new Set(treeState.dirtyAtoms),\n      atomValues: treeState.atomValues.clone(),\n      nonvalidatedAtoms: treeState.nonvalidatedAtoms.clone()\n    },\n    commitDepth: 0,\n    nextTree: null,\n    previousTree: null,\n    knownAtoms: new Set(storeState.knownAtoms),\n    // FIXME here's a copy\n    knownSelectors: new Set(storeState.knownSelectors),\n    // FIXME here's a copy\n    transactionSubscriptions: new Map(),\n    nodeTransactionSubscriptions: new Map(),\n    nodeToComponentSubscriptions: new Map(),\n    queuedComponentCallbacks_DEPRECATED: [],\n    suspendedComponentResolvers: new Set(),\n    graphsByVersion: new Map().set(version, store.getGraph(treeState.version)),\n    retention: {\n      referenceCounts: new Map(),\n      nodesRetainedByZone: new Map(),\n      retainablesToCheckForRelease: new Set()\n    },\n    // FIXME here's a copy\n    // Create blank cleanup handlers for atoms so snapshots don't re-run\n    // atom effects.\n    nodeCleanupFunctions: new Map(Recoil_mapIterable(storeState.nodeCleanupFunctions.entries(), ([key]) => [key, () => {}]))\n  };\n} // Factory to build a fresh snapshot\n\n\nfunction freshSnapshot(initializeState) {\n  const snapshot = new Snapshot(makeEmptyStoreState$1());\n  return initializeState != null ? snapshot.map(initializeState) : snapshot;\n} // Factory to clone a snapshot state\n\n\nconst [memoizedCloneSnapshot, invalidateMemoizedSnapshot$2] = memoizeOneWithArgsHashAndInvalidation$1((store, version) => {\n  var _storeState$nextTree;\n\n  const storeState = store.getState();\n  const treeState = version === 'latest' ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : Recoil_nullthrows(storeState.previousTree);\n  return new Snapshot(cloneStoreState(store, treeState), store.storeID);\n}, (store, version) => {\n  var _store$getState$nextT, _store$getState$previ;\n\n  return String(version) + String(store.storeID) + String((_store$getState$nextT = store.getState().nextTree) === null || _store$getState$nextT === void 0 ? void 0 : _store$getState$nextT.version) + String(store.getState().currentTree.version) + String((_store$getState$previ = store.getState().previousTree) === null || _store$getState$previ === void 0 ? void 0 : _store$getState$previ.version);\n}); // Avoid circular dependencies\n\nsetInvalidateMemoizedSnapshot$1(invalidateMemoizedSnapshot$2);\n\nfunction cloneSnapshot(store, version = 'latest') {\n  const snapshot = memoizedCloneSnapshot(store, version);\n\n  if (!snapshot.isRetained()) {\n    invalidateMemoizedSnapshot$2();\n    return memoizedCloneSnapshot(store, version);\n  }\n\n  return snapshot;\n}\n\nclass MutableSnapshot extends Snapshot {\n  constructor(snapshot, batch) {\n    super(cloneStoreState(snapshot.getStore_INTERNAL(), snapshot.getStore_INTERNAL().getState().currentTree, true), snapshot.getStoreID());\n\n    _defineProperty(this, \"_batch\", void 0);\n\n    _defineProperty(this, \"set\", (recoilState, newValueOrUpdater) => {\n      this.checkRefCount_INTERNAL();\n      const store = this.getStore_INTERNAL(); // This batchUpdates ensures this `set` is applied immediately and you can\n      // read the written value after calling `set`. I would like to remove this\n      // behavior and only batch in `Snapshot.map`, but this would be a breaking\n      // change potentially.\n\n      this._batch(() => {\n        updateRetainCount$1(store, recoilState.key, 1);\n        setRecoilValue$1(this.getStore_INTERNAL(), recoilState, newValueOrUpdater);\n      });\n    });\n\n    _defineProperty(this, \"reset\", recoilState => {\n      this.checkRefCount_INTERNAL();\n      const store = this.getStore_INTERNAL(); // See note at `set` about batched updates.\n\n      this._batch(() => {\n        updateRetainCount$1(store, recoilState.key, 1);\n        setRecoilValue$1(this.getStore_INTERNAL(), recoilState, DEFAULT_VALUE$1);\n      });\n    });\n\n    _defineProperty(this, \"setUnvalidatedAtomValues_DEPRECATED\", values => {\n      this.checkRefCount_INTERNAL();\n      const store = this.getStore_INTERNAL(); // See note at `set` about batched updates.\n\n      batchUpdates$1(() => {\n        for (const [k, v] of values.entries()) {\n          updateRetainCount$1(store, k, 1);\n          setUnvalidatedRecoilValue$1(store, new AbstractRecoilValue$2(k), v);\n        }\n      });\n    });\n\n    this._batch = batch;\n  }\n\n}\n\nvar Recoil_Snapshot = {\n  Snapshot,\n  MutableSnapshot,\n  freshSnapshot,\n  cloneSnapshot\n};\n\nvar Recoil_Snapshot_1 = Recoil_Snapshot.Snapshot;\nvar Recoil_Snapshot_2 = Recoil_Snapshot.MutableSnapshot;\nvar Recoil_Snapshot_3 = Recoil_Snapshot.freshSnapshot;\nvar Recoil_Snapshot_4 = Recoil_Snapshot.cloneSnapshot;\n\nvar Recoil_Snapshot$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  Snapshot: Recoil_Snapshot_1,\n  MutableSnapshot: Recoil_Snapshot_2,\n  freshSnapshot: Recoil_Snapshot_3,\n  cloneSnapshot: Recoil_Snapshot_4\n});\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction unionSets(...sets) {\n  const result = new Set();\n\n  for (const set of sets) {\n    for (const value of set) {\n      result.add(value);\n    }\n  }\n\n  return result;\n}\n\nvar Recoil_unionSets = unionSets;\n\nconst {\n  useRef\n} = react;\n/**\n * The same as `useRef()` except that if a function is specified then it will\n * call that function to get the value to initialize the reference with.\n * This is similar to how `useState()` behaves when given a function.  It allows\n * the user to avoid generating the initial value for subsequent renders.\n * The tradeoff is that to set the reference to a function itself you need to\n * nest it: useRefInitOnce(() => () => {...});\n */\n\n\nfunction useRefInitOnce(initialValue) {\n  // $FlowExpectedError[incompatible-call]\n  const ref = useRef(initialValue);\n\n  if (ref.current === initialValue && typeof initialValue === 'function') {\n    // $FlowExpectedError[incompatible-use]\n    ref.current = initialValue();\n  }\n\n  return ref;\n}\n\nvar Recoil_useRefInitOnce = useRefInitOnce;\n\n// @fb-only: const RecoilusagelogEvent = require('RecoilusagelogEvent');\n// @fb-only: const RecoilUsageLogFalcoEvent = require('RecoilUsageLogFalcoEvent');\n// @fb-only: const URI = require('URI');\n\n\nconst {\n  getNextTreeStateVersion: getNextTreeStateVersion$3,\n  makeEmptyStoreState: makeEmptyStoreState$2\n} = Recoil_State;\n\nconst {\n  cleanUpNode: cleanUpNode$2,\n  getDownstreamNodes: getDownstreamNodes$2,\n  initializeNode: initializeNode$2,\n  setNodeValue: setNodeValue$2,\n  setUnvalidatedAtomValue_DEPRECATED: setUnvalidatedAtomValue_DEPRECATED$1\n} = Recoil_FunctionalCore;\n\nconst {\n  graph: graph$2\n} = Recoil_Graph;\n\nconst {\n  cloneGraph: cloneGraph$1\n} = Recoil_Graph;\n\nconst {\n  getNextStoreID: getNextStoreID$2\n} = Recoil_Keys;\n\nconst {\n  createMutableSource: createMutableSource$1,\n  reactMode: reactMode$2\n} = Recoil_ReactMode;\n\nconst {\n  applyAtomValueWrites: applyAtomValueWrites$1\n} = Recoil_RecoilValueInterface;\n\nconst {\n  releaseScheduledRetainablesNow: releaseScheduledRetainablesNow$1\n} = Recoil_Retention;\n\nconst {\n  freshSnapshot: freshSnapshot$1\n} = Recoil_Snapshot$1;\n\n\n\nconst {\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef: useRef$1,\n  useState\n} = react;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nfunction notInAContext() {\n  throw Recoil_err('This component must be used inside a <RecoilRoot> component.');\n}\n\nconst defaultStore = Object.freeze({\n  storeID: getNextStoreID$2(),\n  getState: notInAContext,\n  replaceState: notInAContext,\n  getGraph: notInAContext,\n  subscribeToTransactions: notInAContext,\n  addTransactionMetadata: notInAContext\n});\nlet stateReplacerIsBeingExecuted = false;\n\nfunction startNextTreeIfNeeded(store) {\n  if (stateReplacerIsBeingExecuted) {\n    throw Recoil_err('An atom update was triggered within the execution of a state updater function. State updater functions provided to Recoil must be pure functions.');\n  }\n\n  const storeState = store.getState();\n\n  if (storeState.nextTree === null) {\n    if (Recoil_gkx('recoil_memory_managament_2020') && Recoil_gkx('recoil_release_on_cascading_update_killswitch_2021')) {\n      // If this is a cascading update (that is, rendering due to one state change\n      // invokes a second state change), we won't have cleaned up retainables yet\n      // because this normally happens after notifying components. Do it before\n      // proceeding with the cascading update so that it remains predictable:\n      if (storeState.commitDepth > 0) {\n        releaseScheduledRetainablesNow$1(store);\n      }\n    }\n\n    const version = storeState.currentTree.version;\n    const nextVersion = getNextTreeStateVersion$3();\n    storeState.nextTree = { ...storeState.currentTree,\n      version: nextVersion,\n      stateID: nextVersion,\n      dirtyAtoms: new Set(),\n      transactionMetadata: {}\n    };\n    storeState.graphsByVersion.set(nextVersion, cloneGraph$1(Recoil_nullthrows(storeState.graphsByVersion.get(version))));\n  }\n}\n\nconst AppContext = react.createContext({\n  current: defaultStore\n});\n\nconst useStoreRef = () => useContext(AppContext); // $FlowExpectedError[incompatible-call]\n\n\nconst MutableSourceContext = react.createContext(null);\n\nfunction useRecoilMutableSource() {\n  const mutableSource = useContext(MutableSourceContext);\n\n  if (mutableSource == null) {\n    Recoil_expectationViolation('Attempted to use a Recoil hook outside of a <RecoilRoot>. ' + '<RecoilRoot> must be an ancestor of any component that uses ' + 'Recoil hooks.');\n  }\n\n  return mutableSource;\n}\n\nfunction notifyComponents(store, storeState, treeState) {\n  const dependentNodes = getDownstreamNodes$2(store, treeState, treeState.dirtyAtoms);\n\n  for (const key of dependentNodes) {\n    const comps = storeState.nodeToComponentSubscriptions.get(key);\n\n    if (comps) {\n      for (const [_subID, [_debugName, callback]] of comps) {\n        callback(treeState);\n      }\n    }\n  }\n}\n\nfunction sendEndOfBatchNotifications(store) {\n  const storeState = store.getState();\n  const treeState = storeState.currentTree; // Inform transaction subscribers of the transaction:\n\n  const dirtyAtoms = treeState.dirtyAtoms;\n\n  if (dirtyAtoms.size) {\n    // Execute Node-specific subscribers before global subscribers\n    for (const [key, subscriptions] of storeState.nodeTransactionSubscriptions) {\n      if (dirtyAtoms.has(key)) {\n        for (const [_, subscription] of subscriptions) {\n          subscription(store);\n        }\n      }\n    }\n\n    for (const [_, subscription] of storeState.transactionSubscriptions) {\n      subscription(store);\n    }\n\n    if (!reactMode$2().early || storeState.suspendedComponentResolvers.size > 0) {\n      // Notifying components is needed to wake from suspense, even when using\n      // early rendering.\n      notifyComponents(store, storeState, treeState); // Wake all suspended components so the right one(s) can try to re-render.\n      // We need to wake up components not just when some asynchronous selector\n      // resolved, but also when changing synchronous values because this may cause\n      // a selector to change from asynchronous to synchronous, in which case there\n      // would be no follow-up asynchronous resolution to wake us up.\n      // TODO OPTIMIZATION Only wake up related downstream components\n\n      storeState.suspendedComponentResolvers.forEach(cb => cb());\n      storeState.suspendedComponentResolvers.clear();\n    }\n  } // Special behavior ONLY invoked by useInterface.\n  // FIXME delete queuedComponentCallbacks_DEPRECATED when deleting useInterface.\n\n\n  storeState.queuedComponentCallbacks_DEPRECATED.forEach(cb => cb(treeState));\n  storeState.queuedComponentCallbacks_DEPRECATED.splice(0, storeState.queuedComponentCallbacks_DEPRECATED.length);\n}\n\nfunction endBatch(store) {\n  const storeState = store.getState();\n  storeState.commitDepth++;\n\n  try {\n    const {\n      nextTree\n    } = storeState; // Ignore commits that are not because of Recoil transactions -- namely,\n    // because something above RecoilRoot re-rendered:\n\n    if (nextTree == null) {\n      return;\n    } // nextTree is now committed -- note that copying and reset occurs when\n    // a transaction begins, in startNextTreeIfNeeded:\n\n\n    storeState.previousTree = storeState.currentTree;\n    storeState.currentTree = nextTree;\n    storeState.nextTree = null;\n    sendEndOfBatchNotifications(store);\n\n    if (storeState.previousTree != null) {\n      storeState.graphsByVersion.delete(storeState.previousTree.version);\n    } else {\n      Recoil_recoverableViolation('Ended batch with no previous state, which is unexpected', 'recoil');\n    }\n\n    storeState.previousTree = null;\n\n    if (Recoil_gkx('recoil_memory_managament_2020')) {\n      // Only release retainables if there were no writes during the end of the\n      // batch.  This avoids releasing something we might be about to use.\n      if (nextTree == null) {\n        releaseScheduledRetainablesNow$1(store);\n      }\n    }\n  } finally {\n    storeState.commitDepth--;\n  }\n}\n/*\n * The purpose of the Batcher is to observe when React batches end so that\n * Recoil state changes can be batched. Whenever Recoil state changes, we call\n * setState on the batcher. Then we wait for that change to be committed, which\n * signifies the end of the batch. That's when we respond to the Recoil change.\n */\n\n\nfunction Batcher({\n  setNotifyBatcherOfChange\n}) {\n  const storeRef = useStoreRef();\n  const [, setState] = useState([]);\n  setNotifyBatcherOfChange(() => setState({}));\n  useEffect(() => {\n    setNotifyBatcherOfChange(() => setState({})); // If an asynchronous selector resolves after the Batcher is unmounted,\n    // notifyBatcherOfChange will still be called. An error gets thrown whenever\n    // setState is called after a component is already unmounted, so this sets\n    // notifyBatcherOfChange to be a no-op.\n\n    return () => {\n      setNotifyBatcherOfChange(() => {});\n    };\n  }, [setNotifyBatcherOfChange]);\n  useEffect(() => {\n    // enqueueExecution runs this function immediately; it is only used to\n    // manipulate the order of useEffects during tests, since React seems to\n    // call useEffect in an unpredictable order sometimes.\n    Recoil_Queue.enqueueExecution('Batcher', () => {\n      endBatch(storeRef.current);\n    });\n  });\n  return null;\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  if (typeof window !== 'undefined' && !window.$recoilDebugStates) {\n    window.$recoilDebugStates = [];\n  }\n} // When removing this deprecated function, remove stateBySettingRecoilValue\n// which will no longer be needed.\n\n\nfunction initialStoreState_DEPRECATED(store, initializeState) {\n  const initial = makeEmptyStoreState$2();\n  initializeState({\n    set: (atom, value) => {\n      const state = initial.currentTree;\n      const writes = setNodeValue$2(store, state, atom.key, value);\n      const writtenNodes = new Set(writes.keys());\n      const nonvalidatedAtoms = state.nonvalidatedAtoms.clone();\n\n      for (const n of writtenNodes) {\n        nonvalidatedAtoms.delete(n);\n      }\n\n      initial.currentTree = { ...state,\n        dirtyAtoms: Recoil_unionSets(state.dirtyAtoms, writtenNodes),\n        atomValues: applyAtomValueWrites$1(state.atomValues, writes),\n        // NB: PLEASE un-export applyAtomValueWrites when deleting this code\n        nonvalidatedAtoms\n      };\n    },\n    setUnvalidatedAtomValues: atomValues => {\n      // FIXME replace this with a mutative loop\n      atomValues.forEach((v, k) => {\n        initial.currentTree = setUnvalidatedAtomValue_DEPRECATED$1(initial.currentTree, k, v);\n      });\n    }\n  });\n  return initial;\n} // Initialize state snapshot for <RecoilRoot> for the initializeState prop.\n// Atom effect initialization takes precedence over this prop.\n// Any atom effects will be run before initialization, but then cleaned up,\n// they are then re-run when used as part of rendering.  These semantics are\n// compatible with React StrictMode where effects may be re-run multiple times\n// but state initialization only happens once the first time.\n\n\nfunction initialStoreState(initializeState) {\n  // Initialize a snapshot and get its store\n  const snapshot = freshSnapshot$1(initializeState);\n  const storeState = snapshot.getStore_INTERNAL().getState(); // Counteract the snapshot auto-release\n\n  snapshot.retain(); // Cleanup any effects run during initialization and clear the handlers so\n  // they will re-initialize if used during rendering.  This allows atom effect\n  // initialization to take precedence over initializeState and be compatible\n  // with StrictMode semantics.\n\n  storeState.nodeCleanupFunctions.forEach(cleanup => cleanup());\n  storeState.nodeCleanupFunctions.clear();\n  return storeState;\n}\n\nlet nextID = 0;\n\nfunction RecoilRoot_INTERNAL({\n  initializeState_DEPRECATED,\n  initializeState,\n  store_INTERNAL: storeProp,\n  // For use with React \"context bridging\"\n  children\n}) {\n  // prettier-ignore\n  // @fb-only: useEffect(() => {\n  // @fb-only: if (gkx('recoil_usage_logging')) {\n  // @fb-only: try {\n  // @fb-only: RecoilUsageLogFalcoEvent.log(() => ({\n  // @fb-only: type: RecoilusagelogEvent.RECOIL_ROOT_MOUNTED,\n  // @fb-only: path: URI.getRequestURI().getPath(),\n  // @fb-only: }));\n  // @fb-only: } catch {\n  // @fb-only: recoverableViolation(\n  // @fb-only: 'Error when logging Recoil Usage event',\n  // @fb-only: 'recoil',\n  // @fb-only: );\n  // @fb-only: }\n  // @fb-only: }\n  // @fb-only: }, []);\n  let storeStateRef; // eslint-disable-line prefer-const\n\n  const getGraph = version => {\n    const graphs = storeStateRef.current.graphsByVersion;\n\n    if (graphs.has(version)) {\n      return Recoil_nullthrows(graphs.get(version));\n    }\n\n    const newGraph = graph$2();\n    graphs.set(version, newGraph);\n    return newGraph;\n  };\n\n  const subscribeToTransactions = (callback, key) => {\n    if (key == null) {\n      // Global transaction subscriptions\n      const {\n        transactionSubscriptions\n      } = storeRef.current.getState();\n      const id = nextID++;\n      transactionSubscriptions.set(id, callback);\n      return {\n        release: () => {\n          transactionSubscriptions.delete(id);\n        }\n      };\n    } else {\n      // Node-specific transaction subscriptions:\n      const {\n        nodeTransactionSubscriptions\n      } = storeRef.current.getState();\n\n      if (!nodeTransactionSubscriptions.has(key)) {\n        nodeTransactionSubscriptions.set(key, new Map());\n      }\n\n      const id = nextID++;\n      Recoil_nullthrows(nodeTransactionSubscriptions.get(key)).set(id, callback);\n      return {\n        release: () => {\n          const subs = nodeTransactionSubscriptions.get(key);\n\n          if (subs) {\n            subs.delete(id);\n\n            if (subs.size === 0) {\n              nodeTransactionSubscriptions.delete(key);\n            }\n          }\n        }\n      };\n    }\n  };\n\n  const addTransactionMetadata = metadata => {\n    startNextTreeIfNeeded(storeRef.current);\n\n    for (const k of Object.keys(metadata)) {\n      Recoil_nullthrows(storeRef.current.getState().nextTree).transactionMetadata[k] = metadata[k];\n    }\n  };\n\n  const replaceState = replacer => {\n    startNextTreeIfNeeded(storeRef.current); // Use replacer to get the next state:\n\n    const nextTree = Recoil_nullthrows(storeStateRef.current.nextTree);\n    let replaced;\n\n    try {\n      stateReplacerIsBeingExecuted = true;\n      replaced = replacer(nextTree);\n    } finally {\n      stateReplacerIsBeingExecuted = false;\n    }\n\n    if (replaced === nextTree) {\n      return;\n    }\n\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof window !== 'undefined') {\n        window.$recoilDebugStates.push(replaced); // TODO this shouldn't happen here because it's not batched\n      }\n    } // Save changes to nextTree and schedule a React update:\n\n\n    storeStateRef.current.nextTree = replaced;\n\n    if (reactMode$2().early) {\n      notifyComponents(storeRef.current, storeStateRef.current, replaced);\n    }\n\n    Recoil_nullthrows(notifyBatcherOfChange.current)();\n  };\n\n  const notifyBatcherOfChange = useRef$1(null);\n  const setNotifyBatcherOfChange = useCallback(x => {\n    notifyBatcherOfChange.current = x;\n  }, [notifyBatcherOfChange]);\n  const storeRef = Recoil_useRefInitOnce(() => storeProp !== null && storeProp !== void 0 ? storeProp : {\n    storeID: getNextStoreID$2(),\n    getState: () => storeStateRef.current,\n    replaceState,\n    getGraph,\n    subscribeToTransactions,\n    addTransactionMetadata\n  });\n\n  if (storeProp != null) {\n    storeRef.current = storeProp;\n  }\n\n  storeStateRef = Recoil_useRefInitOnce(() => initializeState_DEPRECATED != null ? initialStoreState_DEPRECATED(storeRef.current, initializeState_DEPRECATED) : initializeState != null ? initialStoreState(initializeState) : makeEmptyStoreState$2());\n  const mutableSource = useMemo(() => createMutableSource$1 === null || createMutableSource$1 === void 0 ? void 0 : createMutableSource$1(storeStateRef, () => storeStateRef.current.currentTree.version), [storeStateRef]); // Cleanup when the <RecoilRoot> is unmounted\n\n  useEffect(() => {\n    // React is free to call effect cleanup handlers and effects at will, the\n    // deps array is only an optimization.  For example, React strict mode\n    // will execute each effect twice for testing.  Therefore, we need symmetry\n    // to re-initialize all known atoms after they were cleaned up.\n    const store = storeRef.current;\n\n    for (const atomKey of new Set(store.getState().knownAtoms)) {\n      initializeNode$2(store, atomKey, 'get');\n    }\n\n    return () => {\n      for (const atomKey of store.getState().knownAtoms) {\n        cleanUpNode$2(store, atomKey);\n      }\n    };\n  }, [storeRef]);\n  return /*#__PURE__*/react.createElement(AppContext.Provider, {\n    value: storeRef\n  }, /*#__PURE__*/react.createElement(MutableSourceContext.Provider, {\n    value: mutableSource\n  }, /*#__PURE__*/react.createElement(Batcher, {\n    setNotifyBatcherOfChange: setNotifyBatcherOfChange\n  }), children));\n}\n\nfunction RecoilRoot(props) {\n  const {\n    override,\n    ...propsExceptOverride\n  } = props;\n  const ancestorStoreRef = useStoreRef();\n\n  if (override === false && ancestorStoreRef.current !== defaultStore) {\n    // If ancestorStoreRef.current !== defaultStore, it means that this\n    // RecoilRoot is not nested within another.\n    return props.children;\n  }\n\n  return /*#__PURE__*/react.createElement(RecoilRoot_INTERNAL, propsExceptOverride);\n}\n\nfunction useRecoilStoreID() {\n  return useStoreRef().current.storeID;\n}\n\nvar Recoil_RecoilRoot = {\n  RecoilRoot,\n  useStoreRef,\n  useRecoilMutableSource,\n  useRecoilStoreID,\n  notifyComponents_FOR_TESTING: notifyComponents,\n  sendEndOfBatchNotifications_FOR_TESTING: sendEndOfBatchNotifications\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction shallowArrayEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  for (let i = 0, l = a.length; i < l; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nvar Recoil_shallowArrayEqual = shallowArrayEqual;\n\nconst {\n  useEffect: useEffect$1,\n  useRef: useRef$2\n} = react;\n\nfunction usePrevious(value) {\n  const ref = useRef$2();\n  useEffect$1(() => {\n    ref.current = value;\n  });\n  return ref.current;\n}\n\nvar Recoil_usePrevious = usePrevious;\n\nconst {\n  useStoreRef: useStoreRef$1\n} = Recoil_RecoilRoot;\n\nconst {\n  SUSPENSE_TIMEOUT_MS: SUSPENSE_TIMEOUT_MS$1\n} = Recoil_Retention;\n\nconst {\n  updateRetainCount: updateRetainCount$2\n} = Recoil_Retention;\n\nconst {\n  RetentionZone: RetentionZone$3\n} = Recoil_RetentionZone;\n\nconst {\n  useEffect: useEffect$2,\n  useRef: useRef$3\n} = react;\n\nconst {\n  isSSR: isSSR$2\n} = Recoil_Environment;\n\n\n\n\n\n // I don't see a way to avoid the any type here because we want to accept readable\n// and writable values with any type parameter, but normally with writable ones\n// RecoilState<SomeT> is not a subtype of RecoilState<mixed>.\n\n\n// flowlint-line unclear-type:off\nfunction useRetain(toRetain) {\n  if (!Recoil_gkx('recoil_memory_managament_2020')) {\n    return;\n  } // eslint-disable-next-line fb-www/react-hooks\n\n\n  return useRetain_ACTUAL(toRetain);\n}\n\nfunction useRetain_ACTUAL(toRetain) {\n  const array = Array.isArray(toRetain) ? toRetain : [toRetain];\n  const retainables = array.map(a => a instanceof RetentionZone$3 ? a : a.key);\n  const storeRef = useStoreRef$1();\n  useEffect$2(() => {\n    if (!Recoil_gkx('recoil_memory_managament_2020')) {\n      return;\n    }\n\n    const store = storeRef.current;\n\n    if (timeoutID.current && !isSSR$2) {\n      // Already performed a temporary retain on render, simply cancel the release\n      // of that temporary retain.\n      window.clearTimeout(timeoutID.current);\n      timeoutID.current = null;\n    } else {\n      for (const r of retainables) {\n        updateRetainCount$2(store, r, 1);\n      }\n    }\n\n    return () => {\n      for (const r of retainables) {\n        updateRetainCount$2(store, r, -1);\n      }\n    }; // eslint-disable-next-line fb-www/react-hooks-deps\n  }, [storeRef, ...retainables]); // We want to retain if the component suspends. This is terrible but the Suspense\n  // API affords us no better option. If we suspend and never commit after some\n  // seconds, then release. The 'actual' retain/release in the effect above\n  // cancels this.\n\n  const timeoutID = useRef$3();\n  const previousRetainables = Recoil_usePrevious(retainables);\n\n  if (!isSSR$2 && (previousRetainables === undefined || !Recoil_shallowArrayEqual(previousRetainables, retainables))) {\n    const store = storeRef.current;\n\n    for (const r of retainables) {\n      updateRetainCount$2(store, r, 1);\n    }\n\n    if (previousRetainables) {\n      for (const r of previousRetainables) {\n        updateRetainCount$2(store, r, -1);\n      }\n    }\n\n    if (timeoutID.current) {\n      window.clearTimeout(timeoutID.current);\n    }\n\n    timeoutID.current = window.setTimeout(() => {\n      timeoutID.current = null;\n\n      for (const r of retainables) {\n        updateRetainCount$2(store, r, -1);\n      }\n    }, SUSPENSE_TIMEOUT_MS$1);\n  }\n}\n\nvar Recoil_useRetain = useRetain;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * THIS CODE HAS BEEN COMMENTED OUT INTENTIONALLY\n *\n * This technique of getting the component name is imperfect, since it both only\n * works in a non-minified code base, and more importantly introduces performance\n * problems since it relies in throwing errors which is an expensive operation.\n *\n * At some point we may want to reevaluate this technique hence why we have commented\n * this code out, rather than delete it all together.\n */\n// const {useRef} = require('react');\n// const gkx = require('recoil-shared/util/Recoil_gkx');\n// const stackTraceParser = require('recoil-shared/util/Recoil_stackTraceParser');\n\nfunction useComponentName() {\n  // const nameRef = useRef();\n  // if (__DEV__) {\n  //   if (gkx('recoil_infer_component_names')) {\n  //     if (nameRef.current === undefined) {\n  //       // There is no blessed way to determine the calling React component from\n  //       // within a hook. This hack uses the fact that hooks must start with 'use'\n  //       // and that hooks are either called by React Components or other hooks. It\n  //       // follows therefore, that to find the calling component, you simply need\n  //       // to look down the stack and find the first function which doesn't start\n  //       // with 'use'. We are only enabling this in dev for now, since once the\n  //       // codebase is minified, the naming assumptions no longer hold true.\n  //       // eslint-disable-next-line fb-www/no-new-error\n  //       const frames = stackTraceParser(new Error().stack);\n  //       for (const {methodName} of frames) {\n  //         // I observed cases where the frame was of the form 'Object.useXXX'\n  //         // hence why I'm searching for hooks following a word boundary\n  //         if (!methodName.match(/\\buse[^\\b]+$/)) {\n  //           return (nameRef.current = methodName);\n  //         }\n  //       }\n  //       nameRef.current = null;\n  //     }\n  //     return nameRef.current ?? '<unable to determine component name>';\n  //   }\n  // }\n  // @fb-only: return \"<component name only available when both in dev mode and when passing GK 'recoil_infer_component_names'>\";\n  return '<component name not available>'; // @oss-only\n}\n\nvar Recoil_useComponentName = useComponentName;\n\nconst {\n  batchUpdates: batchUpdates$2\n} = Recoil_Batching;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$2\n} = Recoil_Node;\n\nconst {\n  currentRendererSupportsUseSyncExternalStore: currentRendererSupportsUseSyncExternalStore$1,\n  reactMode: reactMode$3,\n  useMutableSource: useMutableSource$1,\n  useSyncExternalStore: useSyncExternalStore$1\n} = Recoil_ReactMode;\n\nconst {\n  useRecoilMutableSource: useRecoilMutableSource$1,\n  useStoreRef: useStoreRef$2\n} = Recoil_RecoilRoot;\n\nconst {\n  isRecoilValue: isRecoilValue$2\n} = Recoil_RecoilValue$1;\n\nconst {\n  AbstractRecoilValue: AbstractRecoilValue$3,\n  getRecoilValueAsLoadable: getRecoilValueAsLoadable$2,\n  setRecoilValue: setRecoilValue$2,\n  setUnvalidatedRecoilValue: setUnvalidatedRecoilValue$2,\n  subscribeToRecoilValue: subscribeToRecoilValue$1\n} = Recoil_RecoilValueInterface;\n\n\n\nconst {\n  useCallback: useCallback$1,\n  useEffect: useEffect$3,\n  useMemo: useMemo$1,\n  useRef: useRef$4,\n  useState: useState$1\n} = react;\n\nconst {\n  setByAddingToSet: setByAddingToSet$2\n} = Recoil_CopyOnWrite;\n\n\n\n\n\n\n\n\n\n\n\n\n\nfunction handleLoadable(loadable, recoilValue, storeRef) {\n  // We can't just throw the promise we are waiting on to Suspense.  If the\n  // upstream dependencies change it may produce a state in which the component\n  // can render, but it would still be suspended on a Promise that may never resolve.\n  if (loadable.state === 'hasValue') {\n    return loadable.contents;\n  } else if (loadable.state === 'loading') {\n    const promise = new Promise(resolve => {\n      storeRef.current.getState().suspendedComponentResolvers.add(resolve);\n    }); // $FlowExpectedError Flow(prop-missing) for integrating with tools that inspect thrown promises @fb-only\n    // @fb-only: promise.displayName = `Recoil State: ${recoilValue.key}`;\n\n    throw promise;\n  } else if (loadable.state === 'hasError') {\n    throw loadable.contents;\n  } else {\n    throw Recoil_err(`Invalid value of loadable atom \"${recoilValue.key}\"`);\n  }\n}\n\nfunction validateRecoilValue(recoilValue, hookName) {\n  if (!isRecoilValue$2(recoilValue)) {\n    throw Recoil_err(`Invalid argument to ${hookName}: expected an atom or selector but got ${String(recoilValue)}`);\n  }\n}\n\n/**\n * Various things are broken with useRecoilInterface, particularly concurrent\n * mode, React strict mode, and memory management. They will not be fixed.\n * */\nfunction useRecoilInterface_DEPRECATED() {\n  const componentName = Recoil_useComponentName();\n  const storeRef = useStoreRef$2(); // eslint-disable-next-line fb-www/react-no-unused-state-hook\n\n  const [, forceUpdate] = useState$1([]);\n  const recoilValuesUsed = useRef$4(new Set());\n  recoilValuesUsed.current = new Set(); // Track the RecoilValues used just during this render\n\n  const previousSubscriptions = useRef$4(new Set());\n  const subscriptions = useRef$4(new Map());\n  const unsubscribeFrom = useCallback$1(key => {\n    const sub = subscriptions.current.get(key);\n\n    if (sub) {\n      sub.release();\n      subscriptions.current.delete(key);\n    }\n  }, [subscriptions]);\n  const updateState = useCallback$1((_state, key) => {\n    if (subscriptions.current.has(key)) {\n      forceUpdate([]);\n    }\n  }, []); // Effect to add/remove subscriptions as nodes are used\n\n  useEffect$3(() => {\n    const store = storeRef.current;\n    Recoil_differenceSets(recoilValuesUsed.current, previousSubscriptions.current).forEach(key => {\n      if (subscriptions.current.has(key)) {\n        Recoil_expectationViolation(`Double subscription to RecoilValue \"${key}\"`);\n        return;\n      }\n\n      const sub = subscribeToRecoilValue$1(store, new AbstractRecoilValue$3(key), state => updateState(state, key), componentName);\n      subscriptions.current.set(key, sub);\n      /**\n       * Since we're subscribing in an effect we need to update to the latest\n       * value of the atom since it may have changed since we rendered. We can\n       * go ahead and do that now, unless we're in the middle of a batch --\n       * in which case we should do it at the end of the batch, due to the\n       * following edge case: Suppose an atom is updated in another useEffect\n       * of this same component. Then the following sequence of events occur:\n       * 1. Atom is updated and subs fired (but we may not be subscribed\n       *    yet depending on order of effects, so we miss this) Updated value\n       *    is now in nextTree, but not currentTree.\n       * 2. This effect happens. We subscribe and update.\n       * 3. From the update we re-render and read currentTree, with old value.\n       * 4. Batcher's effect sets currentTree to nextTree.\n       * In this sequence we miss the update. To avoid that, add the update\n       * to queuedComponentCallback if a batch is in progress.\n       */\n      // FIXME delete queuedComponentCallbacks_DEPRECATED when deleting useInterface.\n\n      const state = store.getState();\n\n      if (state.nextTree) {\n        store.getState().queuedComponentCallbacks_DEPRECATED.push(() => {\n          updateState(store.getState(), key);\n        });\n      } else {\n        updateState(store.getState(), key);\n      }\n    });\n    Recoil_differenceSets(previousSubscriptions.current, recoilValuesUsed.current).forEach(key => {\n      unsubscribeFrom(key);\n    });\n    previousSubscriptions.current = recoilValuesUsed.current;\n  }); // Effect to unsubscribe from all when unmounting\n\n  useEffect$3(() => {\n    const currentSubscriptions = subscriptions.current; // Restore subscriptions that were cleared due to StrictMode running this effect twice\n\n    Recoil_differenceSets(recoilValuesUsed.current, new Set(currentSubscriptions.keys())).forEach(key => {\n      const sub = subscribeToRecoilValue$1(storeRef.current, new AbstractRecoilValue$3(key), state => updateState(state, key), componentName);\n      currentSubscriptions.set(key, sub);\n    });\n    return () => currentSubscriptions.forEach((_, key) => unsubscribeFrom(key));\n  }, [componentName, storeRef, unsubscribeFrom, updateState]);\n  return useMemo$1(() => {\n    // eslint-disable-next-line no-shadow\n    function useSetRecoilState(recoilState) {\n      if (process.env.NODE_ENV !== \"production\") {\n        validateRecoilValue(recoilState, 'useSetRecoilState');\n      }\n\n      return newValueOrUpdater => {\n        setRecoilValue$2(storeRef.current, recoilState, newValueOrUpdater);\n      };\n    } // eslint-disable-next-line no-shadow\n\n\n    function useResetRecoilState(recoilState) {\n      if (process.env.NODE_ENV !== \"production\") {\n        validateRecoilValue(recoilState, 'useResetRecoilState');\n      }\n\n      return () => setRecoilValue$2(storeRef.current, recoilState, DEFAULT_VALUE$2);\n    } // eslint-disable-next-line no-shadow\n\n\n    function useRecoilValueLoadable(recoilValue) {\n      var _storeState$nextTree;\n\n      if (process.env.NODE_ENV !== \"production\") {\n        validateRecoilValue(recoilValue, 'useRecoilValueLoadable');\n      }\n\n      if (!recoilValuesUsed.current.has(recoilValue.key)) {\n        recoilValuesUsed.current = setByAddingToSet$2(recoilValuesUsed.current, recoilValue.key);\n      } // TODO Restore optimization to memoize lookup\n\n\n      const storeState = storeRef.current.getState();\n      return getRecoilValueAsLoadable$2(storeRef.current, recoilValue, reactMode$3().early ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : storeState.currentTree);\n    } // eslint-disable-next-line no-shadow\n\n\n    function useRecoilValue(recoilValue) {\n      if (process.env.NODE_ENV !== \"production\") {\n        validateRecoilValue(recoilValue, 'useRecoilValue');\n      }\n\n      const loadable = useRecoilValueLoadable(recoilValue);\n      return handleLoadable(loadable, recoilValue, storeRef);\n    } // eslint-disable-next-line no-shadow\n\n\n    function useRecoilState(recoilState) {\n      if (process.env.NODE_ENV !== \"production\") {\n        validateRecoilValue(recoilState, 'useRecoilState');\n      }\n\n      return [useRecoilValue(recoilState), useSetRecoilState(recoilState)];\n    } // eslint-disable-next-line no-shadow\n\n\n    function useRecoilStateLoadable(recoilState) {\n      if (process.env.NODE_ENV !== \"production\") {\n        validateRecoilValue(recoilState, 'useRecoilStateLoadable');\n      }\n\n      return [useRecoilValueLoadable(recoilState), useSetRecoilState(recoilState)];\n    }\n\n    return {\n      getRecoilValue: useRecoilValue,\n      getRecoilValueLoadable: useRecoilValueLoadable,\n      getRecoilState: useRecoilState,\n      getRecoilStateLoadable: useRecoilStateLoadable,\n      getSetRecoilState: useSetRecoilState,\n      getResetRecoilState: useResetRecoilState\n    };\n  }, [recoilValuesUsed, storeRef]);\n}\n\nconst recoilComponentGetRecoilValueCount_FOR_TESTING = {\n  current: 0\n};\n\nfunction useRecoilValueLoadable_SYNC_EXTERNAL_STORE(recoilValue) {\n  const storeRef = useStoreRef$2();\n  const componentName = Recoil_useComponentName();\n  const getSnapshot = useCallback$1(() => {\n    var _storeState$nextTree2;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      recoilComponentGetRecoilValueCount_FOR_TESTING.current++;\n    }\n\n    const store = storeRef.current;\n    const storeState = store.getState();\n    const treeState = reactMode$3().early ? (_storeState$nextTree2 = storeState.nextTree) !== null && _storeState$nextTree2 !== void 0 ? _storeState$nextTree2 : storeState.currentTree : storeState.currentTree;\n    const loadable = getRecoilValueAsLoadable$2(store, recoilValue, treeState);\n    return {\n      loadable,\n      key: recoilValue.key\n    };\n  }, [storeRef, recoilValue]); // Memoize the state to avoid unnecessary rerenders\n\n  const memoizePreviousSnapshot = useCallback$1(getState => {\n    let prevState;\n    return () => {\n      var _prevState, _prevState2;\n\n      const nextState = getState();\n\n      if ((_prevState = prevState) !== null && _prevState !== void 0 && _prevState.loadable.is(nextState.loadable) && ((_prevState2 = prevState) === null || _prevState2 === void 0 ? void 0 : _prevState2.key) === nextState.key) {\n        return prevState;\n      }\n\n      prevState = nextState;\n      return nextState;\n    };\n  }, []);\n  const getMemoizedSnapshot = useMemo$1(() => memoizePreviousSnapshot(getSnapshot), [getSnapshot, memoizePreviousSnapshot]);\n  const subscribe = useCallback$1(notify => {\n    const store = storeRef.current;\n    const subscription = subscribeToRecoilValue$1(store, recoilValue, notify, componentName);\n    return subscription.release;\n  }, [storeRef, recoilValue, componentName]);\n  return useSyncExternalStore$1(subscribe, getMemoizedSnapshot, // getSnapshot()\n  getMemoizedSnapshot // getServerSnapshot() for SSR support\n  ).loadable;\n}\n\nfunction useRecoilValueLoadable_MUTABLE_SOURCE(recoilValue) {\n  const storeRef = useStoreRef$2();\n  const getLoadable = useCallback$1(() => {\n    var _storeState$nextTree3;\n\n    const store = storeRef.current;\n    const storeState = store.getState();\n    const treeState = reactMode$3().early ? (_storeState$nextTree3 = storeState.nextTree) !== null && _storeState$nextTree3 !== void 0 ? _storeState$nextTree3 : storeState.currentTree : storeState.currentTree;\n    return getRecoilValueAsLoadable$2(store, recoilValue, treeState);\n  }, [storeRef, recoilValue]);\n  const getLoadableWithTesting = useCallback$1(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      recoilComponentGetRecoilValueCount_FOR_TESTING.current++;\n    }\n\n    return getLoadable();\n  }, [getLoadable]);\n  const componentName = Recoil_useComponentName();\n  const subscribe = useCallback$1((_storeState, notify) => {\n    const store = storeRef.current;\n    const subscription = subscribeToRecoilValue$1(store, recoilValue, () => {\n      if (!Recoil_gkx('recoil_suppress_rerender_in_callback')) {\n        return notify();\n      } // Only re-render if the value has changed.\n      // This will evaluate the atom/selector now as well as when the\n      // component renders, but that may help with prefetching.\n\n\n      const newLoadable = getLoadable();\n\n      if (!prevLoadableRef.current.is(newLoadable)) {\n        notify();\n      } // If the component is suspended then the effect setting prevLoadableRef\n      // will not run.  So, set the previous value here when its subscription\n      // is fired to wake it up.  We can't just rely on this, though, because\n      // this only executes when an atom/selector is dirty and the atom/selector\n      // passed to the hook can dynamically change.\n\n\n      prevLoadableRef.current = newLoadable;\n    }, componentName);\n    return subscription.release;\n  }, [storeRef, recoilValue, componentName, getLoadable]);\n  const source = useRecoilMutableSource$1();\n\n  if (source == null) {\n    throw Recoil_err('Recoil hooks must be used in components contained within a <RecoilRoot> component.');\n  }\n\n  const loadable = useMutableSource$1(source, getLoadableWithTesting, subscribe);\n  const prevLoadableRef = useRef$4(loadable);\n  useEffect$3(() => {\n    prevLoadableRef.current = loadable;\n  });\n  return loadable;\n}\n\nfunction useRecoilValueLoadable_TRANSITION_SUPPORT(recoilValue) {\n  const storeRef = useStoreRef$2();\n  const componentName = Recoil_useComponentName(); // Accessors to get the current state\n\n  const getLoadable = useCallback$1(() => {\n    var _storeState$nextTree4;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      recoilComponentGetRecoilValueCount_FOR_TESTING.current++;\n    }\n\n    const store = storeRef.current;\n    const storeState = store.getState();\n    const treeState = reactMode$3().early ? (_storeState$nextTree4 = storeState.nextTree) !== null && _storeState$nextTree4 !== void 0 ? _storeState$nextTree4 : storeState.currentTree : storeState.currentTree;\n    return getRecoilValueAsLoadable$2(store, recoilValue, treeState);\n  }, [storeRef, recoilValue]);\n  const getState = useCallback$1(() => ({\n    loadable: getLoadable(),\n    key: recoilValue.key\n  }), [getLoadable, recoilValue.key]); // Memoize state snapshots\n\n  const updateState = useCallback$1(prevState => {\n    const nextState = getState();\n    return prevState.loadable.is(nextState.loadable) && prevState.key === nextState.key ? prevState : nextState;\n  }, [getState]); // Subscribe to Recoil state changes\n\n  useEffect$3(() => {\n    const subscription = subscribeToRecoilValue$1(storeRef.current, recoilValue, _state => {\n      setState(updateState);\n    }, componentName); // Update state in case we are using a different key\n\n    setState(updateState);\n    return subscription.release;\n  }, [componentName, recoilValue, storeRef, updateState]); // Get the current state\n\n  const [state, setState] = useState$1(getState); // If we changed keys, then return the state for the new key.\n  // This is important in case the old key would cause the component to suspend.\n  // We don't have to set the new state here since the subscribing effect above\n  // will do that.\n\n  return state.key !== recoilValue.key ? getState().loadable : state.loadable;\n}\n\nfunction useRecoilValueLoadable_LEGACY(recoilValue) {\n  const storeRef = useStoreRef$2(); // eslint-disable-next-line fb-www/react-no-unused-state-hook\n\n  const [, forceUpdate] = useState$1([]);\n  const componentName = Recoil_useComponentName();\n  const getLoadable = useCallback$1(() => {\n    var _storeState$nextTree5;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      recoilComponentGetRecoilValueCount_FOR_TESTING.current++;\n    }\n\n    const store = storeRef.current;\n    const storeState = store.getState();\n    const treeState = reactMode$3().early ? (_storeState$nextTree5 = storeState.nextTree) !== null && _storeState$nextTree5 !== void 0 ? _storeState$nextTree5 : storeState.currentTree : storeState.currentTree;\n    return getRecoilValueAsLoadable$2(store, recoilValue, treeState);\n  }, [storeRef, recoilValue]);\n  const loadable = getLoadable();\n  const prevLoadableRef = useRef$4(loadable);\n  useEffect$3(() => {\n    prevLoadableRef.current = loadable;\n  });\n  useEffect$3(() => {\n    const store = storeRef.current;\n    const storeState = store.getState();\n    const subscription = subscribeToRecoilValue$1(store, recoilValue, _state => {\n      var _prevLoadableRef$curr;\n\n      if (!Recoil_gkx('recoil_suppress_rerender_in_callback')) {\n        return forceUpdate([]);\n      }\n\n      const newLoadable = getLoadable();\n\n      if (!((_prevLoadableRef$curr = prevLoadableRef.current) !== null && _prevLoadableRef$curr !== void 0 && _prevLoadableRef$curr.is(newLoadable))) {\n        forceUpdate(newLoadable);\n      }\n\n      prevLoadableRef.current = newLoadable;\n    }, componentName);\n    /**\n     * Since we're subscribing in an effect we need to update to the latest\n     * value of the atom since it may have changed since we rendered. We can\n     * go ahead and do that now, unless we're in the middle of a batch --\n     * in which case we should do it at the end of the batch, due to the\n     * following edge case: Suppose an atom is updated in another useEffect\n     * of this same component. Then the following sequence of events occur:\n     * 1. Atom is updated and subs fired (but we may not be subscribed\n     *    yet depending on order of effects, so we miss this) Updated value\n     *    is now in nextTree, but not currentTree.\n     * 2. This effect happens. We subscribe and update.\n     * 3. From the update we re-render and read currentTree, with old value.\n     * 4. Batcher's effect sets currentTree to nextTree.\n     * In this sequence we miss the update. To avoid that, add the update\n     * to queuedComponentCallback if a batch is in progress.\n     */\n\n    if (storeState.nextTree) {\n      store.getState().queuedComponentCallbacks_DEPRECATED.push(() => {\n        prevLoadableRef.current = null;\n        forceUpdate([]);\n      });\n    } else {\n      var _prevLoadableRef$curr2;\n\n      if (!Recoil_gkx('recoil_suppress_rerender_in_callback')) {\n        return forceUpdate([]);\n      }\n\n      const newLoadable = getLoadable();\n\n      if (!((_prevLoadableRef$curr2 = prevLoadableRef.current) !== null && _prevLoadableRef$curr2 !== void 0 && _prevLoadableRef$curr2.is(newLoadable))) {\n        forceUpdate(newLoadable);\n      }\n\n      prevLoadableRef.current = newLoadable;\n    }\n\n    return subscription.release;\n  }, [componentName, getLoadable, recoilValue, storeRef]);\n  return loadable;\n}\n/**\n  Like useRecoilValue(), but either returns the value if available or\n  just undefined if not available for any reason, such as pending or error.\n*/\n\n\nfunction useRecoilValueLoadable(recoilValue) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilValue, 'useRecoilValueLoadable');\n  }\n\n  if (Recoil_gkx('recoil_memory_managament_2020')) {\n    // eslint-disable-next-line fb-www/react-hooks\n    Recoil_useRetain(recoilValue);\n  }\n\n  return {\n    TRANSITION_SUPPORT: useRecoilValueLoadable_TRANSITION_SUPPORT,\n    // Recoil will attemp to detect if `useSyncExternalStore()` is supported with\n    // `reactMode()` before calling it.  However, sometimes the host React\n    // environment supports it but uses additional React renderers (such as with\n    // `react-three-fiber`) which do not.  While this is technically a user issue\n    // by using a renderer with React 18+ that doesn't fully support React 18 we\n    // don't want to break users if it can be avoided. As the current renderer can\n    // change at runtime, we need to dynamically check and fallback if necessary.\n    SYNC_EXTERNAL_STORE: currentRendererSupportsUseSyncExternalStore$1() ? useRecoilValueLoadable_SYNC_EXTERNAL_STORE : useRecoilValueLoadable_TRANSITION_SUPPORT,\n    MUTABLE_SOURCE: useRecoilValueLoadable_MUTABLE_SOURCE,\n    LEGACY: useRecoilValueLoadable_LEGACY\n  }[reactMode$3().mode](recoilValue);\n}\n/**\n  Returns the value represented by the RecoilValue.\n  If the value is pending, it will throw a Promise to suspend the component,\n  if the value is an error it will throw it for the nearest React error boundary.\n  This will also subscribe the component for any updates in the value.\n  */\n\n\nfunction useRecoilValue(recoilValue) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilValue, 'useRecoilValue');\n  }\n\n  const storeRef = useStoreRef$2();\n  const loadable = useRecoilValueLoadable(recoilValue);\n  return handleLoadable(loadable, recoilValue, storeRef);\n}\n/**\n  Returns a function that allows the value of a RecoilState to be updated, but does\n  not subscribe the component to changes to that RecoilState.\n*/\n\n\nfunction useSetRecoilState(recoilState) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilState, 'useSetRecoilState');\n  }\n\n  const storeRef = useStoreRef$2();\n  return useCallback$1(newValueOrUpdater => {\n    setRecoilValue$2(storeRef.current, recoilState, newValueOrUpdater);\n  }, [storeRef, recoilState]);\n}\n/**\n  Returns a function that will reset the value of a RecoilState to its default\n*/\n\n\nfunction useResetRecoilState(recoilState) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilState, 'useResetRecoilState');\n  }\n\n  const storeRef = useStoreRef$2();\n  return useCallback$1(() => {\n    setRecoilValue$2(storeRef.current, recoilState, DEFAULT_VALUE$2);\n  }, [storeRef, recoilState]);\n}\n/**\n  Equivalent to useState(). Allows the value of the RecoilState to be read and written.\n  Subsequent updates to the RecoilState will cause the component to re-render. If the\n  RecoilState is pending, this will suspend the component and initiate the\n  retrieval of the value. If evaluating the RecoilState resulted in an error, this will\n  throw the error so that the nearest React error boundary can catch it.\n*/\n\n\nfunction useRecoilState(recoilState) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilState, 'useRecoilState');\n  }\n\n  return [useRecoilValue(recoilState), useSetRecoilState(recoilState)];\n}\n/**\n  Like useRecoilState(), but does not cause Suspense or React error handling. Returns\n  an object that indicates whether the RecoilState is available, pending, or\n  unavailable due to an error.\n*/\n\n\nfunction useRecoilStateLoadable(recoilState) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilState, 'useRecoilStateLoadable');\n  }\n\n  return [useRecoilValueLoadable(recoilState), useSetRecoilState(recoilState)];\n}\n\nfunction useSetUnvalidatedAtomValues() {\n  const storeRef = useStoreRef$2();\n  return (values, transactionMetadata = {}) => {\n    batchUpdates$2(() => {\n      storeRef.current.addTransactionMetadata(transactionMetadata);\n      values.forEach((value, key) => setUnvalidatedRecoilValue$2(storeRef.current, new AbstractRecoilValue$3(key), value));\n    });\n  };\n}\n/**\n * Experimental variants of hooks with support for useTransition()\n */\n\n\nfunction useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE(recoilValue) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilValue, 'useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE');\n\n    if (!reactMode$3().early) {\n      Recoil_recoverableViolation('Attepmt to use a hook with UNSTABLE_TRANSITION_SUPPORT in a rendering mode incompatible with concurrent rendering.  Try enabling the recoil_sync_external_store or recoil_transition_support GKs.');\n    }\n  }\n\n  if (Recoil_gkx('recoil_memory_managament_2020')) {\n    // eslint-disable-next-line fb-www/react-hooks\n    Recoil_useRetain(recoilValue);\n  }\n\n  return useRecoilValueLoadable_TRANSITION_SUPPORT(recoilValue);\n}\n\nfunction useRecoilValue_TRANSITION_SUPPORT_UNSTABLE(recoilValue) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilValue, 'useRecoilValue_TRANSITION_SUPPORT_UNSTABLE');\n  }\n\n  const storeRef = useStoreRef$2();\n  const loadable = useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE(recoilValue);\n  return handleLoadable(loadable, recoilValue, storeRef);\n}\n\nfunction useRecoilState_TRANSITION_SUPPORT_UNSTABLE(recoilState) {\n  if (process.env.NODE_ENV !== \"production\") {\n    validateRecoilValue(recoilState, 'useRecoilState_TRANSITION_SUPPORT_UNSTABLE');\n  }\n\n  return [useRecoilValue_TRANSITION_SUPPORT_UNSTABLE(recoilState), useSetRecoilState(recoilState)];\n}\n\nvar Recoil_Hooks = {\n  recoilComponentGetRecoilValueCount_FOR_TESTING,\n  useRecoilInterface: useRecoilInterface_DEPRECATED,\n  useRecoilState,\n  useRecoilStateLoadable,\n  useRecoilValue,\n  useRecoilValueLoadable,\n  useResetRecoilState,\n  useSetRecoilState,\n  useSetUnvalidatedAtomValues,\n  useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE,\n  useRecoilValue_TRANSITION_SUPPORT_UNSTABLE,\n  useRecoilState_TRANSITION_SUPPORT_UNSTABLE\n};\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Returns a map containing all of the keys + values from the original map where\n * the given callback returned true.\n */\n\nfunction filterMap(map, callback) {\n  const result = new Map();\n\n  for (const [key, value] of map) {\n    if (callback(value, key)) {\n      result.set(key, value);\n    }\n  }\n\n  return result;\n}\n\nvar Recoil_filterMap = filterMap;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n/**\n * Returns a set containing all of the values from the original set where\n * the given callback returned true.\n */\n\nfunction filterSet(set, callback) {\n  const result = new Set();\n\n  for (const value of set) {\n    if (callback(value)) {\n      result.add(value);\n    }\n  }\n\n  return result;\n}\n\nvar Recoil_filterSet = filterSet;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction mergeMaps(...maps) {\n  const result = new Map();\n\n  for (let i = 0; i < maps.length; i++) {\n    const iterator = maps[i].keys();\n    let nextKey;\n\n    while (!(nextKey = iterator.next()).done) {\n      // $FlowIssue[incompatible-call] - map/iterator knows nothing about flow types\n      result.set(nextKey.value, maps[i].get(nextKey.value));\n    }\n  }\n\n  return result;\n}\n\nvar Recoil_mergeMaps = mergeMaps;\n\nconst {\n  batchUpdates: batchUpdates$3\n} = Recoil_Batching;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$3,\n  getNode: getNode$4,\n  nodes: nodes$1\n} = Recoil_Node;\n\nconst {\n  useStoreRef: useStoreRef$3\n} = Recoil_RecoilRoot;\n\nconst {\n  AbstractRecoilValue: AbstractRecoilValue$4,\n  setRecoilValueLoadable: setRecoilValueLoadable$1\n} = Recoil_RecoilValueInterface;\n\nconst {\n  SUSPENSE_TIMEOUT_MS: SUSPENSE_TIMEOUT_MS$2\n} = Recoil_Retention;\n\nconst {\n  cloneSnapshot: cloneSnapshot$1\n} = Recoil_Snapshot$1;\n\nconst {\n  useCallback: useCallback$2,\n  useEffect: useEffect$4,\n  useRef: useRef$5,\n  useState: useState$2\n} = react;\n\nconst {\n  isSSR: isSSR$3\n} = Recoil_Environment;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nfunction useTransactionSubscription(callback) {\n  const storeRef = useStoreRef$3();\n  useEffect$4(() => {\n    const sub = storeRef.current.subscribeToTransactions(callback);\n    return sub.release;\n  }, [callback, storeRef]);\n}\n\nfunction externallyVisibleAtomValuesInState(state) {\n  const atomValues = state.atomValues.toMap();\n  const persistedAtomContentsValues = Recoil_mapMap(Recoil_filterMap(atomValues, (v, k) => {\n    const node = getNode$4(k);\n    const persistence = node.persistence_UNSTABLE;\n    return persistence != null && persistence.type !== 'none' && v.state === 'hasValue';\n  }), v => v.contents); // Merge in nonvalidated atoms; we may not have defs for them but they will\n  // all have persistence on or they wouldn't be there in the first place.\n\n  return Recoil_mergeMaps(state.nonvalidatedAtoms.toMap(), persistedAtomContentsValues);\n}\n\n/**\n  Calls the given callback after any atoms have been modified and the consequent\n  component re-renders have been committed. This is intended for persisting\n  the values of the atoms to storage. The stored values can then be restored\n  using the useSetUnvalidatedAtomValues hook.\n\n  The callback receives the following info:\n\n  atomValues: The current value of every atom that is both persistable (persistence\n              type not set to 'none') and whose value is available (not in an\n              error or loading state).\n\n  previousAtomValues: The value of every persistable and available atom before\n               the transaction began.\n\n  atomInfo: A map containing the persistence settings for each atom. Every key\n            that exists in atomValues will also exist in atomInfo.\n\n  modifiedAtoms: The set of atoms that were written to during the transaction.\n\n  transactionMetadata: Arbitrary information that was added via the\n          useSetUnvalidatedAtomValues hook. Useful for ignoring the useSetUnvalidatedAtomValues\n          transaction, to avoid loops.\n*/\nfunction useTransactionObservation_DEPRECATED(callback) {\n  useTransactionSubscription(useCallback$2(store => {\n    let previousTree = store.getState().previousTree;\n    const currentTree = store.getState().currentTree;\n\n    if (!previousTree) {\n      Recoil_recoverableViolation('Transaction subscribers notified without a previous tree being present -- this is a bug in Recoil');\n      previousTree = store.getState().currentTree; // attempt to trundle on\n    }\n\n    const atomValues = externallyVisibleAtomValuesInState(currentTree);\n    const previousAtomValues = externallyVisibleAtomValuesInState(previousTree);\n    const atomInfo = Recoil_mapMap(nodes$1, node => {\n      var _node$persistence_UNS, _node$persistence_UNS2, _node$persistence_UNS3, _node$persistence_UNS4;\n\n      return {\n        persistence_UNSTABLE: {\n          type: (_node$persistence_UNS = (_node$persistence_UNS2 = node.persistence_UNSTABLE) === null || _node$persistence_UNS2 === void 0 ? void 0 : _node$persistence_UNS2.type) !== null && _node$persistence_UNS !== void 0 ? _node$persistence_UNS : 'none',\n          backButton: (_node$persistence_UNS3 = (_node$persistence_UNS4 = node.persistence_UNSTABLE) === null || _node$persistence_UNS4 === void 0 ? void 0 : _node$persistence_UNS4.backButton) !== null && _node$persistence_UNS3 !== void 0 ? _node$persistence_UNS3 : false\n        }\n      };\n    }); // Filter on existance in atomValues so that externally-visible rules\n    // are also applied to modified atoms (specifically exclude selectors):\n\n    const modifiedAtoms = Recoil_filterSet(currentTree.dirtyAtoms, k => atomValues.has(k) || previousAtomValues.has(k));\n    callback({\n      atomValues,\n      previousAtomValues,\n      atomInfo,\n      modifiedAtoms,\n      transactionMetadata: { ...currentTree.transactionMetadata\n      }\n    });\n  }, [callback]));\n}\n\nfunction useRecoilTransactionObserver(callback) {\n  useTransactionSubscription(useCallback$2(store => {\n    const snapshot = cloneSnapshot$1(store, 'latest');\n    const previousSnapshot = cloneSnapshot$1(store, 'previous');\n    callback({\n      snapshot,\n      previousSnapshot\n    });\n  }, [callback]));\n} // Return a snapshot of the current state and subscribe to all state changes\n\n\nfunction useRecoilSnapshot() {\n  const storeRef = useStoreRef$3();\n  const [snapshot, setSnapshot] = useState$2(() => cloneSnapshot$1(storeRef.current));\n  const previousSnapshot = Recoil_usePrevious(snapshot);\n  const timeoutID = useRef$5();\n  const releaseRef = useRef$5();\n  useTransactionSubscription(useCallback$2(store => setSnapshot(cloneSnapshot$1(store)), [])); // Retain snapshot for duration component is mounted\n\n  useEffect$4(() => {\n    const release = snapshot.retain(); // Release the retain from the rendering call\n\n    if (timeoutID.current && !isSSR$3) {\n      var _releaseRef$current;\n\n      window.clearTimeout(timeoutID.current);\n      timeoutID.current = null;\n      (_releaseRef$current = releaseRef.current) === null || _releaseRef$current === void 0 ? void 0 : _releaseRef$current.call(releaseRef);\n      releaseRef.current = null;\n    }\n\n    return () => {\n      // Defer the release.  If \"Fast Refresh\"\" is used then the component may\n      // re-render with the same state.  The previous cleanup will then run and\n      // then the new effect will run. We don't want the snapshot to be released\n      // by that cleanup before the new effect has a chance to retain it again.\n      // Use timeout of 10 to workaround Firefox issue: https://github.com/facebookexperimental/Recoil/issues/1936\n      window.setTimeout(release, 10);\n    };\n  }, [snapshot]); // Retain snapshot until above effect is run.\n  // Release after a threshold in case component is suspended.\n\n  if (previousSnapshot !== snapshot && !isSSR$3) {\n    // Release the previous snapshot\n    if (timeoutID.current) {\n      var _releaseRef$current2;\n\n      window.clearTimeout(timeoutID.current);\n      timeoutID.current = null;\n      (_releaseRef$current2 = releaseRef.current) === null || _releaseRef$current2 === void 0 ? void 0 : _releaseRef$current2.call(releaseRef);\n      releaseRef.current = null;\n    }\n\n    releaseRef.current = snapshot.retain();\n    timeoutID.current = window.setTimeout(() => {\n      var _releaseRef$current3;\n\n      timeoutID.current = null;\n      (_releaseRef$current3 = releaseRef.current) === null || _releaseRef$current3 === void 0 ? void 0 : _releaseRef$current3.call(releaseRef);\n      releaseRef.current = null;\n    }, SUSPENSE_TIMEOUT_MS$2);\n  }\n\n  return snapshot;\n}\n\nfunction gotoSnapshot(store, snapshot) {\n  var _storeState$nextTree;\n\n  const storeState = store.getState();\n  const prev = (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree;\n  const next = snapshot.getStore_INTERNAL().getState().currentTree;\n  batchUpdates$3(() => {\n    const keysToUpdate = new Set();\n\n    for (const keys of [prev.atomValues.keys(), next.atomValues.keys()]) {\n      for (const key of keys) {\n        var _prev$atomValues$get, _next$atomValues$get;\n\n        if (((_prev$atomValues$get = prev.atomValues.get(key)) === null || _prev$atomValues$get === void 0 ? void 0 : _prev$atomValues$get.contents) !== ((_next$atomValues$get = next.atomValues.get(key)) === null || _next$atomValues$get === void 0 ? void 0 : _next$atomValues$get.contents) && getNode$4(key).shouldRestoreFromSnapshots) {\n          keysToUpdate.add(key);\n        }\n      }\n    }\n\n    keysToUpdate.forEach(key => {\n      setRecoilValueLoadable$1(store, new AbstractRecoilValue$4(key), next.atomValues.has(key) ? Recoil_nullthrows(next.atomValues.get(key)) : DEFAULT_VALUE$3);\n    });\n    store.replaceState(state => ({ ...state,\n      stateID: snapshot.getID()\n    }));\n  });\n}\n\nfunction useGotoRecoilSnapshot() {\n  const storeRef = useStoreRef$3();\n  return useCallback$2(snapshot => gotoSnapshot(storeRef.current, snapshot), [storeRef]);\n}\n\nvar Recoil_SnapshotHooks = {\n  useRecoilSnapshot,\n  gotoSnapshot,\n  useGotoRecoilSnapshot,\n  useRecoilTransactionObserver,\n  useTransactionObservation_DEPRECATED,\n  useTransactionSubscription_DEPRECATED: useTransactionSubscription\n};\n\nconst {\n  peekNodeInfo: peekNodeInfo$2\n} = Recoil_FunctionalCore;\n\nconst {\n  useStoreRef: useStoreRef$4\n} = Recoil_RecoilRoot;\n\nfunction useGetRecoilValueInfo() {\n  const storeRef = useStoreRef$4();\n  return ({\n    key\n  }) => peekNodeInfo$2(storeRef.current, storeRef.current.getState().currentTree, key);\n}\n\nvar Recoil_useGetRecoilValueInfo = useGetRecoilValueInfo;\n\nconst {\n  reactMode: reactMode$4\n} = Recoil_ReactMode;\n\nconst {\n  RecoilRoot: RecoilRoot$1,\n  useStoreRef: useStoreRef$5\n} = Recoil_RecoilRoot;\n\n\n\nconst {\n  useMemo: useMemo$2\n} = react;\n\nfunction useRecoilBridgeAcrossReactRoots() {\n  // The test fails when using useMutableSource(), but only if act() is used\n  // for the nested root.  So, this may only be a testing environment issue.\n  if (reactMode$4().mode === 'MUTABLE_SOURCE') {\n    // eslint-disable-next-line fb-www/no-console\n    console.warn('Warning: There are known issues using useRecoilBridgeAcrossReactRoots() in recoil_mutable_source rendering mode.  Please consider upgrading to recoil_sync_external_store mode.');\n  }\n\n  const store = useStoreRef$5().current;\n  return useMemo$2(() => {\n    // eslint-disable-next-line no-shadow\n    function RecoilBridge({\n      children\n    }) {\n      return /*#__PURE__*/react.createElement(RecoilRoot$1, {\n        store_INTERNAL: store\n      }, children);\n    }\n\n    return RecoilBridge;\n  }, [store]);\n}\n\nvar Recoil_useRecoilBridgeAcrossReactRoots = useRecoilBridgeAcrossReactRoots;\n\nconst {\n  loadableWithValue: loadableWithValue$1\n} = Recoil_Loadable$1;\n\nconst {\n  initializeNode: initializeNode$3\n} = Recoil_FunctionalCore;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$4,\n  getNode: getNode$5\n} = Recoil_Node;\n\nconst {\n  copyTreeState: copyTreeState$1,\n  getRecoilValueAsLoadable: getRecoilValueAsLoadable$3,\n  invalidateDownstreams: invalidateDownstreams$1,\n  writeLoadableToTreeState: writeLoadableToTreeState$1\n} = Recoil_RecoilValueInterface;\n\n\n\nfunction isAtom(recoilValue) {\n  return getNode$5(recoilValue.key).nodeType === 'atom';\n}\n\nclass TransactionInterfaceImpl {\n  constructor(store, treeState) {\n    _defineProperty(this, \"_store\", void 0);\n\n    _defineProperty(this, \"_treeState\", void 0);\n\n    _defineProperty(this, \"_changes\", void 0);\n\n    _defineProperty(this, \"get\", recoilValue => {\n      if (this._changes.has(recoilValue.key)) {\n        // $FlowIssue[incompatible-return]\n        return this._changes.get(recoilValue.key);\n      }\n\n      if (!isAtom(recoilValue)) {\n        throw Recoil_err('Reading selectors within atomicUpdate is not supported');\n      }\n\n      const loadable = getRecoilValueAsLoadable$3(this._store, recoilValue, this._treeState);\n\n      if (loadable.state === 'hasValue') {\n        return loadable.contents;\n      } else if (loadable.state === 'hasError') {\n        throw loadable.contents;\n      } else {\n        throw Recoil_err(`Expected Recoil atom ${recoilValue.key} to have a value, but it is in a loading state.`);\n      }\n    });\n\n    _defineProperty(this, \"set\", (recoilState, valueOrUpdater) => {\n      if (!isAtom(recoilState)) {\n        throw Recoil_err('Setting selectors within atomicUpdate is not supported');\n      }\n\n      if (typeof valueOrUpdater === 'function') {\n        const current = this.get(recoilState);\n\n        this._changes.set(recoilState.key, valueOrUpdater(current)); // flowlint-line unclear-type:off\n\n      } else {\n        // Initialize atom and run effects if not initialized yet\n        initializeNode$3(this._store, recoilState.key, 'set');\n\n        this._changes.set(recoilState.key, valueOrUpdater);\n      }\n    });\n\n    _defineProperty(this, \"reset\", recoilState => {\n      this.set(recoilState, DEFAULT_VALUE$4);\n    });\n\n    this._store = store;\n    this._treeState = treeState;\n    this._changes = new Map();\n  } // Allow destructing\n  // eslint-disable-next-line fb-www/extra-arrow-initializer\n\n\n  newTreeState_INTERNAL() {\n    if (this._changes.size === 0) {\n      return this._treeState;\n    }\n\n    const newState = copyTreeState$1(this._treeState);\n\n    for (const [k, v] of this._changes) {\n      writeLoadableToTreeState$1(newState, k, loadableWithValue$1(v));\n    }\n\n    invalidateDownstreams$1(this._store, newState);\n    return newState;\n  }\n\n}\n\nfunction atomicUpdater(store) {\n  return fn => {\n    store.replaceState(treeState => {\n      const changeset = new TransactionInterfaceImpl(store, treeState);\n      fn(changeset);\n      return changeset.newTreeState_INTERNAL();\n    });\n  };\n}\n\nvar Recoil_AtomicUpdates = {\n  atomicUpdater\n};\n\nvar Recoil_AtomicUpdates_1 = Recoil_AtomicUpdates.atomicUpdater;\n\nvar Recoil_AtomicUpdates$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  atomicUpdater: Recoil_AtomicUpdates_1\n});\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction invariant(condition, message) {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n\nvar invariant_1 = invariant;\n\n// @oss-only\n\n\nvar Recoil_invariant = invariant_1;\n\nconst {\n  atomicUpdater: atomicUpdater$1\n} = Recoil_AtomicUpdates$1;\n\nconst {\n  batchUpdates: batchUpdates$4\n} = Recoil_Batching;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$5\n} = Recoil_Node;\n\nconst {\n  useStoreRef: useStoreRef$6\n} = Recoil_RecoilRoot;\n\nconst {\n  refreshRecoilValue: refreshRecoilValue$1,\n  setRecoilValue: setRecoilValue$3\n} = Recoil_RecoilValueInterface;\n\nconst {\n  cloneSnapshot: cloneSnapshot$2\n} = Recoil_Snapshot$1;\n\nconst {\n  gotoSnapshot: gotoSnapshot$1\n} = Recoil_SnapshotHooks;\n\nconst {\n  useCallback: useCallback$3\n} = react;\n\n\n\n\n\n\n\n\n\nclass Sentinel {}\n\nconst SENTINEL = new Sentinel();\n\nfunction recoilCallback(store, fn, args, extraInterface) {\n  let ret = SENTINEL;\n  let releaseSnapshot;\n  batchUpdates$4(() => {\n    const errMsg = 'useRecoilCallback() expects a function that returns a function: ' + 'it accepts a function of the type (RecoilInterface) => (Args) => ReturnType ' + 'and returns a callback function (Args) => ReturnType, where RecoilInterface is ' + 'an object {snapshot, set, ...} and Args and ReturnType are the argument and return ' + 'types of the callback you want to create.  Please see the docs ' + 'at recoiljs.org for details.';\n\n    if (typeof fn !== 'function') {\n      throw Recoil_err(errMsg);\n    } // Clone the snapshot lazily to avoid overhead if the callback does not use it.\n    // Note that this means the snapshot may represent later state from when\n    // the callback was called if it first accesses the snapshot asynchronously.\n\n\n    const callbackInterface = Recoil_lazyProxy({ ...(extraInterface !== null && extraInterface !== void 0 ? extraInterface : {}),\n      // flowlint-line unclear-type:off\n      set: (node, newValue) => setRecoilValue$3(store, node, newValue),\n      reset: node => setRecoilValue$3(store, node, DEFAULT_VALUE$5),\n      refresh: node => refreshRecoilValue$1(store, node),\n      gotoSnapshot: snapshot => gotoSnapshot$1(store, snapshot),\n      transact_UNSTABLE: transaction => atomicUpdater$1(store)(transaction)\n    }, {\n      snapshot: () => {\n        const snapshot = cloneSnapshot$2(store);\n        releaseSnapshot = snapshot.retain();\n        return snapshot;\n      }\n    });\n    const callback = fn(callbackInterface);\n\n    if (typeof callback !== 'function') {\n      throw Recoil_err(errMsg);\n    }\n\n    ret = callback(...args);\n  });\n  !!(ret instanceof Sentinel) ? process.env.NODE_ENV !== \"production\" ? Recoil_invariant(false, 'batchUpdates should return immediately') : Recoil_invariant(false) : void 0;\n\n  if (Recoil_isPromise(ret)) {\n    ret.finally(() => {\n      var _releaseSnapshot;\n\n      (_releaseSnapshot = releaseSnapshot) === null || _releaseSnapshot === void 0 ? void 0 : _releaseSnapshot();\n    });\n  } else {\n    var _releaseSnapshot2;\n\n    (_releaseSnapshot2 = releaseSnapshot) === null || _releaseSnapshot2 === void 0 ? void 0 : _releaseSnapshot2();\n  }\n\n  return ret;\n}\n\nfunction useRecoilCallback(fn, deps) {\n  const storeRef = useStoreRef$6();\n  return useCallback$3( // $FlowIssue[incompatible-call]\n  (...args) => {\n    return recoilCallback(storeRef.current, fn, args);\n  }, deps != null ? [...deps, storeRef] : undefined // eslint-disable-line fb-www/react-hooks-deps\n  );\n}\n\nvar Recoil_useRecoilCallback = {\n  recoilCallback,\n  useRecoilCallback\n};\n\nconst {\n  useStoreRef: useStoreRef$7\n} = Recoil_RecoilRoot;\n\nconst {\n  refreshRecoilValue: refreshRecoilValue$2\n} = Recoil_RecoilValueInterface;\n\nconst {\n  useCallback: useCallback$4\n} = react;\n\nfunction useRecoilRefresher(recoilValue) {\n  const storeRef = useStoreRef$7();\n  return useCallback$4(() => {\n    const store = storeRef.current;\n    refreshRecoilValue$2(store, recoilValue);\n  }, [recoilValue, storeRef]);\n}\n\nvar Recoil_useRecoilRefresher = useRecoilRefresher;\n\nconst {\n  atomicUpdater: atomicUpdater$2\n} = Recoil_AtomicUpdates$1;\n\nconst {\n  useStoreRef: useStoreRef$8\n} = Recoil_RecoilRoot;\n\nconst {\n  useMemo: useMemo$3\n} = react;\n\nfunction useRecoilTransaction(fn, deps) {\n  const storeRef = useStoreRef$8();\n  return useMemo$3(() => (...args) => {\n    const atomicUpdate = atomicUpdater$2(storeRef.current);\n    atomicUpdate(transactionInterface => {\n      fn(transactionInterface)(...args);\n    });\n  }, deps != null ? [...deps, storeRef] : undefined // eslint-disable-line fb-www/react-hooks-deps\n  );\n}\n\nvar Recoil_useRecoilTransaction = useRecoilTransaction;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nclass WrappedValue {\n  constructor(value) {\n    _defineProperty(this, \"value\", void 0);\n\n    this.value = value;\n  }\n\n}\n\nvar Recoil_Wrapper = {\n  WrappedValue\n};\n\nvar Recoil_Wrapper_1 = Recoil_Wrapper.WrappedValue;\n\nvar Recoil_Wrapper$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  WrappedValue: Recoil_Wrapper_1\n});\n\nconst {\n  isFastRefreshEnabled: isFastRefreshEnabled$2\n} = Recoil_ReactMode;\n\n\n\nclass ChangedPathError extends Error {}\n\nclass TreeCache {\n  // $FlowIssue[unclear-type]\n  constructor(options) {\n    var _options$onHit, _options$onSet, _options$mapNodeValue;\n\n    _defineProperty(this, \"_name\", void 0);\n\n    _defineProperty(this, \"_numLeafs\", void 0);\n\n    _defineProperty(this, \"_root\", void 0);\n\n    _defineProperty(this, \"_onHit\", void 0);\n\n    _defineProperty(this, \"_onSet\", void 0);\n\n    _defineProperty(this, \"_mapNodeValue\", void 0);\n\n    this._name = options === null || options === void 0 ? void 0 : options.name;\n    this._numLeafs = 0;\n    this._root = null;\n    this._onHit = (_options$onHit = options === null || options === void 0 ? void 0 : options.onHit) !== null && _options$onHit !== void 0 ? _options$onHit : () => {};\n    this._onSet = (_options$onSet = options === null || options === void 0 ? void 0 : options.onSet) !== null && _options$onSet !== void 0 ? _options$onSet : () => {};\n    this._mapNodeValue = (_options$mapNodeValue = options === null || options === void 0 ? void 0 : options.mapNodeValue) !== null && _options$mapNodeValue !== void 0 ? _options$mapNodeValue : val => val;\n  }\n\n  size() {\n    return this._numLeafs;\n  } // $FlowIssue[unclear-type]\n\n\n  root() {\n    return this._root;\n  }\n\n  get(getNodeValue, handlers) {\n    var _this$getLeafNode;\n\n    return (_this$getLeafNode = this.getLeafNode(getNodeValue, handlers)) === null || _this$getLeafNode === void 0 ? void 0 : _this$getLeafNode.value;\n  }\n\n  getLeafNode(getNodeValue, handlers) {\n    if (this._root == null) {\n      return undefined;\n    } // Iterate down the tree based on the current node values until we hit a leaf\n    // $FlowIssue[unclear-type]\n\n\n    let node = this._root;\n\n    while (node) {\n      handlers === null || handlers === void 0 ? void 0 : handlers.onNodeVisit(node);\n\n      if (node.type === 'leaf') {\n        this._onHit(node);\n\n        return node;\n      }\n\n      const nodeValue = this._mapNodeValue(getNodeValue(node.nodeKey));\n\n      node = node.branches.get(nodeValue);\n    }\n\n    return undefined;\n  }\n\n  set(route, value, handlers) {\n    const addLeaf = () => {\n      var _node2, _node3, _this$_root2, _handlers$onNodeVisit2;\n\n      // First, setup the branch nodes for the route:\n      // Iterate down the tree to find or add branch nodes following the route\n      let node;\n      let branchKey;\n\n      for (const [nodeKey, nodeValue] of route) {\n        var _node, _handlers$onNodeVisit, _this$_root;\n\n        // If the previous root was a leaf, while we not have a get(), it means\n        // the selector has inconsistent values or implementation changed.\n        const root = this._root;\n\n        if ((root === null || root === void 0 ? void 0 : root.type) === 'leaf') {\n          throw this.invalidCacheError();\n        } // node now refers to the next node down in the tree\n\n\n        const parent = node; // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-type]\n\n        node = parent ? parent.branches.get(branchKey) : root; // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-type]\n\n        node = (_node = node) !== null && _node !== void 0 ? _node : {\n          type: 'branch',\n          nodeKey,\n          parent,\n          branches: new Map(),\n          branchKey\n        }; // If we found an existing node, confirm it has a consistent value\n\n        if (node.type !== 'branch' || node.nodeKey !== nodeKey) {\n          throw this.invalidCacheError();\n        } // Add the branch node to the tree\n\n\n        parent === null || parent === void 0 ? void 0 : parent.branches.set(branchKey, node);\n        handlers === null || handlers === void 0 ? void 0 : (_handlers$onNodeVisit = handlers.onNodeVisit) === null || _handlers$onNodeVisit === void 0 ? void 0 : _handlers$onNodeVisit.call(handlers, node); // Prepare for next iteration and install root if it is new.\n\n        branchKey = this._mapNodeValue(nodeValue);\n        this._root = (_this$_root = this._root) !== null && _this$_root !== void 0 ? _this$_root : node;\n      } // Second, setup the leaf node:\n      // If there is an existing leaf for this route confirm it is consistent\n\n\n      const oldLeaf = node ? (_node2 = node) === null || _node2 === void 0 ? void 0 : _node2.branches.get(branchKey) : this._root;\n\n      if (oldLeaf != null && (oldLeaf.type !== 'leaf' || oldLeaf.branchKey !== branchKey)) {\n        throw this.invalidCacheError();\n      } // Create a new or replacement leaf.\n\n\n      const leafNode = {\n        type: 'leaf',\n        value,\n        parent: node,\n        branchKey\n      }; // Install the leaf and call handlers\n\n      (_node3 = node) === null || _node3 === void 0 ? void 0 : _node3.branches.set(branchKey, leafNode);\n      this._root = (_this$_root2 = this._root) !== null && _this$_root2 !== void 0 ? _this$_root2 : leafNode;\n      this._numLeafs++;\n\n      this._onSet(leafNode);\n\n      handlers === null || handlers === void 0 ? void 0 : (_handlers$onNodeVisit2 = handlers.onNodeVisit) === null || _handlers$onNodeVisit2 === void 0 ? void 0 : _handlers$onNodeVisit2.call(handlers, leafNode);\n    };\n\n    try {\n      addLeaf();\n    } catch (error) {\n      // If the cache was stale or observed inconsistent values, such as with\n      // Fast Refresh, then clear it and rebuild with the new values.\n      if (error instanceof ChangedPathError) {\n        this.clear();\n        addLeaf();\n      } else {\n        throw error;\n      }\n    }\n  } // Returns true if leaf was actually deleted from the tree\n\n\n  delete(leaf) {\n    const root = this.root();\n\n    if (!root) {\n      return false;\n    }\n\n    if (leaf === root) {\n      this._root = null;\n      this._numLeafs = 0;\n      return true;\n    } // Iterate up from the leaf deleteing it from it's parent's branches.\n\n\n    let node = leaf.parent;\n    let branchKey = leaf.branchKey;\n\n    while (node) {\n      var _node4;\n\n      node.branches.delete(branchKey); // Stop iterating if we hit the root.\n\n      if (node === root) {\n        if (node.branches.size === 0) {\n          this._root = null;\n          this._numLeafs = 0;\n        } else {\n          this._numLeafs--;\n        }\n\n        return true;\n      } // Stop iterating if there are other branches since we don't need to\n      // remove any more nodes.\n\n\n      if (node.branches.size > 0) {\n        break;\n      } // Iterate up to our parent\n\n\n      branchKey = (_node4 = node) === null || _node4 === void 0 ? void 0 : _node4.branchKey;\n      node = node.parent;\n    } // Confirm that the leaf we are deleting is actually attached to our tree\n\n\n    for (; node !== root; node = node.parent) {\n      if (node == null) {\n        return false;\n      }\n    }\n\n    this._numLeafs--;\n    return true;\n  }\n\n  clear() {\n    this._numLeafs = 0;\n    this._root = null;\n  }\n\n  invalidCacheError() {\n    const CHANGED_PATH_ERROR_MESSAGE = isFastRefreshEnabled$2() ? 'Possible Fast Refresh module reload detected.  ' + 'This may also be caused by an selector returning inconsistent values. ' + 'Resetting cache.' : 'Invalid cache values.  This happens when selectors do not return ' + 'consistent values for the same input dependency values.  That may also ' + 'be caused when using Fast Refresh to change a selector implementation.  ' + 'Resetting cache.';\n    Recoil_recoverableViolation(CHANGED_PATH_ERROR_MESSAGE + (this._name != null ? ` - ${this._name}` : ''));\n    throw new ChangedPathError();\n  }\n\n}\n\nvar Recoil_TreeCache = {\n  TreeCache\n};\n\nvar Recoil_TreeCache_1 = Recoil_TreeCache.TreeCache;\n\nvar Recoil_TreeCache$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  TreeCache: Recoil_TreeCache_1\n});\n\nclass LRUCache {\n  constructor(options) {\n    var _options$mapKey;\n\n    _defineProperty(this, \"_maxSize\", void 0);\n\n    _defineProperty(this, \"_size\", void 0);\n\n    _defineProperty(this, \"_head\", void 0);\n\n    _defineProperty(this, \"_tail\", void 0);\n\n    _defineProperty(this, \"_map\", void 0);\n\n    _defineProperty(this, \"_keyMapper\", void 0);\n\n    this._maxSize = options.maxSize;\n    this._size = 0;\n    this._head = null;\n    this._tail = null;\n    this._map = new Map();\n    this._keyMapper = (_options$mapKey = options.mapKey) !== null && _options$mapKey !== void 0 ? _options$mapKey : v => v;\n  }\n\n  head() {\n    return this._head;\n  }\n\n  tail() {\n    return this._tail;\n  }\n\n  size() {\n    return this._size;\n  }\n\n  maxSize() {\n    return this._maxSize;\n  }\n\n  has(key) {\n    return this._map.has(this._keyMapper(key));\n  }\n\n  get(key) {\n    const mappedKey = this._keyMapper(key);\n\n    const node = this._map.get(mappedKey);\n\n    if (!node) {\n      return undefined;\n    }\n\n    this.set(key, node.value);\n    return node.value;\n  }\n\n  set(key, val) {\n    const mappedKey = this._keyMapper(key);\n\n    const existingNode = this._map.get(mappedKey);\n\n    if (existingNode) {\n      this.delete(key);\n    }\n\n    const head = this.head();\n    const node = {\n      key,\n      right: head,\n      left: null,\n      value: val\n    };\n\n    if (head) {\n      head.left = node;\n    } else {\n      this._tail = node;\n    }\n\n    this._map.set(mappedKey, node);\n\n    this._head = node;\n    this._size++;\n\n    this._maybeDeleteLRU();\n  }\n\n  _maybeDeleteLRU() {\n    if (this.size() > this.maxSize()) {\n      this.deleteLru();\n    }\n  }\n\n  deleteLru() {\n    const tail = this.tail();\n\n    if (tail) {\n      this.delete(tail.key);\n    }\n  }\n\n  delete(key) {\n    const mappedKey = this._keyMapper(key);\n\n    if (!this._size || !this._map.has(mappedKey)) {\n      return;\n    }\n\n    const node = Recoil_nullthrows(this._map.get(mappedKey));\n    const right = node.right;\n    const left = node.left;\n\n    if (right) {\n      right.left = node.left;\n    }\n\n    if (left) {\n      left.right = node.right;\n    }\n\n    if (node === this.head()) {\n      this._head = right;\n    }\n\n    if (node === this.tail()) {\n      this._tail = left;\n    }\n\n    this._map.delete(mappedKey);\n\n    this._size--;\n  }\n\n  clear() {\n    this._size = 0;\n    this._head = null;\n    this._tail = null;\n    this._map = new Map();\n  }\n\n}\n\nvar Recoil_LRUCache = {\n  LRUCache\n};\n\nvar Recoil_LRUCache_1 = Recoil_LRUCache.LRUCache;\n\nvar Recoil_LRUCache$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  LRUCache: Recoil_LRUCache_1\n});\n\nconst {\n  LRUCache: LRUCache$1\n} = Recoil_LRUCache$1;\n\nconst {\n  TreeCache: TreeCache$1\n} = Recoil_TreeCache$1;\n\nfunction treeCacheLRU({\n  name,\n  maxSize,\n  mapNodeValue = v => v\n}) {\n  const lruCache = new LRUCache$1({\n    maxSize\n  });\n  const cache = new TreeCache$1({\n    name,\n    mapNodeValue,\n    onHit: node => {\n      lruCache.set(node, true);\n    },\n    onSet: node => {\n      const lruNode = lruCache.tail();\n      lruCache.set(node, true);\n\n      if (lruNode && cache.size() > maxSize) {\n        cache.delete(lruNode.key);\n      }\n    }\n  });\n  return cache;\n}\n\nvar Recoil_treeCacheLRU = treeCacheLRU;\n\nconst TIME_WARNING_THRESHOLD_MS = 15;\n\nfunction stringify(x, opt, key) {\n  // A optimization to avoid the more expensive JSON.stringify() for simple strings\n  // This may lose protection for u2028 and u2029, though.\n  if (typeof x === 'string' && !x.includes('\"') && !x.includes('\\\\')) {\n    return `\"${x}\"`;\n  } // Handle primitive types\n\n\n  switch (typeof x) {\n    case 'undefined':\n      return '';\n    // JSON.stringify(undefined) returns undefined, but we always want to return a string\n\n    case 'boolean':\n      return x ? 'true' : 'false';\n\n    case 'number':\n    case 'symbol':\n      // case 'bigint': // BigInt is not supported in www\n      return String(x);\n\n    case 'string':\n      // Add surrounding quotes and escape internal quotes\n      return JSON.stringify(x);\n\n    case 'function':\n      if ((opt === null || opt === void 0 ? void 0 : opt.allowFunctions) !== true) {\n        throw Recoil_err('Attempt to serialize function in a Recoil cache key');\n      }\n\n      return `__FUNCTION(${x.name})__`;\n  }\n\n  if (x === null) {\n    return 'null';\n  } // Fallback case for unknown types\n\n\n  if (typeof x !== 'object') {\n    var _JSON$stringify;\n\n    return (_JSON$stringify = JSON.stringify(x)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : '';\n  } // Deal with all promises as equivalent for now.\n\n\n  if (Recoil_isPromise(x)) {\n    return '__PROMISE__';\n  } // Arrays handle recursive stringification\n\n\n  if (Array.isArray(x)) {\n    return `[${x.map((v, i) => stringify(v, opt, i.toString()))}]`;\n  } // If an object defines a toJSON() method, then use that to override the\n  // serialization.  This matches the behavior of JSON.stringify().\n  // Pass the key for compatibility.\n  // Immutable.js collections define this method to allow us to serialize them.\n\n\n  if (typeof x.toJSON === 'function') {\n    // flowlint-next-line unclear-type: off\n    return stringify(x.toJSON(key), opt, key);\n  } // For built-in Maps, sort the keys in a stable order instead of the\n  // default insertion order.  Support non-string keys.\n\n\n  if (x instanceof Map) {\n    const obj = {};\n\n    for (const [k, v] of x) {\n      // Stringify will escape any nested quotes\n      obj[typeof k === 'string' ? k : stringify(k, opt)] = v;\n    }\n\n    return stringify(obj, opt, key);\n  } // For built-in Sets, sort the keys in a stable order instead of the\n  // default insertion order.\n\n\n  if (x instanceof Set) {\n    return stringify(Array.from(x).sort((a, b) => stringify(a, opt).localeCompare(stringify(b, opt))), opt, key);\n  } // Anything else that is iterable serialize as an Array.\n\n\n  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === 'function') {\n    // flowlint-next-line unclear-type: off\n    return stringify(Array.from(x), opt, key);\n  } // For all other Objects, sort the keys in a stable order.\n\n\n  return `{${Object.keys(x).filter(k => x[k] !== undefined).sort() // stringify the key to add quotes and escape any nested slashes or quotes.\n  .map(k => `${stringify(k, opt)}:${stringify(x[k], opt, k)}`).join(',')}}`;\n} // Utility similar to JSON.stringify() except:\n// * Serialize built-in Sets as an Array\n// * Serialize built-in Maps as an Object.  Supports non-string keys.\n// * Serialize other iterables as arrays\n// * Sort the keys of Objects and Maps to have a stable order based on string conversion.\n//    This overrides their default insertion order.\n// * Still uses toJSON() of any object to override serialization\n// * Support Symbols (though don't guarantee uniqueness)\n// * We could support BigInt, but Flow doesn't seem to like it.\n// See Recoil_stableStringify-test.js for examples\n\n\nfunction stableStringify(x, opt = {\n  allowFunctions: false\n}) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof window !== 'undefined') {\n      const startTime = window.performance ? window.performance.now() : 0;\n      const str = stringify(x, opt);\n      const endTime = window.performance ? window.performance.now() : 0;\n\n      if (endTime - startTime > TIME_WARNING_THRESHOLD_MS) {\n        /* eslint-disable fb-www/no-console */\n        console.groupCollapsed(`Recoil: Spent ${endTime - startTime}ms computing a cache key`);\n        console.warn(x, str);\n        console.groupEnd();\n        /* eslint-enable fb-www/no-console */\n      }\n\n      return str;\n    }\n  }\n\n  return stringify(x, opt);\n}\n\nvar Recoil_stableStringify = stableStringify;\n\nconst {\n  TreeCache: TreeCache$2\n} = Recoil_TreeCache$1;\n\n\n\n\n\n\n\n\n\nconst defaultPolicy = {\n  equality: 'reference',\n  eviction: 'keep-all',\n  maxSize: Infinity\n};\n\nfunction treeCacheFromPolicy({\n  equality = defaultPolicy.equality,\n  eviction = defaultPolicy.eviction,\n  maxSize = defaultPolicy.maxSize\n} = defaultPolicy, name) {\n  const valueMapper = getValueMapper(equality);\n  return getTreeCache(eviction, maxSize, valueMapper, name);\n}\n\nfunction getValueMapper(equality) {\n  switch (equality) {\n    case 'reference':\n      return val => val;\n\n    case 'value':\n      return val => Recoil_stableStringify(val);\n  }\n\n  throw Recoil_err(`Unrecognized equality policy ${equality}`);\n}\n\nfunction getTreeCache(eviction, maxSize, mapNodeValue, name) {\n  switch (eviction) {\n    case 'keep-all':\n      return new TreeCache$2({\n        name,\n        mapNodeValue\n      });\n\n    case 'lru':\n      return Recoil_treeCacheLRU({\n        name,\n        maxSize: Recoil_nullthrows(maxSize),\n        mapNodeValue\n      });\n\n    case 'most-recent':\n      return Recoil_treeCacheLRU({\n        name,\n        maxSize: 1,\n        mapNodeValue\n      });\n  }\n\n  throw Recoil_err(`Unrecognized eviction policy ${eviction}`);\n}\n\nvar Recoil_treeCacheFromPolicy = treeCacheFromPolicy;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction isNode(object) {\n  var _ownerDocument, _doc$defaultView;\n\n  if (typeof window === 'undefined') {\n    return false;\n  }\n\n  const doc = object != null ? (_ownerDocument = object.ownerDocument) !== null && _ownerDocument !== void 0 ? _ownerDocument : object : document;\n  const defaultView = (_doc$defaultView = doc.defaultView) !== null && _doc$defaultView !== void 0 ? _doc$defaultView : window;\n  return !!(object != null && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));\n}\n\nvar Recoil_isNode = isNode;\n\nconst {\n  isReactNative: isReactNative$1,\n  isWindow: isWindow$1\n} = Recoil_Environment;\n\n\n\n\n\nfunction shouldNotBeFrozen(value) {\n  // Primitives and functions:\n  if (value === null || typeof value !== 'object') {\n    return true;\n  } // React elements:\n\n\n  switch (typeof value.$$typeof) {\n    case 'symbol':\n      return true;\n\n    case 'number':\n      return true;\n  } // Immutable structures:\n\n\n  if (value['@@__IMMUTABLE_ITERABLE__@@'] != null || value['@@__IMMUTABLE_KEYED__@@'] != null || value['@@__IMMUTABLE_INDEXED__@@'] != null || value['@@__IMMUTABLE_ORDERED__@@'] != null || value['@@__IMMUTABLE_RECORD__@@'] != null) {\n    return true;\n  } // DOM nodes:\n\n\n  if (Recoil_isNode(value)) {\n    return true;\n  }\n\n  if (Recoil_isPromise(value)) {\n    return true;\n  }\n\n  if (value instanceof Error) {\n    return true;\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return true;\n  } // Some environments, just as Jest, don't work with the instanceof check\n\n\n  if (!isReactNative$1 && isWindow$1(value)) {\n    return true;\n  }\n\n  return false;\n} // Recursively freeze a value to enforce it is read-only.\n// This may also have minimal performance improvements for enumerating\n// objects (based on browser implementations, of course)\n\n\nfunction deepFreezeValue(value) {\n  if (typeof value !== 'object' || shouldNotBeFrozen(value)) {\n    return;\n  }\n\n  Object.freeze(value); // Make all properties read-only\n\n  for (const key in value) {\n    // $FlowIssue[method-unbinding] added when improving typing for this parameters\n    if (Object.prototype.hasOwnProperty.call(value, key)) {\n      const prop = value[key]; // Prevent infinite recurssion for circular references.\n\n      if (typeof prop === 'object' && prop != null && !Object.isFrozen(prop)) {\n        deepFreezeValue(prop);\n      }\n    }\n  }\n\n  Object.seal(value); // This also makes existing properties non-configurable.\n}\n\nvar Recoil_deepFreezeValue = deepFreezeValue;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * This is a stub for some integration into FB internal stuff\n *\n * \n * @format\n * @oncall recoil\n */\nfunction startPerfBlock(_id) {\n  return () => null;\n}\n\nvar Recoil_PerformanceTimings = {\n  startPerfBlock\n};\n\nconst {\n  isLoadable: isLoadable$1,\n  loadableWithError: loadableWithError$1,\n  loadableWithPromise: loadableWithPromise$1,\n  loadableWithValue: loadableWithValue$2\n} = Recoil_Loadable$1;\n\nconst {\n  WrappedValue: WrappedValue$1\n} = Recoil_Wrapper$1;\n\n\n\nconst {\n  getNodeLoadable: getNodeLoadable$2,\n  peekNodeLoadable: peekNodeLoadable$1,\n  setNodeValue: setNodeValue$3\n} = Recoil_FunctionalCore;\n\nconst {\n  saveDepsToStore: saveDepsToStore$1\n} = Recoil_Graph;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$6,\n  getConfigDeletionHandler: getConfigDeletionHandler$1,\n  getNode: getNode$6,\n  registerNode: registerNode$1\n} = Recoil_Node;\n\nconst {\n  isRecoilValue: isRecoilValue$3\n} = Recoil_RecoilValue$1;\n\nconst {\n  markRecoilValueModified: markRecoilValueModified$1\n} = Recoil_RecoilValueInterface;\n\nconst {\n  retainedByOptionWithDefault: retainedByOptionWithDefault$1\n} = Recoil_Retention;\n\nconst {\n  recoilCallback: recoilCallback$1\n} = Recoil_useRecoilCallback;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst {\n  startPerfBlock: startPerfBlock$1\n} = Recoil_PerformanceTimings;\n\n\n\nclass Canceled {}\n\nconst CANCELED = new Canceled();\n/**\n * An ExecutionID is an arbitrary ID that lets us distinguish executions from\n * each other. This is necessary as we need a way of solving this problem:\n * \"given 3 async executions, only update state for the 'latest' execution when\n * it finishes running regardless of when the other 2 finish\". ExecutionIDs\n * provide a convenient way of identifying executions so that we can track and\n * manage them over time.\n */\n\nconst dependencyStack = []; // for detecting circular dependencies.\n\nconst waitingStores = new Map();\n\nconst getNewExecutionID = (() => {\n  let executionID = 0;\n  return () => executionID++;\n})();\n/* eslint-disable no-redeclare */\n\n\nfunction selector(options) {\n  let recoilValue = null;\n  const {\n    key,\n    get,\n    cachePolicy_UNSTABLE: cachePolicy\n  } = options;\n  const set = options.set != null ? options.set : undefined; // flow\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof key !== 'string') {\n      throw Recoil_err('A key option with a unique string value must be provided when creating a selector.');\n    }\n\n    if (typeof get !== 'function') {\n      throw Recoil_err('Selectors must specify a get callback option to get the selector value.');\n    }\n  } // This is every discovered dependency across all executions\n\n\n  const discoveredDependencyNodeKeys = new Set();\n  const cache = Recoil_treeCacheFromPolicy(cachePolicy !== null && cachePolicy !== void 0 ? cachePolicy : {\n    equality: 'reference',\n    eviction: 'keep-all'\n  }, key);\n  const retainedBy = retainedByOptionWithDefault$1(options.retainedBy_UNSTABLE);\n  const executionInfoMap = new Map();\n  let liveStoresCount = 0;\n\n  function selectorIsLive() {\n    return !Recoil_gkx('recoil_memory_managament_2020') || liveStoresCount > 0;\n  }\n\n  function selectorInit(store) {\n    store.getState().knownSelectors.add(key);\n    liveStoresCount++;\n    return () => {\n      liveStoresCount--;\n    };\n  }\n\n  function selectorShouldDeleteConfigOnRelease() {\n    return getConfigDeletionHandler$1(key) !== undefined && !selectorIsLive();\n  }\n\n  function resolveAsync(store, state, executionID, loadable, depValues) {\n    setCache(state, loadable, depValues);\n    notifyStoresOfResolvedAsync(store, executionID);\n  }\n\n  function notifyStoresOfResolvedAsync(store, executionID) {\n    if (isLatestExecution(store, executionID)) {\n      clearExecutionInfo(store);\n    }\n\n    notifyWaitingStores(executionID, true);\n  }\n  /**\n   * Notify stores to pull the selector again if a new async dep was discovered.\n   * 1) Async selector adds a new dep but doesn't resolve yet.\n   *    Note that deps for an async selector are based on the state when the\n   *    evaluation started, in order to provide a consistent picture of state.\n   * 2) But, new value of dep based on the current state might cause the selector\n   *    to resolve or resolve differently.\n   * 3) Therefore, this notification will pull the selector based on the current\n   *    state for the components\n   */\n\n\n  function notifyStoresOfNewAsyncDep(store, executionID) {\n    if (isLatestExecution(store, executionID)) {\n      const executionInfo = Recoil_nullthrows(getExecutionInfo(store));\n      executionInfo.stateVersions.clear();\n      notifyWaitingStores(executionID, false);\n    }\n  }\n\n  function notifyWaitingStores(executionID, clearWaitlist) {\n    const stores = waitingStores.get(executionID);\n\n    if (stores != null) {\n      for (const waitingStore of stores) {\n        markRecoilValueModified$1(waitingStore, Recoil_nullthrows(recoilValue));\n      }\n\n      if (clearWaitlist) {\n        waitingStores.delete(executionID);\n      }\n    }\n  }\n\n  function markStoreWaitingForResolvedAsync(store, executionID) {\n    let stores = waitingStores.get(executionID);\n\n    if (stores == null) {\n      waitingStores.set(executionID, stores = new Set());\n    }\n\n    stores.add(store);\n  }\n  /**\n   * This function attaches a then() and a catch() to a promise that was\n   * returned from a selector's get() (either explicitly or implicitly by\n   * running a function that uses the \"async\" keyword). If a selector's get()\n   * returns a promise, we have two possibilities:\n   *\n   * 1. The promise will resolve, in which case it will have completely finished\n   *    executing without any remaining pending dependencies. No more retries\n   *    are needed and we can proceed with updating the cache and notifying\n   *    subscribers (if it is the latest execution, otherwise only the cache\n   *    will be updated and subscriptions will not be fired). This is the case\n   *    handled by the attached then() handler.\n   *\n   * 2. The promise will throw because it either has an error or it came across\n   *    an async dependency that has not yet resolved, in which case we will\n   *    call wrapDepdencyPromise(), whose responsibility is to handle dependency\n   *    promises. This case is handled by the attached catch() handler.\n   *\n   * Both branches will eventually resolve to the final result of the selector\n   * (or an error if a real error occurred).\n   *\n   * The execution will run to completion even if it is stale, and its value\n   * will be cached. But stale executions will not update global state or update\n   * executionInfo as that is the responsibility of the 'latest' execution.\n   *\n   * Note this function should not be passed a promise that was thrown--AKA a\n   * dependency promise. Dependency promises should be passed to\n   * wrapPendingDependencyPromise()).\n   */\n\n\n  function wrapResultPromise(store, promise, state, depValues, executionID, loadingDepsState) {\n    return promise.then(value => {\n      if (!selectorIsLive()) {\n        // The selector was released since the request began; ignore the response.\n        clearExecutionInfo(store);\n        throw CANCELED;\n      }\n\n      const loadable = loadableWithValue$2(value);\n      resolveAsync(store, state, executionID, loadable, depValues);\n      return value;\n    }).catch(errorOrPromise => {\n      if (!selectorIsLive()) {\n        // The selector was released since the request began; ignore the response.\n        clearExecutionInfo(store);\n        throw CANCELED;\n      }\n\n      if (Recoil_isPromise(errorOrPromise)) {\n        return wrapPendingDependencyPromise(store, errorOrPromise, state, depValues, executionID, loadingDepsState);\n      }\n\n      const loadable = loadableWithError$1(errorOrPromise);\n      resolveAsync(store, state, executionID, loadable, depValues);\n      throw errorOrPromise;\n    });\n  }\n  /**\n   * This function attaches a then() and a catch() to a promise that was\n   * thrown from a selector's get(). If a selector's get() throws a promise,\n   * we have two possibilities:\n   *\n   * 1. The promise will resolve, meaning one of our selector's dependencies is\n   *    now available and we should \"retry\" our get() by running it again. This\n   *    is the case handled by the attached then() handler.\n   *\n   * 2. The promise will throw because something went wrong with the dependency\n   *    promise (in other words a real error occurred). This case is handled by\n   *    the attached catch() handler. If the dependency promise throws, it is\n   *    _always_ a real error and not another dependency promise (any dependency\n   *    promises would have been handled upstream).\n   *\n   * The then() branch will eventually resolve to the final result of the\n   * selector (or an error if a real error occurs), and the catch() will always\n   * resolve to an error because the dependency promise is a promise that was\n   * wrapped upstream, meaning it will only resolve to its real value or to a\n   * real error.\n   *\n   * The execution will run to completion even if it is stale, and its value\n   * will be cached. But stale executions will not update global state or update\n   * executionInfo as that is the responsibility of the 'latest' execution.\n   *\n   * Note this function should not be passed a promise that was returned from\n   * get(). The intention is that this function is only passed promises that\n   * were thrown due to a pending dependency. Promises returned by get() should\n   * be passed to wrapResultPromise() instead.\n   */\n\n\n  function wrapPendingDependencyPromise(store, promise, state, existingDeps, executionID, loadingDepsState) {\n    return promise.then(resolvedDep => {\n      if (!selectorIsLive()) {\n        // The selector was released since the request began; ignore the response.\n        clearExecutionInfo(store);\n        throw CANCELED;\n      } // Check if we are handling a pending Recoil dependency or if the user\n      // threw their own Promise to \"suspend\" a selector evaluation.  We need\n      // to check that the loadingDepPromise actually matches the promise that\n      // we caught in case the selector happened to catch the promise we threw\n      // for a pending Recoil dependency from `getRecoilValue()` and threw\n      // their own promise instead.\n\n\n      if (loadingDepsState.loadingDepKey != null && loadingDepsState.loadingDepPromise === promise) {\n        /**\n         * Note for async atoms, this means we are changing the atom's value\n         * in the store for the given version. This should be alright because\n         * the version of state is now stale and a new version will have\n         * already been triggered by the atom being resolved (see this logic\n         * in Recoil_atom.js)\n         */\n        state.atomValues.set(loadingDepsState.loadingDepKey, loadableWithValue$2(resolvedDep));\n      } else {\n        /**\n         * If resolvedDepKey is not defined, the promise was a user-thrown\n         * promise. User-thrown promises are an advanced feature and they\n         * should be avoided in almost all cases. Using `loadable.map()` inside\n         * of selectors for loading loadables and then throwing that mapped\n         * loadable's promise is an example of a user-thrown promise.\n         *\n         * When we hit a user-thrown promise, we have to bail out of an optimization\n         * where we bypass calculating selector cache keys for selectors that\n         * have been previously seen for a given state (these selectors are saved in\n         * state.atomValues) to avoid stale state as we have no way of knowing\n         * what state changes happened (if any) in result to the promise resolving.\n         *\n         * Ideally we would only bail out selectors that are in the chain of\n         * dependencies for this selector, but there's currently no way to get\n         * a full list of a selector's downstream nodes because the state that\n         * is executing may be a discarded tree (so store.getGraph(state.version)\n         * will be empty), and the full dep tree may not be in the selector\n         * caches in the case where the selector's cache was cleared. To solve\n         * for this we would have to keep track of all running selector\n         * executions and their downstream deps. Because this only covers edge\n         * cases, that complexity might not be justifyable.\n         */\n        store.getState().knownSelectors.forEach(nodeKey => {\n          state.atomValues.delete(nodeKey);\n        });\n      }\n      /**\n       * Optimization: Now that the dependency has resolved, let's try hitting\n       * the cache in case the dep resolved to a value we have previously seen.\n       *\n       * TODO:\n       * Note this optimization is not perfect because it only prevents re-executions\n       * _after_ the point where an async dependency is found. Any code leading\n       * up to the async dependency may have run unnecessarily. The ideal case\n       * would be to wait for the async dependency to resolve first, check the\n       * cache, and prevent _any_ execution of the selector if the resulting\n       * value of the dependency leads to a path that is found in the cache.\n       * The ideal case is more difficult to implement as it would require that\n       * we capture and wait for the the async dependency right after checking\n       * the cache. The current approach takes advantage of the fact that running\n       * the selector already has a code path that lets us exit early when\n       * an async dep resolves.\n       */\n\n\n      const cachedLoadable = getLoadableFromCacheAndUpdateDeps(store, state);\n\n      if (cachedLoadable && cachedLoadable.state !== 'loading') {\n        /**\n         * This has to notify stores of a resolved async, even if there is no\n         * current pending execution for the following case:\n         * 1) A component renders with this pending loadable.\n         * 2) The upstream dependency resolves.\n         * 3) While processing some other selector it reads this one, such as\n         *    while traversing its dependencies.  At this point it gets the\n         *    new resolved value synchronously and clears the current\n         *    execution ID.  The component wasn't getting the value itself,\n         *    though, so it still has the pending loadable.\n         * 4) When this code executes the current execution id was cleared\n         *    and it wouldn't notify the component of the new value.\n         *\n         * I think this is only an issue with \"early\" rendering since the\n         * components got their value using the in-progress execution.\n         * We don't have a unit test for this case yet.  I'm not sure it is\n         * necessary with recoil_transition_support mode.\n         */\n        if (isLatestExecution(store, executionID) || getExecutionInfo(store) == null) {\n          notifyStoresOfResolvedAsync(store, executionID);\n        }\n\n        if (cachedLoadable.state === 'hasValue') {\n          return cachedLoadable.contents;\n        } else {\n          throw cachedLoadable.contents;\n        }\n      }\n      /**\n       * If this execution is stale, let's check to see if there is some in\n       * progress execution with a matching state. If we find a match, then\n       * we can take the value from that in-progress execution. Note this may\n       * sound like an edge case, but may be very common in cases where a\n       * loading dependency resolves from loading to having a value (thus\n       * possibly triggering a re-render), and React re-renders before the\n       * chained .then() functions run, thus starting a new execution as the\n       * dep has changed value. Without this check we will run the selector\n       * twice (once in the new execution and once again in this .then(), so\n       * this check is necessary to keep unnecessary re-executions to a\n       * minimum).\n       *\n       * Also note this code does not check across all executions that may be\n       * running. It only optimizes for the _latest_ execution per store as\n       * we currently do not maintain a list of all currently running executions.\n       * This means in some cases we may run selectors more than strictly\n       * necessary when there are multiple executions running for the same\n       * selector. This may be a valid tradeoff as checking for dep changes\n       * across all in-progress executions may take longer than just\n       * re-running the selector. This will be app-dependent, and maybe in the\n       * future we can make the behavior configurable. An ideal fix may be\n       * to extend the tree cache to support caching loading states.\n       */\n\n\n      if (!isLatestExecution(store, executionID)) {\n        const executionInfo = getInProgressExecutionInfo(store, state);\n\n        if (executionInfo != null) {\n          /**\n           * Returning promise here without wrapping as the wrapper logic was\n           * already done upstream when this promise was generated.\n           */\n          return executionInfo.loadingLoadable.contents;\n        }\n      } // Retry the selector evaluation now that the dependency has resolved\n\n\n      const [loadable, depValues] = evaluateSelectorGetter(store, state, executionID);\n\n      if (loadable.state !== 'loading') {\n        resolveAsync(store, state, executionID, loadable, depValues);\n      }\n\n      if (loadable.state === 'hasError') {\n        throw loadable.contents;\n      }\n\n      return loadable.contents;\n    }).catch(error => {\n      // The selector was released since the request began; ignore the response.\n      if (error instanceof Canceled) {\n        throw CANCELED;\n      }\n\n      if (!selectorIsLive()) {\n        clearExecutionInfo(store);\n        throw CANCELED;\n      }\n\n      const loadable = loadableWithError$1(error);\n      resolveAsync(store, state, executionID, loadable, existingDeps);\n      throw error;\n    });\n  }\n\n  function updateDeps(store, state, deps, executionID) {\n    var _store$getState, _store$getState$curre, _store$getState2, _store$getState2$next;\n\n    if (isLatestExecution(store, executionID) || state.version === ((_store$getState = store.getState()) === null || _store$getState === void 0 ? void 0 : (_store$getState$curre = _store$getState.currentTree) === null || _store$getState$curre === void 0 ? void 0 : _store$getState$curre.version) || state.version === ((_store$getState2 = store.getState()) === null || _store$getState2 === void 0 ? void 0 : (_store$getState2$next = _store$getState2.nextTree) === null || _store$getState2$next === void 0 ? void 0 : _store$getState2$next.version)) {\n      var _store$getState$nextT, _store$getState3, _store$getState3$next;\n\n      saveDepsToStore$1(key, deps, store, (_store$getState$nextT = (_store$getState3 = store.getState()) === null || _store$getState3 === void 0 ? void 0 : (_store$getState3$next = _store$getState3.nextTree) === null || _store$getState3$next === void 0 ? void 0 : _store$getState3$next.version) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree.version);\n    }\n\n    for (const nodeKey of deps) {\n      discoveredDependencyNodeKeys.add(nodeKey);\n    }\n  }\n\n  function evaluateSelectorGetter(store, state, executionID) {\n    const endPerfBlock = startPerfBlock$1(key); // TODO T63965866: use execution ID here\n\n    let duringSynchronousExecution = true;\n    let duringAsynchronousExecution = true;\n\n    const finishEvaluation = () => {\n      endPerfBlock();\n      duringAsynchronousExecution = false;\n    };\n\n    let result;\n    let resultIsError = false;\n    let loadable;\n    const loadingDepsState = {\n      loadingDepKey: null,\n      loadingDepPromise: null\n    };\n    /**\n     * Starting a fresh set of deps that we'll be using to update state. We're\n     * starting a new set versus adding it in existing state deps because\n     * the version of state that we update deps for may be a more recent version\n     * than the version the selector was called with. This is because the latest\n     * execution will update the deps of the current/latest version of state\n     * (This is safe to do because the fact that the selector is the latest\n     * execution means the deps we discover below are our best guess at the\n     * deps for the current/latest state in the store)\n     */\n\n    const depValues = new Map();\n\n    function getRecoilValue({\n      key: depKey\n    }) {\n      const depLoadable = getNodeLoadable$2(store, state, depKey);\n      depValues.set(depKey, depLoadable); // We need to update asynchronous dependencies as we go so the selector\n      // knows if it has to restart evaluation if one of them is updated before\n      // the asynchronous selector completely resolves.\n\n      if (!duringSynchronousExecution) {\n        updateDeps(store, state, new Set(depValues.keys()), executionID);\n        notifyStoresOfNewAsyncDep(store, executionID);\n      }\n\n      switch (depLoadable.state) {\n        case 'hasValue':\n          return depLoadable.contents;\n\n        case 'hasError':\n          throw depLoadable.contents;\n\n        case 'loading':\n          loadingDepsState.loadingDepKey = depKey;\n          loadingDepsState.loadingDepPromise = depLoadable.contents;\n          throw depLoadable.contents;\n      }\n\n      throw Recoil_err('Invalid Loadable state');\n    }\n\n    const getCallback = fn => {\n      return (...args) => {\n        if (duringAsynchronousExecution) {\n          throw Recoil_err('Callbacks from getCallback() should only be called asynchronously after the selector is evalutated.  It can be used for selectors to return objects with callbacks that can work with Recoil state without a subscription.');\n        }\n\n        !(recoilValue != null) ? process.env.NODE_ENV !== \"production\" ? Recoil_invariant(false, 'Recoil Value can never be null') : Recoil_invariant(false) : void 0;\n        return recoilCallback$1(store, fn, args, {\n          node: recoilValue\n        } // flowlint-line unclear-type:off\n        );\n      };\n    };\n\n    try {\n      result = get({\n        get: getRecoilValue,\n        getCallback\n      });\n      result = isRecoilValue$3(result) ? getRecoilValue(result) : result;\n\n      if (isLoadable$1(result)) {\n        if (result.state === 'hasError') {\n          resultIsError = true;\n        }\n\n        result = result.contents;\n      }\n\n      if (Recoil_isPromise(result)) {\n        result = wrapResultPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);\n      } else {\n        finishEvaluation();\n      }\n\n      result = result instanceof WrappedValue$1 ? result.value : result;\n    } catch (errorOrDepPromise) {\n      result = errorOrDepPromise;\n\n      if (Recoil_isPromise(result)) {\n        result = wrapPendingDependencyPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);\n      } else {\n        resultIsError = true;\n        finishEvaluation();\n      }\n    }\n\n    if (resultIsError) {\n      loadable = loadableWithError$1(result);\n    } else if (Recoil_isPromise(result)) {\n      loadable = loadableWithPromise$1(result);\n    } else {\n      loadable = loadableWithValue$2(result);\n    }\n\n    duringSynchronousExecution = false;\n    updateExecutionInfoDepValues(store, executionID, depValues);\n    updateDeps(store, state, new Set(depValues.keys()), executionID);\n    return [loadable, depValues];\n  }\n\n  function getLoadableFromCacheAndUpdateDeps(store, state) {\n    // First, look up in the state cache\n    // If it's here, then the deps in the store should already be valid.\n    let cachedLoadable = state.atomValues.get(key);\n\n    if (cachedLoadable != null) {\n      return cachedLoadable;\n    } // Second, look up in the selector cache and update the deps in the store\n\n\n    const depsAfterCacheLookup = new Set();\n\n    try {\n      cachedLoadable = cache.get(nodeKey => {\n        !(typeof nodeKey === 'string') ? process.env.NODE_ENV !== \"production\" ? Recoil_invariant(false, 'Cache nodeKey is type string') : Recoil_invariant(false) : void 0;\n        return getNodeLoadable$2(store, state, nodeKey).contents;\n      }, {\n        onNodeVisit: node => {\n          if (node.type === 'branch' && node.nodeKey !== key) {\n            depsAfterCacheLookup.add(node.nodeKey);\n          }\n        }\n      });\n    } catch (error) {\n      throw Recoil_err(`Problem with cache lookup for selector \"${key}\": ${error.message}`);\n    }\n\n    if (cachedLoadable) {\n      var _getExecutionInfo;\n\n      // Cache the results in the state to allow for cheaper lookup than\n      // iterating the tree cache of dependencies.\n      state.atomValues.set(key, cachedLoadable);\n      /**\n       * Ensure store contains correct dependencies if we hit the cache so that\n       * the store deps and cache are in sync for a given state. This is important\n       * because store deps are normally updated when new executions are created,\n       * but cache hits don't trigger new executions but they still _may_ signify\n       * a change in deps in the store if the store deps for this state are empty\n       * or stale.\n       */\n\n      updateDeps(store, state, depsAfterCacheLookup, (_getExecutionInfo = getExecutionInfo(store)) === null || _getExecutionInfo === void 0 ? void 0 : _getExecutionInfo.executionID);\n    }\n\n    return cachedLoadable;\n  }\n  /**\n   * Given a tree state, this function returns a Loadable of the current state.\n   *\n   * The selector's get() function will only be re-evaluated if _both_ of the\n   * following statements are true:\n   *\n   * 1. The current dep values from the given state produced a cache key that\n   *    was not found in the cache.\n   * 2. There is no currently running async execution OR there is an\n   *    async execution that is running, but after comparing the dep values in\n   *    the given state with the dep values that the execution has discovered so\n   *    far we find that at least one dep value has changed, in which case we\n   *    start a new execution (the previously running execution will continue to\n   *    run to completion, but only the new execution will be deemed the\n   *    'latest' execution, meaning it will be the only execution that will\n   *    update global state when it is finished. Any non-latest executions will\n   *    run to completion and update the selector cache but not global state).\n   */\n\n\n  function getSelectorLoadableAndUpdateDeps(store, state) {\n    // First, see if our current state is cached\n    const cachedVal = getLoadableFromCacheAndUpdateDeps(store, state);\n\n    if (cachedVal != null) {\n      clearExecutionInfo(store);\n      return cachedVal;\n    } // Second, check if there is already an ongoing execution based on the current state\n\n\n    const inProgressExecutionInfo = getInProgressExecutionInfo(store, state);\n\n    if (inProgressExecutionInfo != null) {\n      var _inProgressExecutionI;\n\n      if (((_inProgressExecutionI = inProgressExecutionInfo.loadingLoadable) === null || _inProgressExecutionI === void 0 ? void 0 : _inProgressExecutionI.state) === 'loading') {\n        markStoreWaitingForResolvedAsync(store, inProgressExecutionInfo.executionID);\n      } // FIXME: check after the fact to see if we made the right choice by waiting\n\n\n      return inProgressExecutionInfo.loadingLoadable;\n    } // Third, start a new evaluation of the selector\n\n\n    const newExecutionID = getNewExecutionID();\n    const [loadable, newDepValues] = evaluateSelectorGetter(store, state, newExecutionID);\n    /**\n     * Conditionally updates the cache with a given loadable.\n     *\n     * We only cache loadables that are not loading because our cache keys are\n     * based on dep values, which are in an unfinished state for loadables that\n     * have a 'loading' state (new deps may be discovered while the selector\n     * runs its async code). We never want to cache partial dependencies b/c it\n     * could lead to errors, such as prematurely returning the result based on a\n     * partial list of deps-- we need the full list of deps to ensure that we\n     * are returning the correct result from cache.\n     */\n\n    if (loadable.state === 'loading') {\n      setExecutionInfo(store, newExecutionID, loadable, newDepValues, state);\n      markStoreWaitingForResolvedAsync(store, newExecutionID);\n    } else {\n      clearExecutionInfo(store);\n      setCache(state, loadable, newDepValues);\n    }\n\n    return loadable;\n  }\n  /**\n   * Searches execution info across all stores to see if there is an in-progress\n   * execution whose dependency values match the values of the requesting store.\n   */\n\n\n  function getInProgressExecutionInfo(store, state) {\n    // Sort the pending executions so that our current store is checked first.\n    const pendingExecutions = Recoil_concatIterables([executionInfoMap.has(store) ? [Recoil_nullthrows(executionInfoMap.get(store))] : [], Recoil_mapIterable(Recoil_filterIterable(executionInfoMap, ([s]) => s !== store), ([, execInfo]) => execInfo)]);\n\n    function anyDepChanged(execDepValues) {\n      for (const [depKey, execLoadable] of execDepValues) {\n        if (!getNodeLoadable$2(store, state, depKey).is(execLoadable)) {\n          return true;\n        }\n      }\n\n      return false;\n    }\n\n    for (const execInfo of pendingExecutions) {\n      if ( // If this execution was already checked to be valid with this version\n      // of state, then let's use it!\n      execInfo.stateVersions.get(state.version) || // If the deps for the execution match our current state, then it's valid\n      !anyDepChanged(execInfo.depValuesDiscoveredSoFarDuringAsyncWork)) {\n        execInfo.stateVersions.set(state.version, true);\n        return execInfo;\n      } else {\n        execInfo.stateVersions.set(state.version, false);\n      }\n    }\n\n    return undefined;\n  }\n\n  function getExecutionInfo(store) {\n    return executionInfoMap.get(store);\n  }\n  /**\n   * This function will update the selector's execution info when the selector\n   * has either finished running an execution or has started a new execution. If\n   * the given loadable is in a 'loading' state, the intention is that a new\n   * execution has started. Otherwise, the intention is that an execution has\n   * just finished.\n   */\n\n\n  function setExecutionInfo(store, newExecutionID, loadable, depValues, state) {\n    executionInfoMap.set(store, {\n      depValuesDiscoveredSoFarDuringAsyncWork: depValues,\n      executionID: newExecutionID,\n      loadingLoadable: loadable,\n      stateVersions: new Map([[state.version, true]])\n    });\n  }\n\n  function updateExecutionInfoDepValues(store, executionID, depValues) {\n    // We only need to bother updating the deps for the latest execution because\n    // that's all getInProgressExecutionInfo() will be looking for.\n    if (isLatestExecution(store, executionID)) {\n      const executionInfo = getExecutionInfo(store);\n\n      if (executionInfo != null) {\n        executionInfo.depValuesDiscoveredSoFarDuringAsyncWork = depValues;\n      }\n    }\n  }\n\n  function clearExecutionInfo(store) {\n    executionInfoMap.delete(store);\n  }\n\n  function isLatestExecution(store, executionID) {\n    var _getExecutionInfo2;\n\n    return executionID === ((_getExecutionInfo2 = getExecutionInfo(store)) === null || _getExecutionInfo2 === void 0 ? void 0 : _getExecutionInfo2.executionID);\n  }\n  /**\n   * FIXME: dep keys should take into account the state of the loadable to\n   * prevent the edge case where a loadable with an error and a loadable with\n   * an error as a value are treated as the same thing incorrectly. For example\n   * these two should be treated differently:\n   *\n   * selector({key: '', get: () => new Error('hi')});\n   * selector({key: '', get () => {throw new Error('hi')}});\n   *\n   * With current implementation they are treated the same\n   */\n\n\n  function depValuesToDepRoute(depValues) {\n    return Array.from(depValues.entries()).map(([depKey, valLoadable]) => [depKey, valLoadable.contents]);\n  }\n\n  function setCache(state, loadable, depValues) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (loadable.state !== 'loading' && Boolean(options.dangerouslyAllowMutability) === false) {\n        Recoil_deepFreezeValue(loadable.contents);\n      }\n    }\n\n    state.atomValues.set(key, loadable);\n\n    try {\n      cache.set(depValuesToDepRoute(depValues), loadable);\n    } catch (error) {\n      throw Recoil_err(`Problem with setting cache for selector \"${key}\": ${error.message}`);\n    }\n  }\n\n  function detectCircularDependencies(fn) {\n    if (dependencyStack.includes(key)) {\n      const message = `Recoil selector has circular dependencies: ${dependencyStack.slice(dependencyStack.indexOf(key)).join(' \\u2192 ')}`;\n      return loadableWithError$1(Recoil_err(message));\n    }\n\n    dependencyStack.push(key);\n\n    try {\n      return fn();\n    } finally {\n      dependencyStack.pop();\n    }\n  }\n\n  function selectorPeek(store, state) {\n    const cachedLoadable = state.atomValues.get(key);\n\n    if (cachedLoadable != null) {\n      return cachedLoadable;\n    }\n\n    return cache.get(nodeKey => {\n      var _peekNodeLoadable;\n\n      !(typeof nodeKey === 'string') ? process.env.NODE_ENV !== \"production\" ? Recoil_invariant(false, 'Cache nodeKey is type string') : Recoil_invariant(false) : void 0;\n      return (_peekNodeLoadable = peekNodeLoadable$1(store, state, nodeKey)) === null || _peekNodeLoadable === void 0 ? void 0 : _peekNodeLoadable.contents;\n    });\n  }\n\n  function selectorGet(store, state) {\n    return detectCircularDependencies(() => getSelectorLoadableAndUpdateDeps(store, state));\n  }\n\n  function invalidateSelector(state) {\n    state.atomValues.delete(key);\n  }\n\n  function clearSelectorCache(store, treeState) {\n    !(recoilValue != null) ? process.env.NODE_ENV !== \"production\" ? Recoil_invariant(false, 'Recoil Value can never be null') : Recoil_invariant(false) : void 0;\n\n    for (const nodeKey of discoveredDependencyNodeKeys) {\n      var _node$clearCache;\n\n      const node = getNode$6(nodeKey);\n      (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, treeState);\n    }\n\n    discoveredDependencyNodeKeys.clear();\n    invalidateSelector(treeState);\n    cache.clear();\n    markRecoilValueModified$1(store, recoilValue);\n  }\n\n  if (set != null) {\n    /**\n     * ES5 strict mode prohibits defining non-top-level function declarations,\n     * so don't use function declaration syntax here\n     */\n    const selectorSet = (store, state, newValue) => {\n      let syncSelectorSetFinished = false;\n      const writes = new Map();\n\n      function getRecoilValue({\n        key: depKey\n      }) {\n        if (syncSelectorSetFinished) {\n          throw Recoil_err('Recoil: Async selector sets are not currently supported.');\n        }\n\n        const loadable = getNodeLoadable$2(store, state, depKey);\n\n        if (loadable.state === 'hasValue') {\n          return loadable.contents;\n        } else if (loadable.state === 'loading') {\n          const msg = `Getting value of asynchronous atom or selector \"${depKey}\" in a pending state while setting selector \"${key}\" is not yet supported.`;\n          Recoil_recoverableViolation(msg);\n          throw Recoil_err(msg);\n        } else {\n          throw loadable.contents;\n        }\n      }\n\n      function setRecoilState(recoilState, valueOrUpdater) {\n        if (syncSelectorSetFinished) {\n          const msg = 'Recoil: Async selector sets are not currently supported.';\n          Recoil_recoverableViolation(msg);\n          throw Recoil_err(msg);\n        }\n\n        const setValue = typeof valueOrUpdater === 'function' ? // cast to any because we can't restrict type S from being a function itself without losing support for opaque types\n        // flowlint-next-line unclear-type:off\n        valueOrUpdater(getRecoilValue(recoilState)) : valueOrUpdater;\n        const upstreamWrites = setNodeValue$3(store, state, recoilState.key, setValue);\n        upstreamWrites.forEach((v, k) => writes.set(k, v));\n      }\n\n      function resetRecoilState(recoilState) {\n        setRecoilState(recoilState, DEFAULT_VALUE$6);\n      }\n\n      const ret = set({\n        set: setRecoilState,\n        get: getRecoilValue,\n        reset: resetRecoilState\n      }, newValue); // set should be a void method, but if the user makes it `async`, then it\n      // will return a Promise, which we don't currently support.\n\n      if (ret !== undefined) {\n        throw Recoil_isPromise(ret) ? Recoil_err('Recoil: Async selector sets are not currently supported.') : Recoil_err('Recoil: selector set should be a void function.');\n      }\n\n      syncSelectorSetFinished = true;\n      return writes;\n    };\n\n    return recoilValue = registerNode$1({\n      key,\n      nodeType: 'selector',\n      peek: selectorPeek,\n      get: selectorGet,\n      set: selectorSet,\n      init: selectorInit,\n      invalidate: invalidateSelector,\n      clearCache: clearSelectorCache,\n      shouldDeleteConfigOnRelease: selectorShouldDeleteConfigOnRelease,\n      dangerouslyAllowMutability: options.dangerouslyAllowMutability,\n      shouldRestoreFromSnapshots: false,\n      retainedBy\n    });\n  } else {\n    return recoilValue = registerNode$1({\n      key,\n      nodeType: 'selector',\n      peek: selectorPeek,\n      get: selectorGet,\n      init: selectorInit,\n      invalidate: invalidateSelector,\n      clearCache: clearSelectorCache,\n      shouldDeleteConfigOnRelease: selectorShouldDeleteConfigOnRelease,\n      dangerouslyAllowMutability: options.dangerouslyAllowMutability,\n      shouldRestoreFromSnapshots: false,\n      retainedBy\n    });\n  }\n}\n/* eslint-enable no-redeclare */\n// $FlowIssue[incompatible-use]\n// $FlowFixMe[missing-local-annot]\n\n\nselector.value = value => new WrappedValue$1(value);\n\nvar Recoil_selector = selector;\n\n// @fb-only: import type {ScopeRules} from 'Recoil_ScopedAtom';\n// @fb-only: const {scopedAtom} = require('Recoil_ScopedAtom');\nconst {\n  isLoadable: isLoadable$2,\n  loadableWithError: loadableWithError$2,\n  loadableWithPromise: loadableWithPromise$2,\n  loadableWithValue: loadableWithValue$3\n} = Recoil_Loadable$1;\n\nconst {\n  WrappedValue: WrappedValue$2\n} = Recoil_Wrapper$1;\n\nconst {\n  peekNodeInfo: peekNodeInfo$3\n} = Recoil_FunctionalCore;\n\nconst {\n  DEFAULT_VALUE: DEFAULT_VALUE$7,\n  DefaultValue: DefaultValue$2,\n  getConfigDeletionHandler: getConfigDeletionHandler$2,\n  registerNode: registerNode$2,\n  setConfigDeletionHandler: setConfigDeletionHandler$1\n} = Recoil_Node;\n\nconst {\n  isRecoilValue: isRecoilValue$4\n} = Recoil_RecoilValue$1;\n\nconst {\n  getRecoilValueAsLoadable: getRecoilValueAsLoadable$4,\n  markRecoilValueModified: markRecoilValueModified$2,\n  setRecoilValue: setRecoilValue$4,\n  setRecoilValueLoadable: setRecoilValueLoadable$2\n} = Recoil_RecoilValueInterface;\n\nconst {\n  retainedByOptionWithDefault: retainedByOptionWithDefault$2\n} = Recoil_Retention;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst unwrap = x => x instanceof WrappedValue$2 ? x.value : x;\n\nfunction baseAtom(options) {\n  const {\n    key,\n    persistence_UNSTABLE: persistence\n  } = options;\n  const retainedBy = retainedByOptionWithDefault$2(options.retainedBy_UNSTABLE);\n  let liveStoresCount = 0;\n\n  function unwrapPromise(promise) {\n    return loadableWithPromise$2(promise.then(value => {\n      defaultLoadable = loadableWithValue$3(value);\n      return value;\n    }).catch(error => {\n      defaultLoadable = loadableWithError$2(error);\n      throw error;\n    }));\n  }\n\n  let defaultLoadable = Recoil_isPromise(options.default) ? unwrapPromise(options.default) : isLoadable$2(options.default) ? options.default.state === 'loading' ? unwrapPromise(options.default.contents) : options.default : loadableWithValue$3(unwrap(options.default));\n  maybeFreezeValueOrPromise(defaultLoadable.contents);\n  let cachedAnswerForUnvalidatedValue = undefined; // Cleanup handlers for this atom\n  // Rely on stable reference equality of the store to use it as a key per <RecoilRoot>\n\n  const cleanupEffectsByStore = new Map();\n\n  function maybeFreezeValueOrPromise(valueOrPromise) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (options.dangerouslyAllowMutability !== true) {\n        if (Recoil_isPromise(valueOrPromise)) {\n          return valueOrPromise.then(value => {\n            Recoil_deepFreezeValue(value);\n            return value;\n          });\n        } else {\n          Recoil_deepFreezeValue(valueOrPromise);\n          return valueOrPromise;\n        }\n      }\n    }\n\n    return valueOrPromise;\n  }\n\n  function wrapPendingPromise(store, promise) {\n    const wrappedPromise = promise.then(value => {\n      var _store$getState$nextT, _state$atomValues$get;\n\n      const state = (_store$getState$nextT = store.getState().nextTree) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree;\n\n      if (((_state$atomValues$get = state.atomValues.get(key)) === null || _state$atomValues$get === void 0 ? void 0 : _state$atomValues$get.contents) === wrappedPromise) {\n        setRecoilValue$4(store, node, value);\n      }\n\n      return value;\n    }).catch(error => {\n      var _store$getState$nextT2, _state$atomValues$get2;\n\n      const state = (_store$getState$nextT2 = store.getState().nextTree) !== null && _store$getState$nextT2 !== void 0 ? _store$getState$nextT2 : store.getState().currentTree;\n\n      if (((_state$atomValues$get2 = state.atomValues.get(key)) === null || _state$atomValues$get2 === void 0 ? void 0 : _state$atomValues$get2.contents) === wrappedPromise) {\n        setRecoilValueLoadable$2(store, node, loadableWithError$2(error));\n      }\n\n      throw error;\n    });\n    return wrappedPromise;\n  }\n\n  function initAtom(store, initState, trigger) {\n    var _options$effects;\n\n    liveStoresCount++;\n\n    const cleanupAtom = () => {\n      var _cleanupEffectsByStor;\n\n      liveStoresCount--;\n      (_cleanupEffectsByStor = cleanupEffectsByStore.get(store)) === null || _cleanupEffectsByStor === void 0 ? void 0 : _cleanupEffectsByStor.forEach(cleanup => cleanup());\n      cleanupEffectsByStore.delete(store);\n    };\n\n    store.getState().knownAtoms.add(key); // Setup async defaults to notify subscribers when they resolve\n\n    if (defaultLoadable.state === 'loading') {\n      const notifyDefaultSubscribers = () => {\n        var _store$getState$nextT3;\n\n        const state = (_store$getState$nextT3 = store.getState().nextTree) !== null && _store$getState$nextT3 !== void 0 ? _store$getState$nextT3 : store.getState().currentTree;\n\n        if (!state.atomValues.has(key)) {\n          markRecoilValueModified$2(store, node);\n        }\n      };\n\n      defaultLoadable.contents.finally(notifyDefaultSubscribers);\n    } ///////////////////\n    // Run Atom Effects\n    ///////////////////\n\n\n    const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : options.effects_UNSTABLE;\n\n    if (effects != null) {\n      // This state is scoped by Store, since this is in the initAtom() closure\n      let initValue = DEFAULT_VALUE$7;\n      let isDuringInit = true;\n      let isInitError = false;\n      let pendingSetSelf = null;\n\n      function getLoadable(recoilValue) {\n        // Normally we can just get the current value of another atom.\n        // But for our own value we need to check if there is a pending\n        // initialized value or get the fallback default value.\n        if (isDuringInit && recoilValue.key === key) {\n          // Cast T to S\n          const retValue = initValue; // flowlint-line unclear-type:off\n\n          return retValue instanceof DefaultValue$2 ? peekAtom(store, initState) // flowlint-line unclear-type:off\n          : Recoil_isPromise(retValue) ? loadableWithPromise$2(retValue.then(v => v instanceof DefaultValue$2 ? // Cast T to S\n          defaultLoadable.toPromise() // flowlint-line unclear-type:off\n          : v)) : loadableWithValue$3(retValue);\n        }\n\n        return getRecoilValueAsLoadable$4(store, recoilValue);\n      }\n\n      function getPromise(recoilValue) {\n        return getLoadable(recoilValue).toPromise();\n      }\n\n      function getInfo_UNSTABLE(recoilValue) {\n        var _store$getState$nextT4;\n\n        const info = peekNodeInfo$3(store, (_store$getState$nextT4 = store.getState().nextTree) !== null && _store$getState$nextT4 !== void 0 ? _store$getState$nextT4 : store.getState().currentTree, recoilValue.key);\n        return isDuringInit && recoilValue.key === key && !(initValue instanceof DefaultValue$2) ? { ...info,\n          isSet: true,\n          loadable: getLoadable(recoilValue)\n        } : info;\n      }\n\n      const setSelf = effect => valueOrUpdater => {\n        if (isDuringInit) {\n          const currentLoadable = getLoadable(node);\n          const currentValue = currentLoadable.state === 'hasValue' ? currentLoadable.contents : DEFAULT_VALUE$7;\n          initValue = typeof valueOrUpdater === 'function' ? // cast to any because we can't restrict T from being a function without losing support for opaque types\n          valueOrUpdater(currentValue) // flowlint-line unclear-type:off\n          : valueOrUpdater;\n\n          if (Recoil_isPromise(initValue)) {\n            initValue = initValue.then(value => {\n              // Avoid calling onSet() when setSelf() initializes with a Promise\n              pendingSetSelf = {\n                effect,\n                value\n              };\n              return value;\n            });\n          }\n        } else {\n          if (Recoil_isPromise(valueOrUpdater)) {\n            throw Recoil_err('Setting atoms to async values is not implemented.');\n          }\n\n          if (typeof valueOrUpdater !== 'function') {\n            pendingSetSelf = {\n              effect,\n              value: unwrap(valueOrUpdater)\n            };\n          }\n\n          setRecoilValue$4(store, node, typeof valueOrUpdater === 'function' ? currentValue => {\n            const newValue = unwrap( // cast to any because we can't restrict T from being a function without losing support for opaque types\n            valueOrUpdater(currentValue) // flowlint-line unclear-type:off\n            );\n            pendingSetSelf = {\n              effect,\n              value: newValue\n            };\n            return newValue;\n          } : unwrap(valueOrUpdater));\n        }\n      };\n\n      const resetSelf = effect => () => setSelf(effect)(DEFAULT_VALUE$7);\n\n      const onSet = effect => handler => {\n        var _cleanupEffectsByStor2;\n\n        const {\n          release\n        } = store.subscribeToTransactions(currentStore => {\n          var _currentTree$atomValu;\n\n          // eslint-disable-next-line prefer-const\n          let {\n            currentTree,\n            previousTree\n          } = currentStore.getState();\n\n          if (!previousTree) {\n            Recoil_recoverableViolation('Transaction subscribers notified without a next tree being present -- this is a bug in Recoil');\n            previousTree = currentTree; // attempt to trundle on\n          }\n\n          const newLoadable = (_currentTree$atomValu = currentTree.atomValues.get(key)) !== null && _currentTree$atomValu !== void 0 ? _currentTree$atomValu : defaultLoadable;\n\n          if (newLoadable.state === 'hasValue') {\n            var _previousTree$atomVal, _pendingSetSelf, _pendingSetSelf2, _pendingSetSelf3;\n\n            const newValue = newLoadable.contents;\n            const oldLoadable = (_previousTree$atomVal = previousTree.atomValues.get(key)) !== null && _previousTree$atomVal !== void 0 ? _previousTree$atomVal : defaultLoadable;\n            const oldValue = oldLoadable.state === 'hasValue' ? oldLoadable.contents : DEFAULT_VALUE$7; // TODO This isn't actually valid, use as a placeholder for now.\n            // Ignore atom value changes that were set via setSelf() in the same effect.\n            // We will still properly call the handler if there was a subsequent\n            // set from something other than an atom effect which was batched\n            // with the `setSelf()` call.  However, we may incorrectly ignore\n            // the handler if the subsequent batched call happens to set the\n            // atom to the exact same value as the `setSelf()`.   But, in that\n            // case, it was kind of a noop, so the semantics are debatable..\n\n            if (((_pendingSetSelf = pendingSetSelf) === null || _pendingSetSelf === void 0 ? void 0 : _pendingSetSelf.effect) !== effect || ((_pendingSetSelf2 = pendingSetSelf) === null || _pendingSetSelf2 === void 0 ? void 0 : _pendingSetSelf2.value) !== newValue) {\n              handler(newValue, oldValue, !currentTree.atomValues.has(key));\n            } else if (((_pendingSetSelf3 = pendingSetSelf) === null || _pendingSetSelf3 === void 0 ? void 0 : _pendingSetSelf3.effect) === effect) {\n              pendingSetSelf = null;\n            }\n          }\n        }, key);\n        cleanupEffectsByStore.set(store, [...((_cleanupEffectsByStor2 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor2 !== void 0 ? _cleanupEffectsByStor2 : []), release]);\n      };\n\n      for (const effect of effects) {\n        try {\n          const cleanup = effect({\n            node,\n            storeID: store.storeID,\n            parentStoreID_UNSTABLE: store.parentStoreID,\n            trigger,\n            setSelf: setSelf(effect),\n            resetSelf: resetSelf(effect),\n            onSet: onSet(effect),\n            getPromise,\n            getLoadable,\n            getInfo_UNSTABLE\n          });\n\n          if (cleanup != null) {\n            var _cleanupEffectsByStor3;\n\n            cleanupEffectsByStore.set(store, [...((_cleanupEffectsByStor3 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor3 !== void 0 ? _cleanupEffectsByStor3 : []), cleanup]);\n          }\n        } catch (error) {\n          initValue = error;\n          isInitError = true;\n        }\n      }\n\n      isDuringInit = false; // Mutate initial state in place since we know there are no other subscribers\n      // since we are the ones initializing on first use.\n\n      if (!(initValue instanceof DefaultValue$2)) {\n        var _store$getState$nextT5;\n\n        const initLoadable = isInitError ? loadableWithError$2(initValue) : Recoil_isPromise(initValue) ? loadableWithPromise$2(wrapPendingPromise(store, initValue)) : loadableWithValue$3(unwrap(initValue));\n        maybeFreezeValueOrPromise(initLoadable.contents);\n        initState.atomValues.set(key, initLoadable); // If there is a pending transaction, then also mutate the next state tree.\n        // This could happen if the atom was first initialized in an action that\n        // also updated some other atom's state.\n\n        (_store$getState$nextT5 = store.getState().nextTree) === null || _store$getState$nextT5 === void 0 ? void 0 : _store$getState$nextT5.atomValues.set(key, initLoadable);\n      }\n    }\n\n    return cleanupAtom;\n  }\n\n  function peekAtom(_store, state) {\n    var _ref, _state$atomValues$get3;\n\n    return (_ref = (_state$atomValues$get3 = state.atomValues.get(key)) !== null && _state$atomValues$get3 !== void 0 ? _state$atomValues$get3 : cachedAnswerForUnvalidatedValue) !== null && _ref !== void 0 ? _ref : defaultLoadable;\n  }\n\n  function getAtom(_store, state) {\n    if (state.atomValues.has(key)) {\n      // Atom value is stored in state:\n      return Recoil_nullthrows(state.atomValues.get(key));\n    } else if (state.nonvalidatedAtoms.has(key)) {\n      // Atom value is stored but needs validation before use.\n      // We might have already validated it and have a cached validated value:\n      if (cachedAnswerForUnvalidatedValue != null) {\n        return cachedAnswerForUnvalidatedValue;\n      }\n\n      if (persistence == null) {\n        Recoil_expectationViolation(`Tried to restore a persisted value for atom ${key} but it has no persistence settings.`);\n        return defaultLoadable;\n      }\n\n      const nonvalidatedValue = state.nonvalidatedAtoms.get(key);\n      const validatorResult = persistence.validator(nonvalidatedValue, DEFAULT_VALUE$7);\n      const validatedValueLoadable = validatorResult instanceof DefaultValue$2 ? defaultLoadable : loadableWithValue$3(validatorResult);\n      cachedAnswerForUnvalidatedValue = validatedValueLoadable;\n      return cachedAnswerForUnvalidatedValue;\n    } else {\n      return defaultLoadable;\n    }\n  }\n\n  function invalidateAtom() {\n    cachedAnswerForUnvalidatedValue = undefined;\n  }\n\n  function setAtom(_store, state, newValue) {\n    // Bail out if we're being set to the existing value, or if we're being\n    // reset but have no stored value (validated or unvalidated) to reset from:\n    if (state.atomValues.has(key)) {\n      const existing = Recoil_nullthrows(state.atomValues.get(key));\n\n      if (existing.state === 'hasValue' && newValue === existing.contents) {\n        return new Map();\n      }\n    } else if (!state.nonvalidatedAtoms.has(key) && newValue instanceof DefaultValue$2) {\n      return new Map();\n    }\n\n    maybeFreezeValueOrPromise(newValue);\n    cachedAnswerForUnvalidatedValue = undefined; // can be released now if it was previously in use\n\n    return new Map().set(key, loadableWithValue$3(newValue));\n  }\n\n  function shouldDeleteConfigOnReleaseAtom() {\n    return getConfigDeletionHandler$2(key) !== undefined && liveStoresCount <= 0;\n  }\n\n  const node = registerNode$2({\n    key,\n    nodeType: 'atom',\n    peek: peekAtom,\n    get: getAtom,\n    set: setAtom,\n    init: initAtom,\n    invalidate: invalidateAtom,\n    shouldDeleteConfigOnRelease: shouldDeleteConfigOnReleaseAtom,\n    dangerouslyAllowMutability: options.dangerouslyAllowMutability,\n    persistence_UNSTABLE: options.persistence_UNSTABLE ? {\n      type: options.persistence_UNSTABLE.type,\n      backButton: options.persistence_UNSTABLE.backButton\n    } : undefined,\n    shouldRestoreFromSnapshots: true,\n    retainedBy\n  });\n  return node;\n} // prettier-ignore\n\n\nfunction atom(options) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof options.key !== 'string') {\n      throw Recoil_err('A key option with a unique string value must be provided when creating an atom.');\n    }\n  }\n\n  const { // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS,\n    ...restOptions\n  } = options;\n  const optionsDefault = 'default' in options ? // $FlowIssue[incompatible-type] No way to refine in Flow that property is not defined\n  options.default : new Promise(() => {});\n\n  if (isRecoilValue$4(optionsDefault) // Continue to use atomWithFallback for promise defaults for scoped atoms\n  // for now, since scoped atoms don't support async defaults\n  // @fb-only: || (isPromise(optionsDefault) && scopeRules_APPEND_ONLY_READ_THE_DOCS)\n  // @fb-only: || (isLoadable(optionsDefault) && scopeRules_APPEND_ONLY_READ_THE_DOCS)\n  ) {\n    return atomWithFallback({ ...restOptions,\n      default: optionsDefault // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS,\n\n    }); // @fb-only: } else if (scopeRules_APPEND_ONLY_READ_THE_DOCS\n    // @fb-only: && !isPromise(optionsDefault)\n    // @fb-only: && !isLoadable(optionsDefault)\n    // @fb-only: ) {\n    // @fb-only: return scopedAtom<T>({\n    // @fb-only: ...restOptions,\n    // @fb-only: default: unwrap<T>(optionsDefault),\n    // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS,\n    // @fb-only: });\n  } else {\n    return baseAtom({ ...restOptions,\n      default: optionsDefault\n    });\n  }\n}\n\nfunction atomWithFallback(options) {\n  const base = atom({ ...options,\n    default: DEFAULT_VALUE$7,\n    persistence_UNSTABLE: options.persistence_UNSTABLE === undefined ? undefined : { ...options.persistence_UNSTABLE,\n      validator: storedValue => storedValue instanceof DefaultValue$2 ? storedValue : Recoil_nullthrows(options.persistence_UNSTABLE).validator(storedValue, DEFAULT_VALUE$7)\n    },\n    // TODO Hack for now.\n    effects: options.effects,\n    // flowlint-line unclear-type: off\n    effects_UNSTABLE: options.effects_UNSTABLE // flowlint-line unclear-type: off\n\n  });\n  const sel = Recoil_selector({\n    key: `${options.key}__withFallback`,\n    get: ({\n      get\n    }) => {\n      const baseValue = get(base);\n      return baseValue instanceof DefaultValue$2 ? options.default : baseValue;\n    },\n    set: ({\n      set\n    }, newValue) => set(base, newValue),\n    // This selector does not need to cache as it is a wrapper selector\n    // and the selector within the wrapper selector will have a cache\n    // option by default\n    cachePolicy_UNSTABLE: {\n      eviction: 'most-recent'\n    },\n    dangerouslyAllowMutability: options.dangerouslyAllowMutability\n  });\n  setConfigDeletionHandler$1(sel.key, getConfigDeletionHandler$2(options.key));\n  return sel;\n} // $FlowFixMe[missing-local-annot]\n\n\natom.value = value => new WrappedValue$2(value);\n\nvar Recoil_atom = atom;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @oncall recoil\n */\n\nclass MapCache {\n  constructor(options) {\n    var _options$mapKey;\n\n    _defineProperty(this, \"_map\", void 0);\n\n    _defineProperty(this, \"_keyMapper\", void 0);\n\n    this._map = new Map();\n    this._keyMapper = (_options$mapKey = options === null || options === void 0 ? void 0 : options.mapKey) !== null && _options$mapKey !== void 0 ? _options$mapKey : v => v;\n  }\n\n  size() {\n    return this._map.size;\n  }\n\n  has(key) {\n    return this._map.has(this._keyMapper(key));\n  }\n\n  get(key) {\n    return this._map.get(this._keyMapper(key));\n  }\n\n  set(key, val) {\n    this._map.set(this._keyMapper(key), val);\n  }\n\n  delete(key) {\n    this._map.delete(this._keyMapper(key));\n  }\n\n  clear() {\n    this._map.clear();\n  }\n\n}\n\nvar Recoil_MapCache = {\n  MapCache\n};\n\nvar Recoil_MapCache_1 = Recoil_MapCache.MapCache;\n\nvar Recoil_MapCache$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  MapCache: Recoil_MapCache_1\n});\n\nconst {\n  LRUCache: LRUCache$2\n} = Recoil_LRUCache$1;\n\nconst {\n  MapCache: MapCache$1\n} = Recoil_MapCache$1;\n\n\n\n\n\n\n\nconst defaultPolicy$1 = {\n  equality: 'reference',\n  eviction: 'none',\n  maxSize: Infinity\n};\n\nfunction cacheFromPolicy({\n  equality = defaultPolicy$1.equality,\n  eviction = defaultPolicy$1.eviction,\n  maxSize = defaultPolicy$1.maxSize\n} = defaultPolicy$1) {\n  const valueMapper = getValueMapper$1(equality);\n  const cache = getCache(eviction, maxSize, valueMapper);\n  return cache;\n}\n\nfunction getValueMapper$1(equality) {\n  switch (equality) {\n    case 'reference':\n      return val => val;\n\n    case 'value':\n      return val => Recoil_stableStringify(val);\n  }\n\n  throw Recoil_err(`Unrecognized equality policy ${equality}`);\n}\n\nfunction getCache(eviction, maxSize, mapKey) {\n  switch (eviction) {\n    case 'keep-all':\n      return new MapCache$1({\n        mapKey\n      });\n\n    case 'lru':\n      return new LRUCache$2({\n        mapKey,\n        maxSize: Recoil_nullthrows(maxSize)\n      });\n\n    case 'most-recent':\n      return new LRUCache$2({\n        mapKey,\n        maxSize: 1\n      });\n  }\n\n  throw Recoil_err(`Unrecognized eviction policy ${eviction}`);\n}\n\nvar Recoil_cacheFromPolicy = cacheFromPolicy;\n\n// @fb-only: import type {ScopeRules} from 'Recoil_ScopedAtom';\n\n\nconst {\n  setConfigDeletionHandler: setConfigDeletionHandler$2\n} = Recoil_Node;\n\n\n\n\n\n// Process scopeRules to handle any entries which are functions taking parameters\n// prettier-ignore\n// @fb-only: function mapScopeRules<P>(\n// @fb-only: scopeRules?: ParameterizedScopeRules<P>,\n// @fb-only: param: P,\n// @fb-only: ): ScopeRules | void {\n// @fb-only: return scopeRules?.map(rule =>\n// @fb-only: Array.isArray(rule)\n// @fb-only: ? rule.map(entry => (typeof entry === 'function' ? entry(param) : entry))\n// @fb-only: : rule,\n// @fb-only: );\n// @fb-only: }\n\n/*\nA function which returns an atom based on the input parameter.\n\nEach unique parameter returns a unique atom. E.g.,\n\n  const f = atomFamily(...);\n  f({a: 1}) => an atom\n  f({a: 2}) => a different atom\n\nThis allows components to persist local, private state using atoms.  Each\ninstance of the component may have a different key, which it uses as the\nparameter for a family of atoms; in this way, each component will have\nits own atom not shared by other instances.  These state keys may be composed\ninto children's state keys as well.\n*/\nfunction atomFamily(options) {\n  var _options$cachePolicyF, _options$cachePolicyF2;\n\n  const atomCache = Recoil_cacheFromPolicy({\n    equality: (_options$cachePolicyF = (_options$cachePolicyF2 = options.cachePolicyForParams_UNSTABLE) === null || _options$cachePolicyF2 === void 0 ? void 0 : _options$cachePolicyF2.equality) !== null && _options$cachePolicyF !== void 0 ? _options$cachePolicyF : 'value',\n    eviction: 'keep-all'\n  }); // Simple atomFamily implementation to cache individual atoms based\n  // on the parameter value equality.\n\n  return params => {\n    var _stableStringify, _options$effects;\n\n    const cachedAtom = atomCache.get(params);\n\n    if (cachedAtom != null) {\n      return cachedAtom;\n    }\n\n    const {\n      cachePolicyForParams_UNSTABLE,\n      ...atomOptions\n    } = options;\n    const optionsDefault = 'default' in options ? // $FlowIssue[incompatible-type] No way to refine in Flow that property is not defined\n    options.default : new Promise(() => {});\n    const newAtom = Recoil_atom({ ...atomOptions,\n      key: `${options.key}__${(_stableStringify = Recoil_stableStringify(params)) !== null && _stableStringify !== void 0 ? _stableStringify : 'void'}`,\n      default: typeof optionsDefault === 'function' ? // The default was parameterized\n      // Flow doesn't know that T isn't a function, so we need to case to any\n      // $FlowIssue[incompatible-use]\n      optionsDefault(params) : // Default may be a static value, promise, or RecoilValue\n      optionsDefault,\n      retainedBy_UNSTABLE: typeof options.retainedBy_UNSTABLE === 'function' ? options.retainedBy_UNSTABLE(params) : options.retainedBy_UNSTABLE,\n      effects: typeof options.effects === 'function' ? options.effects(params) : typeof options.effects_UNSTABLE === 'function' ? options.effects_UNSTABLE(params) : (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : options.effects_UNSTABLE // prettier-ignore\n      // @fb-only: scopeRules_APPEND_ONLY_READ_THE_DOCS: mapScopeRules(\n      // @fb-only: options.scopeRules_APPEND_ONLY_READ_THE_DOCS,\n      // @fb-only: params,\n      // @fb-only: ),\n\n    });\n    atomCache.set(params, newAtom);\n    setConfigDeletionHandler$2(newAtom.key, () => {\n      atomCache.delete(params);\n    });\n    return newAtom;\n  };\n}\n\nvar Recoil_atomFamily = atomFamily;\n\nconst {\n  setConfigDeletionHandler: setConfigDeletionHandler$3\n} = Recoil_Node;\n\n\n\n\n\n // Keep in mind the parameter needs to be serializable as a cahche key\n// using Recoil_stableStringify\n\n\n// Add a unique index to each selector in case the cache implementation allows\n// duplicate keys based on equivalent stringified parameters\nlet nextIndex = 0;\n/* eslint-disable no-redeclare */\n\n// Return a function that returns members of a family of selectors of the same type\n// E.g.,\n//\n// const s = selectorFamily(...);\n// s({a: 1}) => a selector\n// s({a: 2}) => a different selector\n//\n// By default, the selectors are distinguished by distinct values of the\n// parameter based on value equality, not reference equality.  This allows using\n// object literals or other equivalent objects at callsites to not create\n// duplicate cache entries.  This behavior may be overridden with the\n// cacheImplementationForParams option.\nfunction selectorFamily(options) {\n  var _options$cachePolicyF, _options$cachePolicyF2;\n\n  const selectorCache = Recoil_cacheFromPolicy({\n    equality: (_options$cachePolicyF = (_options$cachePolicyF2 = options.cachePolicyForParams_UNSTABLE) === null || _options$cachePolicyF2 === void 0 ? void 0 : _options$cachePolicyF2.equality) !== null && _options$cachePolicyF !== void 0 ? _options$cachePolicyF : 'value',\n    eviction: 'keep-all'\n  });\n  return params => {\n    var _stableStringify;\n\n    // Throw an error with selector key so that it is clear which\n    // selector is causing an error\n    let cachedSelector;\n\n    try {\n      cachedSelector = selectorCache.get(params);\n    } catch (error) {\n      throw Recoil_err(`Problem with cache lookup for selector ${options.key}: ${error.message}`);\n    }\n\n    if (cachedSelector != null) {\n      return cachedSelector;\n    }\n\n    const myKey = `${options.key}__selectorFamily/${(_stableStringify = Recoil_stableStringify(params, {\n      // It is possible to use functions in parameters if the user uses\n      // a cache with reference equality thanks to the incrementing index.\n      allowFunctions: true\n    })) !== null && _stableStringify !== void 0 ? _stableStringify : 'void'}/${nextIndex++}`; // Append index in case values serialize to the same key string\n\n    const myGet = callbacks => options.get(params)(callbacks);\n\n    const myCachePolicy = options.cachePolicy_UNSTABLE;\n    const retainedBy = typeof options.retainedBy_UNSTABLE === 'function' ? options.retainedBy_UNSTABLE(params) : options.retainedBy_UNSTABLE;\n    let newSelector;\n\n    if (options.set != null) {\n      const set = options.set;\n\n      const mySet = (callbacks, newValue) => set(params)(callbacks, newValue);\n\n      newSelector = Recoil_selector({\n        key: myKey,\n        get: myGet,\n        set: mySet,\n        cachePolicy_UNSTABLE: myCachePolicy,\n        dangerouslyAllowMutability: options.dangerouslyAllowMutability,\n        retainedBy_UNSTABLE: retainedBy\n      });\n    } else {\n      newSelector = Recoil_selector({\n        key: myKey,\n        get: myGet,\n        cachePolicy_UNSTABLE: myCachePolicy,\n        dangerouslyAllowMutability: options.dangerouslyAllowMutability,\n        retainedBy_UNSTABLE: retainedBy\n      });\n    }\n\n    selectorCache.set(params, newSelector);\n    setConfigDeletionHandler$3(newSelector.key, () => {\n      selectorCache.delete(params);\n    });\n    return newSelector;\n  };\n}\n/* eslint-enable no-redeclare */\n\n\nvar Recoil_selectorFamily = selectorFamily;\n\n// flowlint-next-line unclear-type:off\n\n\nconst constantSelector = Recoil_selectorFamily({\n  key: '__constant',\n  get: constant => () => constant,\n  cachePolicyForParams_UNSTABLE: {\n    equality: 'reference'\n  }\n}); // Function that returns a selector which always produces the\n// same constant value.  It may be called multiple times with the\n// same value, based on reference equality, and will provide the\n// same selector.\n\nfunction constSelector(constant) {\n  return constantSelector(constant);\n}\n\nvar Recoil_constSelector = constSelector;\n\n// flowlint-next-line unclear-type:off\n\n\nconst throwingSelector = Recoil_selectorFamily({\n  key: '__error',\n  get: message => () => {\n    throw Recoil_err(message);\n  },\n  // TODO Why?\n  cachePolicyForParams_UNSTABLE: {\n    equality: 'reference'\n  }\n}); // Function that returns a selector which always throws an error\n// with the provided message.\n\nfunction errorSelector(message) {\n  return throwingSelector(message);\n}\n\nvar Recoil_errorSelector = errorSelector;\n\n/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * Wraps another recoil value and prevents writing to it.\n *\n * \n * @format\n * @oncall recoil\n */\n\nfunction readOnlySelector(atom) {\n  // flowlint-next-line unclear-type: off\n  return atom;\n}\n\nvar Recoil_readOnlySelector = readOnlySelector;\n\nconst {\n  loadableWithError: loadableWithError$3,\n  loadableWithPromise: loadableWithPromise$3,\n  loadableWithValue: loadableWithValue$4\n} = Recoil_Loadable$1;\n\n\n\n\n\n /////////////////\n//  TRUTH TABLE\n/////////////////\n// Dependencies        waitForNone         waitForAny        waitForAll       waitForAllSettled\n//  [loading, loading]  [Promise, Promise]  Promise           Promise         Promise\n//  [value, loading]    [value, Promise]    [value, Promise]  Promise         Promise\n//  [value, value]      [value, value]      [value, value]    [value, value]  [value, value]\n//\n//  [error, loading]    [Error, Promise]    [Error, Promise]  Error           Promise\n//  [error, error]      [Error, Error]      [Error, Error]    Error           [error, error]\n//  [value, error]      [value, Error]      [value, Error]    Error           [value, error]\n// Issue parallel requests for all dependencies and return the current\n// status if they have results, have some error, or are still pending.\n\n\nfunction concurrentRequests(getRecoilValue, deps) {\n  const results = Array(deps.length).fill(undefined);\n  const exceptions = Array(deps.length).fill(undefined);\n\n  for (const [i, dep] of deps.entries()) {\n    try {\n      results[i] = getRecoilValue(dep);\n    } catch (e) {\n      // exceptions can either be Promises of pending results or real errors\n      exceptions[i] = e;\n    }\n  }\n\n  return [results, exceptions];\n}\n\nfunction isError(exp) {\n  return exp != null && !Recoil_isPromise(exp);\n}\n\nfunction unwrapDependencies(dependencies) {\n  return Array.isArray(dependencies) ? dependencies : Object.getOwnPropertyNames(dependencies).map(key => dependencies[key]);\n}\n\nfunction wrapResults(dependencies,\n/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's\n * LTI update could not be added via codemod */\nresults) {\n  return Array.isArray(dependencies) ? results : // Object.getOwnPropertyNames() has consistent key ordering with ES6\n  Object.getOwnPropertyNames(dependencies).reduce((out, key, idx) => ({ ...out,\n    [key]: results[idx]\n  }), {});\n}\n\nfunction wrapLoadables(dependencies, results, exceptions) {\n  const output = exceptions.map((exception, idx) => exception == null ? loadableWithValue$4(results[idx]) : Recoil_isPromise(exception) ? loadableWithPromise$3(exception) : loadableWithError$3(exception));\n  return wrapResults(dependencies, output);\n}\n\nfunction combineAsyncResultsWithSyncResults(syncResults, asyncResults) {\n  return asyncResults.map((result, idx) =>\n  /**\n   * it's important we use === undefined as opposed to == null, because the\n   * resolved value of the async promise could be `null`, in which case we\n   * don't want to use syncResults[idx], which would be undefined. If async\n   * promise resolves to `undefined`, that's ok because `syncResults[idx]`\n   * will also be `undefined`. That's a little hacky, but it works.\n   */\n  result === undefined ? syncResults[idx] : result);\n} // Selector that requests all dependencies in parallel and immediately returns\n// current results without waiting.\n\n\nconst waitForNone = Recoil_selectorFamily({\n  key: '__waitForNone',\n  get: dependencies => ({\n    get\n  }) => {\n    // Issue requests for all dependencies in parallel.\n    const deps = unwrapDependencies(dependencies);\n    const [results, exceptions] = concurrentRequests(get, deps); // Always return the current status of the results; never block.\n\n    return wrapLoadables(dependencies, results, exceptions);\n  },\n  dangerouslyAllowMutability: true\n}); // Selector that requests all dependencies in parallel and waits for at least\n// one to be available before returning results.  It will only error if all\n// dependencies have errors.\n\nconst waitForAny = Recoil_selectorFamily({\n  key: '__waitForAny',\n  get: dependencies => ({\n    get\n  }) => {\n    // Issue requests for all dependencies in parallel.\n    // Exceptions can either be Promises of pending results or real errors\n    const deps = unwrapDependencies(dependencies);\n    const [results, exceptions] = concurrentRequests(get, deps); // If any results are available, value or error, return the current status\n\n    if (exceptions.some(exp => !Recoil_isPromise(exp))) {\n      return wrapLoadables(dependencies, results, exceptions);\n    } // Otherwise, return a promise that will resolve when the next result is\n    // available, whichever one happens to be next.  But, if all pending\n    // dependencies end up with errors, then reject the promise.\n\n\n    return new Promise(resolve => {\n      for (const [i, exp] of exceptions.entries()) {\n        if (Recoil_isPromise(exp)) {\n          exp.then(result => {\n            results[i] = result;\n            exceptions[i] = undefined;\n            resolve(wrapLoadables(dependencies, results, exceptions));\n          }).catch(error => {\n            exceptions[i] = error;\n            resolve(wrapLoadables(dependencies, results, exceptions));\n          });\n        }\n      }\n    });\n  },\n  dangerouslyAllowMutability: true\n}); // Selector that requests all dependencies in parallel and waits for all to be\n// available before returning a value.  It will error if any dependencies error.\n\nconst waitForAll = Recoil_selectorFamily({\n  key: '__waitForAll',\n  get: dependencies => ({\n    get\n  }) => {\n    // Issue requests for all dependencies in parallel.\n    // Exceptions can either be Promises of pending results or real errors\n    const deps = unwrapDependencies(dependencies);\n    const [results, exceptions] = concurrentRequests(get, deps); // If all results are available, return the results\n\n    if (exceptions.every(exp => exp == null)) {\n      return wrapResults(dependencies, results);\n    } // If we have any errors, throw the first error\n\n\n    const error = exceptions.find(isError);\n\n    if (error != null) {\n      throw error;\n    } // Otherwise, return a promise that will resolve when all results are available\n\n\n    return Promise.all(exceptions).then(exceptionResults => wrapResults(dependencies, combineAsyncResultsWithSyncResults(results, exceptionResults)));\n  },\n  dangerouslyAllowMutability: true\n});\nconst waitForAllSettled = Recoil_selectorFamily({\n  key: '__waitForAllSettled',\n  get: dependencies => ({\n    get\n  }) => {\n    // Issue requests for all dependencies in parallel.\n    // Exceptions can either be Promises of pending results or real errors\n    const deps = unwrapDependencies(dependencies);\n    const [results, exceptions] = concurrentRequests(get, deps); // If all results are available, return the results\n\n    if (exceptions.every(exp => !Recoil_isPromise(exp))) {\n      return wrapLoadables(dependencies, results, exceptions);\n    } // Wait for all results to settle\n\n\n    return Promise.all(exceptions.map((exp, i) => Recoil_isPromise(exp) ? exp.then(result => {\n      results[i] = result;\n      exceptions[i] = undefined;\n    }).catch(error => {\n      results[i] = undefined;\n      exceptions[i] = error;\n    }) : null)) // Then wrap them as loadables\n    .then(() => wrapLoadables(dependencies, results, exceptions));\n  },\n  dangerouslyAllowMutability: true\n});\nconst noWait = Recoil_selectorFamily({\n  key: '__noWait',\n  get: dependency => ({\n    get\n  }) => {\n    try {\n      return Recoil_selector.value(loadableWithValue$4(get(dependency)));\n    } catch (exception) {\n      return Recoil_selector.value(Recoil_isPromise(exception) ? loadableWithPromise$3(exception) : loadableWithError$3(exception));\n    }\n  },\n  dangerouslyAllowMutability: true\n});\nvar Recoil_WaitFor = {\n  waitForNone,\n  waitForAny,\n  waitForAll,\n  waitForAllSettled,\n  noWait\n};\n\nconst {\n  RecoilLoadable\n} = Recoil_Loadable$1;\n\nconst {\n  DefaultValue: DefaultValue$3\n} = Recoil_Node;\n\n\n\nconst {\n  RecoilRoot: RecoilRoot$2,\n  useRecoilStoreID: useRecoilStoreID$1\n} = Recoil_RecoilRoot;\n\nconst {\n  isRecoilValue: isRecoilValue$5\n} = Recoil_RecoilValue$1;\n\nconst {\n  retentionZone: retentionZone$1\n} = Recoil_RetentionZone;\n\nconst {\n  freshSnapshot: freshSnapshot$2\n} = Recoil_Snapshot$1;\n\nconst {\n  useRecoilState: useRecoilState$1,\n  useRecoilState_TRANSITION_SUPPORT_UNSTABLE: useRecoilState_TRANSITION_SUPPORT_UNSTABLE$1,\n  useRecoilStateLoadable: useRecoilStateLoadable$1,\n  useRecoilValue: useRecoilValue$1,\n  useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: useRecoilValue_TRANSITION_SUPPORT_UNSTABLE$1,\n  useRecoilValueLoadable: useRecoilValueLoadable$1,\n  useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE$1,\n  useResetRecoilState: useResetRecoilState$1,\n  useSetRecoilState: useSetRecoilState$1\n} = Recoil_Hooks;\n\nconst {\n  useGotoRecoilSnapshot: useGotoRecoilSnapshot$1,\n  useRecoilSnapshot: useRecoilSnapshot$1,\n  useRecoilTransactionObserver: useRecoilTransactionObserver$1\n} = Recoil_SnapshotHooks;\n\n\n\n\n\nconst {\n  useRecoilCallback: useRecoilCallback$1\n} = Recoil_useRecoilCallback;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst {\n  noWait: noWait$1,\n  waitForAll: waitForAll$1,\n  waitForAllSettled: waitForAllSettled$1,\n  waitForAny: waitForAny$1,\n  waitForNone: waitForNone$1\n} = Recoil_WaitFor;\n\nvar Recoil_index = {\n  // Types\n  DefaultValue: DefaultValue$3,\n  isRecoilValue: isRecoilValue$5,\n  RecoilLoadable,\n  // Global Recoil environment settiongs\n  RecoilEnv: Recoil_RecoilEnv,\n  // Recoil Root\n  RecoilRoot: RecoilRoot$2,\n  useRecoilStoreID: useRecoilStoreID$1,\n  useRecoilBridgeAcrossReactRoots_UNSTABLE: Recoil_useRecoilBridgeAcrossReactRoots,\n  // Atoms/Selectors\n  atom: Recoil_atom,\n  selector: Recoil_selector,\n  // Convenience Atoms/Selectors\n  atomFamily: Recoil_atomFamily,\n  selectorFamily: Recoil_selectorFamily,\n  constSelector: Recoil_constSelector,\n  errorSelector: Recoil_errorSelector,\n  readOnlySelector: Recoil_readOnlySelector,\n  // Concurrency Helpers for Atoms/Selectors\n  noWait: noWait$1,\n  waitForNone: waitForNone$1,\n  waitForAny: waitForAny$1,\n  waitForAll: waitForAll$1,\n  waitForAllSettled: waitForAllSettled$1,\n  // Hooks for Atoms/Selectors\n  useRecoilValue: useRecoilValue$1,\n  useRecoilValueLoadable: useRecoilValueLoadable$1,\n  useRecoilState: useRecoilState$1,\n  useRecoilStateLoadable: useRecoilStateLoadable$1,\n  useSetRecoilState: useSetRecoilState$1,\n  useResetRecoilState: useResetRecoilState$1,\n  useGetRecoilValueInfo_UNSTABLE: Recoil_useGetRecoilValueInfo,\n  useRecoilRefresher_UNSTABLE: Recoil_useRecoilRefresher,\n  useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE$1,\n  useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: useRecoilValue_TRANSITION_SUPPORT_UNSTABLE$1,\n  useRecoilState_TRANSITION_SUPPORT_UNSTABLE: useRecoilState_TRANSITION_SUPPORT_UNSTABLE$1,\n  // Hooks for complex operations\n  useRecoilCallback: useRecoilCallback$1,\n  useRecoilTransaction_UNSTABLE: Recoil_useRecoilTransaction,\n  // Snapshots\n  useGotoRecoilSnapshot: useGotoRecoilSnapshot$1,\n  useRecoilSnapshot: useRecoilSnapshot$1,\n  useRecoilTransactionObserver_UNSTABLE: useRecoilTransactionObserver$1,\n  snapshot_UNSTABLE: freshSnapshot$2,\n  // Memory Management\n  useRetain: Recoil_useRetain,\n  retentionZone: retentionZone$1\n};\nvar Recoil_index_1 = Recoil_index.DefaultValue;\nvar Recoil_index_2 = Recoil_index.isRecoilValue;\nvar Recoil_index_3 = Recoil_index.RecoilLoadable;\nvar Recoil_index_4 = Recoil_index.RecoilEnv;\nvar Recoil_index_5 = Recoil_index.RecoilRoot;\nvar Recoil_index_6 = Recoil_index.useRecoilStoreID;\nvar Recoil_index_7 = Recoil_index.useRecoilBridgeAcrossReactRoots_UNSTABLE;\nvar Recoil_index_8 = Recoil_index.atom;\nvar Recoil_index_9 = Recoil_index.selector;\nvar Recoil_index_10 = Recoil_index.atomFamily;\nvar Recoil_index_11 = Recoil_index.selectorFamily;\nvar Recoil_index_12 = Recoil_index.constSelector;\nvar Recoil_index_13 = Recoil_index.errorSelector;\nvar Recoil_index_14 = Recoil_index.readOnlySelector;\nvar Recoil_index_15 = Recoil_index.noWait;\nvar Recoil_index_16 = Recoil_index.waitForNone;\nvar Recoil_index_17 = Recoil_index.waitForAny;\nvar Recoil_index_18 = Recoil_index.waitForAll;\nvar Recoil_index_19 = Recoil_index.waitForAllSettled;\nvar Recoil_index_20 = Recoil_index.useRecoilValue;\nvar Recoil_index_21 = Recoil_index.useRecoilValueLoadable;\nvar Recoil_index_22 = Recoil_index.useRecoilState;\nvar Recoil_index_23 = Recoil_index.useRecoilStateLoadable;\nvar Recoil_index_24 = Recoil_index.useSetRecoilState;\nvar Recoil_index_25 = Recoil_index.useResetRecoilState;\nvar Recoil_index_26 = Recoil_index.useGetRecoilValueInfo_UNSTABLE;\nvar Recoil_index_27 = Recoil_index.useRecoilRefresher_UNSTABLE;\nvar Recoil_index_28 = Recoil_index.useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE;\nvar Recoil_index_29 = Recoil_index.useRecoilValue_TRANSITION_SUPPORT_UNSTABLE;\nvar Recoil_index_30 = Recoil_index.useRecoilState_TRANSITION_SUPPORT_UNSTABLE;\nvar Recoil_index_31 = Recoil_index.useRecoilCallback;\nvar Recoil_index_32 = Recoil_index.useRecoilTransaction_UNSTABLE;\nvar Recoil_index_33 = Recoil_index.useGotoRecoilSnapshot;\nvar Recoil_index_34 = Recoil_index.useRecoilSnapshot;\nvar Recoil_index_35 = Recoil_index.useRecoilTransactionObserver_UNSTABLE;\nvar Recoil_index_36 = Recoil_index.snapshot_UNSTABLE;\nvar Recoil_index_37 = Recoil_index.useRetain;\nvar Recoil_index_38 = Recoil_index.retentionZone;\n\nexport default Recoil_index;\nexport { Recoil_index_1 as DefaultValue, Recoil_index_4 as RecoilEnv, Recoil_index_3 as RecoilLoadable, Recoil_index_5 as RecoilRoot, Recoil_index_8 as atom, Recoil_index_10 as atomFamily, Recoil_index_12 as constSelector, Recoil_index_13 as errorSelector, Recoil_index_2 as isRecoilValue, Recoil_index_15 as noWait, Recoil_index_14 as readOnlySelector, Recoil_index_38 as retentionZone, Recoil_index_9 as selector, Recoil_index_11 as selectorFamily, Recoil_index_36 as snapshot_UNSTABLE, Recoil_index_26 as useGetRecoilValueInfo_UNSTABLE, Recoil_index_33 as useGotoRecoilSnapshot, Recoil_index_7 as useRecoilBridgeAcrossReactRoots_UNSTABLE, Recoil_index_31 as useRecoilCallback, Recoil_index_27 as useRecoilRefresher_UNSTABLE, Recoil_index_34 as useRecoilSnapshot, Recoil_index_22 as useRecoilState, Recoil_index_23 as useRecoilStateLoadable, Recoil_index_30 as useRecoilState_TRANSITION_SUPPORT_UNSTABLE, Recoil_index_6 as useRecoilStoreID, Recoil_index_35 as useRecoilTransactionObserver_UNSTABLE, Recoil_index_32 as useRecoilTransaction_UNSTABLE, Recoil_index_20 as useRecoilValue, Recoil_index_21 as useRecoilValueLoadable, Recoil_index_28 as useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE, Recoil_index_29 as useRecoilValue_TRANSITION_SUPPORT_UNSTABLE, Recoil_index_25 as useResetRecoilState, Recoil_index_37 as useRetain, Recoil_index_24 as useSetRecoilState, Recoil_index_18 as waitForAll, Recoil_index_19 as waitForAllSettled, Recoil_index_17 as waitForAny, Recoil_index_16 as waitForNone };\n","import { QueryClient, QueryClientProvider } from \"@tanstack/react-query\";\nimport { ReactQueryDevtools } from \"@tanstack/react-query-devtools\";\nimport { nextDatadogRumInit } from \"datadog\";\nimport type { AppProps } from \"next/app\";\nimport dynamic from \"next/dynamic\";\nimport Head from \"next/head\";\nimport Router from \"next/router\";\nimport { Suspense, useEffect } from \"react\";\nimport { CookiesProvider } from \"react-cookie\";\n// eslint-disable-next-line import/order\nimport { RecoilRoot } from \"recoil\";\n\nimport \"../styles/global.css\";\n\nimport appPacakge from \"../package.json\";\nimport { settings } from \"@/configs/settings\";\nimport { GA_ID } from \"@/contents/landingPage\";\n\nnextDatadogRumInit(\n  process.env.NEXT_PUBLIC_MODE === \"development\"\n    ? {\n        sessionSampleRate: 100,\n        sessionReplaySampleRate: 20,\n        packageVersion: appPacakge.version\n      }\n    : {\n        sessionSampleRate: 3,\n        sessionReplaySampleRate: 20,\n        packageVersion: appPacakge.version\n      }\n);\n\nconst queryClient = new QueryClient({\n  defaultOptions: {\n    queries: {\n      retry: 0,\n      refetchOnWindowFocus: false,\n      useErrorBoundary: true,\n      staleTime: 1000\n    },\n    mutations: {\n      useErrorBoundary: true\n    }\n  }\n});\n\nconst App = ({ Component, pageProps }: AppProps) => {\n  useEffect(() => {\n    if (settings.MODE === \"production\") {\n      const handleRouteChangeComplete = () => {\n        if (typeof window === \"object\") {\n          const { pathname } = window.location;\n\n          //TODE: <GoogleAnalytics />를 사용하는 형태로 변경\n          window.gtag(\"config\", `${GA_ID}`, {\n            page_path: pathname\n          });\n        }\n      };\n\n      Router.events.on(\"routeChangeComplete\", handleRouteChangeComplete);\n\n      return () => {\n        Router.events.off(\"routeChangeComplete\", handleRouteChangeComplete);\n      };\n    }\n  }, []);\n\n  return (\n    <>\n      <Head>\n        <meta\n          name=\"viewport\"\n          content=\"width=device-width, initial-scale=1, user-scalable=no\"\n        />\n      </Head>\n      <RecoilRoot>\n        <Suspense fallback={<></>}>\n          <CookiesProvider>\n            <QueryClientProvider client={queryClient}>\n              <Component {...pageProps} />\n              <ReactQueryDevtools initialIsOpen={false} />\n            </QueryClientProvider>\n          </CookiesProvider>\n        </Suspense>\n      </RecoilRoot>\n    </>\n  );\n};\n\nexport default dynamic(() => Promise.resolve(App), {\n  ssr: false\n});\n","import { parseFilterArgs, parseQueryArgs, functionalUpdate, noop, hashQueryKey, partialMatchKey, hashQueryKeyByOptions } from './utils.mjs';\nimport { QueryCache } from './queryCache.mjs';\nimport { MutationCache } from './mutationCache.mjs';\nimport { focusManager } from './focusManager.mjs';\nimport { onlineManager } from './onlineManager.mjs';\nimport { notifyManager } from './notifyManager.mjs';\nimport { infiniteQueryBehavior } from './infiniteQueryBehavior.mjs';\nimport { defaultLogger } from './logger.mjs';\n\n// CLASS\nclass QueryClient {\n  constructor(config = {}) {\n    this.queryCache = config.queryCache || new QueryCache();\n    this.mutationCache = config.mutationCache || new MutationCache();\n    this.logger = config.logger || defaultLogger;\n    this.defaultOptions = config.defaultOptions || {};\n    this.queryDefaults = [];\n    this.mutationDefaults = [];\n    this.mountCount = 0;\n\n    if (process.env.NODE_ENV !== 'production' && config.logger) {\n      this.logger.error(\"Passing a custom logger has been deprecated and will be removed in the next major version.\");\n    }\n  }\n\n  mount() {\n    this.mountCount++;\n    if (this.mountCount !== 1) return;\n    this.unsubscribeFocus = focusManager.subscribe(() => {\n      if (focusManager.isFocused()) {\n        this.resumePausedMutations();\n        this.queryCache.onFocus();\n      }\n    });\n    this.unsubscribeOnline = onlineManager.subscribe(() => {\n      if (onlineManager.isOnline()) {\n        this.resumePausedMutations();\n        this.queryCache.onOnline();\n      }\n    });\n  }\n\n  unmount() {\n    var _this$unsubscribeFocu, _this$unsubscribeOnli;\n\n    this.mountCount--;\n    if (this.mountCount !== 0) return;\n    (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);\n    this.unsubscribeFocus = undefined;\n    (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);\n    this.unsubscribeOnline = undefined;\n  }\n\n  isFetching(arg1, arg2) {\n    const [filters] = parseFilterArgs(arg1, arg2);\n    filters.fetchStatus = 'fetching';\n    return this.queryCache.findAll(filters).length;\n  }\n\n  isMutating(filters) {\n    return this.mutationCache.findAll({ ...filters,\n      fetching: true\n    }).length;\n  }\n\n  getQueryData(queryKey, filters) {\n    var _this$queryCache$find;\n\n    return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;\n  }\n\n  ensureQueryData(arg1, arg2, arg3) {\n    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);\n    const cachedData = this.getQueryData(parsedOptions.queryKey);\n    return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(parsedOptions);\n  }\n\n  getQueriesData(queryKeyOrFilters) {\n    return this.getQueryCache().findAll(queryKeyOrFilters).map(({\n      queryKey,\n      state\n    }) => {\n      const data = state.data;\n      return [queryKey, data];\n    });\n  }\n\n  setQueryData(queryKey, updater, options) {\n    const query = this.queryCache.find(queryKey);\n    const prevData = query == null ? void 0 : query.state.data;\n    const data = functionalUpdate(updater, prevData);\n\n    if (typeof data === 'undefined') {\n      return undefined;\n    }\n\n    const parsedOptions = parseQueryArgs(queryKey);\n    const defaultedOptions = this.defaultQueryOptions(parsedOptions);\n    return this.queryCache.build(this, defaultedOptions).setData(data, { ...options,\n      manual: true\n    });\n  }\n\n  setQueriesData(queryKeyOrFilters, updater, options) {\n    return notifyManager.batch(() => this.getQueryCache().findAll(queryKeyOrFilters).map(({\n      queryKey\n    }) => [queryKey, this.setQueryData(queryKey, updater, options)]));\n  }\n\n  getQueryState(queryKey, filters) {\n    var _this$queryCache$find2;\n\n    return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;\n  }\n\n  removeQueries(arg1, arg2) {\n    const [filters] = parseFilterArgs(arg1, arg2);\n    const queryCache = this.queryCache;\n    notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach(query => {\n        queryCache.remove(query);\n      });\n    });\n  }\n\n  resetQueries(arg1, arg2, arg3) {\n    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);\n    const queryCache = this.queryCache;\n    const refetchFilters = {\n      type: 'active',\n      ...filters\n    };\n    return notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach(query => {\n        query.reset();\n      });\n      return this.refetchQueries(refetchFilters, options);\n    });\n  }\n\n  cancelQueries(arg1, arg2, arg3) {\n    const [filters, cancelOptions = {}] = parseFilterArgs(arg1, arg2, arg3);\n\n    if (typeof cancelOptions.revert === 'undefined') {\n      cancelOptions.revert = true;\n    }\n\n    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));\n    return Promise.all(promises).then(noop).catch(noop);\n  }\n\n  invalidateQueries(arg1, arg2, arg3) {\n    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);\n    return notifyManager.batch(() => {\n      var _ref, _filters$refetchType;\n\n      this.queryCache.findAll(filters).forEach(query => {\n        query.invalidate();\n      });\n\n      if (filters.refetchType === 'none') {\n        return Promise.resolve();\n      }\n\n      const refetchFilters = { ...filters,\n        type: (_ref = (_filters$refetchType = filters.refetchType) != null ? _filters$refetchType : filters.type) != null ? _ref : 'active'\n      };\n      return this.refetchQueries(refetchFilters, options);\n    });\n  }\n\n  refetchQueries(arg1, arg2, arg3) {\n    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);\n    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {\n      var _options$cancelRefetc;\n\n      return query.fetch(undefined, { ...options,\n        cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,\n        meta: {\n          refetchPage: filters.refetchPage\n        }\n      });\n    }));\n    let promise = Promise.all(promises).then(noop);\n\n    if (!(options != null && options.throwOnError)) {\n      promise = promise.catch(noop);\n    }\n\n    return promise;\n  }\n\n  fetchQuery(arg1, arg2, arg3) {\n    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);\n    const defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652\n\n    if (typeof defaultedOptions.retry === 'undefined') {\n      defaultedOptions.retry = false;\n    }\n\n    const query = this.queryCache.build(this, defaultedOptions);\n    return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);\n  }\n\n  prefetchQuery(arg1, arg2, arg3) {\n    return this.fetchQuery(arg1, arg2, arg3).then(noop).catch(noop);\n  }\n\n  fetchInfiniteQuery(arg1, arg2, arg3) {\n    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);\n    parsedOptions.behavior = infiniteQueryBehavior();\n    return this.fetchQuery(parsedOptions);\n  }\n\n  prefetchInfiniteQuery(arg1, arg2, arg3) {\n    return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop).catch(noop);\n  }\n\n  resumePausedMutations() {\n    return this.mutationCache.resumePausedMutations();\n  }\n\n  getQueryCache() {\n    return this.queryCache;\n  }\n\n  getMutationCache() {\n    return this.mutationCache;\n  }\n\n  getLogger() {\n    return this.logger;\n  }\n\n  getDefaultOptions() {\n    return this.defaultOptions;\n  }\n\n  setDefaultOptions(options) {\n    this.defaultOptions = options;\n  }\n\n  setQueryDefaults(queryKey, options) {\n    const result = this.queryDefaults.find(x => hashQueryKey(queryKey) === hashQueryKey(x.queryKey));\n\n    if (result) {\n      result.defaultOptions = options;\n    } else {\n      this.queryDefaults.push({\n        queryKey,\n        defaultOptions: options\n      });\n    }\n  }\n\n  getQueryDefaults(queryKey) {\n    if (!queryKey) {\n      return undefined;\n    } // Get the first matching defaults\n\n\n    const firstMatchingDefaults = this.queryDefaults.find(x => partialMatchKey(queryKey, x.queryKey)); // Additional checks and error in dev mode\n\n    if (process.env.NODE_ENV !== 'production') {\n      // Retrieve all matching defaults for the given key\n      const matchingDefaults = this.queryDefaults.filter(x => partialMatchKey(queryKey, x.queryKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key\n\n      if (matchingDefaults.length > 1) {\n        this.logger.error(\"[QueryClient] Several query defaults match with key '\" + JSON.stringify(queryKey) + \"'. The first matching query defaults are used. Please check how query defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetquerydefaults.\");\n      }\n    }\n\n    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;\n  }\n\n  setMutationDefaults(mutationKey, options) {\n    const result = this.mutationDefaults.find(x => hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey));\n\n    if (result) {\n      result.defaultOptions = options;\n    } else {\n      this.mutationDefaults.push({\n        mutationKey,\n        defaultOptions: options\n      });\n    }\n  }\n\n  getMutationDefaults(mutationKey) {\n    if (!mutationKey) {\n      return undefined;\n    } // Get the first matching defaults\n\n\n    const firstMatchingDefaults = this.mutationDefaults.find(x => partialMatchKey(mutationKey, x.mutationKey)); // Additional checks and error in dev mode\n\n    if (process.env.NODE_ENV !== 'production') {\n      // Retrieve all matching defaults for the given key\n      const matchingDefaults = this.mutationDefaults.filter(x => partialMatchKey(mutationKey, x.mutationKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key\n\n      if (matchingDefaults.length > 1) {\n        this.logger.error(\"[QueryClient] Several mutation defaults match with key '\" + JSON.stringify(mutationKey) + \"'. The first matching mutation defaults are used. Please check how mutation defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetmutationdefaults.\");\n      }\n    }\n\n    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;\n  }\n\n  defaultQueryOptions(options) {\n    if (options != null && options._defaulted) {\n      return options;\n    }\n\n    const defaultedOptions = { ...this.defaultOptions.queries,\n      ...this.getQueryDefaults(options == null ? void 0 : options.queryKey),\n      ...options,\n      _defaulted: true\n    };\n\n    if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);\n    } // dependent default values\n\n\n    if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {\n      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';\n    }\n\n    if (typeof defaultedOptions.useErrorBoundary === 'undefined') {\n      defaultedOptions.useErrorBoundary = !!defaultedOptions.suspense;\n    }\n\n    return defaultedOptions;\n  }\n\n  defaultMutationOptions(options) {\n    if (options != null && options._defaulted) {\n      return options;\n    }\n\n    return { ...this.defaultOptions.mutations,\n      ...this.getMutationDefaults(options == null ? void 0 : options.mutationKey),\n      ...options,\n      _defaulted: true\n    };\n  }\n\n  clear() {\n    this.queryCache.clear();\n    this.mutationCache.clear();\n  }\n\n}\n\nexport { QueryClient };\n//# sourceMappingURL=queryClient.mjs.map\n","module.exports = require('./dist/shared/lib/dynamic')\n","module.exports = require('./dist/shared/lib/head')\n","module.exports = require('./dist/client/router')\n","/*!\n * cookie\n * Copyright(c) 2012-2014 Roman Shtylman\n * Copyright(c) 2015 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module exports.\n * @public\n */\n\nexports.parse = parse;\nexports.serialize = serialize;\n\n/**\n * Module variables.\n * @private\n */\n\nvar decode = decodeURIComponent;\nvar encode = encodeURIComponent;\n\n/**\n * RegExp to match field-content in RFC 7230 sec 3.2\n *\n * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]\n * field-vchar   = VCHAR / obs-text\n * obs-text      = %x80-FF\n */\n\nvar fieldContentRegExp = /^[\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+$/;\n\n/**\n * Parse a cookie header.\n *\n * Parse the given cookie header string into an object\n * The object has the various cookies as keys(names) => values\n *\n * @param {string} str\n * @param {object} [options]\n * @return {object}\n * @public\n */\n\nfunction parse(str, options) {\n  if (typeof str !== 'string') {\n    throw new TypeError('argument str must be a string');\n  }\n\n  var obj = {}\n  var opt = options || {};\n  var pairs = str.split(';')\n  var dec = opt.decode || decode;\n\n  for (var i = 0; i < pairs.length; i++) {\n    var pair = pairs[i];\n    var index = pair.indexOf('=')\n\n    // skip things that don't look like key=value\n    if (index < 0) {\n      continue;\n    }\n\n    var key = pair.substring(0, index).trim()\n\n    // only assign once\n    if (undefined == obj[key]) {\n      var val = pair.substring(index + 1, pair.length).trim()\n\n      // quoted values\n      if (val[0] === '\"') {\n        val = val.slice(1, -1)\n      }\n\n      obj[key] = tryDecode(val, dec);\n    }\n  }\n\n  return obj;\n}\n\n/**\n * Serialize data into a cookie header.\n *\n * Serialize the a name value pair into a cookie string suitable for\n * http headers. An optional options object specified cookie parameters.\n *\n * serialize('foo', 'bar', { httpOnly: true })\n *   => \"foo=bar; httpOnly\"\n *\n * @param {string} name\n * @param {string} val\n * @param {object} [options]\n * @return {string}\n * @public\n */\n\nfunction serialize(name, val, options) {\n  var opt = options || {};\n  var enc = opt.encode || encode;\n\n  if (typeof enc !== 'function') {\n    throw new TypeError('option encode is invalid');\n  }\n\n  if (!fieldContentRegExp.test(name)) {\n    throw new TypeError('argument name is invalid');\n  }\n\n  var value = enc(val);\n\n  if (value && !fieldContentRegExp.test(value)) {\n    throw new TypeError('argument val is invalid');\n  }\n\n  var str = name + '=' + value;\n\n  if (null != opt.maxAge) {\n    var maxAge = opt.maxAge - 0;\n\n    if (isNaN(maxAge) || !isFinite(maxAge)) {\n      throw new TypeError('option maxAge is invalid')\n    }\n\n    str += '; Max-Age=' + Math.floor(maxAge);\n  }\n\n  if (opt.domain) {\n    if (!fieldContentRegExp.test(opt.domain)) {\n      throw new TypeError('option domain is invalid');\n    }\n\n    str += '; Domain=' + opt.domain;\n  }\n\n  if (opt.path) {\n    if (!fieldContentRegExp.test(opt.path)) {\n      throw new TypeError('option path is invalid');\n    }\n\n    str += '; Path=' + opt.path;\n  }\n\n  if (opt.expires) {\n    if (typeof opt.expires.toUTCString !== 'function') {\n      throw new TypeError('option expires is invalid');\n    }\n\n    str += '; Expires=' + opt.expires.toUTCString();\n  }\n\n  if (opt.httpOnly) {\n    str += '; HttpOnly';\n  }\n\n  if (opt.secure) {\n    str += '; Secure';\n  }\n\n  if (opt.sameSite) {\n    var sameSite = typeof opt.sameSite === 'string'\n      ? opt.sameSite.toLowerCase() : opt.sameSite;\n\n    switch (sameSite) {\n      case true:\n        str += '; SameSite=Strict';\n        break;\n      case 'lax':\n        str += '; SameSite=Lax';\n        break;\n      case 'strict':\n        str += '; SameSite=Strict';\n        break;\n      case 'none':\n        str += '; SameSite=None';\n        break;\n      default:\n        throw new TypeError('option sameSite is invalid');\n    }\n  }\n\n  return str;\n}\n\n/**\n * Try decoding a string using a decoding function.\n *\n * @param {string} str\n * @param {function} decode\n * @private\n */\n\nfunction tryDecode(str, decode) {\n  try {\n    return decode(str);\n  } catch (e) {\n    return str;\n  }\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","import Cookies from 'universal-cookie';\r\nexport default Cookies;\r\n","import * as cookie from 'cookie';\r\nexport function hasDocumentCookie() {\r\n    // Can we get/set cookies on document.cookie?\r\n    return typeof document === 'object' && typeof document.cookie === 'string';\r\n}\r\nexport function cleanCookies() {\r\n    document.cookie.split(';').forEach(function (c) {\r\n        document.cookie = c\r\n            .replace(/^ +/, '')\r\n            .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/');\r\n    });\r\n}\r\nexport function parseCookies(cookies, options) {\r\n    if (typeof cookies === 'string') {\r\n        return cookie.parse(cookies, options);\r\n    }\r\n    else if (typeof cookies === 'object' && cookies !== null) {\r\n        return cookies;\r\n    }\r\n    else {\r\n        return {};\r\n    }\r\n}\r\nexport function isParsingCookie(value, doNotParse) {\r\n    if (typeof doNotParse === 'undefined') {\r\n        // We guess if the cookie start with { or [, it has been serialized\r\n        doNotParse =\r\n            !value || (value[0] !== '{' && value[0] !== '[' && value[0] !== '\"');\r\n    }\r\n    return !doNotParse;\r\n}\r\nexport function readCookie(value, options) {\r\n    if (options === void 0) { options = {}; }\r\n    var cleanValue = cleanupCookieValue(value);\r\n    if (isParsingCookie(cleanValue, options.doNotParse)) {\r\n        try {\r\n            return JSON.parse(cleanValue);\r\n        }\r\n        catch (e) {\r\n            // At least we tried\r\n        }\r\n    }\r\n    // Ignore clean value if we failed the deserialization\r\n    // It is not relevant anymore to trim those values\r\n    return value;\r\n}\r\nfunction cleanupCookieValue(value) {\r\n    // express prepend j: before serializing a cookie\r\n    if (value && value[0] === 'j' && value[1] === ':') {\r\n        return value.substr(2);\r\n    }\r\n    return value;\r\n}\r\n","var __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nimport * as cookie from 'cookie';\r\nimport { hasDocumentCookie, parseCookies, readCookie } from './utils';\r\nvar Cookies = /** @class */ (function () {\r\n    function Cookies(cookies, options) {\r\n        var _this = this;\r\n        this.changeListeners = [];\r\n        this.HAS_DOCUMENT_COOKIE = false;\r\n        this.cookies = parseCookies(cookies, options);\r\n        new Promise(function () {\r\n            _this.HAS_DOCUMENT_COOKIE = hasDocumentCookie();\r\n        }).catch(function () { });\r\n    }\r\n    Cookies.prototype._updateBrowserValues = function (parseOptions) {\r\n        if (!this.HAS_DOCUMENT_COOKIE) {\r\n            return;\r\n        }\r\n        this.cookies = cookie.parse(document.cookie, parseOptions);\r\n    };\r\n    Cookies.prototype._emitChange = function (params) {\r\n        for (var i = 0; i < this.changeListeners.length; ++i) {\r\n            this.changeListeners[i](params);\r\n        }\r\n    };\r\n    Cookies.prototype.get = function (name, options, parseOptions) {\r\n        if (options === void 0) { options = {}; }\r\n        this._updateBrowserValues(parseOptions);\r\n        return readCookie(this.cookies[name], options);\r\n    };\r\n    Cookies.prototype.getAll = function (options, parseOptions) {\r\n        if (options === void 0) { options = {}; }\r\n        this._updateBrowserValues(parseOptions);\r\n        var result = {};\r\n        for (var name_1 in this.cookies) {\r\n            result[name_1] = readCookie(this.cookies[name_1], options);\r\n        }\r\n        return result;\r\n    };\r\n    Cookies.prototype.set = function (name, value, options) {\r\n        var _a;\r\n        if (typeof value === 'object') {\r\n            value = JSON.stringify(value);\r\n        }\r\n        this.cookies = __assign(__assign({}, this.cookies), (_a = {}, _a[name] = value, _a));\r\n        if (this.HAS_DOCUMENT_COOKIE) {\r\n            document.cookie = cookie.serialize(name, value, options);\r\n        }\r\n        this._emitChange({ name: name, value: value, options: options });\r\n    };\r\n    Cookies.prototype.remove = function (name, options) {\r\n        var finalOptions = (options = __assign(__assign({}, options), { expires: new Date(1970, 1, 1, 0, 0, 1), maxAge: 0 }));\r\n        this.cookies = __assign({}, this.cookies);\r\n        delete this.cookies[name];\r\n        if (this.HAS_DOCUMENT_COOKIE) {\r\n            document.cookie = cookie.serialize(name, '', finalOptions);\r\n        }\r\n        this._emitChange({ name: name, value: undefined, options: options });\r\n    };\r\n    Cookies.prototype.addChangeListener = function (callback) {\r\n        this.changeListeners.push(callback);\r\n    };\r\n    Cookies.prototype.removeChangeListener = function (callback) {\r\n        var idx = this.changeListeners.indexOf(callback);\r\n        if (idx >= 0) {\r\n            this.changeListeners.splice(idx, 1);\r\n        }\r\n    };\r\n    return Cookies;\r\n}());\r\nexport default Cookies;\r\n","import Cookies from './Cookies';\r\nexport default Cookies;\r\n","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n","import defineProperty from './_define_property.mjs';\n\nexport default function _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) {\n      symbols = symbols.filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n      });\n    }\n    keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\n\nexport default function _objectSpreadProps(target, source) {\n  source = source != null ? source : {}\n  if (Object.getOwnPropertyDescriptors) {\n    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n  } else {\n    ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(\n        target,\n        key,\n        Object.getOwnPropertyDescriptor(source, key)\n      );\n    });\n  }\n\n  return target;\n}","import { Subscribable } from './subscribable.mjs';\nimport { isServer } from './utils.mjs';\n\nclass FocusManager extends Subscribable {\n  constructor() {\n    super();\n\n    this.setup = onFocus => {\n      // addEventListener does not exist in React Native, but window does\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (!isServer && window.addEventListener) {\n        const listener = () => onFocus(); // Listen to visibillitychange and focus\n\n\n        window.addEventListener('visibilitychange', listener, false);\n        window.addEventListener('focus', listener, false);\n        return () => {\n          // Be sure to unsubscribe if a new handler is set\n          window.removeEventListener('visibilitychange', listener);\n          window.removeEventListener('focus', listener);\n        };\n      }\n\n      return;\n    };\n  }\n\n  onSubscribe() {\n    if (!this.cleanup) {\n      this.setEventListener(this.setup);\n    }\n  }\n\n  onUnsubscribe() {\n    if (!this.hasListeners()) {\n      var _this$cleanup;\n\n      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);\n      this.cleanup = undefined;\n    }\n  }\n\n  setEventListener(setup) {\n    var _this$cleanup2;\n\n    this.setup = setup;\n    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);\n    this.cleanup = setup(focused => {\n      if (typeof focused === 'boolean') {\n        this.setFocused(focused);\n      } else {\n        this.onFocus();\n      }\n    });\n  }\n\n  setFocused(focused) {\n    const changed = this.focused !== focused;\n\n    if (changed) {\n      this.focused = focused;\n      this.onFocus();\n    }\n  }\n\n  onFocus() {\n    this.listeners.forEach(({\n      listener\n    }) => {\n      listener();\n    });\n  }\n\n  isFocused() {\n    if (typeof this.focused === 'boolean') {\n      return this.focused;\n    } // document global can be unavailable in react native\n\n\n    if (typeof document === 'undefined') {\n      return true;\n    }\n\n    return [undefined, 'visible', 'prerender'].includes(document.visibilityState);\n  }\n\n}\nconst focusManager = new FocusManager();\n\nexport { FocusManager, focusManager };\n//# sourceMappingURL=focusManager.mjs.map\n","import { scheduleMicrotask } from './utils.mjs';\n\nfunction createNotifyManager() {\n  let queue = [];\n  let transactions = 0;\n\n  let notifyFn = callback => {\n    callback();\n  };\n\n  let batchNotifyFn = callback => {\n    callback();\n  };\n\n  const batch = callback => {\n    let result;\n    transactions++;\n\n    try {\n      result = callback();\n    } finally {\n      transactions--;\n\n      if (!transactions) {\n        flush();\n      }\n    }\n\n    return result;\n  };\n\n  const schedule = callback => {\n    if (transactions) {\n      queue.push(callback);\n    } else {\n      scheduleMicrotask(() => {\n        notifyFn(callback);\n      });\n    }\n  };\n  /**\n   * All calls to the wrapped function will be batched.\n   */\n\n\n  const batchCalls = callback => {\n    return (...args) => {\n      schedule(() => {\n        callback(...args);\n      });\n    };\n  };\n\n  const flush = () => {\n    const originalQueue = queue;\n    queue = [];\n\n    if (originalQueue.length) {\n      scheduleMicrotask(() => {\n        batchNotifyFn(() => {\n          originalQueue.forEach(callback => {\n            notifyFn(callback);\n          });\n        });\n      });\n    }\n  };\n  /**\n   * Use this method to set a custom notify function.\n   * This can be used to for example wrap notifications with `React.act` while running tests.\n   */\n\n\n  const setNotifyFunction = fn => {\n    notifyFn = fn;\n  };\n  /**\n   * Use this method to set a custom function to batch notifications together into a single tick.\n   * By default React Query will use the batch function provided by ReactDOM or React Native.\n   */\n\n\n  const setBatchNotifyFunction = fn => {\n    batchNotifyFn = fn;\n  };\n\n  return {\n    batch,\n    batchCalls,\n    schedule,\n    setNotifyFunction,\n    setBatchNotifyFunction\n  };\n} // SINGLETON\n\nconst notifyManager = createNotifyManager();\n\nexport { createNotifyManager, notifyManager };\n//# sourceMappingURL=notifyManager.mjs.map\n","import { Subscribable } from './subscribable.mjs';\nimport { isServer } from './utils.mjs';\n\nconst onlineEvents = ['online', 'offline'];\nclass OnlineManager extends Subscribable {\n  constructor() {\n    super();\n\n    this.setup = onOnline => {\n      // addEventListener does not exist in React Native, but window does\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (!isServer && window.addEventListener) {\n        const listener = () => onOnline(); // Listen to online\n\n\n        onlineEvents.forEach(event => {\n          window.addEventListener(event, listener, false);\n        });\n        return () => {\n          // Be sure to unsubscribe if a new handler is set\n          onlineEvents.forEach(event => {\n            window.removeEventListener(event, listener);\n          });\n        };\n      }\n\n      return;\n    };\n  }\n\n  onSubscribe() {\n    if (!this.cleanup) {\n      this.setEventListener(this.setup);\n    }\n  }\n\n  onUnsubscribe() {\n    if (!this.hasListeners()) {\n      var _this$cleanup;\n\n      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);\n      this.cleanup = undefined;\n    }\n  }\n\n  setEventListener(setup) {\n    var _this$cleanup2;\n\n    this.setup = setup;\n    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);\n    this.cleanup = setup(online => {\n      if (typeof online === 'boolean') {\n        this.setOnline(online);\n      } else {\n        this.onOnline();\n      }\n    });\n  }\n\n  setOnline(online) {\n    const changed = this.online !== online;\n\n    if (changed) {\n      this.online = online;\n      this.onOnline();\n    }\n  }\n\n  onOnline() {\n    this.listeners.forEach(({\n      listener\n    }) => {\n      listener();\n    });\n  }\n\n  isOnline() {\n    if (typeof this.online === 'boolean') {\n      return this.online;\n    }\n\n    if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {\n      return true;\n    }\n\n    return navigator.onLine;\n  }\n\n}\nconst onlineManager = new OnlineManager();\n\nexport { OnlineManager, onlineManager };\n//# sourceMappingURL=onlineManager.mjs.map\n","import { focusManager } from './focusManager.mjs';\nimport { onlineManager } from './onlineManager.mjs';\nimport { sleep } from './utils.mjs';\n\nfunction defaultRetryDelay(failureCount) {\n  return Math.min(1000 * 2 ** failureCount, 30000);\n}\n\nfunction canFetch(networkMode) {\n  return (networkMode != null ? networkMode : 'online') === 'online' ? onlineManager.isOnline() : true;\n}\nclass CancelledError {\n  constructor(options) {\n    this.revert = options == null ? void 0 : options.revert;\n    this.silent = options == null ? void 0 : options.silent;\n  }\n\n}\nfunction isCancelledError(value) {\n  return value instanceof CancelledError;\n}\nfunction createRetryer(config) {\n  let isRetryCancelled = false;\n  let failureCount = 0;\n  let isResolved = false;\n  let continueFn;\n  let promiseResolve;\n  let promiseReject;\n  const promise = new Promise((outerResolve, outerReject) => {\n    promiseResolve = outerResolve;\n    promiseReject = outerReject;\n  });\n\n  const cancel = cancelOptions => {\n    if (!isResolved) {\n      reject(new CancelledError(cancelOptions));\n      config.abort == null ? void 0 : config.abort();\n    }\n  };\n\n  const cancelRetry = () => {\n    isRetryCancelled = true;\n  };\n\n  const continueRetry = () => {\n    isRetryCancelled = false;\n  };\n\n  const shouldPause = () => !focusManager.isFocused() || config.networkMode !== 'always' && !onlineManager.isOnline();\n\n  const resolve = value => {\n    if (!isResolved) {\n      isResolved = true;\n      config.onSuccess == null ? void 0 : config.onSuccess(value);\n      continueFn == null ? void 0 : continueFn();\n      promiseResolve(value);\n    }\n  };\n\n  const reject = value => {\n    if (!isResolved) {\n      isResolved = true;\n      config.onError == null ? void 0 : config.onError(value);\n      continueFn == null ? void 0 : continueFn();\n      promiseReject(value);\n    }\n  };\n\n  const pause = () => {\n    return new Promise(continueResolve => {\n      continueFn = value => {\n        const canContinue = isResolved || !shouldPause();\n\n        if (canContinue) {\n          continueResolve(value);\n        }\n\n        return canContinue;\n      };\n\n      config.onPause == null ? void 0 : config.onPause();\n    }).then(() => {\n      continueFn = undefined;\n\n      if (!isResolved) {\n        config.onContinue == null ? void 0 : config.onContinue();\n      }\n    });\n  }; // Create loop function\n\n\n  const run = () => {\n    // Do nothing if already resolved\n    if (isResolved) {\n      return;\n    }\n\n    let promiseOrValue; // Execute query\n\n    try {\n      promiseOrValue = config.fn();\n    } catch (error) {\n      promiseOrValue = Promise.reject(error);\n    }\n\n    Promise.resolve(promiseOrValue).then(resolve).catch(error => {\n      var _config$retry, _config$retryDelay;\n\n      // Stop if the fetch is already resolved\n      if (isResolved) {\n        return;\n      } // Do we need to retry the request?\n\n\n      const retry = (_config$retry = config.retry) != null ? _config$retry : 3;\n      const retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;\n      const delay = typeof retryDelay === 'function' ? retryDelay(failureCount, error) : retryDelay;\n      const shouldRetry = retry === true || typeof retry === 'number' && failureCount < retry || typeof retry === 'function' && retry(failureCount, error);\n\n      if (isRetryCancelled || !shouldRetry) {\n        // We are done if the query does not need to be retried\n        reject(error);\n        return;\n      }\n\n      failureCount++; // Notify on fail\n\n      config.onFail == null ? void 0 : config.onFail(failureCount, error); // Delay\n\n      sleep(delay) // Pause if the document is not visible or when the device is offline\n      .then(() => {\n        if (shouldPause()) {\n          return pause();\n        }\n\n        return;\n      }).then(() => {\n        if (isRetryCancelled) {\n          reject(error);\n        } else {\n          run();\n        }\n      });\n    });\n  }; // Start loop\n\n\n  if (canFetch(config.networkMode)) {\n    run();\n  } else {\n    pause().then(run);\n  }\n\n  return {\n    promise,\n    cancel,\n    continue: () => {\n      const didContinue = continueFn == null ? void 0 : continueFn();\n      return didContinue ? promise : Promise.resolve();\n    },\n    cancelRetry,\n    continueRetry\n  };\n}\n\nexport { CancelledError, canFetch, createRetryer, isCancelledError };\n//# sourceMappingURL=retryer.mjs.map\n","class Subscribable {\n  constructor() {\n    this.listeners = new Set();\n    this.subscribe = this.subscribe.bind(this);\n  }\n\n  subscribe(listener) {\n    const identity = {\n      listener\n    };\n    this.listeners.add(identity);\n    this.onSubscribe();\n    return () => {\n      this.listeners.delete(identity);\n      this.onUnsubscribe();\n    };\n  }\n\n  hasListeners() {\n    return this.listeners.size > 0;\n  }\n\n  onSubscribe() {// Do nothing\n  }\n\n  onUnsubscribe() {// Do nothing\n  }\n\n}\n\nexport { Subscribable };\n//# sourceMappingURL=subscribable.mjs.map\n","// TYPES\n// UTILS\nconst isServer = typeof window === 'undefined' || 'Deno' in window;\nfunction noop() {\n  return undefined;\n}\nfunction functionalUpdate(updater, input) {\n  return typeof updater === 'function' ? updater(input) : updater;\n}\nfunction isValidTimeout(value) {\n  return typeof value === 'number' && value >= 0 && value !== Infinity;\n}\nfunction difference(array1, array2) {\n  return array1.filter(x => !array2.includes(x));\n}\nfunction replaceAt(array, index, value) {\n  const copy = array.slice(0);\n  copy[index] = value;\n  return copy;\n}\nfunction timeUntilStale(updatedAt, staleTime) {\n  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);\n}\nfunction parseQueryArgs(arg1, arg2, arg3) {\n  if (!isQueryKey(arg1)) {\n    return arg1;\n  }\n\n  if (typeof arg2 === 'function') {\n    return { ...arg3,\n      queryKey: arg1,\n      queryFn: arg2\n    };\n  }\n\n  return { ...arg2,\n    queryKey: arg1\n  };\n}\nfunction parseMutationArgs(arg1, arg2, arg3) {\n  if (isQueryKey(arg1)) {\n    if (typeof arg2 === 'function') {\n      return { ...arg3,\n        mutationKey: arg1,\n        mutationFn: arg2\n      };\n    }\n\n    return { ...arg2,\n      mutationKey: arg1\n    };\n  }\n\n  if (typeof arg1 === 'function') {\n    return { ...arg2,\n      mutationFn: arg1\n    };\n  }\n\n  return { ...arg1\n  };\n}\nfunction parseFilterArgs(arg1, arg2, arg3) {\n  return isQueryKey(arg1) ? [{ ...arg2,\n    queryKey: arg1\n  }, arg3] : [arg1 || {}, arg2];\n}\nfunction parseMutationFilterArgs(arg1, arg2, arg3) {\n  return isQueryKey(arg1) ? [{ ...arg2,\n    mutationKey: arg1\n  }, arg3] : [arg1 || {}, arg2];\n}\nfunction matchQuery(filters, query) {\n  const {\n    type = 'all',\n    exact,\n    fetchStatus,\n    predicate,\n    queryKey,\n    stale\n  } = filters;\n\n  if (isQueryKey(queryKey)) {\n    if (exact) {\n      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {\n        return false;\n      }\n    } else if (!partialMatchKey(query.queryKey, queryKey)) {\n      return false;\n    }\n  }\n\n  if (type !== 'all') {\n    const isActive = query.isActive();\n\n    if (type === 'active' && !isActive) {\n      return false;\n    }\n\n    if (type === 'inactive' && isActive) {\n      return false;\n    }\n  }\n\n  if (typeof stale === 'boolean' && query.isStale() !== stale) {\n    return false;\n  }\n\n  if (typeof fetchStatus !== 'undefined' && fetchStatus !== query.state.fetchStatus) {\n    return false;\n  }\n\n  if (predicate && !predicate(query)) {\n    return false;\n  }\n\n  return true;\n}\nfunction matchMutation(filters, mutation) {\n  const {\n    exact,\n    fetching,\n    predicate,\n    mutationKey\n  } = filters;\n\n  if (isQueryKey(mutationKey)) {\n    if (!mutation.options.mutationKey) {\n      return false;\n    }\n\n    if (exact) {\n      if (hashQueryKey(mutation.options.mutationKey) !== hashQueryKey(mutationKey)) {\n        return false;\n      }\n    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {\n      return false;\n    }\n  }\n\n  if (typeof fetching === 'boolean' && mutation.state.status === 'loading' !== fetching) {\n    return false;\n  }\n\n  if (predicate && !predicate(mutation)) {\n    return false;\n  }\n\n  return true;\n}\nfunction hashQueryKeyByOptions(queryKey, options) {\n  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;\n  return hashFn(queryKey);\n}\n/**\n * Default query keys hash function.\n * Hashes the value into a stable hash.\n */\n\nfunction hashQueryKey(queryKey) {\n  return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {\n    result[key] = val[key];\n    return result;\n  }, {}) : val);\n}\n/**\n * Checks if key `b` partially matches with key `a`.\n */\n\nfunction partialMatchKey(a, b) {\n  return partialDeepEqual(a, b);\n}\n/**\n * Checks if `b` partially matches with `a`.\n */\n\nfunction partialDeepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  if (a && b && typeof a === 'object' && typeof b === 'object') {\n    return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));\n  }\n\n  return false;\n}\n/**\n * This function returns `a` if `b` is deeply equal.\n * If not, it will replace any deeply equal children of `b` with those of `a`.\n * This can be used for structural sharing between JSON values for example.\n */\n\nfunction replaceEqualDeep(a, b) {\n  if (a === b) {\n    return a;\n  }\n\n  const array = isPlainArray(a) && isPlainArray(b);\n\n  if (array || isPlainObject(a) && isPlainObject(b)) {\n    const aSize = array ? a.length : Object.keys(a).length;\n    const bItems = array ? b : Object.keys(b);\n    const bSize = bItems.length;\n    const copy = array ? [] : {};\n    let equalItems = 0;\n\n    for (let i = 0; i < bSize; i++) {\n      const key = array ? i : bItems[i];\n      copy[key] = replaceEqualDeep(a[key], b[key]);\n\n      if (copy[key] === a[key]) {\n        equalItems++;\n      }\n    }\n\n    return aSize === bSize && equalItems === aSize ? a : copy;\n  }\n\n  return b;\n}\n/**\n * Shallow compare objects. Only works with objects that always have the same properties.\n */\n\nfunction shallowEqualObjects(a, b) {\n  if (a && !b || b && !a) {\n    return false;\n  }\n\n  for (const key in a) {\n    if (a[key] !== b[key]) {\n      return false;\n    }\n  }\n\n  return true;\n}\nfunction isPlainArray(value) {\n  return Array.isArray(value) && value.length === Object.keys(value).length;\n} // Copied from: https://github.com/jonschlinkert/is-plain-object\n\nfunction isPlainObject(o) {\n  if (!hasObjectPrototype(o)) {\n    return false;\n  } // If has modified constructor\n\n\n  const ctor = o.constructor;\n\n  if (typeof ctor === 'undefined') {\n    return true;\n  } // If has modified prototype\n\n\n  const prot = ctor.prototype;\n\n  if (!hasObjectPrototype(prot)) {\n    return false;\n  } // If constructor does not have an Object-specific method\n\n\n  if (!prot.hasOwnProperty('isPrototypeOf')) {\n    return false;\n  } // Most likely a plain Object\n\n\n  return true;\n}\n\nfunction hasObjectPrototype(o) {\n  return Object.prototype.toString.call(o) === '[object Object]';\n}\n\nfunction isQueryKey(value) {\n  return Array.isArray(value);\n}\nfunction isError(value) {\n  return value instanceof Error;\n}\nfunction sleep(timeout) {\n  return new Promise(resolve => {\n    setTimeout(resolve, timeout);\n  });\n}\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\n\nfunction scheduleMicrotask(callback) {\n  sleep(0).then(callback);\n}\nfunction getAbortController() {\n  if (typeof AbortController === 'function') {\n    return new AbortController();\n  }\n\n  return;\n}\nfunction replaceData(prevData, data, options) {\n  // Use prev data if an isDataEqual function is defined and returns `true`\n  if (options.isDataEqual != null && options.isDataEqual(prevData, data)) {\n    return prevData;\n  } else if (typeof options.structuralSharing === 'function') {\n    return options.structuralSharing(prevData, data);\n  } else if (options.structuralSharing !== false) {\n    // Structurally share data between prev and new data if needed\n    return replaceEqualDeep(prevData, data);\n  }\n\n  return data;\n}\n\nexport { difference, functionalUpdate, getAbortController, hashQueryKey, hashQueryKeyByOptions, isError, isPlainArray, isPlainObject, isQueryKey, isServer, isValidTimeout, matchMutation, matchQuery, noop, parseFilterArgs, parseMutationArgs, parseMutationFilterArgs, parseQueryArgs, partialDeepEqual, partialMatchKey, replaceAt, replaceData, replaceEqualDeep, scheduleMicrotask, shallowEqualObjects, sleep, timeUntilStale };\n//# sourceMappingURL=utils.mjs.map\n","'use client';\nimport * as React from 'react';\n\nconst defaultContext = /*#__PURE__*/React.createContext(undefined);\nconst QueryClientSharingContext = /*#__PURE__*/React.createContext(false); // If we are given a context, we will use it.\n// Otherwise, if contextSharing is on, we share the first and at least one\n// instance of the context across the window\n// to ensure that if React Query is used across\n// different bundles or microfrontends they will\n// all use the same **instance** of context, regardless\n// of module scoping.\n\nfunction getQueryClientContext(context, contextSharing) {\n  if (context) {\n    return context;\n  }\n\n  if (contextSharing && typeof window !== 'undefined') {\n    if (!window.ReactQueryClientContext) {\n      window.ReactQueryClientContext = defaultContext;\n    }\n\n    return window.ReactQueryClientContext;\n  }\n\n  return defaultContext;\n}\n\nconst useQueryClient = ({\n  context\n} = {}) => {\n  const queryClient = React.useContext(getQueryClientContext(context, React.useContext(QueryClientSharingContext)));\n\n  if (!queryClient) {\n    throw new Error('No QueryClient set, use QueryClientProvider to set one');\n  }\n\n  return queryClient;\n};\nconst QueryClientProvider = ({\n  client,\n  children,\n  context,\n  contextSharing = false\n}) => {\n  React.useEffect(() => {\n    client.mount();\n    return () => {\n      client.unmount();\n    };\n  }, [client]);\n\n  if (process.env.NODE_ENV !== 'production' && contextSharing) {\n    client.getLogger().error(\"The contextSharing option has been deprecated and will be removed in the next major version\");\n  }\n\n  const Context = getQueryClientContext(context, contextSharing);\n  return /*#__PURE__*/React.createElement(QueryClientSharingContext.Provider, {\n    value: !context && contextSharing\n  }, /*#__PURE__*/React.createElement(Context.Provider, {\n    value: client\n  }, children));\n};\n\nexport { QueryClientProvider, defaultContext, useQueryClient };\n//# sourceMappingURL=QueryClientProvider.mjs.map\n"],"names":["window","__NEXT_P","push","environmentSettings","development","API_DOMAIN","CDN_DOMAIN","PEOPLES_S3_DOMAIN","MODE","production","settings","chatbotSettings","BRAND_KEY","process","CHANNEL_TYPE","SCENARIO_ID","SPIRIT","id","title","PARTNERS","ARTICLES","subtitle","link","GA_ID","Object","defineProperty","exports","value","dynamicOptions","options","loadableFn","_loadable","default","loadableOptions","suspense","loading","error","isLoading","pastDelay","Promise","loader","_extends","ssr","loadableGenerated","noSSR","require","_interop_require_default","LoadableInitializer","webpack","modules","__esModule","assign","module","LoadableContext","createContext","_react","_loadableContext","useSyncExternalStore","ALL_INITIALIZERS","READY_INITIALIZERS","initialized","load","promise","state","loaded","then","catch","err","LoadableSubscription","loadFn","opts","this","_loadFn","_opts","_callbacks","Set","_delay","_timeout","retry","_res","_clearTimeouts","_state","timedOut","res","delay","setTimeout","_update","timeout","_err","partial","forEach","callback","clearTimeout","getCurrentValue","subscribe","add","delete","Loadable","init","subscription","sub","bind","useLoadableModule","context","useContext","Array","isArray","moduleName","lazy","moduleIds","ids","moduleId","indexOf","LoadableComponent","props","ref","createElement","useImperativeHandle","useMemo","obj","preload","displayName","forwardRef","createLoadableComponent","flushInitializers","initializers","promises","length","pop","all","preloadAll","resolveInitializers","reject","preloadReady","resolvePreload","__NEXT_PRELOADREADY","_default","defaultLogger","console","Removable","destroy","clearGcTimeout","scheduleGc","cacheTime","gcTimeout","optionalRemove","updateCacheTime","newCacheTime","Math","max","Infinity","undefined","Query","constructor","config","super","abortSignalConsumed","defaultOptions","setOptions","observers","cache","logger","queryKey","queryHash","initialState","data","initialData","hasData","initialDataUpdatedAt","dataUpdateCount","dataUpdatedAt","Date","now","errorUpdateCount","errorUpdatedAt","fetchFailureCount","fetchFailureReason","fetchMeta","isInvalidated","status","fetchStatus","getDefaultState","meta","remove","setData","newData","dispatch","type","updatedAt","manual","setState","setStateOptions","cancel","_this$retryer","retryer","resolve","silent","reset","isActive","some","observer","enabled","isDisabled","getObserversCount","isStale","getCurrentResult","isStaleByTime","staleTime","onFocus","_this$retryer2","find","x","shouldFetchOnWindowFocus","refetch","cancelRefetch","continue","onOnline","_this$retryer3","shouldFetchOnReconnect","addObserver","includes","notify","query","removeObserver","filter","revert","cancelRetry","invalidate","fetch","fetchOptions","_this$options$behavio","_context$fetchOptions","_this$retryer4","continueRetry","queryFn","abortController","queryFnContext","pageParam","addSignalProperty","object","enumerable","get","signal","fetchFn","_context$fetchOptions2","behavior","onFetch","revertState","onError","_this$cache$config$on","_this$cache$config","_this$cache$config$on2","_this$cache$config2","call","onSettled","isFetchingOptimistic","fn","abort","onSuccess","_this$cache$config$on3","_this$cache$config3","_this$cache$config$on4","_this$cache$config4","Error","onFail","failureCount","onPause","onContinue","retryDelay","networkMode","action","_action$meta","_action$dataUpdatedAt","reducer","notifyManager","onQueryUpdate","QueryCache","queries","queriesMap","build","client","_options$queryHash","getLogger","defaultQueryOptions","getQueryDefaults","queryInMap","clear","getAll","arg1","arg2","filters","exact","findAll","keys","event","listeners","listener","Mutation","mutationId","mutationCache","failureReason","isPaused","variables","mutation","_this$retryer$continu","execute","async","executeMutation","_this$options$retry","mutationFn","restored","_this$mutationCache$c3","_this$mutationCache$c4","_this$options$onSucce","_this$options2","_this$mutationCache$c5","_this$mutationCache$c6","_this$options$onSettl","_this$options3","_this$mutationCache$c","_this$mutationCache$c2","_this$options$onMutat","_this$options","onMutate","_this$mutationCache$c7","_this$mutationCache$c8","_this$options$onError","_this$options4","_this$mutationCache$c9","_this$mutationCache$c10","_this$options$onSettl2","_this$options5","onMutationUpdate","MutationCache","mutations","defaultMutationOptions","mutationKey","getMutationDefaults","resumePausedMutations","_this$resuming","resuming","pausedMutations","reduce","infiniteQueryBehavior","_context$fetchOptions3","_context$fetchOptions4","_context$state$data","_context$state$data2","refetchPage","fetchMore","isFetchingNextPage","direction","isFetchingPreviousPage","oldPages","pages","oldPageParams","pageParams","newPageParams","cancelled","buildNewPages","param","page","previous","fetchPage","_context$signal","_context$signal2","aborted","addEventListener","queryFnResult","getNextPageParam","getPreviousPageParam","i","ReactQueryDevtools","ConsoleApiName","log","debug","info","warn","globalConsole","originalConsoleMethods","name","PREFIX","display","catchUserErrors","errorMsg","args","_i","arguments","apply","onMonitorErrorCollected","__spreadArray","to","from","pack","ar","l","prototype","slice","concat","debugMode","setDebugMode","newDebugMode","monitor","callMonitored","e","displayIfDebugEnabled","candidate","search","arrayFrom","arrayLike","array","item","predicate","objectValues","map","key","objectEntries","startsWith","cssEscape","str","CSS","escape","replace","ch","asCodePoint","charCodeAt","toString","target","toAssign","source","hasOwnProperty","getGlobalObject","globalThis","configurable","globalObject","_dd_temp_","self","HAS_MULTI_BYTES_CHARACTERS","computeBytesCount","test","TextEncoder","encode","Blob","size","getZoneJsOriginalValue","original","browserWindow","Zone","__symbol__","timeoutId","throttle","wait","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","noop","getType","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","has","createCircularReferenceChecker","getTime","RegExp","flags","global","ignoreCase","multiline","sticky","unicode","join","merged_1","merged","deepClone","combine","sources","_a","sources_1","jsonStringify","replacer","space","JSON","stringify","restoreObjectPrototypeToJson","detachToJsonMethod","restoreArrayPrototypeToJson","restoreValuePrototypeToJson","getPrototypeOf","restoreValueToJson","objectToJson","toJSON","sanitize","maxCharacterCount","containerQueue","visitedObjectsWithPath","WeakMap","sanitizedData","sanitizeProcessor","accumulatedCharacterCount","containerToProcess","shift","separatorLength","targetData","path","warnOverCharacterLimit","parentPath","queue","sourceToSanitize","tryToApplyToJSON","description","sanitizePrimitivesAndFunctions","sanitizedSource","Event","isTrusted","match","sanitizeObjects","sourceAsObject","currentPath","set","changeType","Observable","onFirstSubscribe","f","_this","onLastUnsubscribe","unsubscribe","other","mergeObservables","observables","globalObservable","subscriptions","observable","CustomerDataLabel","warnIfCustomerDataLimitReached","bytesCount","customerDataType","CUSTOMER_DATA_BYTES_LIMIT","createContextManager","computeBytesCountImpl","bytesCountCache","alreadyWarned","changeObservable","computeBytesCountThrottled","contextManager","getBytesCount","newContext","getContext","setContext","clearContext","setContextProperty","property","removeContextProperty","BoundedBuffer","buffer","splice","drain","performDraw","threshold","random","round","num","decimals","toFixed","isPercentage","isNumber","navigationStart","getCurrentSiteCache","ONE_SECOND","ONE_MINUTE","relativeToClocks","relative","timeStamp","getCorrectedTimeStamp","relativeTime","correctedOrigin","dateNow","performance","getNavigationStart","addDuration","getTimeStamp","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","a","b","getRelativeTime","timestamp","timing","generateUUID","placeholder","parseInt","findCommaSeparatedValue","rawString","matches","exec","safeTruncate","suffix","lastChar","correctedLength","setCookie","expireDelay","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","document","cookie","getCookie","deleteCookie","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","canUseEventBridge","currentHost","location","hostname","bridge","allowedHost","configuration","eventTarget","eventName","addEventListeners","_","eventNames","_b","once","capture","passive","listenerWithMonitor","stop","CONTEXT_STORE_KEY_PREFIX","storageListeners","createStoredContextManager","productKey","storageKey","buildStorageKey","synchronizeWithStorage","localStorage","setItem","rawContext","getItem","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","exString","String","split","line","stackFrame","parts","CHROME_LINE_RE","isNative","isEval","submatch","CHROME_EVAL_RE","column","func","url","parseChromeLine","CHROME_ANONYMOUS_FUNCTION_RE","parseChromeAnonymousLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","message","fileUrl","filePosition","ExperimentalFeature","NO_ERROR_STACK_PRESENT_MESSAGE","computeRawError","stackTrace","originalError","handlingStack","startClocks","nonErrorPrefix","handling","isErrorInstance","computeMessage","hasUsableStack","toStackTraceString","causes","parentSource","currentError","cause","flattenErrorCauses","fingerprint","tryToGetFingerprint","dd_fingerprint","result","formatErrorMessage","frame","createHandlingStack","formattedStack","sanitizeUser","newUser","user","enabledExperimentalFeatures","isExperimentalFeatureEnabled","featureName","getExperimentalFeatures","shallowClone","objectHasValue","isEmptyObject","browserIsIE","browserIsChromium","browserIsSafari","SESSION_TIME_OUT_DELAY","SESSION_EXPIRATION_DELAY","SESSION_STORE_KEY","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","isSessionInExpiredState","session","expandSessionState","expire","toSessionString","toSessionState","sessionString","isValidSessionString","entry","selectCookieStrategy","initConfiguration","cookieOptions","useSecureSessionCookie","useCrossSiteSessionCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","getCurrentSite","buildCookieOptions","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","initCookieStrategy","cookieStore","isLockEnabled","chrome","navigator","userAgent","persistSession","retrieveSession","retrieveSessionCookie","clearSession","deleteSessionCookie","cookieStoreStrategy","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","persistInLocalStorage","sessionState","retrieveSessionFromLocalStorage","clearSessionFromLocalStorage","removeItem","ongoingOperations","bufferedOperations","processSessionStoreOperations","operations","sessionStoreStrategy","numberOfRetries","next","currentLock","currentSession","lock","retryLater","processedSession","after","sessionStore","currentNumberOfRetries","nextOperations","selectSessionStoreStrategyType","sessionStoreStrategyType","allowFallbackToLocalStorage","testKey","retrievedId","selectLocalStorageStrategy","startSessionStore","computeSessionState","renewObservable","expireObservable","watchSessionTimeoutId","isActiveSession","synchronizeSession","sessionCache","retrieveActiveSession","hasSessionInCache","isSessionInCacheOutdated","created","Number","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewSessionState","renewSessionInCache","expandSession","getSession","normalizeUrl","buildUrl","getLinkElementOrigin","href","getOrigin","base","supportedURL","isURLSupported","originalURL","getSupportedUrl","doc","anchorElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","URL","element","origin","sanitizedHost","host","protocol","INTAKE_SITE_STAGING","INTAKE_SITE_US1","INTAKE_SITE_EU1","INTAKE_SITE_AP1","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","createEndpointBuilder","endpointType","configurationTags","buildUrlWithParameters","proxy","proxyUrl","normalizedProxyUrl_1","encodeURIComponent","site","internalAnalyticsSubdomain","domainParts","extension","subdomain","buildEndpointHost","normalizedProxyUrl_2","createEndpointUrlWithParametersBuilder","api","payload","clientToken","flushReason","encoding","tags","COLLECT_FLUSH_REASON","count","lastFailureStatus","reverse","buildEndpointParameters","urlPrefix","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","computeTransportConfiguration","env","service","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","computeEndpointBuilders","intakeUrlPrefixes","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","intakeEndpoint","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","_c","sessionSampleRate","sampleRate","telemetrySampleRate","telemetryConfigurationSampleRate","enableExperimentalFeatures","flag","beforeSend","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","maxTelemetryEventsPerPage","flushTimeout","batchMessagesLimit","messageBytesLimit","isMatchOption","itemType","matchList","list","useStartsWith","clearTracingIfNeeded","isAborted","traceId","spanId","traceSampled","injectHeadersIfTracingAllowed","sessionManager","inject","getCrypto","findTrackedSession","tracingOption","allowedTracingUrls","TraceIdentifier","traceSampleRate","propagatorTypes","tracingHeaders","propagatorType","toDecimalString","traceparent","toPaddedHexadecimalString","b3","makeTracingHeaders","crypto","msCrypto","Uint8Array","getRandomValues","radix","high","readInt32","low","mod","floor","offset","validateAndBuildRumConfiguration","_d","_e","_f","sessionReplaySampleRate","premiumSampleRate","replaySampleRate","tracingSampleRate","excludedActivityUrls","allowedTracingOrigins","tracingOptions_1","option","expectedItem","isTracingOption","tracingOptions_2","legacyMatchOption","convertLegacyMatchOptionToTracingOption","validateAndBuildTracingOptions","baseConfiguration","trackUserInteractions","trackInteractions","trackFrustrations","actionNameAttribute","oldPlansBehavior","workerUrl","trackViewsManually","trackResources","trackLongTasks","defaultPrivacyLevel","customerDataTelemetrySampleRate","getSelectedTracingPropagators","usedTracingPropagators","buildCommonContext","globalContextManager","userContextManager","recorderApi","hasReplay","isRecording","sendToExtension","__ddBrowserSdkExtensionCallback","onRawTelemetryEventCollected","TelemetryType","ALLOWED_FRAME_URLS","TELEMETRY_EXCLUDED_SITES","telemetryConfiguration","maxEventsPerPage","sentEventCount","telemetryEnabled","telemetryConfigurationEnabled","startTelemetry","telemetryService","contextProvider","runtimeEnvInfo","is_local_file","is_worker","rawEvent","event_1","_dd","format_version","telemetry","runtime_env","experimental_features","toTelemetryEvent","addTelemetryError","setContextProvider","provider","addTelemetryDebug","addTelemetry","kind","scrubCustomerFrames","formatError","allowedFrameUrl","PageExitReason","HIDDEN","UNLOADING","PAGEHIDE","FROZEN","isPageExitReason","reason","getMutationObserverConstructor","MutationObserver","originalInstance","runOnReadyState","expectedReadyState","readyState","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","computeResourceKind","isValidUrl","pathname","getPathName","RESOURCE_TYPES_1","isType","areInOrder","numbers","computePerformanceResourceDuration","startTime","responseEnd","computePerformanceResourceDetails","validEntry","toValidEntry","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","first_byte","connect","ssl","dns","hasRedirection","redirect","computeSize","decodedBodySize","isAllowedRequestUrl","isTextNode","node","nodeType","Node","TEXT_NODE","isElementNode","ELEMENT_NODE","isNodeShadowHost","shadowRoot","isNodeShadowRoot","DOCUMENT_FRAGMENT_NODE","forEachChildNodes","childNodes","getParentNode","parentNode","RumPerformanceEntryType","getDocumentTraceId","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","getTraceCommentFromNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","rawTraceTime","COMMENT_NODE","isCommentNode","supportPerformanceObject","supportPerformanceTimingEvent","entryType","PerformanceObserver","supportedEntryTypes","startPerformanceCollection","lifeCycle","forcedAttributes","RESOURCE","NAVIGATION","getEntriesByType","navigationEntry","relativePerformanceTiming","computeRelativePerformanceTiming","retrieveInitialDocumentResourceTiming","handleRumPerformanceEntries","performanceEntries_1","getEntries","handlePerformanceEntryList_1","entries","mainEntries","LONG_TASK","PAINT","experimentalEntries","LARGEST_CONTENTFUL_PAINT","FIRST_INPUT","LAYOUT_SHIFT","EVENT","observe","buffered","durationThreshold","entryTypes","clearResourceTimings","sendFakeTiming","retrieveNavigationTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","processingEnd","sendTimingIfPointerIsNotCancelled","sendTiming","retrieveFirstInputTiming","numberKey","timingElement","rumAllowedPerformanceEntries","loadEventEnd","isIncompleteNavigation","isForbiddenResource","ErrorSource","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","getSyntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","getSyntheticsTestId","resultId","_DATADOG_SYNTHETICS_RESULT_ID","getSyntheticsResultId","test_id","result_id","injected","limitModification","modifiableFieldPaths","modifier","clone","fieldPath","fieldType","newValue","current","field","isValidObjectContaining","newType","fields","isValidObject","modifiableFieldPathsByEvent","VIEW_MODIFIABLE_FIELD_PATHS","USER_CUSTOMIZABLE_FIELD_PATHS","startRumAssembly","viewContexts","urlContexts","actionContexts","displayContext","reportError","eventRateLimiters","syntheticsContext","ciTestContext","testExecutionId","Cypress","test_execution_id","getCiTestContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","commonContext","actionId","findActionId","serverRumEvent","drift","plan","session_sample_rate","session_replay_sample_rate","browser_sdk_version","application","view","referrer","synthetics","ci_test","has_replay","usr","shouldSend","xhrObservable","LifeCycle","AbstractLifeCycle","callbacks","eventCallbacks","END_OF_TIMES","ValueHistory","maxEntries","clearOldValuesInterval","clearOldValues","endTime","index","close","unshift","closeActive","latestEntry","oldTimeThreshold","instrumentMethod","method","instrumentationFactory","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","fetchObservable","xhrContexts","initXhrObservable","stopInstrumentingStart","XMLHttpRequest","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","createXhrObservable","startContext","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","unsubscribeLoadEndListener","completeContext","initFetchObservable","originalFetch","input","responsePromise","afterSend","createFetchObservable","Request","reportFetch","response","DOMException","code","ABORT_ERR","responseType","nextRequestIndex","startRequestCollection","tracer","traceFetch","headers","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","requestIndex","getNextRequestIndex","trackXhr","clonedResponse","tryToClone","stream","reader","getReader","chunks","readBytesCount","onDone","bytes","limitExceeded","collectStreamBody","completeBuffer_1","offset_1","chunk","bytesLimit","readMore","read","done","readBytesFromStream","POSITIVE_INFINITY","waitForResponseToComplete","trackFetch","trackEventCounts","isChildEvent","onChange","eventCounts","errorCount","longTaskCount","resourceCount","actionCount","frustrationCount","frustration","discarded","PAGE_ACTIVITY_VALIDATION_DELAY","waitPageActivityEnd","domMutationObservable","pageActivityEndCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","isExcludedUrl","startEvent","request","stopTrackingWindowOpen","s","isBusy","createPageActivityObservable","pageActivityEndTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitPageActivityEnd","requestUrl","DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE","getActionNameFromElement","userProgrammaticAttribute","getActionNameFromElementProgrammatically","getActionNameFromElementForStrategies","priorityStrategies","fallbackStrategies","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","supportsElementClosest","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","HTMLInputElement","supportsLabelProperty","labels","getTextualContent","label","ownerDocument","querySelectorAll","htmlFor","nodeName","labelledByAttribute","refElement","getElementById","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","isContentEditable","text_1","innerText","removeTextFromElements","element_1","textToReplace","documentMode","textContent","supportScopeSelectorCache","STABLE_ATTRIBUTES","GLOBALLY_UNIQUE_SELECTOR_GETTERS","getStableAttributeSelector","isGeneratedValue","UNIQUE_AMONG_CHILDREN_SELECTOR_GETTERS","tagName","classList","className","getSelectorFromElement","targetElementSelector","globallyUniqueSelector","findSelector","isSelectorUniqueGlobally","isSelectorUniqueAmongSiblings","combineSelector","getPositionSelector","selector","getAttributeSelector","STABLE_ATTRIBUTES_1","attributeName","sibling","firstElementChild","elementIndex","nextElementSibling","selectorGetters","childSelector","selectorGetters_1","elementSelector","selectorGetter","fullSelector","supportScopeSelector","parent","child","MAX_DURATION_BETWEEN_CLICKS","createClickChain","firstClick","onFinalize","maxDurationBetweenClicksTimeoutId","bufferedClicks","appendClick","click","stopObservable","tryFinalize","dontAcceptMoreClick","every","isStopped","tryAppend","first","second","sqrt","pow","clientX","clientY","areEventsSimilar","isSelectionEmpty","selection","getSelection","isCollapsed","isValidPointerEvent","Element","isPrimary","computeFrustration","clicks","rageClick","getUserActivity","isRage","addFrustration","isDead","hasError","hasSelectionChanged","hasPageActivity","msMatchesSelector","elementMatches","trackClickActions","currentClickChain","history","stopClickChain","stopActionEventsListener","selectionEmptyAtPointerDown","clickContext","onPointerDown","onPointerUp","userActivity","localUserActivity_1","listenActionEvents","pointerDownEvent","clickActionBase","rect","getBoundingClientRect","width","height","position","left","y","top","computeClickActionBase","hadActivityOnPointerDown","pageActivityEndEvent","processPointerDown","appendClickToClickChain","newClick","stopWaitPageActivityEnd","discard","validate","viewEndedSubscription","endClocks","stopSubscription","startClickAction","rageClick_1","finalizeClicks","activityEndTime","historyEntry","eventCountsSubscription","frustrationTypes","newActivityEndTime","frustrationType","domEvents","clickAction","counts","events","processAction","pageStateHistory","autoActionProperties","isAutoAction","loading_time","long_task","resource","in_foreground","isInActivePageStateAt","ERROR_TYPES_RE","startUnhandledErrorCollection","stopInstrumentingOnError","messageObj","errorObj","tryToParseMessage","instrumentOnError","stopInstrumentingOnUnhandledRejection","instrumentUnhandledRejection","consoleObservablesByApi","initConsoleObservable","apis","consoleObservables","originalConsoleApi","params","buildConsoleLog","createConsoleObservable","formatConsoleParameters","firstErrorParam","RawReportType","initReportObservable","blockedURI","effectiveDirective","subtype","buildStack","originalPolicy","sourceFile","lineNumber","columnNumber","buildRawReportFromCspViolation","createCspViolationReportObservable","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportFromReport","types","disconnect","createReportObservable","startErrorCollection","featureFlagContexts","errorObservable","consoleError","trackConsoleError","trackRuntimeError","trackReportError","handling_stack","source_type","featureFlagContext","findFeatureFlagEvaluations","feature_flags","processError","addError","rawError","doStartErrorCollection","matchRequestTiming","sameNameEntries","getEntriesByName","candidates","errorMargin","isBetween","startResourceCollection","matchingTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","span_id","trace_id","rule_psr","getRulePsr","computeRequestTracingInfo","indexingInfo","computeIndexingInfo","NO_RESOURCE_DURATION_FROZEN_STATE","pageState","computeRequestDuration","pageStateInfo","computePageStateInfo","resourceEvent","status_code","performanceEntry","requestInput","requestInit","processRequest","entries_1","processResourceEntry","entryMetrics","computeEntryTracingInfo","resourceStart","resourceAllowed","RESOURCE_PAGE_STATES","page_states","page_was_discarded","wasDiscarded","mapToForegroundPeriods","pageStateServerEntries","foregroundPeriods","trackInitialViewMetrics","setLoadEvent","scheduleViewUpdate","initialViewMetrics","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","firstByte","trackNavigationTimings","navigationTimings","firstHidden","stopListeners","visibilityState","trackFirstHidden","stopFCPTracking","fcpEntry","trackFirstContentfulPaint","firstContentfulPaint","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","findLast","lcpTargetSelector","WEB_VITALS_ATTRIBUTION","targetSelector","trackLargestContentfulPaint","largestContentfulPaint","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTargetSelector","time","trackFirstInput","firstInput","trackCumulativeLayoutShift","maxClsValue","largestLayoutShiftTarget","largestLayoutShiftTime","largestLayoutShift","update","slidingSessionWindow","hadRecentInput","cls","clsTarget","cslTargetSelector","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","viewportObservable","getInteractionCount","interactionCount","trackInteractionToNextPaint","viewStart","viewLoadingType","PerformanceEventTiming","INTERACTION_TO_NEXT_PAINT","getInteractionToNextPaint","interactionToNextPaintTargetSelector","getViewInteractionCount","interactionId","min","previousInteractionCount","trackViewInteractionCount","longestInteractions","sortAndTrimLongestInteractions","sort","interactionIndex","findIndex","interaction","minLongestInteraction","estimateP98Interaction","trackLongestInteractions","interactionToNextPaint","telemetryCollected","newInteraction","inp","timeFromViewStart","targetNodeName","getScrollX","scrollX","visual","visualViewport","pageLeft","offsetLeft","pageXOffset","getScrollY","scrollY","pageTop","offsetTop","pageYOffset","initViewportObservable","updateDimension","getViewportDimension","createViewportObservable","scale","innerWidth","innerHeight","trackScrollMetrics","scrollValues","throttleDuration","scrollTop","scrollHeight","scrollingElement","documentElement","scrollDepth","computeScrollValues","ResizeObserver","throttledNotify_1","observerTarget_1","resizeObserver_1","eventListener_1","unobserve","createScrollValuesObservable","maxScrollDepth","maxScrollHeight","maxScrollHeightTime","shouldUpdate","maxDepth","maxDepthScrollTop","trackCommonViewMetrics","loadingType","commonViewMetrics","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","trackLoadingTime","newLoadingTime","loadingTime","stopLoadingTimeTracking","stopScrollMetricsTracking","newScrollMetrics","scroll","stopCLSTracking","cumulativeLayoutShift","stopINPTracking","getCommonViewMetrics","SESSION_KEEP_ALIVE_INTERVAL","KEEP_TRACKING_AFTER_VIEW_DELAY","trackViews","locationChangeObservable","areViewsTrackedAutomatically","initialViewOptions","locationChangeSubscription","activeViews","currentView","startNewView","viewOptions","newlyCreatedView","initialLocation","customTimings","documentVersion","sessionIsActive","triggerViewUpdate","cancelScheduleViewUpdate","stopCommonViewMetricsTracking","stopInitialViewMetricsTracking","viewId","trackViewEventCounts","stopEventCountsTracking","keepAliveIntervalId","currentEnd","addTiming","looksLikeRelativeTime","sanitized","sanitizeTiming","newView","pageExitEvent","currentLocation","otherLocation","oldLocation","newLocation","hash","correspondingId","substr","isHashAnAnchor","getPathFromHash","renewViewOnLocationChange","startView","startViewCollection","_g","_h","_j","_k","_l","_m","_o","_p","replayStats","getReplayStats","pageStatesEnabled","PAGE_STATES","pageStates","viewEvent","document_version","replay_stats","cumulative_layout_shift","cumulative_layout_shift_target_selector","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","first_input_target_selector","interaction_to_next_paint","interaction_to_next_paint_target_selector","is_active","largest_contentful_paint","largest_contentful_paint_target_selector","load_event","discardNegativeDuration","loading_type","time_spent","in_foreground_periods","max_depth","max_depth_scroll_top","max_scroll_height","max_scroll_height_time","privacy","replay_level","custom_timings","newObject","mapValues","processViewUpdate","stopCallbacks","startSessionManager","sessionContextHistory","buildSessionContext","trackActivity","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","startRumSessionManager","rawTrackingType","hasValidRumSession","isTypeTracked","sessionReplayAllowed","longTaskAllowed","rumSessionType","Batch","flushController","pushOnlyBuffer","upsertBuffer","flushSubscription","flushObservable","flush","addOrUpdate","upsert","messages","sendOnExit","processedMessage","messageBytesCount","hasMessageFor","separatorBytesCount","messagesCount","notifyBeforeAddMessage","notifyAfterAddMessage","removedMessage","notifyAfterRemoveMessage","MAX_QUEUE_BYTES_COUNT","sendWithRetryStrategy","sendStrategy","transportStatus","queuedPayloads","bandwidthMonitor","canHandle","retryQueuedPayloads","onFailure","enqueue","scheduleRetry","dequeue","currentBackoffTime","onLine","shouldRetryRequest","ongoingRequestCount","isFull","queueFullReported","previousQueue","newPayloadQueue","createHttpRequest","endpointBuilder","retryState","ongoingByteCount","sendStrategyForRetry","onResponse","isKeepAliveSupported","fetchUrl","keepalive","mode","xhrUrl","sendXHR","fetchKeepAliveStrategy","sendBeacon","beaconUrl","hasReportedBeaconError","reportBeaconError","sendBeaconStrategy","open","createFlushController","durationLimitTimeoutId","messagesLimit","durationLimit","pageExitObservable","sessionExpireObservable","pageExitSubscription","sessionExpireSubscription","currentBytesCount","currentMessagesCount","cancelDurationLimitTimeout","startRumBatch","telemetryEventObservable","batch","primary","primaryBatch","createBatch","endpoint","replicaBatch","replicated","transformMessage","startBatchWithReplica","isTelemetryReplicationAllowed","createLocationChangeObservable","stopHistoryTracking","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","removeListener","trackHistory","onLocationChange","stopHashTracking","onHashChange","trackHash","currentPeriodMeasures","currentBatchMeasures","batchHasRumEvent","sendCurrentPeriodMeasures","batchCount","initCurrentPeriodMeasures","updateMeasure","measure","sum","mergeMeasure","batchBytesCount","batchMessagesCount","globalContextBytes","userContextBytes","featureFlagBytes","initCurrentBatchMeasures","startPageStateHistory","maxPageStateEntriesSelectable","currentPageState","addPageState","getPageState","stopEventListeners","persisted","computePageState","nextPageState","eventStartTime","pageStateEntries","relativeStartTime","pageStateEntry","hasFocus","getSessionReplayUrl","errorType","sessionId","rumConfiguration","getSiteDefaultSubdomain","getDatadogSiteUrl","RecordType","NodeType","IncrementalSource","MouseInteractionType","MediaInteractionType","assembleIncrementalSnapshot","NodePrivacyLevel","IGNORE","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","CENSORED_STRING_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","parentNodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","privAttr","inputElement","autocomplete","contains","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","getTextContent","textNode","ignoreWhiteSpace","parentTagName","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","nodePrivacyLevel","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","quote","baseUrl","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","serializeStyleSheets","cssStyleSheets","cssStyleSheet","rules","cssRules","cssRule","disabled","media","serializeAttribute","attributeValue","getCssRulesString","getCssRuleStringForSafari","getCssRuleString","rule","isCSSStyleRule","selectorText","isCSSImportRule","styleSheet","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","isSVG","el","SVGElement","attributes","rr_width","rr_height","safeAttrs","formValue","optionElement","selected","stylesheet","styleSheets","DISABLE_REPLAY_INLINE_CSS","_cssText","sheet","scrollLeft","checked","mediaElement","rr_mediaState","paused","elementsScrollPositions","rr_scrollLeft","rr_scrollTop","serializeAttributes","hasChildNodes","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","serializeDocument","isTouchEvent","changedTouches","getEventTarget","composed","composedPath","convertMouseEventToLayoutCoordinates","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","isVisualViewportFactoredIn","getVisualViewport","tryToComputeCoordinates","isFinite","eventTypeToMouseInteraction","initInputObserver","cb","stopPropertySetterInstrumentation","lastInputStateMap","HTMLTextAreaElement","HTMLSelectElement","onElementChange","instrumentationStoppers_1","stopper","inputState","isChecked","text","cbWithDedup","lastInputState","getPathToNestedCSSRule","currentRule","parentRule","index_1","parentStyleSheet","createMutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","requestIdleCallback","cancelIdleCallback","id_1","requestAnimationFrame","cancelAnimationFrame","initMutationObserver","mutationCallback","mutationBatch","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","isConnected","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","Map","_loop_1","addedNodes","mutations_1","sortedAddedAndMovedNodes","nodes","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","sortAddedAndMovedNodes","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","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","shadowDomRemovedCallback","initObservers","o","mediaInteractionCb","focusCb","recordIds","getIdForEvent","initRecordIds","mutationHandler","mutationCb","mousemoveHandler","updatePosition","coordinates","timeOffset","initMoveObserver","mousemoveCb","mouseInteractionHandler","record","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","scrollPositions","initScrollObserver","scrollCb","viewportResizeHandler","initViewportResizeObserver","viewportResizeCb","inputHandler","inputCb","mediaInteractionHandler","styleSheetObserver","checkStyleSheetAndCallback","ownerNode","instrumentationStoppers","CSSStyleSheet","instrumentGroupingCSSRuleClass","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","initStyleSheetObserver","styleSheetCb","focusHandler","has_focus","visualViewportResizeHandler","cancelThrottle","initVisualViewportResizeObserver","visualViewportResizeCb","frustrationHandler","frustrationCb","initFrustrationObserver","emit","scrollPositionsByElement","createElementsScrollPositions","controllerByShadowRoot","stopMutationObserver","stopInputObserver","initShadowRootsController","takeFullSnapshot","initialOffset","p","mouseInteractionRecord","positions","r","d","frustrationRecord","stopObservers","flushMutationsFromObservers","flushMutations","takeSubsequentFullSnapshot","statsPerView","getSegmentsCount","getOrCreateReplayStats","segments_count","records_count","segments_total_raw_size","isFirst_1","_value","deleteOldestStats","Segment","encoder","creationReason","metadata","creation_reason","has_full_snapshot","index_in_view","addRecord","segment","prefix","write","additionalBytesCount","rawBytesCount","SEGMENT_BYTES_LIMIT","startSegmentCollection","httpRequest","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","rawSegmentBytesCount","formData","FormData","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","buildReplayPayload","encodedBytes","expirationTimeoutId","encodedBytesCount","doStartSegmentCollection","computeSegmentContext","isBrowserSupported","createObjectURL","NodeList","getSessionReplayLink","isRecordingStarted","getErrorType","createDeflateEncoder","worker","streamId","compressedDataTrailer","compressedData","nextWriteActionId","pendingWriteActions","removeMessageListener","nextPendingAction","trailer","buffers","total","buffers_1","concatBuffers","postMessage","createDeflateWorker","Worker","startDeflateWorker","onInitializationFailure","createDeflateWorkerImpl","removeErrorListener_1","removeMessageListener_1","initializationFailureCallbacks","onTimeout","doStartDeflateWorker","getDeflateWorkerStatus","baseMessage","worker_version","stream_id","startRecordingImpl","onRumStart","startStrategy","stopStrategy","stopRecording","makeRecorderApi","replayRequest","stopSegmentCollection","unsubscribeViewEnded","startRumImpl","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","getInternalContextStrategy","getInitConfigurationStrategy","stopSessionStrategy","getSessionReplayLinkStrategy","bufferApiCalls","addTimingStrategy","startViewStrategy","addActionStrategy","addErrorStrategy","providedError","addFeatureFlagEvaluationStrategy","doStartRum","storeContextsAcrossPages","beforeInitGlobalContext","beforeInitUserContext","startRumResults","addAction","addFeatureFlagEvaluation","getInternalContext","stopSession","rumPublicApi","stub","publicApi","onReady","makePublicApi","eventBridgeAvailable","overrideInitConfigurationForBridge","canInitRum","beforeInitCalls","addRumGlobalContext","setGlobalContextProperty","removeRumGlobalContext","removeGlobalContextProperty","getRumGlobalContext","getGlobalContext","setRumGlobalContext","setGlobalContext","clearGlobalContext","getInitConfiguration","setUser","isValid","checkUser","getUser","setUserProperty","sanitizedProperty","removeUserProperty","removeUser","clearUser","startSessionReplayRecording","stopSessionReplayRecording","makeRumPublicApi","cleanupTasks","bridge_1","startRumTelemetry","FEATURE_FLAGS","getFeatureFlagBytesCount","currentContext","startFeatureFlagContexts","pagehideEnabled","stopBeforeUnloadListener","createPageExitObservable","startRumSessionManagerStub","startRumEventBridge","batch_1","batchFlushObservable","hasFeatureFlagContext","startCustomerDataTelemetry","createDOMMutationObservable","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","changeTime","startUrlContexts","startActionCollection","viewport","viewportDimension","startDisplayContext","startRumEventCollection","stopRumEventCollection","addTelemetryConfiguration","baseSerializedConfiguration","telemetry_sample_rate","telemetry_configuration_sample_rate","use_before_send","use_cross_site_session_cookie","use_secure_session_cookie","use_proxy","silent_multiple_init","track_session_across_subdomains","track_resources","track_long_task","allow_fallback_to_local_storage","store_contexts_across_pages","serializeConfiguration","premium_sample_rate","replay_sample_rate","trace_sample_rate","action_name_attribute","use_allowed_tracing_origins","use_allowed_tracing_urls","selected_tracing_propagators","default_privacy_level","use_excluded_activity_urls","use_worker_url","track_frustrations","track_views_manually","track_user_interactions","serializeRumConfiguration","startLongTaskCollection","stopViewCollection","internalContext","application_id","session_id","user_action","startInternalContext","task","existingGlobalVariable","q","defineGlobal","__defProp","__getOwnPropSymbols","getOwnPropertySymbols","__hasOwnProp","__propIsEnum","propertyIsEnumerable","__defNormalProp","writable","__spreadValues","prop","isBrowser","nextDatadogRumInit_default","packageVersion","NEXT_PUBLIC_API_DOMAIN","NEXT_PUBLIC_CDN_DOMAIN","excludeAuthError","accessTokenExpired","accessTokenNotexist","nextConfig","CookiesContext","Cookies","Provider","__extends","Consumer","extendStatics","setPrototypeOf","__proto__","__","create","_super","CookiesProvider","cookies","render","children","Recoil_err","Recoil_isPromise","Recoil_nullthrows","_defineProperty","BaseLoadable","getValue","toPromise","valueMaybe","valueOrThrow","promiseMaybe","promiseOrThrow","errorMaybe","errorOrThrow","is","contents","_map","ValueLoadable","loadableWithPromise","isLoadable","loadableWithValue","loadableWithError","ErrorLoadable","LoadingLoadable","nextLoadable","freeze","loadableLoading","loadableAll","inputs","output","loadableAllArray","getOwnPropertyNames","outputs","out","idx","LoadableStaticInterface","of","Recoil_Loadable","RecoilLoadable","Recoil_Loadable_1","Recoil_Loadable_2","Recoil_Loadable_3","Recoil_Loadable_4","Recoil_Loadable_5","Recoil_Loadable_6","Recoil_Loadable_7","Recoil_Loadable$1","gks","Recoil_gkx_OSS","gk","_gks$get","setPass","setFail","Recoil_gkx","_createMutableSource","_useMutableSource","_useSyncExternalStore","Recoil_recoverableViolation","_projectName","createMutableSource","react","unstable_createMutableSource","useMutableSource","unstable_useMutableSource","unstable_useSyncExternalStore","ReactRendererVersionMismatchWarnOnce","Recoil_ReactMode","currentRendererSupportsUseSyncExternalStore","_ReactCurrentDispatch","ReactCurrentDispatcher","ReactCurrentOwner","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","isUseSyncExternalStoreSupported","currentDispatcher","reactMode","early","concurrent","$disableRecoilValueMutableSource_TEMP_HACK_DO_NOT_USE","isFastRefreshEnabled","RECOIL_DUPLICATE_ATOM_KEY_CHECKING_ENABLED","_process$env$RECOIL_D","_process$env$RECOIL_D2","applyProcessEnvFlagOverrides","Recoil_RecoilEnv","AbstractRecoilValue","newKey","RecoilState","RecoilValueReadOnly","Recoil_RecoilValue","isRecoilValue","Recoil_RecoilValue_1","Recoil_RecoilValue_2","Recoil_RecoilValue_3","Recoil_RecoilValue_4","Recoil_RecoilValue$1","Recoil_expectationViolation","format","Recoil_mapIterable","iterable","isFastRefreshEnabled$1","DefaultValue","DEFAULT_VALUE","recoilValues","NodeMissingError","configDeletionHandlers","getConfigDeletionHandler","Recoil_Node","registerNode","checkForDuplicateAtomKey","recoilValue","getNode","getNodeMaybe","deleteNodeConfigIfPossible","_node$shouldDeleteCon","_getConfigDeletionHan","shouldDeleteConfigOnRelease","setConfigDeletionHandler","recoilValuesForKeys","Recoil_Queue","enqueueExecution","hamt_1","_typeof","Symbol","iterator","hamt","BUCKET_SIZE","MAX_INDEX_NODE","MIN_ARRAY_NODE","nothing","constant","len","hashFragment","h","toBitmap","fromBitmap","bitmap","bit","arrayUpdate","mutate","at","v","arr","arraySpliceOut","newLen","g","empty","__hamt_isEmpty","isEmptyNode","Leaf","edit","_modify","Leaf__modify","Collision","Collision__modify","IndexedNode","mask","IndexedNode__modify","ArrayNode","ArrayNode__modify","mergeLeaves","h1","n1","h2","n2","subH1","subH2","canEditNode","keyEq","k","_v","_newValue","updateCollisionList","frag","indx","exists","canEdit","newChildren","subNodes","expand","arraySpliceIn","newChild","removed","elements","elem","editable","root","_editable","_edit","_config","_root","_size","setTree","newRoot","newSize","tryGetHash","alt","tryGet","getHash","hasHash","defKeyCompare","make","isEmpty","modifyHash","NaN","modify","setHash","del","removeHash","deleteHash","beginMutation","endMutation","transient","appk","lazyVisitChildren","lazyVisit","rest","MapIterator","v0","visit","buildPairs","buildKeys","buildValues","values","fold","z","m","toVisit","BuiltInMap","existing","persistentMap","toMap","HashArrayMappedTrieMap","_hamt","Recoil_PersistentMap_1","Recoil_PersistentMap$1","Recoil_differenceSets","setsWithValuesToRemove","ret","FIRST","otherSet","Recoil_mapMap","mergeDepsIntoGraph","newDeps","graph","olderGraph","nodeDeps","nodeToNodeSubscriptions","oldDeps","addedDeps","dep","removedDeps","Recoil_Graph","cloneGraph","saveDepsToStore","deps","store","_storeState$nextTree","_storeState$previousT","_storeState$previousT2","_storeState$previousT3","storeState","getState","currentTree","nextTree","previousTree","getGraph","_storeState$nextTree2","nextVersion","nextTreeStateVersion","nextStoreID","nextComponentID","Recoil_Keys","getNextTreeStateVersion","getNextStoreID","getNextComponentID","persistentMap$1","getNextTreeStateVersion$1","makeEmptyTreeState","stateID","transactionMetadata","dirtyAtoms","atomValues","nonvalidatedAtoms","Recoil_State","makeEmptyStoreState","commitDepth","knownAtoms","knownSelectors","transactionSubscriptions","nodeTransactionSubscriptions","nodeToComponentSubscriptions","queuedComponentCallbacks_DEPRECATED","suspendedComponentResolvers","graphsByVersion","retention","referenceCounts","nodesRetainedByZone","retainablesToCheckForRelease","nodeCleanupFunctions","RetentionZone","Recoil_RetentionZone","retentionZone","Recoil_CopyOnWrite","setByAddingToSet","setByDeletingFromSet","mapBySettingInMap","mapByUpdatingInMap","updater","mapByDeletingFromMap","mapByDeletingMultipleFromMap","ks","Recoil_filterIterable","Recoil_lazyProxy","factories","Proxy","ownKeys","getNode$1","getNodeMaybe$1","recoilValuesForKeys$1","RetentionZone$1","setByAddingToSet$1","emptySet","ReadOnlyRecoilValueError","initializeNodeIfNewToStore","treeState","trigger","retentionCleanup","nodeKey","retainedBy","addToZone","zone","deleteFromZone","initializeRetentionForNode","nodeCleanup","peekNodeLoadable","peek","getDownstreamNodes","visitedNodes","visitingNodes","_graph$nodeToNodeSubs","subscribedNodes","downstreamNode","Recoil_FunctionalCore","getNodeLoadable","setNodeValue","initializeNode","cleanUpNode","_state$nodeCleanupFun","setUnvalidatedAtomValue_DEPRECATED","_node$invalidate","peekNodeInfo","loadable","isSet","isModified","_graph$nodeDeps$get","subscribers","_storeState$nodeToCom","_storeState$nodeToCom2","components","_invalidateMemoizedSnapshot","Recoil_SnapshotCache","setInvalidateMemoizedSnapshot","invalidateMemoizedSnapshot","_invalidateMemoizedSn","getDownstreamNodes$1","getNodeLoadable$1","setNodeValue$1","getNextComponentID$1","getNode$2","getNodeMaybe$2","DefaultValue$1","reactMode$1","AbstractRecoilValue$1","RecoilState$1","RecoilValueReadOnly$1","isRecoilValue$1","invalidateMemoizedSnapshot$1","applyAction","valueOrUpdater","msg","valueFromValueOrUpdater","writes","writeLoadableToTreeState","unvalidatedValue","applyActionsToStore","actions","replaceState","newState","copyTreeState","invalidateDownstreams","queueOrPerformStateUpdate","batchStack","actionsByStore","downstreams","_getNodeMaybe","_getNodeMaybe$invalid","setRecoilValue","Recoil_RecoilValueInterface","getRecoilValueAsLoadable","setRecoilValueLoadable","markRecoilValueModified","setUnvalidatedRecoilValue","subscribeToRecoilValue","componentDebugName","subID","release","releaseStoreState","subs","applyAtomValueWrites","batchStart","refreshRecoilValue","_node$clearCache","clearCache","Recoil_someSet","cleanUpNode$1","deleteNodeConfigIfPossible$1","getNode$3","RetentionZone$2","emptySet$1","releaseRetainablesNowOnCurrentTree","retainables","n","releasableNodes","searchFromNodes","nonReleasableNodes","findReleasableNodesInner","releasableNodesFoundThisIteration","doNotDescendInto1","doNotDescendInto2","answer","visited","getDownstreamNodesInTopologicalOrder","_storeState$retention","zonesThatCouldRetainNode","nodeChildren","parents","findReleasableNodes","releaseNode","zones","_storeState$retention2","_storeState$retention3","updateRetainCountToZero","retainable","scheduleOrPerformPossibleReleaseOfRetainable","Recoil_Retention","SUSPENSE_TIMEOUT_MS","updateRetainCount","delta","_map$get","newCount","releaseScheduledRetainablesNow","retainedByOptionWithDefault","unstable_batchedUpdates","ReactBatchedUpdates","unstable_batchedUpdates$1","Recoil_ReactBatchedUpdates","batchStart$1","unstable_batchedUpdates$2","batcher","Recoil_Batching","getBatcher","setBatcher","newBatcher","batchUpdates","batchEnd","Recoil_concatIterables","iters","iter","val","isSSR","Window","isReactNative","product","Recoil_Environment","isWindow","Recoil_Memoize","memoizeWithArgsHash","hashFunction","memoizeOneWithArgsHash","lastKey","lastResult","memoizeOneWithArgsHashAndInvalidation","batchUpdates$1","initializeNode$1","peekNodeInfo$1","graph$1","getNextStoreID$1","DEFAULT_VALUE$1","recoilValues$1","recoilValuesForKeys$2","AbstractRecoilValue$2","getRecoilValueAsLoadable$1","setRecoilValue$1","setUnvalidatedRecoilValue$1","updateRetainCount$1","setInvalidateMemoizedSnapshot$1","getNextTreeStateVersion$2","makeEmptyStoreState$1","isSSR$1","memoizeOneWithArgsHashAndInvalidation$1","Snapshot","parentStoreID","checkRefCount_INTERNAL","_store","getLoadable","opt","isInitialized","mapper","mutableSnapshot","MutableSnapshot","retain","autoRelease_INTERNAL","storeID","graphs","newGraph","subscribeToTransactions","addTransactionMetadata","_refCount","released","_release","cleanup","isRetained","getStore_INTERNAL","getID","getStoreID","cloneStoreState","bumpVersion","memoizedCloneSnapshot","invalidateMemoizedSnapshot$2","_store$getState$nextT","_store$getState$previ","snapshot","recoilState","newValueOrUpdater","_batch","Recoil_Snapshot","freshSnapshot","initializeState","cloneSnapshot","Recoil_Snapshot_1","Recoil_Snapshot_2","Recoil_Snapshot_3","Recoil_Snapshot_4","Recoil_Snapshot$1","Recoil_unionSets","sets","useRef","Recoil_useRefInitOnce","initialValue","getNextTreeStateVersion$3","makeEmptyStoreState$2","cleanUpNode$2","getDownstreamNodes$2","initializeNode$2","setNodeValue$2","setUnvalidatedAtomValue_DEPRECATED$1","graph$2","cloneGraph$1","getNextStoreID$2","createMutableSource$1","reactMode$2","applyAtomValueWrites$1","releaseScheduledRetainablesNow$1","freshSnapshot$1","useCallback","useEffect","useRef$1","useState","notInAContext","defaultStore","stateReplacerIsBeingExecuted","startNextTreeIfNeeded","AppContext","useStoreRef","MutableSourceContext","notifyComponents","dependentNodes","comps","_subID","_debugName","sendEndOfBatchNotifications","Batcher","setNotifyBatcherOfChange","storeRef","endBatch","nextID","RecoilRoot_INTERNAL","initializeState_DEPRECATED","store_INTERNAL","storeProp","storeStateRef","replaced","notifyBatcherOfChange","initial","atom","writtenNodes","setUnvalidatedAtomValues","initialStoreState_DEPRECATED","initialStoreState","mutableSource","atomKey","Recoil_RecoilRoot","RecoilRoot","override","propsExceptOverride","ancestorStoreRef","useRecoilMutableSource","useRecoilStoreID","notifyComponents_FOR_TESTING","sendEndOfBatchNotifications_FOR_TESTING","Recoil_shallowArrayEqual","useEffect$1","useRef$2","Recoil_usePrevious","useStoreRef$1","SUSPENSE_TIMEOUT_MS$1","updateRetainCount$2","RetentionZone$3","useEffect$2","useRef$3","isSSR$2","Recoil_useRetain","toRetain","timeoutID","previousRetainables","useRetain_ACTUAL","Recoil_useComponentName","batchUpdates$2","DEFAULT_VALUE$2","currentRendererSupportsUseSyncExternalStore$1","reactMode$3","useMutableSource$1","useSyncExternalStore$1","useRecoilMutableSource$1","useStoreRef$2","isRecoilValue$2","AbstractRecoilValue$3","getRecoilValueAsLoadable$2","setRecoilValue$2","setUnvalidatedRecoilValue$2","subscribeToRecoilValue$1","useCallback$1","useEffect$3","useMemo$1","useRef$4","useState$1","setByAddingToSet$2","handleLoadable","useRecoilValueLoadable_SYNC_EXTERNAL_STORE","componentName","getSnapshot","memoizePreviousSnapshot","prevState","_prevState","_prevState2","nextState","getMemoizedSnapshot","useRecoilValueLoadable_MUTABLE_SOURCE","_storeState$nextTree3","getLoadableWithTesting","_storeState","newLoadable","prevLoadableRef","useRecoilValueLoadable_TRANSITION_SUPPORT","_storeState$nextTree4","updateState","useRecoilValueLoadable_LEGACY","forceUpdate","_storeState$nextTree5","_prevLoadableRef$curr","_prevLoadableRef$curr2","useRecoilValueLoadable","TRANSITION_SUPPORT","SYNC_EXTERNAL_STORE","MUTABLE_SOURCE","LEGACY","useRecoilValue","useSetRecoilState","useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE","useRecoilValue_TRANSITION_SUPPORT_UNSTABLE","Recoil_Hooks","recoilComponentGetRecoilValueCount_FOR_TESTING","useRecoilInterface","recoilValuesUsed","previousSubscriptions","unsubscribeFrom","currentSubscriptions","getRecoilValue","getRecoilValueLoadable","getRecoilState","getRecoilStateLoadable","getSetRecoilState","getResetRecoilState","useRecoilState","useRecoilStateLoadable","useResetRecoilState","useSetUnvalidatedAtomValues","useRecoilState_TRANSITION_SUPPORT_UNSTABLE","Recoil_filterMap","Recoil_filterSet","Recoil_mergeMaps","maps","nextKey","batchUpdates$3","DEFAULT_VALUE$3","getNode$4","nodes$1","useStoreRef$3","AbstractRecoilValue$4","setRecoilValueLoadable$1","SUSPENSE_TIMEOUT_MS$2","cloneSnapshot$1","useCallback$2","useEffect$4","useRef$5","useState$2","isSSR$3","useTransactionSubscription","externallyVisibleAtomValuesInState","persistedAtomContentsValues","persistence","persistence_UNSTABLE","gotoSnapshot","prev","keysToUpdate","_prev$atomValues$get","_next$atomValues$get","shouldRestoreFromSnapshots","Recoil_SnapshotHooks","useRecoilSnapshot","setSnapshot","previousSnapshot","releaseRef","_releaseRef$current","_releaseRef$current2","_releaseRef$current3","useGotoRecoilSnapshot","useRecoilTransactionObserver","useTransactionObservation_DEPRECATED","previousAtomValues","atomInfo","_node$persistence_UNS","_node$persistence_UNS2","_node$persistence_UNS3","_node$persistence_UNS4","backButton","modifiedAtoms","useTransactionSubscription_DEPRECATED","peekNodeInfo$2","useStoreRef$4","Recoil_useGetRecoilValueInfo","reactMode$4","RecoilRoot$1","useStoreRef$5","useMemo$2","Recoil_useRecoilBridgeAcrossReactRoots","loadableWithValue$1","initializeNode$3","DEFAULT_VALUE$4","getNode$5","copyTreeState$1","getRecoilValueAsLoadable$3","invalidateDownstreams$1","writeLoadableToTreeState$1","isAtom","TransactionInterfaceImpl","_changes","_treeState","newTreeState_INTERNAL","Recoil_AtomicUpdates","changeset","Recoil_AtomicUpdates_1","Recoil_AtomicUpdates$1","atomicUpdater","Recoil_invariant","condition","atomicUpdater$1","batchUpdates$4","DEFAULT_VALUE$5","useStoreRef$6","refreshRecoilValue$1","setRecoilValue$3","cloneSnapshot$2","gotoSnapshot$1","useCallback$3","Sentinel","SENTINEL","recoilCallback","extraInterface","releaseSnapshot","_releaseSnapshot2","errMsg","callbackInterface","refresh","transact_UNSTABLE","transaction","finally","_releaseSnapshot","Recoil_useRecoilCallback","useRecoilCallback","useStoreRef$7","refreshRecoilValue$2","useCallback$4","Recoil_useRecoilRefresher","atomicUpdater$2","useStoreRef$8","useMemo$3","Recoil_useRecoilTransaction","atomicUpdate","transactionInterface","Recoil_Wrapper_1","Recoil_Wrapper$1","WrappedValue","isFastRefreshEnabled$2","ChangedPathError","Recoil_TreeCache_1","_options$onHit","_options$onSet","_options$mapNodeValue","_name","_numLeafs","_onHit","onHit","_onSet","onSet","_mapNodeValue","mapNodeValue","getNodeValue","handlers","_this$getLeafNode","getLeafNode","onNodeVisit","nodeValue","branches","route","addLeaf","_node2","_node3","_this$_root2","_handlers$onNodeVisit2","branchKey","_node","_handlers$onNodeVisit","_this$_root","invalidCacheError","oldLeaf","leafNode","leaf","_node4","CHANGED_PATH_ERROR_MESSAGE","Recoil_TreeCache$1","TreeCache","Recoil_LRUCache","_options$mapKey","_maxSize","maxSize","_head","_tail","_keyMapper","mapKey","tail","mappedKey","right","_maybeDeleteLRU","deleteLru","Recoil_LRUCache_1","Recoil_LRUCache$1","LRUCache","LRUCache$1","TreeCache$1","Recoil_treeCacheLRU","lruCache","lruNode","allowFunctions","_JSON$stringify","localeCompare","Recoil_stableStringify","TreeCache$2","defaultPolicy","equality","eviction","Recoil_treeCacheFromPolicy","valueMapper","getValueMapper","getTreeCache","isReactNative$1","isWindow$1","Recoil_PerformanceTimings","startPerfBlock","_id","isLoadable$1","loadableWithError$1","loadableWithPromise$1","loadableWithValue$2","WrappedValue$1","getNodeLoadable$2","peekNodeLoadable$1","setNodeValue$3","saveDepsToStore$1","DEFAULT_VALUE$6","getConfigDeletionHandler$1","getNode$6","registerNode$1","isRecoilValue$3","markRecoilValueModified$1","retainedByOptionWithDefault$1","recoilCallback$1","startPerfBlock$1","Canceled","CANCELED","dependencyStack","waitingStores","getNewExecutionID","executionID","cachePolicy_UNSTABLE","cachePolicy","discoveredDependencyNodeKeys","retainedBy_UNSTABLE","executionInfoMap","liveStoresCount","selectorIsLive","selectorInit","selectorShouldDeleteConfigOnRelease","resolveAsync","depValues","setCache","notifyStoresOfResolvedAsync","isLatestExecution","clearExecutionInfo","notifyWaitingStores","clearWaitlist","stores","waitingStore","markStoreWaitingForResolvedAsync","wrapPendingDependencyPromise","existingDeps","loadingDepsState","resolvedDep","loadingDepKey","loadingDepPromise","cachedLoadable","getLoadableFromCacheAndUpdateDeps","getExecutionInfo","executionInfo","getInProgressExecutionInfo","loadingLoadable","evaluateSelectorGetter","updateDeps","_store$getState","_store$getState$curre","_store$getState2","_store$getState2$next","_store$getState3","_store$getState3$next","endPerfBlock","duringSynchronousExecution","duringAsynchronousExecution","finishEvaluation","resultIsError","depKey","depLoadable","stateVersions","notifyStoresOfNewAsyncDep","getCallback","errorOrPromise","wrapResultPromise","errorOrDepPromise","depValuesDiscoveredSoFarDuringAsyncWork","updateExecutionInfoDepValues","depsAfterCacheLookup","_getExecutionInfo","getSelectorLoadableAndUpdateDeps","cachedVal","inProgressExecutionInfo","_inProgressExecutionI","newExecutionID","newDepValues","setExecutionInfo","pendingExecutions","execInfo","anyDepChanged","execDepValues","execLoadable","_getExecutionInfo2","valLoadable","depValuesToDepRoute","selectorPeek","_peekNodeLoadable","selectorGet","detectCircularDependencies","invalidateSelector","clearSelectorCache","selectorSet","syncSelectorSetFinished","setRecoilState","setValue","dangerouslyAllowMutability","Recoil_selector","isLoadable$2","loadableWithError$2","loadableWithPromise$2","loadableWithValue$3","WrappedValue$2","peekNodeInfo$3","DEFAULT_VALUE$7","DefaultValue$2","getConfigDeletionHandler$2","registerNode$2","setConfigDeletionHandler$1","isRecoilValue$4","getRecoilValueAsLoadable$4","markRecoilValueModified$2","setRecoilValue$4","setRecoilValueLoadable$2","retainedByOptionWithDefault$2","unwrap","baseAtom","unwrapPromise","defaultLoadable","cachedAnswerForUnvalidatedValue","maybeFreezeValueOrPromise","cleanupEffectsByStore","valueOrPromise","peekAtom","_ref","_state$atomValues$get3","nonvalidatedValue","validatorResult","validator","validatedValueLoadable","initState","_options$effects","notifyDefaultSubscribers","_store$getState$nextT3","effects","effects_UNSTABLE","initValue","isDuringInit","isInitError","pendingSetSelf","retValue","getPromise","getInfo_UNSTABLE","_store$getState$nextT4","setSelf","effect","currentLoadable","currentValue","resetSelf","handler","_cleanupEffectsByStor2","currentStore","_currentTree$atomValu","_previousTree$atomVal","_pendingSetSelf","_pendingSetSelf2","_pendingSetSelf3","oldLoadable","parentStoreID_UNSTABLE","_cleanupEffectsByStor3","_store$getState$nextT5","initLoadable","wrappedPromise","_state$atomValues$get","_store$getState$nextT2","_state$atomValues$get2","wrapPendingPromise","_cleanupEffectsByStor","restOptions","optionsDefault","storedValue","sel","baseValue","atomWithFallback","Recoil_atom","Recoil_MapCache_1","Recoil_MapCache$1","MapCache","LRUCache$2","MapCache$1","defaultPolicy$1","Recoil_cacheFromPolicy","getValueMapper$1","getCache","setConfigDeletionHandler$2","Recoil_atomFamily","_options$cachePolicyF","_options$cachePolicyF2","atomCache","cachePolicyForParams_UNSTABLE","_stableStringify","cachedAtom","atomOptions","newAtom","setConfigDeletionHandler$3","nextIndex","Recoil_selectorFamily","selectorCache","cachedSelector","myKey","myGet","myCachePolicy","newSelector","constantSelector","Recoil_constSelector","throwingSelector","Recoil_errorSelector","Recoil_readOnlySelector","loadableWithError$3","loadableWithPromise$3","loadableWithValue$4","concurrentRequests","results","fill","exceptions","isError","exp","unwrapDependencies","dependencies","wrapResults","wrapLoadables","exception","waitForNone","waitForAny","waitForAll","exceptionResults","syncResults","waitForAllSettled","noWait","dependency","Recoil_WaitFor","DefaultValue$3","RecoilRoot$2","useRecoilStoreID$1","isRecoilValue$5","retentionZone$1","freshSnapshot$2","useRecoilState$1","useRecoilState_TRANSITION_SUPPORT_UNSTABLE$1","useRecoilStateLoadable$1","useRecoilValue$1","useRecoilValue_TRANSITION_SUPPORT_UNSTABLE$1","useRecoilValueLoadable$1","useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE$1","useResetRecoilState$1","useSetRecoilState$1","useGotoRecoilSnapshot$1","useRecoilSnapshot$1","useRecoilTransactionObserver$1","useRecoilCallback$1","noWait$1","waitForAll$1","waitForAllSettled$1","waitForAny$1","waitForNone$1","Recoil_index","RecoilEnv","useRecoilBridgeAcrossReactRoots_UNSTABLE","atomFamily","selectorFamily","constSelector","errorSelector","readOnlySelector","useGetRecoilValueInfo_UNSTABLE","useRecoilRefresher_UNSTABLE","useRecoilTransaction_UNSTABLE","useRecoilTransactionObserver_UNSTABLE","snapshot_UNSTABLE","useRetain","Recoil_index_5","nextDatadogRumInit","queryClient","queryCache","queryDefaults","mutationDefaults","mountCount","mount","unsubscribeFocus","focusManager","unsubscribeOnline","onlineManager","unmount","_this$unsubscribeFocu","_this$unsubscribeOnli","isFetching","isMutating","fetching","getQueryData","_this$queryCache$find","ensureQueryData","arg3","parsedOptions","cachedData","fetchQuery","getQueriesData","queryKeyOrFilters","getQueryCache","setQueryData","prevData","defaultedOptions","setQueriesData","getQueryState","_this$queryCache$find2","removeQueries","resetQueries","refetchFilters","refetchQueries","cancelQueries","cancelOptions","invalidateQueries","_filters$refetchType","refetchType","_options$cancelRefetc","throwOnError","prefetchQuery","fetchInfiniteQuery","prefetchInfiniteQuery","getMutationCache","getDefaultOptions","setDefaultOptions","setQueryDefaults","firstMatchingDefaults","setMutationDefaults","_defaulted","refetchOnReconnect","useErrorBoundary","refetchOnWindowFocus","App","Component","pageProps","handleRouteChangeComplete","gtag","page_path","Router","Head","Suspense","fallback","QueryClientProvider","initialIsOpen","dynamic","TypeError","pairs","dec","decode","pair","substring","tryDecode","enc","fieldContentRegExp","maxAge","isNaN","httpOnly","decodeURIComponent","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","run","marker","runClearTimeout","Item","nextTick","browser","argv","versions","on","addListener","off","removeAllListeners","prependListener","prependOnceListener","binding","cwd","chdir","dir","umask","readCookie","cleanValue","cleanupCookieValue","doNotParse","isParsingCookie","__assign","t","changeListeners","HAS_DOCUMENT_COOKIE","parseCookies","_updateBrowserValues","parseOptions","_emitChange","finalOptions","addChangeListener","removeChangeListener","_objectSpread","sym","_objectSpreadProps","getOwnPropertyDescriptors","defineProperties","enumerableOnly","symbols","FocusManager","setup","removeEventListener","onSubscribe","setEventListener","onUnsubscribe","_this$cleanup","hasListeners","_this$cleanup2","focused","setFocused","isFocused","transactions","notifyFn","batchNotifyFn","schedule","originalQueue","batchCalls","setNotifyFunction","setBatchNotifyFunction","createNotifyManager","onlineEvents","OnlineManager","online","setOnline","isOnline","defaultRetryDelay","canFetch","CancelledError","isCancelledError","createRetryer","continueFn","promiseResolve","promiseReject","isRetryCancelled","isResolved","outerResolve","outerReject","shouldPause","pause","continueResolve","canContinue","promiseOrValue","_config$retry","_config$retryDelay","shouldRetry","Subscribable","identity","isServer","functionalUpdate","isValidTimeout","timeUntilStale","parseQueryArgs","isQueryKey","parseFilterArgs","matchQuery","stale","hashQueryKeyByOptions","partialMatchKey","matchMutation","hashQueryKey","queryKeyHashFn","isPlainObject","partialDeepEqual","replaceEqualDeep","isPlainArray","aSize","bItems","bSize","copy","equalItems","shallowEqualObjects","hasObjectPrototype","ctor","prot","sleep","scheduleMicrotask","getAbortController","AbortController","replaceData","isDataEqual","structuralSharing","defaultContext","QueryClientSharingContext","getQueryClientContext","contextSharing","ReactQueryClientContext","useQueryClient","Context"],"sourceRoot":""}