@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/cjs/domain/resource/resourceUtils.d.ts

@@ -1,8 +1,9 @@
-import type { Duration } from '@kubesense/kubesense-browser-core';
+import type { Duration } from '@kubesense/kubesense-js-core/time';
 import { ResourceType } from '@kubesense/kubesense-browser-core';
-import type { MatchOption } from '@kubesense/kubesense-browser-core';
-import type { RumPerformanceResourceTiming } from '../../browser/performanceObservable';
+import type { MatchOption } from '@kubesense/kubesense-js-core/configuration';
+import type { RumPerformanceNavigationTiming, RumPerformanceResourceTiming } from '../../browser/performanceObservable';
 import type { ResourceEntryDetailsElement, DeliveryType } from '../../rawRumEvent.types';
+export type ResourceLikeEntry = RumPerformanceResourceTiming | RumPerformanceNavigationTiming;
 export interface ResourceEntryDetails {
     worker?: ResourceEntryDetailsElement;
     redirect?: ResourceEntryDetailsElement;
@@ -12,32 +13,31 @@ export interface ResourceEntryDetails {
     first_byte?: ResourceEntryDetailsElement;
     download?: ResourceEntryDetailsElement;
 }
-export declare const FAKE_INITIAL_DOCUMENT = "initial_document";
-export declare function computeResourceEntryType(entry: RumPerformanceResourceTiming): ResourceType;
-export declare function isResourceEntryRequestType(entry: RumPerformanceResourceTiming): boolean;
-export declare function computeResourceEntryDuration(entry: RumPerformanceResourceTiming): Duration;
-export declare function computeResourceEntryDetails(entry: RumPerformanceResourceTiming): ResourceEntryDetails | undefined;
+export declare function computeResourceEntryType(entry: ResourceLikeEntry): ResourceType;
+export declare function isResourceEntryRequestType(entry: ResourceLikeEntry): entry is RumPerformanceResourceTiming;
+export declare function computeResourceEntryDuration(entry: ResourceLikeEntry): Duration;
+export declare function computeResourceEntryDetails(entry: ResourceLikeEntry): ResourceEntryDetails | undefined;
 /**
  * Entries with negative duration are unexpected and should be dismissed. The intake will ignore RUM
  * Resource events with negative durations anyway.
  * Since Chromium 128, more entries have unexpected negative durations, see
  * https://issues.chromium.org/issues/363031537
  */
-export declare function hasValidResourceEntryDuration(entry: RumPerformanceResourceTiming): boolean;
-export declare function hasValidResourceEntryTimings(entry: RumPerformanceResourceTiming): boolean;
+export declare function hasValidResourceEntryDuration(entry: ResourceLikeEntry): boolean;
+export declare function hasValidResourceEntryTimings(entry: ResourceLikeEntry): boolean;
 /**
  * The 'nextHopProtocol' is an empty string for cross-origin resources without CORS headers,
  * meaning the protocol is unknown, and we shouldn't report it.
  * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/nextHopProtocol#cross-origin_resources
  */
-export declare function computeResourceEntryProtocol(entry: RumPerformanceResourceTiming): string | undefined;
+export declare function computeResourceEntryProtocol(entry: ResourceLikeEntry): string | undefined;
 /**
  * Handles the 'deliveryType' property to distinguish between supported values ('cache', 'navigational-prefetch'),
  * undefined (unsupported in some browsers), and other cases ('other' for unknown or unrecognized values).
  * see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType
  */
-export declare function computeResourceEntryDeliveryType(entry: RumPerformanceResourceTiming): DeliveryType | undefined;
-export declare function computeResourceEntrySize(entry: RumPerformanceResourceTiming): {
+export declare function computeResourceEntryDeliveryType(entry: ResourceLikeEntry): DeliveryType | undefined;
+export declare function computeResourceEntrySize(entry: ResourceLikeEntry): {
     size: number | undefined;
     encoded_body_size: number | undefined;
     decoded_body_size: number | undefined;

package/cjs/domain/resource/resourceUtils.js

@@ -1,259 +1,361 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_RESOURCE_VALUE_CHAR_LENGTH = exports.FAKE_INITIAL_DOCUMENT = void 0;
-exports.computeResourceEntryType = computeResourceEntryType;
-exports.isResourceEntryRequestType = isResourceEntryRequestType;
-exports.computeResourceEntryDuration = computeResourceEntryDuration;
-exports.computeResourceEntryDetails = computeResourceEntryDetails;
-exports.hasValidResourceEntryDuration = hasValidResourceEntryDuration;
-exports.hasValidResourceEntryTimings = hasValidResourceEntryTimings;
-exports.computeResourceEntryProtocol = computeResourceEntryProtocol;
-exports.computeResourceEntryDeliveryType = computeResourceEntryDeliveryType;
-exports.computeResourceEntrySize = computeResourceEntrySize;
-exports.isAllowedRequestUrl = isAllowedRequestUrl;
-exports.computeResourceProvider = computeResourceProvider;
-exports.sanitizeIfLongDataUrl = sanitizeIfLongDataUrl;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-exports.FAKE_INITIAL_DOCUMENT = 'initial_document';
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_transport = require("@kubesense/kubesense-js-core/transport");
+//#region src/domain/resource/resourceUtils.ts
 const RESOURCE_TYPES = [
-    [kubesense_browser_core_1.ResourceType.DOCUMENT, (initiatorType) => exports.FAKE_INITIAL_DOCUMENT === initiatorType],
-    [kubesense_browser_core_1.ResourceType.XHR, (initiatorType) => 'xmlhttprequest' === initiatorType],
-    [kubesense_browser_core_1.ResourceType.FETCH, (initiatorType) => 'fetch' === initiatorType],
-    [kubesense_browser_core_1.ResourceType.BEACON, (initiatorType) => 'beacon' === initiatorType],
-    [kubesense_browser_core_1.ResourceType.CSS, (_, path) => /\.css$/i.test(path)],
-    [kubesense_browser_core_1.ResourceType.JS, (_, path) => /\.js$/i.test(path)],
-    [
-        kubesense_browser_core_1.ResourceType.IMAGE,
-        (initiatorType, path) => ['image', 'img', 'icon'].includes(initiatorType) || /\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null,
-    ],
-    [kubesense_browser_core_1.ResourceType.FONT, (_, path) => /\.(woff|eot|woff2|ttf)$/i.exec(path) !== null],
-    [
-        kubesense_browser_core_1.ResourceType.MEDIA,
-        (initiatorType, path) => ['audio', 'video'].includes(initiatorType) || /\.(mp3|mp4)$/i.exec(path) !== null,
-    ],
+	[_kubesense_kubesense_browser_core.ResourceType.DOCUMENT, (initiatorType) => "navigation" === initiatorType],
+	[_kubesense_kubesense_browser_core.ResourceType.XHR, (initiatorType) => "xmlhttprequest" === initiatorType],
+	[_kubesense_kubesense_browser_core.ResourceType.FETCH, (initiatorType) => "fetch" === initiatorType],
+	[_kubesense_kubesense_browser_core.ResourceType.BEACON, (initiatorType) => "beacon" === initiatorType],
+	[_kubesense_kubesense_browser_core.ResourceType.CSS, (_, path) => /\.css$/i.test(path)],
+	[_kubesense_kubesense_browser_core.ResourceType.JS, (_, path) => /\.js$/i.test(path)],
+	[_kubesense_kubesense_browser_core.ResourceType.IMAGE, (initiatorType, path) => [
+		"image",
+		"img",
+		"icon"
+	].includes(initiatorType) || /\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null],
+	[_kubesense_kubesense_browser_core.ResourceType.FONT, (_, path) => /\.(woff|eot|woff2|ttf)$/i.exec(path) !== null],
+	[_kubesense_kubesense_browser_core.ResourceType.MEDIA, (initiatorType, path) => ["audio", "video"].includes(initiatorType) || /\.(mp3|mp4)$/i.exec(path) !== null]
 ];
 function computeResourceEntryType(entry) {
-    const url = entry.name;
-    if (!(0, kubesense_browser_core_1.isValidUrl)(url)) {
-        return kubesense_browser_core_1.ResourceType.OTHER;
-    }
-    const path = (0, kubesense_browser_core_1.getPathName)(url);
-    for (const [type, isType] of RESOURCE_TYPES) {
-        if (isType(entry.initiatorType, path)) {
-            return type;
-        }
-    }
-    return kubesense_browser_core_1.ResourceType.OTHER;
+	const url = entry.name;
+	if (!(0, _kubesense_kubesense_js_core_util.isValidUrl)(url)) return _kubesense_kubesense_browser_core.ResourceType.OTHER;
+	const path = (0, _kubesense_kubesense_js_core_util.getPathName)(url);
+	for (const [type, isType] of RESOURCE_TYPES) if (isType(entry.initiatorType, path)) return type;
+	return _kubesense_kubesense_browser_core.ResourceType.OTHER;
 }
 function areInOrder(...numbers) {
-    for (let i = 1; i < numbers.length; i += 1) {
-        if (numbers[i - 1] > numbers[i]) {
-            return false;
-        }
-    }
-    return true;
+	for (let i = 1; i < numbers.length; i += 1) if (numbers[i - 1] > numbers[i]) return false;
+	return true;
 }
 function isResourceEntryRequestType(entry) {
-    return entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch';
+	return entry.initiatorType === "xmlhttprequest" || entry.initiatorType === "fetch";
 }
 function computeResourceEntryDuration(entry) {
-    const { duration, startTime, responseEnd } = entry;
-    // Safari duration is always 0 on timings blocked by cross origin policies.
-    if (duration === 0 && startTime < responseEnd) {
-        return (0, kubesense_browser_core_1.elapsed)(startTime, responseEnd);
-    }
-    return duration;
+	const { duration, startTime, responseEnd } = entry;
+	if (entry.initiatorType === "navigation" || duration === 0 && startTime < responseEnd) return (0, _kubesense_kubesense_js_core_time.elapsed)(startTime, responseEnd);
+	return duration;
 }
 function computeResourceEntryDetails(entry) {
-    if (!hasValidResourceEntryTimings(entry)) {
-        return undefined;
-    }
-    const { startTime, fetchStart, workerStart, redirectStart, redirectEnd, domainLookupStart, domainLookupEnd, connectStart, secureConnectionStart, connectEnd, requestStart, responseStart, responseEnd, } = entry;
-    const details = {
-        download: formatTiming(startTime, responseStart, responseEnd),
-        first_byte: formatTiming(startTime, requestStart, responseStart),
-    };
-    // Make sure a worker processing time is recorded
-    if (0 < workerStart && workerStart < fetchStart) {
-        details.worker = formatTiming(startTime, workerStart, fetchStart);
-    }
-    // Make sure a connection occurred
-    if (fetchStart < connectEnd) {
-        details.connect = formatTiming(startTime, connectStart, connectEnd);
-        // Make sure a secure connection occurred
-        if (connectStart <= secureConnectionStart && secureConnectionStart <= connectEnd) {
-            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);
-        }
-    }
-    // Make sure a domain lookup occurred
-    if (fetchStart < domainLookupEnd) {
-        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);
-    }
-    // Make sure a redirection occurred
-    if (startTime < redirectEnd) {
-        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);
-    }
-    return details;
+	if (!hasValidResourceEntryTimings(entry)) return;
+	const { startTime, fetchStart, workerStart, redirectStart, redirectEnd, domainLookupStart, domainLookupEnd, connectStart, secureConnectionStart, connectEnd, requestStart, responseStart, responseEnd } = entry;
+	const details = {
+		download: formatTiming(startTime, responseStart, responseEnd),
+		first_byte: formatTiming(startTime, requestStart, responseStart)
+	};
+	if (0 < workerStart && workerStart < fetchStart) details.worker = formatTiming(startTime, workerStart, fetchStart);
+	if (fetchStart < connectEnd) {
+		details.connect = formatTiming(startTime, connectStart, connectEnd);
+		if (connectStart <= secureConnectionStart && secureConnectionStart <= connectEnd) details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);
+	}
+	if (fetchStart < domainLookupEnd) details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);
+	if (startTime < redirectEnd) details.redirect = formatTiming(startTime, redirectStart, redirectEnd);
+	return details;
 }
 /**
- * Entries with negative duration are unexpected and should be dismissed. The intake will ignore RUM
- * Resource events with negative durations anyway.
- * Since Chromium 128, more entries have unexpected negative durations, see
- * https://issues.chromium.org/issues/363031537
- */
+* Entries with negative duration are unexpected and should be dismissed. The intake will ignore RUM
+* Resource events with negative durations anyway.
+* Since Chromium 128, more entries have unexpected negative durations, see
+* https://issues.chromium.org/issues/363031537
+*/
 function hasValidResourceEntryDuration(entry) {
-    return entry.duration >= 0;
+	return entry.duration >= 0;
 }
 function hasValidResourceEntryTimings(entry) {
-    // Ensure timings are in the right order. On top of filtering out potential invalid
-    // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be
-    // collected, for example cross origin requests without a "Timing-Allow-Origin" header allowing
-    // it.
-    const areCommonTimingsInOrder = areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd);
-    const areRedirectionTimingsInOrder = hasRedirection(entry)
-        ? areInOrder(entry.startTime, entry.redirectStart, entry.redirectEnd, entry.fetchStart)
-        : true;
-    return areCommonTimingsInOrder && areRedirectionTimingsInOrder;
+	const areCommonTimingsInOrder = areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd);
+	const areRedirectionTimingsInOrder = hasRedirection(entry) ? areInOrder(entry.startTime, entry.redirectStart, entry.redirectEnd, entry.fetchStart) : true;
+	return areCommonTimingsInOrder && areRedirectionTimingsInOrder;
 }
 function hasRedirection(entry) {
-    return entry.redirectEnd > entry.startTime;
+	return entry.redirectEnd > entry.startTime;
 }
 function formatTiming(origin, start, end) {
-    if (origin <= start && start <= end) {
-        return {
-            duration: (0, kubesense_browser_core_1.toServerDuration)((0, kubesense_browser_core_1.elapsed)(start, end)),
-            start: (0, kubesense_browser_core_1.toServerDuration)((0, kubesense_browser_core_1.elapsed)(origin, start)),
-        };
-    }
+	if (origin <= start && start <= end) return {
+		duration: (0, _kubesense_kubesense_js_core_time.toServerDuration)((0, _kubesense_kubesense_js_core_time.elapsed)(start, end)),
+		start: (0, _kubesense_kubesense_js_core_time.toServerDuration)((0, _kubesense_kubesense_js_core_time.elapsed)(origin, start))
+	};
 }
 /**
- * The 'nextHopProtocol' is an empty string for cross-origin resources without CORS headers,
- * meaning the protocol is unknown, and we shouldn't report it.
- * https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/nextHopProtocol#cross-origin_resources
- */
+* The 'nextHopProtocol' is an empty string for cross-origin resources without CORS headers,
+* meaning the protocol is unknown, and we shouldn't report it.
+* https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/nextHopProtocol#cross-origin_resources
+*/
 function computeResourceEntryProtocol(entry) {
-    return entry.nextHopProtocol === '' ? undefined : entry.nextHopProtocol;
+	return entry.nextHopProtocol === "" ? void 0 : entry.nextHopProtocol;
 }
 /**
- * Handles the 'deliveryType' property to distinguish between supported values ('cache', 'navigational-prefetch'),
- * undefined (unsupported in some browsers), and other cases ('other' for unknown or unrecognized values).
- * see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType
- */
+* Handles the 'deliveryType' property to distinguish between supported values ('cache', 'navigational-prefetch'),
+* undefined (unsupported in some browsers), and other cases ('other' for unknown or unrecognized values).
+* see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType
+*/
 function computeResourceEntryDeliveryType(entry) {
-    return entry.deliveryType === '' ? 'other' : entry.deliveryType;
+	return entry.deliveryType === "" ? "other" : entry.deliveryType;
 }
 function computeResourceEntrySize(entry) {
-    const { encodedBodySize, decodedBodySize, transferSize } = entry;
-    // Report sizes when:
-    // 1. Timing data is valid (same-origin, non-cached) — timings in order confirms sizes are real
-    // 2. Body sizes are non-zero even without valid timings — happens for memory/disk-cached
-    //    resources where browsers zero out responseStart but still expose body sizes
-    //
-    // We skip reporting when all sizes are 0 AND timings are invalid (cross-origin resources
-    // where the browser zeros everything out as a security restriction).
-    if (hasValidResourceEntryTimings(entry) || (decodedBodySize !== null && decodedBodySize !== void 0 ? decodedBodySize : 0) > 0 || (encodedBodySize !== null && encodedBodySize !== void 0 ? encodedBodySize : 0) > 0) {
-        return {
-            size: decodedBodySize,
-            encoded_body_size: encodedBodySize,
-            decoded_body_size: decodedBodySize,
-            transfer_size: transferSize,
-        };
-    }
-    return {
-        size: undefined,
-        encoded_body_size: undefined,
-        decoded_body_size: undefined,
-        transfer_size: undefined,
-    };
+	const { encodedBodySize, decodedBodySize, transferSize } = entry;
+	if (hasValidResourceEntryTimings(entry) || (decodedBodySize ?? 0) > 0 || (encodedBodySize ?? 0) > 0) return {
+		size: decodedBodySize,
+		encoded_body_size: encodedBodySize,
+		decoded_body_size: decodedBodySize,
+		transfer_size: transferSize
+	};
+	return {
+		size: void 0,
+		encoded_body_size: void 0,
+		decoded_body_size: void 0,
+		transfer_size: void 0
+	};
 }
 function isAllowedRequestUrl(url) {
-    return url && (!(0, kubesense_browser_core_1.isIntakeUrl)(url) || (0, kubesense_browser_core_1.isExperimentalFeatureEnabled)(kubesense_browser_core_1.ExperimentalFeature.TRACK_INTAKE_REQUESTS));
+	return url && (!(0, _kubesense_kubesense_js_core_transport.isIntakeUrl)(url) || (0, _kubesense_kubesense_browser_core.isExperimentalFeatureEnabled)(_kubesense_kubesense_browser_core.ExperimentalFeature.TRACK_INTAKE_REQUESTS));
 }
 const KNOWN_PROVIDERS = [
-    // Analytics
-    { domains: ['google-analytics.com', 'analytics.google.com'], name: 'Google Analytics', type: 'analytics' },
-    { domains: ['segment.com', 'segment.io', 'cdn.segment.com'], name: 'Segment', type: 'analytics' },
-    { domains: ['amplitude.com'], name: 'Amplitude', type: 'analytics' },
-    { domains: ['mixpanel.com'], name: 'Mixpanel', type: 'analytics' },
-    { domains: ['hotjar.com'], name: 'Hotjar', type: 'analytics' },
-    { domains: ['fullstory.com'], name: 'FullStory', type: 'analytics' },
-    { domains: ['heap.io'], name: 'Heap', type: 'analytics' },
-    // Tag Manager
-    { domains: ['googletagmanager.com'], name: 'Google Tag Manager', type: 'tag-manager' },
-    { domains: ['tealiumiq.com'], name: 'Tealium', type: 'tag-manager' },
-    // CDN
-    { domains: ['cloudfront.net'], name: 'Amazon CloudFront', type: 'cdn' },
-    { domains: ['fastly.net'], name: 'Fastly', type: 'cdn' },
-    { domains: ['akamaiedge.net', 'akamaistream.net', 'akamai.net'], name: 'Akamai', type: 'cdn' },
-    { domains: ['jsdelivr.net'], name: 'jsDelivr', type: 'cdn' },
-    { domains: ['unpkg.com'], name: 'unpkg', type: 'cdn' },
-    { domains: ['bootstrapcdn.com'], name: 'Bootstrap CDN', type: 'cdn' },
-    // Advertising
-    { domains: ['doubleclick.net'], name: 'Google DoubleClick', type: 'advertising' },
-    { domains: ['googlesyndication.com'], name: 'Google AdSense', type: 'advertising' },
-    { domains: ['adnxs.com'], name: 'AppNexus', type: 'advertising' },
-    { domains: ['criteo.com', 'criteo.net'], name: 'Criteo', type: 'advertising' },
-    // Social
-    { domains: ['facebook.com', 'fbcdn.net', 'connect.facebook.net'], name: 'Facebook', type: 'social' },
-    { domains: ['twitter.com', 'twimg.com', 'platform.twitter.com'], name: 'Twitter', type: 'social' },
-    { domains: ['linkedin.com'], name: 'LinkedIn', type: 'social' },
-    { domains: ['instagram.com', 'cdninstagram.com'], name: 'Instagram', type: 'social' },
-    { domains: ['pinterest.com'], name: 'Pinterest', type: 'social' },
-    // Video
-    { domains: ['youtube.com', 'youtu.be', 'ytimg.com', 'googlevideo.com'], name: 'YouTube', type: 'video' },
-    { domains: ['vimeo.com', 'vimeocdn.com'], name: 'Vimeo', type: 'video' },
-    { domains: ['wistia.com'], name: 'Wistia', type: 'video' },
-    // Marketing
-    { domains: ['hubspot.com', 'hs-scripts.com', 'hsforms.com'], name: 'HubSpot', type: 'marketing' },
-    { domains: ['marketo.com', 'mktoresp.com'], name: 'Marketo', type: 'marketing' },
-    { domains: ['mailchimp.com'], name: 'Mailchimp', type: 'marketing' },
-    // Customer Success
-    { domains: ['intercom.io', 'intercomcdn.com'], name: 'Intercom', type: 'customer-success' },
-    { domains: ['zendesk.com', 'zdassets.com'], name: 'Zendesk', type: 'customer-success' },
-    // Utility
-    { domains: ['stripe.com', 'js.stripe.com'], name: 'Stripe', type: 'utility' },
-    { domains: ['code.jquery.com'], name: 'jQuery', type: 'utility' },
-    { domains: ['recaptcha.net'], name: 'reCAPTCHA', type: 'utility' },
+	{
+		domains: ["google-analytics.com", "analytics.google.com"],
+		name: "Google Analytics",
+		type: "analytics"
+	},
+	{
+		domains: [
+			"segment.com",
+			"segment.io",
+			"cdn.segment.com"
+		],
+		name: "Segment",
+		type: "analytics"
+	},
+	{
+		domains: ["amplitude.com"],
+		name: "Amplitude",
+		type: "analytics"
+	},
+	{
+		domains: ["mixpanel.com"],
+		name: "Mixpanel",
+		type: "analytics"
+	},
+	{
+		domains: ["hotjar.com"],
+		name: "Hotjar",
+		type: "analytics"
+	},
+	{
+		domains: ["fullstory.com"],
+		name: "FullStory",
+		type: "analytics"
+	},
+	{
+		domains: ["heap.io"],
+		name: "Heap",
+		type: "analytics"
+	},
+	{
+		domains: ["googletagmanager.com"],
+		name: "Google Tag Manager",
+		type: "tag-manager"
+	},
+	{
+		domains: ["tealiumiq.com"],
+		name: "Tealium",
+		type: "tag-manager"
+	},
+	{
+		domains: ["cloudfront.net"],
+		name: "Amazon CloudFront",
+		type: "cdn"
+	},
+	{
+		domains: ["fastly.net"],
+		name: "Fastly",
+		type: "cdn"
+	},
+	{
+		domains: [
+			"akamaiedge.net",
+			"akamaistream.net",
+			"akamai.net"
+		],
+		name: "Akamai",
+		type: "cdn"
+	},
+	{
+		domains: ["jsdelivr.net"],
+		name: "jsDelivr",
+		type: "cdn"
+	},
+	{
+		domains: ["unpkg.com"],
+		name: "unpkg",
+		type: "cdn"
+	},
+	{
+		domains: ["bootstrapcdn.com"],
+		name: "Bootstrap CDN",
+		type: "cdn"
+	},
+	{
+		domains: ["doubleclick.net"],
+		name: "Google DoubleClick",
+		type: "advertising"
+	},
+	{
+		domains: ["googlesyndication.com"],
+		name: "Google AdSense",
+		type: "advertising"
+	},
+	{
+		domains: ["adnxs.com"],
+		name: "AppNexus",
+		type: "advertising"
+	},
+	{
+		domains: ["criteo.com", "criteo.net"],
+		name: "Criteo",
+		type: "advertising"
+	},
+	{
+		domains: [
+			"facebook.com",
+			"fbcdn.net",
+			"connect.facebook.net"
+		],
+		name: "Facebook",
+		type: "social"
+	},
+	{
+		domains: [
+			"twitter.com",
+			"twimg.com",
+			"platform.twitter.com"
+		],
+		name: "Twitter",
+		type: "social"
+	},
+	{
+		domains: ["linkedin.com"],
+		name: "LinkedIn",
+		type: "social"
+	},
+	{
+		domains: ["instagram.com", "cdninstagram.com"],
+		name: "Instagram",
+		type: "social"
+	},
+	{
+		domains: ["pinterest.com"],
+		name: "Pinterest",
+		type: "social"
+	},
+	{
+		domains: [
+			"youtube.com",
+			"youtu.be",
+			"ytimg.com",
+			"googlevideo.com"
+		],
+		name: "YouTube",
+		type: "video"
+	},
+	{
+		domains: ["vimeo.com", "vimeocdn.com"],
+		name: "Vimeo",
+		type: "video"
+	},
+	{
+		domains: ["wistia.com"],
+		name: "Wistia",
+		type: "video"
+	},
+	{
+		domains: [
+			"hubspot.com",
+			"hs-scripts.com",
+			"hsforms.com"
+		],
+		name: "HubSpot",
+		type: "marketing"
+	},
+	{
+		domains: ["marketo.com", "mktoresp.com"],
+		name: "Marketo",
+		type: "marketing"
+	},
+	{
+		domains: ["mailchimp.com"],
+		name: "Mailchimp",
+		type: "marketing"
+	},
+	{
+		domains: ["intercom.io", "intercomcdn.com"],
+		name: "Intercom",
+		type: "customer-success"
+	},
+	{
+		domains: ["zendesk.com", "zdassets.com"],
+		name: "Zendesk",
+		type: "customer-success"
+	},
+	{
+		domains: ["stripe.com", "js.stripe.com"],
+		name: "Stripe",
+		type: "utility"
+	},
+	{
+		domains: ["code.jquery.com"],
+		name: "jQuery",
+		type: "utility"
+	},
+	{
+		domains: ["recaptcha.net"],
+		name: "reCAPTCHA",
+		type: "utility"
+	}
 ];
 function computeResourceProvider(url, firstPartyDomains = []) {
-    if (!(0, kubesense_browser_core_1.isValidUrl)(url)) {
-        return undefined;
-    }
-    let hostname;
-    try {
-        hostname = (0, kubesense_browser_core_1.buildUrl)(url).hostname;
-    }
-    catch (_a) {
-        return undefined;
-    }
-    if (!hostname) {
-        return undefined;
-    }
-    // First-party: same hostname as the page, or matches configured firstPartyDomains
-    if (hostname === location.hostname || (firstPartyDomains.length > 0 && (0, kubesense_browser_core_1.matchList)(firstPartyDomains, hostname))) {
-        return { domain: hostname, type: 'first party' };
-    }
-    for (const provider of KNOWN_PROVIDERS) {
-        for (const domain of provider.domains) {
-            if (hostname === domain || hostname.endsWith(`.${domain}`)) {
-                return { domain: hostname, name: provider.name, type: provider.type };
-            }
-        }
-    }
-    // Unknown third-party
-    return { domain: hostname, type: 'other' };
+	if (!(0, _kubesense_kubesense_js_core_util.isValidUrl)(url)) return;
+	let hostname;
+	try {
+		hostname = (0, _kubesense_kubesense_js_core_util.buildUrl)(url).hostname;
+	} catch {
+		return;
+	}
+	if (!hostname) return;
+	if (hostname === location.hostname || firstPartyDomains.length > 0 && (0, _kubesense_kubesense_browser_core.matchList)(firstPartyDomains, hostname)) return {
+		domain: hostname,
+		type: "first party"
+	};
+	for (const provider of KNOWN_PROVIDERS) for (const domain of provider.domains) if (hostname === domain || hostname.endsWith(`.${domain}`)) return {
+		domain: hostname,
+		name: provider.name,
+		type: provider.type
+	};
+	return {
+		domain: hostname,
+		type: "other"
+	};
 }
 const DATA_URL_REGEX = /data:(.+)?(;base64)?,/g;
-exports.MAX_RESOURCE_VALUE_CHAR_LENGTH = 24000;
-function sanitizeIfLongDataUrl(url, lengthLimit = exports.MAX_RESOURCE_VALUE_CHAR_LENGTH) {
-    if (url.length <= lengthLimit || !url.startsWith('data:')) {
-        return url;
-    }
-    // truncate url first to a random length to prevent match error when the url is too long
-    const dataUrlMatchArray = url.substring(0, 100).match(DATA_URL_REGEX);
-    if (!dataUrlMatchArray) {
-        return url;
-    }
-    return `${dataUrlMatchArray[0]}[...]`;
+const MAX_RESOURCE_VALUE_CHAR_LENGTH = 24e3;
+function sanitizeIfLongDataUrl(url, lengthLimit = MAX_RESOURCE_VALUE_CHAR_LENGTH) {
+	if (url.length <= lengthLimit || !url.startsWith("data:")) return url;
+	const dataUrlMatchArray = url.substring(0, 100).match(DATA_URL_REGEX);
+	if (!dataUrlMatchArray) return url;
+	return `${dataUrlMatchArray[0]}[...]`;
 }
+//#endregion
+exports.MAX_RESOURCE_VALUE_CHAR_LENGTH = MAX_RESOURCE_VALUE_CHAR_LENGTH;
+exports.computeResourceEntryDeliveryType = computeResourceEntryDeliveryType;
+exports.computeResourceEntryDetails = computeResourceEntryDetails;
+exports.computeResourceEntryDuration = computeResourceEntryDuration;
+exports.computeResourceEntryProtocol = computeResourceEntryProtocol;
+exports.computeResourceEntrySize = computeResourceEntrySize;
+exports.computeResourceEntryType = computeResourceEntryType;
+exports.computeResourceProvider = computeResourceProvider;
+exports.hasValidResourceEntryDuration = hasValidResourceEntryDuration;
+exports.hasValidResourceEntryTimings = hasValidResourceEntryTimings;
+exports.isAllowedRequestUrl = isAllowedRequestUrl;
+exports.isResourceEntryRequestType = isResourceEntryRequestType;
+exports.sanitizeIfLongDataUrl = sanitizeIfLongDataUrl;
+
 //# sourceMappingURL=resourceUtils.js.map