@kubesense/kubesense-browser-rum-core 1.0.0

package/cjs/domain/view/viewMetrics/interactionCountPolyfill.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * performance.interactionCount polyfill
+ *
+ * The interactionCount is an integer which counts the total number of distinct user interactions,
+ * for which there was a unique interactionId.
+ *
+ * The interactionCount polyfill is an estimate based on a convention specific to Chrome. Cf: https://github.com/GoogleChrome/web-vitals/pull/213
+ * This is currently not an issue as the polyfill is only used for INP which is currently only supported on Chrome.
+ * 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.
+ *
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInteractionCount = void 0;
+exports.initInteractionCountPolyfill = initInteractionCountPolyfill;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+let observer;
+let interactionCountEstimate = 0;
+let minKnownInteractionId = Infinity;
+let maxKnownInteractionId = 0;
+function initInteractionCountPolyfill() {
+    if ('interactionCount' in performance || observer) {
+        return;
+    }
+    observer = new window.PerformanceObserver((0, kubesense_browser_core_1.monitor)((entries) => {
+        entries.getEntries().forEach((e) => {
+            const entry = e;
+            if (entry.interactionId) {
+                minKnownInteractionId = Math.min(minKnownInteractionId, entry.interactionId);
+                maxKnownInteractionId = Math.max(maxKnownInteractionId, entry.interactionId);
+                interactionCountEstimate = (maxKnownInteractionId - minKnownInteractionId) / 7 + 1;
+            }
+        });
+    }));
+    observer.observe({ type: 'event', buffered: true, durationThreshold: 0 });
+}
+/**
+ * Returns the `interactionCount` value using the native API (if available)
+ * or the polyfill estimate in this module.
+ */
+const getInteractionCount = () => observer ? interactionCountEstimate : window.performance.interactionCount || 0;
+exports.getInteractionCount = getInteractionCount;
+//# sourceMappingURL=interactionCountPolyfill.js.map

package/cjs/domain/view/viewMetrics/interactionCountPolyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionCountPolyfill.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/interactionCountPolyfill.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAeH,oEAqBC;AAlCD,8EAA2D;AAO3D,IAAI,QAA4C,CAAA;AAEhD,IAAI,wBAAwB,GAAG,CAAC,CAAA;AAChC,IAAI,qBAAqB,GAAG,QAAQ,CAAA;AACpC,IAAI,qBAAqB,GAAG,CAAC,CAAA;AAE7B,SAAgB,4BAA4B;IAC1C,IAAI,kBAAkB,IAAI,WAAW,IAAI,QAAQ,EAAE,CAAC;QAClD,OAAM;IACR,CAAC;IAED,QAAQ,GAAG,IAAK,MAAwB,CAAC,mBAAmB,CAC1D,IAAA,gCAAO,EAAC,CAAC,OAAqC,EAAE,EAAE;QAChD,OAAO,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACjC,MAAM,KAAK,GAAG,CAAyC,CAAA;YAEvD,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;gBACxB,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;gBAC5E,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;gBAE5E,wBAAwB,GAAG,CAAC,qBAAqB,GAAG,qBAAqB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YACpF,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CACH,CAAA;IAED,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC,CAAA;AAC3E,CAAC;AAED;;;GAGG;AACI,MAAM,mBAAmB,GAAG,GAAG,EAAE,CACtC,QAAQ,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAE,MAAwB,CAAC,WAAW,CAAC,gBAAiB,IAAI,CAAC,CAAA;AADvF,QAAA,mBAAmB,uBACoE"}

package/cjs/domain/view/viewMetrics/startInitialViewMetricsTelemetry.d.ts

@@ -0,0 +1,6 @@
+import type { Telemetry } from '@kubesense/kubesense-browser-core';
+import { noop } from '@kubesense/kubesense-browser-core';
+import type { LifeCycle } from '../../lifeCycle';
+export declare function startInitialViewMetricsTelemetry(lifeCycle: LifeCycle, telemetry: Telemetry): {
+    stop: typeof noop;
+};

package/cjs/domain/view/viewMetrics/startInitialViewMetricsTelemetry.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startInitialViewMetricsTelemetry = startInitialViewMetricsTelemetry;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+function startInitialViewMetricsTelemetry(lifeCycle, telemetry) {
+    if (!telemetry.metricsEnabled) {
+        return { stop: kubesense_browser_core_1.noop };
+    }
+    const { unsubscribe } = lifeCycle.subscribe(4 /* LifeCycleEventType.VIEW_UPDATED */, ({ initialViewMetrics }) => {
+        if (!initialViewMetrics.largestContentfulPaint || !initialViewMetrics.navigationTimings) {
+            return;
+        }
+        // The navigation timings become available shortly after the load event fires, so
+        // we're snapshotting the LCP value available at that point. However, more LCP values
+        // can be emitted until the page is scrolled or interacted with, so it's possible that
+        // the final LCP value may differ. These metrics are intended to help diagnose
+        // performance issues early in the page load process, and using LCP-at-page-load is a
+        // good fit for that use case, but it's important to be aware that this is not
+        // necessarily equivalent to the normal LCP metric.
+        // monitor-until: 2026-07-01
+        (0, kubesense_browser_core_1.addTelemetryMetrics)("Initial view metrics" /* TelemetryMetrics.INITIAL_VIEW_METRICS_TELEMETRY_NAME */, {
+            metrics: createCoreInitialViewMetrics(initialViewMetrics.largestContentfulPaint, initialViewMetrics.navigationTimings),
+        });
+        unsubscribe();
+    });
+    return {
+        stop: unsubscribe,
+    };
+}
+function createCoreInitialViewMetrics(lcp, navigation) {
+    return {
+        lcp: {
+            value: lcp.value,
+        },
+        navigation: {
+            domComplete: navigation.domComplete,
+            domContentLoaded: navigation.domContentLoaded,
+            domInteractive: navigation.domInteractive,
+            firstByte: navigation.firstByte,
+            loadEvent: navigation.loadEvent,
+        },
+    };
+}
+//# sourceMappingURL=startInitialViewMetricsTelemetry.js.map

package/cjs/domain/view/viewMetrics/startInitialViewMetricsTelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startInitialViewMetricsTelemetry.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/startInitialViewMetricsTelemetry.ts"],"names":[],"mappings":";;AAoBA,4EA+BC;AAlDD,8EAA+F;AAmB/F,SAAgB,gCAAgC,CAAC,SAAoB,EAAE,SAAoB;IACzF,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,6BAAI,EAAE,CAAA;IACvB,CAAC;IAED,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,CAAC,SAAS,0CAAkC,CAAC,EAAE,kBAAkB,EAAE,EAAE,EAAE;QACtG,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,EAAE,CAAC;YACxF,OAAM;QACR,CAAC;QAED,iFAAiF;QACjF,qFAAqF;QACrF,sFAAsF;QACtF,8EAA8E;QAC9E,qFAAqF;QACrF,8EAA8E;QAC9E,mDAAmD;QACnD,4BAA4B;QAC5B,IAAA,4CAAmB,qFAAuD;YACxE,OAAO,EAAE,4BAA4B,CACnC,kBAAkB,CAAC,sBAAsB,EACzC,kBAAkB,CAAC,iBAAiB,CACrC;SACF,CAAC,CAAA;QAEF,WAAW,EAAE,CAAA;IACf,CAAC,CAAC,CAAA;IAEF,OAAO;QACL,IAAI,EAAE,WAAW;KAClB,CAAA;AACH,CAAC;AAED,SAAS,4BAA4B,CACnC,GAA2B,EAC3B,UAA6B;IAE7B,OAAO;QACL,GAAG,EAAE;YACH,KAAK,EAAE,GAAG,CAAC,KAAK;SACjB;QACD,UAAU,EAAE;YACV,WAAW,EAAE,UAAU,CAAC,WAAW;YACnC,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;YAC7C,cAAc,EAAE,UAAU,CAAC,cAAc;YACzC,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,SAAS,EAAE,UAAU,CAAC,SAAS;SAChC;KACF,CAAA;AACH,CAAC"}

package/cjs/domain/view/viewMetrics/trackBfcacheMetrics.d.ts

@@ -0,0 +1,8 @@
+import type { ClocksState } from '@kubesense/kubesense-browser-core';
+import type { InitialViewMetrics } from './trackInitialViewMetrics';
+/**
+ * BFCache keeps a full in-memory snapshot of the DOM. When the page is restored, nothing needs to be fetched, so the whole
+ * viewport repaints in a single frame. Consequently, LCP almost always equals FCP.
+ * (See: https://github.com/GoogleChrome/web-vitals/pull/87)
+ */
+export declare function trackBfcacheMetrics(viewStart: ClocksState, metrics: InitialViewMetrics, scheduleViewUpdate: () => void): void;

package/cjs/domain/view/viewMetrics/trackBfcacheMetrics.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackBfcacheMetrics = trackBfcacheMetrics;
+const trackFirstContentfulPaint_1 = require("./trackFirstContentfulPaint");
+/**
+ * BFCache keeps a full in-memory snapshot of the DOM. When the page is restored, nothing needs to be fetched, so the whole
+ * viewport repaints in a single frame. Consequently, LCP almost always equals FCP.
+ * (See: https://github.com/GoogleChrome/web-vitals/pull/87)
+ */
+function trackBfcacheMetrics(viewStart, metrics, scheduleViewUpdate) {
+    (0, trackFirstContentfulPaint_1.trackRestoredFirstContentfulPaint)(viewStart.relative, (paintTime) => {
+        metrics.firstContentfulPaint = paintTime;
+        metrics.largestContentfulPaint = { value: paintTime };
+        scheduleViewUpdate();
+    });
+}
+//# sourceMappingURL=trackBfcacheMetrics.js.map

package/cjs/domain/view/viewMetrics/trackBfcacheMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackBfcacheMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackBfcacheMetrics.ts"],"names":[],"mappings":";;AASA,kDAUC;AAjBD,2EAA+E;AAE/E;;;;GAIG;AACH,SAAgB,mBAAmB,CACjC,SAAsB,EACtB,OAA2B,EAC3B,kBAA8B;IAE9B,IAAA,6DAAiC,EAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,EAAE;QAClE,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAA;QACxC,OAAO,CAAC,sBAAsB,GAAG,EAAE,KAAK,EAAE,SAAyB,EAAE,CAAA;QACrE,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/cjs/domain/view/viewMetrics/trackCommonViewMetrics.d.ts

@@ -0,0 +1,21 @@
+import type { ClocksState, Duration, Observable } from '@kubesense/kubesense-browser-core';
+import type { ViewLoadingType } from '../../../rawRumEvent.types';
+import type { RumConfiguration } from '../../configuration';
+import type { LifeCycle } from '../../lifeCycle';
+import type { RumMutationRecord } from '../../../browser/domMutationObservable';
+import type { CumulativeLayoutShift } from './trackCumulativeLayoutShift';
+import type { InteractionToNextPaint } from './trackInteractionToNextPaint';
+import type { ScrollMetrics } from './trackScrollMetrics';
+export interface CommonViewMetrics {
+    loadingTime?: Duration;
+    cumulativeLayoutShift?: CumulativeLayoutShift;
+    interactionToNextPaint?: InteractionToNextPaint;
+    scroll?: ScrollMetrics;
+}
+export declare function trackCommonViewMetrics(lifeCycle: LifeCycle, domMutationObservable: Observable<RumMutationRecord[]>, windowOpenObservable: Observable<void>, configuration: RumConfiguration, scheduleViewUpdate: () => void, loadingType: ViewLoadingType, viewStart: ClocksState): {
+    stop: () => void;
+    stopINPTracking: () => void;
+    setLoadEvent: (loadEvent: Duration) => void;
+    setViewEnd: (viewEndTime: import("@kubesense/kubesense-browser-core").RelativeTime) => void;
+    getCommonViewMetrics: () => CommonViewMetrics;
+};

package/cjs/domain/view/viewMetrics/trackCommonViewMetrics.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackCommonViewMetrics = trackCommonViewMetrics;
+const trackCumulativeLayoutShift_1 = require("./trackCumulativeLayoutShift");
+const trackInteractionToNextPaint_1 = require("./trackInteractionToNextPaint");
+const trackLoadingTime_1 = require("./trackLoadingTime");
+const trackScrollMetrics_1 = require("./trackScrollMetrics");
+function trackCommonViewMetrics(lifeCycle, domMutationObservable, windowOpenObservable, configuration, scheduleViewUpdate, loadingType, viewStart) {
+    const commonViewMetrics = {};
+    const { stop: stopLoadingTimeTracking, setLoadEvent } = (0, trackLoadingTime_1.trackLoadingTime)(lifeCycle, domMutationObservable, windowOpenObservable, configuration, loadingType, viewStart, (newLoadingTime) => {
+        commonViewMetrics.loadingTime = newLoadingTime;
+        scheduleViewUpdate();
+    });
+    const { stop: stopScrollMetricsTracking } = (0, trackScrollMetrics_1.trackScrollMetrics)(configuration, viewStart, (newScrollMetrics) => {
+        commonViewMetrics.scroll = newScrollMetrics;
+    });
+    const { stop: stopCLSTracking } = (0, trackCumulativeLayoutShift_1.trackCumulativeLayoutShift)(configuration, viewStart.relative, (cumulativeLayoutShift) => {
+        commonViewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;
+        scheduleViewUpdate();
+    });
+    const { stop: stopINPTracking, getInteractionToNextPaint, setViewEnd, } = (0, trackInteractionToNextPaint_1.trackInteractionToNextPaint)(configuration, viewStart.relative, loadingType);
+    return {
+        stop: () => {
+            stopLoadingTimeTracking();
+            stopCLSTracking();
+            stopScrollMetricsTracking();
+        },
+        stopINPTracking,
+        setLoadEvent,
+        setViewEnd,
+        getCommonViewMetrics: () => {
+            commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint();
+            return commonViewMetrics;
+        },
+    };
+}
+//# sourceMappingURL=trackCommonViewMetrics.js.map

package/cjs/domain/view/viewMetrics/trackCommonViewMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackCommonViewMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackCommonViewMetrics.ts"],"names":[],"mappings":";;AAoBA,wDAyDC;AAvED,6EAAyE;AAEzE,+EAA2E;AAC3E,yDAAqD;AAErD,6DAAyD;AASzD,SAAgB,sBAAsB,CACpC,SAAoB,EACpB,qBAAsD,EACtD,oBAAsC,EACtC,aAA+B,EAC/B,kBAA8B,EAC9B,WAA4B,EAC5B,SAAsB;IAEtB,MAAM,iBAAiB,GAAsB,EAAE,CAAA;IAE/C,MAAM,EAAE,IAAI,EAAE,uBAAuB,EAAE,YAAY,EAAE,GAAG,IAAA,mCAAgB,EACtE,SAAS,EACT,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,WAAW,EACX,SAAS,EACT,CAAC,cAAc,EAAE,EAAE;QACjB,iBAAiB,CAAC,WAAW,GAAG,cAAc,CAAA;QAC9C,kBAAkB,EAAE,CAAA;IACtB,CAAC,CACF,CAAA;IAED,MAAM,EAAE,IAAI,EAAE,yBAAyB,EAAE,GAAG,IAAA,uCAAkB,EAAC,aAAa,EAAE,SAAS,EAAE,CAAC,gBAAgB,EAAE,EAAE;QAC5G,iBAAiB,CAAC,MAAM,GAAG,gBAAgB,CAAA;IAC7C,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,uDAA0B,EAC1D,aAAa,EACb,SAAS,CAAC,QAAQ,EAClB,CAAC,qBAAqB,EAAE,EAAE;QACxB,iBAAiB,CAAC,qBAAqB,GAAG,qBAAqB,CAAA;QAC/D,kBAAkB,EAAE,CAAA;IACtB,CAAC,CACF,CAAA;IAED,MAAM,EACJ,IAAI,EAAE,eAAe,EACrB,yBAAyB,EACzB,UAAU,GACX,GAAG,IAAA,yDAA2B,EAAC,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;IAE/E,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,uBAAuB,EAAE,CAAA;YACzB,eAAe,EAAE,CAAA;YACjB,yBAAyB,EAAE,CAAA;QAC7B,CAAC;QACD,eAAe;QACf,YAAY;QACZ,UAAU;QACV,oBAAoB,EAAE,GAAG,EAAE;YACzB,iBAAiB,CAAC,sBAAsB,GAAG,yBAAyB,EAAE,CAAA;YACtE,OAAO,iBAAiB,CAAA;QAC1B,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/domain/view/viewMetrics/trackCumulativeLayoutShift.d.ts

@@ -0,0 +1,37 @@
+import { noop } from '@kubesense/kubesense-browser-core';
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+import type { RumRect } from '../../../rumEvent.types';
+export interface CumulativeLayoutShift {
+    value: number;
+    targetSelector?: string;
+    time?: Duration;
+    previousRect?: RumRect;
+    currentRect?: RumRect;
+    devicePixelRatio?: number;
+}
+/**
+ * Track the cumulative layout shifts (CLS).
+ * Layout shifts are grouped into session windows.
+ * The minimum gap between session windows is 1 second.
+ * The maximum duration of a session window is 5 second.
+ * The session window layout shift value is the sum of layout shifts inside it.
+ * The CLS value is the max of session windows values.
+ *
+ * This yields a new value whenever the CLS value is updated (a higher session window value is computed).
+ *
+ * See isLayoutShiftSupported to check for browser support.
+ *
+ * Documentation:
+ * https://web.dev/cls/
+ * https://web.dev/evolving-cls/
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts
+ */
+export declare function trackCumulativeLayoutShift(configuration: RumConfiguration, viewStart: RelativeTime, callback: (cumulativeLayoutShift: CumulativeLayoutShift) => void): {
+    stop: typeof noop;
+};
+export declare const MAX_WINDOW_DURATION: number;
+/**
+ * Check whether `layout-shift` is supported by the browser.
+ */
+export declare function isLayoutShiftSupported(): boolean;

package/cjs/domain/view/viewMetrics/trackCumulativeLayoutShift.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_WINDOW_DURATION = void 0;
+exports.trackCumulativeLayoutShift = trackCumulativeLayoutShift;
+exports.isLayoutShiftSupported = isLayoutShiftSupported;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const htmlDomUtils_1 = require("../../../browser/htmlDomUtils");
+const performanceObservable_1 = require("../../../browser/performanceObservable");
+const getSelectorFromElement_1 = require("../../getSelectorFromElement");
+const getClsAttributionImpactedArea_1 = require("./getClsAttributionImpactedArea");
+/**
+ * Track the cumulative layout shifts (CLS).
+ * Layout shifts are grouped into session windows.
+ * The minimum gap between session windows is 1 second.
+ * The maximum duration of a session window is 5 second.
+ * The session window layout shift value is the sum of layout shifts inside it.
+ * The CLS value is the max of session windows values.
+ *
+ * This yields a new value whenever the CLS value is updated (a higher session window value is computed).
+ *
+ * See isLayoutShiftSupported to check for browser support.
+ *
+ * Documentation:
+ * https://web.dev/cls/
+ * https://web.dev/evolving-cls/
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts
+ */
+function trackCumulativeLayoutShift(configuration, viewStart, callback) {
+    if (!isLayoutShiftSupported()) {
+        return {
+            stop: kubesense_browser_core_1.noop,
+        };
+    }
+    let maxClsValue = 0;
+    let biggestShift;
+    // if no layout shift happen the value should be reported as 0
+    callback({
+        value: 0,
+    });
+    const slidingWindow = slidingSessionWindow();
+    const performanceSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
+        type: performanceObservable_1.RumPerformanceEntryType.LAYOUT_SHIFT,
+        buffered: true,
+    }).subscribe((entries) => {
+        var _a;
+        for (const entry of entries) {
+            if (entry.hadRecentInput || entry.startTime < viewStart) {
+                continue;
+            }
+            const { cumulatedValue, isMaxValue } = slidingWindow.update(entry);
+            if (isMaxValue) {
+                const attribution = getTopImpactedElement(entry.sources);
+                biggestShift = {
+                    target: (attribution === null || attribution === void 0 ? void 0 : attribution.node) ? new WeakRef(attribution.node) : undefined,
+                    time: (0, kubesense_browser_core_1.elapsed)(viewStart, entry.startTime),
+                    previousRect: attribution === null || attribution === void 0 ? void 0 : attribution.previousRect,
+                    currentRect: attribution === null || attribution === void 0 ? void 0 : attribution.currentRect,
+                    devicePixelRatio: window.devicePixelRatio,
+                };
+            }
+            if (cumulatedValue > maxClsValue) {
+                maxClsValue = cumulatedValue;
+                const target = (_a = biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.target) === null || _a === void 0 ? void 0 : _a.deref();
+                callback({
+                    value: (0, kubesense_browser_core_1.round)(maxClsValue, 4),
+                    targetSelector: target && (0, getSelectorFromElement_1.getSelectorFromElement)(target, configuration.actionNameAttribute),
+                    time: biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.time,
+                    previousRect: (biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.previousRect) ? asRumRect(biggestShift.previousRect) : undefined,
+                    currentRect: (biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.currentRect) ? asRumRect(biggestShift.currentRect) : undefined,
+                    devicePixelRatio: biggestShift === null || biggestShift === void 0 ? void 0 : biggestShift.devicePixelRatio,
+                });
+            }
+        }
+    });
+    return {
+        stop: () => {
+            performanceSubscription.unsubscribe();
+        },
+    };
+}
+function getTopImpactedElement(sources) {
+    let topImpactedSource;
+    for (const source of sources) {
+        if (source.node && (0, htmlDomUtils_1.isElementNode)(source.node)) {
+            const currentImpactedArea = (0, getClsAttributionImpactedArea_1.getClsAttributionImpactedArea)(source);
+            if (!topImpactedSource || (0, getClsAttributionImpactedArea_1.getClsAttributionImpactedArea)(topImpactedSource) < currentImpactedArea) {
+                topImpactedSource = source;
+            }
+        }
+    }
+    return topImpactedSource;
+}
+function asRumRect({ x, y, width, height }) {
+    return { x, y, width, height };
+}
+exports.MAX_WINDOW_DURATION = 5 * kubesense_browser_core_1.ONE_SECOND;
+const MAX_UPDATE_GAP = kubesense_browser_core_1.ONE_SECOND;
+function slidingSessionWindow() {
+    let cumulatedValue = 0;
+    let startTime;
+    let endTime;
+    let maxValue = 0;
+    return {
+        update: (entry) => {
+            const shouldCreateNewWindow = startTime === undefined ||
+                entry.startTime - endTime >= MAX_UPDATE_GAP ||
+                entry.startTime - startTime >= exports.MAX_WINDOW_DURATION;
+            let isMaxValue;
+            if (shouldCreateNewWindow) {
+                startTime = endTime = entry.startTime;
+                maxValue = cumulatedValue = entry.value;
+                isMaxValue = true;
+            }
+            else {
+                cumulatedValue += entry.value;
+                endTime = entry.startTime;
+                isMaxValue = entry.value > maxValue;
+                if (isMaxValue) {
+                    maxValue = entry.value;
+                }
+            }
+            return {
+                cumulatedValue,
+                isMaxValue,
+            };
+        },
+    };
+}
+/**
+ * Check whether `layout-shift` is supported by the browser.
+ */
+function isLayoutShiftSupported() {
+    return (0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.LAYOUT_SHIFT) && 'WeakRef' in window;
+}
+//# sourceMappingURL=trackCumulativeLayoutShift.js.map

package/cjs/domain/view/viewMetrics/trackCumulativeLayoutShift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackCumulativeLayoutShift.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackCumulativeLayoutShift.ts"],"names":[],"mappings":"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"}

package/cjs/domain/view/viewMetrics/trackFirstContentfulPaint.d.ts

@@ -0,0 +1,13 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+import type { FirstHidden } from './trackFirstHidden';
+export declare const FCP_MAXIMUM_DELAY: number;
+export declare function trackFirstContentfulPaint(configuration: RumConfiguration, firstHidden: FirstHidden, callback: (fcpTiming: RelativeTime) => void): {
+    stop: () => void;
+};
+/**
+ * Measure the First Contentful Paint after a BFCache restoration.
+ * The DOM is restored synchronously, so we approximate the FCP with the first frame
+ * rendered just after the pageshow event, using two nested requestAnimationFrame calls.
+ */
+export declare function trackRestoredFirstContentfulPaint(viewStartRelative: RelativeTime, callback: (fcp: Duration) => void): void;

package/cjs/domain/view/viewMetrics/trackFirstContentfulPaint.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FCP_MAXIMUM_DELAY = void 0;
+exports.trackFirstContentfulPaint = trackFirstContentfulPaint;
+exports.trackRestoredFirstContentfulPaint = trackRestoredFirstContentfulPaint;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const performanceObservable_1 = require("../../../browser/performanceObservable");
+// Discard FCP timings above a certain delay to avoid incorrect data
+// It happens in some cases like sleep mode or some browser implementations
+exports.FCP_MAXIMUM_DELAY = 10 * kubesense_browser_core_1.ONE_MINUTE;
+function trackFirstContentfulPaint(configuration, firstHidden, callback) {
+    const performanceSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
+        type: performanceObservable_1.RumPerformanceEntryType.PAINT,
+        buffered: true,
+    }).subscribe((entries) => {
+        const fcpEntry = entries.find((entry) => entry.name === 'first-contentful-paint' &&
+            entry.startTime < firstHidden.timeStamp &&
+            entry.startTime < exports.FCP_MAXIMUM_DELAY);
+        if (fcpEntry) {
+            callback(fcpEntry.startTime);
+        }
+    });
+    return {
+        stop: performanceSubscription.unsubscribe,
+    };
+}
+/**
+ * Measure the First Contentful Paint after a BFCache restoration.
+ * The DOM is restored synchronously, so we approximate the FCP with the first frame
+ * rendered just after the pageshow event, using two nested requestAnimationFrame calls.
+ */
+function trackRestoredFirstContentfulPaint(viewStartRelative, callback) {
+    requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+            callback((0, kubesense_browser_core_1.elapsed)(viewStartRelative, (0, kubesense_browser_core_1.relativeNow)()));
+        });
+    });
+}
+//# sourceMappingURL=trackFirstContentfulPaint.js.map

package/cjs/domain/view/viewMetrics/trackFirstContentfulPaint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackFirstContentfulPaint.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackFirstContentfulPaint.ts"],"names":[],"mappings":";;;AAWA,8DAsBC;AAOD,8EAMC;AA7CD,8EAAoF;AAEpF,kFAA6G;AAI7G,oEAAoE;AACpE,2EAA2E;AAC9D,QAAA,iBAAiB,GAAG,EAAE,GAAG,mCAAU,CAAA;AAEhD,SAAgB,yBAAyB,CACvC,aAA+B,EAC/B,WAAwB,EACxB,QAA2C;IAE3C,MAAM,uBAAuB,GAAG,IAAA,mDAA2B,EAAC,aAAa,EAAE;QACzE,IAAI,EAAE,+CAAuB,CAAC,KAAK;QACnC,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QACvB,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAC3B,CAAC,KAAK,EAAsC,EAAE,CAC5C,KAAK,CAAC,IAAI,KAAK,wBAAwB;YACvC,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS;YACvC,KAAK,CAAC,SAAS,GAAG,yBAAiB,CACtC,CAAA;QACD,IAAI,QAAQ,EAAE,CAAC;YACb,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;QAC9B,CAAC;IACH,CAAC,CAAC,CAAA;IACF,OAAO;QACL,IAAI,EAAE,uBAAuB,CAAC,WAAW;KAC1C,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,iCAAiC,CAAC,iBAA+B,EAAE,QAAiC;IAClH,qBAAqB,CAAC,GAAG,EAAE;QACzB,qBAAqB,CAAC,GAAG,EAAE;YACzB,QAAQ,CAAC,IAAA,gCAAO,EAAC,iBAAiB,EAAE,IAAA,oCAAW,GAAE,CAAC,CAAC,CAAA;QACrD,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/cjs/domain/view/viewMetrics/trackFirstHidden.d.ts

@@ -0,0 +1,10 @@
+import type { ClocksState, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+export type FirstHidden = ReturnType<typeof trackFirstHidden>;
+export interface Options {
+    viewStart: ClocksState;
+}
+export declare function trackFirstHidden(configuration: RumConfiguration, viewStart: ClocksState, eventTarget?: Window): {
+    readonly timeStamp: RelativeTime;
+    stop: () => void;
+};

package/cjs/domain/view/viewMetrics/trackFirstHidden.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackFirstHidden = trackFirstHidden;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const performanceObservable_1 = require("../../../browser/performanceObservable");
+function trackFirstHidden(configuration, viewStart, eventTarget = window) {
+    if (document.visibilityState === 'hidden') {
+        return { timeStamp: 0, stop: kubesense_browser_core_1.noop };
+    }
+    if ((0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.VISIBILITY_STATE)) {
+        const firstHiddenEntry = performance
+            .getEntriesByType(performanceObservable_1.RumPerformanceEntryType.VISIBILITY_STATE)
+            .filter((entry) => entry.name === 'hidden')
+            .find((entry) => entry.startTime >= viewStart.relative);
+        if (firstHiddenEntry) {
+            return { timeStamp: firstHiddenEntry.startTime, stop: kubesense_browser_core_1.noop };
+        }
+    }
+    let timeStamp = Infinity;
+    const { stop } = (0, kubesense_browser_core_1.addEventListeners)(configuration, eventTarget, ["pagehide" /* DOM_EVENT.PAGE_HIDE */, "visibilitychange" /* DOM_EVENT.VISIBILITY_CHANGE */], (event) => {
+        if (event.type === "pagehide" /* DOM_EVENT.PAGE_HIDE */ || document.visibilityState === 'hidden') {
+            timeStamp = event.timeStamp;
+            stop();
+        }
+    }, { capture: true });
+    return {
+        get timeStamp() {
+            return timeStamp;
+        },
+        stop,
+    };
+}
+//# sourceMappingURL=trackFirstHidden.js.map

package/cjs/domain/view/viewMetrics/trackFirstHidden.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackFirstHidden.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackFirstHidden.ts"],"names":[],"mappings":";;AAWA,4CAyCC;AAnDD,8EAAsF;AAEtF,kFAA+G;AAQ/G,SAAgB,gBAAgB,CAC9B,aAA+B,EAC/B,SAAsB,EACtB,cAAsB,MAAM;IAE5B,IAAI,QAAQ,CAAC,eAAe,KAAK,QAAQ,EAAE,CAAC;QAC1C,OAAO,EAAE,SAAS,EAAE,CAAiB,EAAE,IAAI,EAAE,6BAAI,EAAE,CAAA;IACrD,CAAC;IAED,IAAI,IAAA,qDAA6B,EAAC,+CAAuB,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC5E,MAAM,gBAAgB,GAAG,WAAW;aACjC,gBAAgB,CAAC,+CAAuB,CAAC,gBAAgB,CAAC;aAC1D,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;aAC1C,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,IAAI,SAAS,CAAC,QAAQ,CAAC,CAAA;QAEzD,IAAI,gBAAgB,EAAE,CAAC;YACrB,OAAO,EAAE,SAAS,EAAE,gBAAgB,CAAC,SAAyB,EAAE,IAAI,EAAE,6BAAI,EAAE,CAAA;QAC9E,CAAC;IACH,CAAC;IAED,IAAI,SAAS,GAAiB,QAAwB,CAAA;IAEtD,MAAM,EAAE,IAAI,EAAE,GAAG,IAAA,0CAAiB,EAChC,aAAa,EACb,WAAW,EACX,4FAAkD,EAClD,CAAC,KAAK,EAAE,EAAE;QACR,IAAI,KAAK,CAAC,IAAI,yCAAwB,IAAI,QAAQ,CAAC,eAAe,KAAK,QAAQ,EAAE,CAAC;YAChF,SAAS,GAAG,KAAK,CAAC,SAAyB,CAAA;YAC3C,IAAI,EAAE,CAAA;QACR,CAAC;IACH,CAAC,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAA;IAED,OAAO;QACL,IAAI,SAAS;YACX,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,IAAI;KACL,CAAA;AACH,CAAC"}

package/cjs/domain/view/viewMetrics/trackFirstInput.d.ts

@@ -0,0 +1,19 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+import type { FirstHidden } from './trackFirstHidden';
+export interface FirstInput {
+    delay: Duration;
+    time: RelativeTime;
+    targetSelector?: string;
+}
+/**
+ * Track the first input occurring during the initial View to return:
+ * - First Input Delay
+ * - First Input Time
+ * Callback is called at most one time.
+ * Documentation: https://web.dev/fid/
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts
+ */
+export declare function trackFirstInput(configuration: RumConfiguration, firstHidden: FirstHidden, callback: (firstInput: FirstInput) => void): {
+    stop: () => void;
+};

package/cjs/domain/view/viewMetrics/trackFirstInput.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackFirstInput = trackFirstInput;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const htmlDomUtils_1 = require("../../../browser/htmlDomUtils");
+const performanceObservable_1 = require("../../../browser/performanceObservable");
+const getSelectorFromElement_1 = require("../../getSelectorFromElement");
+/**
+ * Track the first input occurring during the initial View to return:
+ * - First Input Delay
+ * - First Input Time
+ * Callback is called at most one time.
+ * Documentation: https://web.dev/fid/
+ * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts
+ */
+function trackFirstInput(configuration, firstHidden, callback) {
+    const performanceFirstInputSubscription = (0, performanceObservable_1.createPerformanceObservable)(configuration, {
+        type: performanceObservable_1.RumPerformanceEntryType.FIRST_INPUT,
+        buffered: true,
+    }).subscribe((entries) => {
+        const firstInputEntry = entries.find((entry) => entry.startTime < firstHidden.timeStamp);
+        if (firstInputEntry) {
+            const firstInputDelay = (0, kubesense_browser_core_1.elapsed)(firstInputEntry.startTime, firstInputEntry.processingStart);
+            let firstInputTargetSelector;
+            if (firstInputEntry.target && (0, htmlDomUtils_1.isElementNode)(firstInputEntry.target)) {
+                firstInputTargetSelector = (0, getSelectorFromElement_1.getSelectorFromElement)(firstInputEntry.target, configuration.actionNameAttribute);
+            }
+            callback({
+                // Ensure firstInputDelay to be positive, see
+                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815
+                delay: firstInputDelay >= 0 ? firstInputDelay : 0,
+                time: firstInputEntry.startTime,
+                targetSelector: firstInputTargetSelector,
+            });
+        }
+    });
+    return {
+        stop: () => {
+            performanceFirstInputSubscription.unsubscribe();
+        },
+    };
+}
+//# sourceMappingURL=trackFirstInput.js.map

package/cjs/domain/view/viewMetrics/trackFirstInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackFirstInput.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackFirstInput.ts"],"names":[],"mappings":";;AAuBA,0CAmCC;AAzDD,8EAA2D;AAC3D,gEAA6D;AAE7D,kFAA6G;AAE7G,yEAAqE;AASrE;;;;;;;GAOG;AACH,SAAgB,eAAe,CAC7B,aAA+B,EAC/B,WAAwB,EACxB,QAA0C;IAE1C,MAAM,iCAAiC,GAAG,IAAA,mDAA2B,EAAC,aAAa,EAAE;QACnF,IAAI,EAAE,+CAAuB,CAAC,WAAW;QACzC,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QACvB,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAClC,CAAC,KAAK,EAAgC,EAAE,CAAC,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,CACjF,CAAA;QACD,IAAI,eAAe,EAAE,CAAC;YACpB,MAAM,eAAe,GAAG,IAAA,gCAAO,EAAC,eAAe,CAAC,SAAS,EAAE,eAAe,CAAC,eAAe,CAAC,CAAA;YAC3F,IAAI,wBAAwB,CAAA;YAE5B,IAAI,eAAe,CAAC,MAAM,IAAI,IAAA,4BAAa,EAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC;gBACpE,wBAAwB,GAAG,IAAA,+CAAsB,EAAC,eAAe,CAAC,MAAM,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAA;YAC9G,CAAC;YAED,QAAQ,CAAC;gBACP,6CAA6C;gBAC7C,gEAAgE;gBAChE,KAAK,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAE,CAAc;gBAC/D,IAAI,EAAE,eAAe,CAAC,SAAS;gBAC/B,cAAc,EAAE,wBAAwB;aACzC,CAAC,CAAA;QACJ,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,iCAAiC,CAAC,WAAW,EAAE,CAAA;QACjD,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/domain/view/viewMetrics/trackInitialViewMetrics.d.ts

@@ -0,0 +1,15 @@
+import type { ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../../configuration';
+import type { FirstInput } from './trackFirstInput';
+import type { NavigationTimings } from './trackNavigationTimings';
+import type { LargestContentfulPaint } from './trackLargestContentfulPaint';
+export interface InitialViewMetrics {
+    firstContentfulPaint?: Duration;
+    navigationTimings?: NavigationTimings;
+    largestContentfulPaint?: LargestContentfulPaint;
+    firstInput?: FirstInput;
+}
+export declare function trackInitialViewMetrics(configuration: RumConfiguration, viewStart: ClocksState, setLoadEvent: (loadEnd: Duration) => void, scheduleViewUpdate: () => void): {
+    stop: () => void;
+    initialViewMetrics: InitialViewMetrics;
+};

package/cjs/domain/view/viewMetrics/trackInitialViewMetrics.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackInitialViewMetrics = trackInitialViewMetrics;
+const trackFirstContentfulPaint_1 = require("./trackFirstContentfulPaint");
+const trackFirstInput_1 = require("./trackFirstInput");
+const trackNavigationTimings_1 = require("./trackNavigationTimings");
+const trackLargestContentfulPaint_1 = require("./trackLargestContentfulPaint");
+const trackFirstHidden_1 = require("./trackFirstHidden");
+function trackInitialViewMetrics(configuration, viewStart, setLoadEvent, scheduleViewUpdate) {
+    const initialViewMetrics = {};
+    const { stop: stopNavigationTracking } = (0, trackNavigationTimings_1.trackNavigationTimings)(configuration, (navigationTimings) => {
+        setLoadEvent(navigationTimings.loadEvent);
+        initialViewMetrics.navigationTimings = navigationTimings;
+        scheduleViewUpdate();
+    });
+    const firstHidden = (0, trackFirstHidden_1.trackFirstHidden)(configuration, viewStart);
+    const { stop: stopFCPTracking } = (0, trackFirstContentfulPaint_1.trackFirstContentfulPaint)(configuration, firstHidden, (firstContentfulPaint) => {
+        initialViewMetrics.firstContentfulPaint = firstContentfulPaint;
+        scheduleViewUpdate();
+    });
+    const { stop: stopLCPTracking } = (0, trackLargestContentfulPaint_1.trackLargestContentfulPaint)(configuration, firstHidden, window, (largestContentfulPaint) => {
+        initialViewMetrics.largestContentfulPaint = largestContentfulPaint;
+        scheduleViewUpdate();
+    });
+    const { stop: stopFIDTracking } = (0, trackFirstInput_1.trackFirstInput)(configuration, firstHidden, (firstInput) => {
+        initialViewMetrics.firstInput = firstInput;
+        scheduleViewUpdate();
+    });
+    function stop() {
+        stopNavigationTracking();
+        stopFCPTracking();
+        stopLCPTracking();
+        stopFIDTracking();
+        firstHidden.stop();
+    }
+    return {
+        stop,
+        initialViewMetrics,
+    };
+}
+//# sourceMappingURL=trackInitialViewMetrics.js.map

package/cjs/domain/view/viewMetrics/trackInitialViewMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackInitialViewMetrics.js","sourceRoot":"","sources":["../../../../src/domain/view/viewMetrics/trackInitialViewMetrics.ts"],"names":[],"mappings":";;AAkBA,0DA+CC;AA/DD,2EAAuE;AAEvE,uDAAmD;AAEnD,qEAAiE;AAEjE,+EAA2E;AAC3E,yDAAqD;AASrD,SAAgB,uBAAuB,CACrC,aAA+B,EAC/B,SAAsB,EACtB,YAAyC,EACzC,kBAA8B;IAE9B,MAAM,kBAAkB,GAAuB,EAAE,CAAA;IAEjD,MAAM,EAAE,IAAI,EAAE,sBAAsB,EAAE,GAAG,IAAA,+CAAsB,EAAC,aAAa,EAAE,CAAC,iBAAiB,EAAE,EAAE;QACnG,YAAY,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAA;QACzC,kBAAkB,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QACxD,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;IAEF,MAAM,WAAW,GAAG,IAAA,mCAAgB,EAAC,aAAa,EAAE,SAAS,CAAC,CAAA;IAC9D,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,qDAAyB,EAAC,aAAa,EAAE,WAAW,EAAE,CAAC,oBAAoB,EAAE,EAAE;QAC/G,kBAAkB,CAAC,oBAAoB,GAAG,oBAAoB,CAAA;QAC9D,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;IAEF,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,yDAA2B,EAC3D,aAAa,EACb,WAAW,EACX,MAAM,EACN,CAAC,sBAAsB,EAAE,EAAE;QACzB,kBAAkB,CAAC,sBAAsB,GAAG,sBAAsB,CAAA;QAClE,kBAAkB,EAAE,CAAA;IACtB,CAAC,CACF,CAAA;IAED,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,IAAA,iCAAe,EAAC,aAAa,EAAE,WAAW,EAAE,CAAC,UAAU,EAAE,EAAE;QAC3F,kBAAkB,CAAC,UAAU,GAAG,UAAU,CAAA;QAC1C,kBAAkB,EAAE,CAAA;IACtB,CAAC,CAAC,CAAA;IAEF,SAAS,IAAI;QACX,sBAAsB,EAAE,CAAA;QACxB,eAAe,EAAE,CAAA;QACjB,eAAe,EAAE,CAAA;QACjB,eAAe,EAAE,CAAA;QACjB,WAAW,CAAC,IAAI,EAAE,CAAA;IACpB,CAAC;IAED,OAAO;QACL,IAAI;QACJ,kBAAkB;KACnB,CAAA;AACH,CAAC"}