@lenne.tech/ng-base 18.1.2 → 22.0.0

package/fesm2022/lenne.tech-ng-base-bug-capture-engine-TkjMDdqj.mjs

@@ -0,0 +1,1046 @@
+import { t as LT_BUG_UI_ATTRIBUTE } from "./lenne.tech-ng-base-bug-constants-Brm2KGHi.mjs";
+import { buildLtBugReport } from "./lenne.tech-ng-base-bug-report-Tzlhe1Cm.mjs";
+import { NavigationEnd } from "@angular/router";
+const LT_BUG_REDACTED = "[redacted]";
+const LT_BUG_SENSITIVE_HEADERS = Object.freeze([
+	"api-key",
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"set-cookie",
+	"x-access-token",
+	"x-api-key",
+	"x-auth-token",
+	"x-csrf-token",
+	"x-system-setup-token",
+	"x-xsrf-token"
+]);
+const LT_BUG_BODY_EXCLUDED_SEGMENTS = Object.freeze([
+	"auth",
+	"iam",
+	"login",
+	"logout",
+	"oauth",
+	"oauth2",
+	"passkey",
+	"reset-password",
+	"sign-in",
+	"sign-up",
+	"signin",
+	"signup",
+	"system-setup",
+	"token",
+	"two-factor",
+	"verify-email"
+]);
+const SENSITIVE_KEY_PARTS = [
+	"apikey",
+	"authorization",
+	"backupcode",
+	"cardnumber",
+	"cookie",
+	"credential",
+	"creditcard",
+	"passwd",
+	"password",
+	"privatekey",
+	"recoverycode",
+	"secret",
+	"signature",
+	"token",
+	"totp",
+	"twofactor",
+	"verificationcode"
+];
+const SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+	"auth",
+	"code",
+	"csc",
+	"cvc",
+	"cvv",
+	"iban",
+	"jwt",
+	"otp",
+	"pin",
+	"pwd",
+	"sessionid",
+	"sid",
+	"ssn"
+]);
+const SENSITIVE_HEADER_SET = new Set(LT_BUG_SENSITIVE_HEADERS);
+const BODY_EXCLUDED = new RegExp(`/(?:${LT_BUG_BODY_EXCLUDED_SEGMENTS.map((segment) => segment.replace(/[-/]/g, "\\$&")).join("|")})(?:[/?#;]|$)`, "i");
+const USERINFO = /\b([a-z][a-z\d+.-]*:\/\/)[^\s/?#@:]+:[^\s/?#@]+@/gi;
+const JWT = /\beyJ[\w-]{5,}\.[\w-]{5,}\.[\w-]*/g;
+const BEARER = /\b(Bearer)\s+(?=[\w\-.~+/]*[\d.\-_~+/])[\w\-.~+/]{8,}=*/g;
+const PATH_TOKEN = /(\/(?:activate|confirm-email|email-verification|invitation|invite|magic-link|reset-password|verify-email)\/)[^/?#\s"'<>]+/gi;
+const PARAM = /(^|[?&#;\s"'(,{]|%3[fF]|%26|%23)((?:[\w.\-~[\]]|%5[bBdD])+)(=|%3[dD])([^&#;\s"'<>)}]*?)(?=$|[&#;\s"'<>)}]|%26|%23)/g;
+const JSON_PAIR = /("((?:[^"\\]|\\.)*)"\s*:\s*)("(?:[^"\\]|\\.)*"|-?\d[\d.eE+-]*|true|false|null)/g;
+const JSON_PAIR_OPEN = /("((?:[^"\\]|\\.)*)"\s*:\s*)"(?:[^"\\]|\\.)*$/;
+const LABELLED = /\b(api[-_]?key|otp|passwd|password|secret|token)(\s*:\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi;
+function isLtSensitiveHeader(name) {
+	return SENSITIVE_HEADER_SET.has(name.trim().toLowerCase());
+}
+function isLtSensitiveKey(key) {
+	const decoded = safeDecode(key);
+	const normalized = (decoded.split(/[[\].]/).filter(Boolean).pop() ?? decoded).toLowerCase().replace(/[-_\s]/g, "");
+	return SENSITIVE_KEYS.has(normalized) || SENSITIVE_KEY_PARTS.some((part) => normalized.includes(part));
+}
+function isLtBodyExcludedUrl(url) {
+	const path = url.replace(/^[a-z][a-z\d+.-]*:\/\/[^/?#]*/i, "").split(/[?#]/)[0] ?? "";
+	return BODY_EXCLUDED.test(path);
+}
+function redactLtText(text) {
+	if (!text) return text;
+	let result = text.replace(USERINFO, `$1${LT_BUG_REDACTED}@`).replace(JWT, LT_BUG_REDACTED).replace(BEARER, `$1 ${LT_BUG_REDACTED}`).replace(PATH_TOKEN, `$1${LT_BUG_REDACTED}`);
+	result = redactParams(result, 0);
+	result = result.replace(JSON_PAIR, (match, prefix, key) => isLtSensitiveKey(key) ? `${prefix}"${LT_BUG_REDACTED}"` : match);
+	result = result.replace(JSON_PAIR_OPEN, (match, prefix, key) => isLtSensitiveKey(key) ? `${prefix}"${LT_BUG_REDACTED}"` : match);
+	return result.replace(LABELLED, `$1$2${LT_BUG_REDACTED}`);
+}
+function redactLtUrl(url) {
+	return redactLtText(url);
+}
+function redactLtValue(value, depth = 0) {
+	if (typeof value === "string") return redactLtText(value);
+	if (depth > 20 || value === null || typeof value !== "object") return depth > 20 ? LT_BUG_REDACTED : value;
+	if (Array.isArray(value)) return value.map((item) => redactLtValue(item, depth + 1));
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = isLtSensitiveKey(key) ? LT_BUG_REDACTED : redactLtValue(item, depth + 1);
+	return result;
+}
+function redactLtBody(body, maxLength = 1e3) {
+	const input = body.length > 2e4 ? body.slice(0, 2e4) : body;
+	const trimmed = input.trim();
+	let redacted;
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) try {
+		redacted = JSON.stringify(redactLtValue(JSON.parse(trimmed)));
+	} catch {
+		redacted = redactLtText(input);
+	}
+	else redacted = redactLtText(input);
+	return truncateLt(redacted, maxLength);
+}
+function redactLtHeaders(headers) {
+	const result = {};
+	for (const [name, value] of Object.entries(headers)) result[name] = isLtSensitiveHeader(name) ? LT_BUG_REDACTED : redactLtText(String(value));
+	return result;
+}
+function truncateLt(text, maxLength) {
+	return text.length <= maxLength ? text : `${text.slice(0, maxLength)}... [truncated ${text.length - maxLength} characters]`;
+}
+function redactParams(text, depth) {
+	return text.replace(PARAM, (match, separator, key, equals, value) => {
+		if (isLtSensitiveKey(key)) return `${separator}${key}${equals}${value ? LT_BUG_REDACTED : ""}`;
+		if (depth < 3 && /=|%3[dD]/.test(value)) return `${separator}${key}${equals}${redactParams(value, depth + 1)}`;
+		return match;
+	});
+}
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+const BROWSERS = [
+	{
+		name: "Edge",
+		regex: /Edg(?:e|A|iOS)?\/([\d.]+)/
+	},
+	{
+		name: "Opera",
+		regex: /(?:OPR|Opera)\/([\d.]+)/
+	},
+	{
+		name: "Firefox",
+		regex: /(?:Firefox|FxiOS)\/([\d.]+)/
+	},
+	{
+		name: "Chrome",
+		regex: /(?:Chrome|CriOS)\/([\d.]+)/
+	},
+	{
+		name: "Safari",
+		regex: /Version\/([\d.]+).*Safari/
+	}
+];
+const SYSTEMS = [
+	{
+		name: "Windows",
+		regex: /Windows NT ([\d.]+)/
+	},
+	{
+		name: "Android",
+		regex: /Android ([\d.]+)/
+	},
+	{
+		name: "iOS",
+		regex: /(?:iPhone|iPad|iPod).*? OS ([\d_]+)/
+	},
+	{
+		name: "macOS",
+		regex: /Mac OS X ([\d_.]+)/
+	},
+	{
+		name: "Linux",
+		regex: /Linux/
+	}
+];
+function detectLtBrowser(userAgent) {
+	for (const browser of BROWSERS) {
+		const match = browser.regex.exec(userAgent);
+		if (match) return {
+			name: browser.name,
+			version: match[1] ?? "Unknown"
+		};
+	}
+	return {
+		name: "Unknown",
+		version: "Unknown"
+	};
+}
+function detectLtOs(userAgent) {
+	for (const system of SYSTEMS) {
+		const match = system.regex.exec(userAgent);
+		if (match) return {
+			name: system.name,
+			version: match[1] ? match[1].replace(/_/g, ".") : "Unknown"
+		};
+	}
+	return {
+		name: "Unknown",
+		version: "Unknown"
+	};
+}
+function getLtBrowserInfo(view = typeof window === "undefined" ? void 0 : window) {
+	if (!view?.navigator) throw new TypeError("Browser info collection is only available in the browser");
+	const { document, location, navigator, screen } = view;
+	let timezone = "Unknown";
+	try {
+		timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown";
+	} catch {}
+	return {
+		browser: detectLtBrowser(navigator.userAgent ?? ""),
+		cookieEnabled: !!navigator.cookieEnabled,
+		language: navigator.language,
+		languages: navigator.languages?.length ? [...navigator.languages] : [navigator.language],
+		onLine: !!navigator.onLine,
+		os: detectLtOs(navigator.userAgent ?? ""),
+		performance: performanceInfo(view),
+		platform: navigator.platform ?? "",
+		referrer: document?.referrer ? redactLtUrl(document.referrer) : "",
+		screen: {
+			colorDepth: screen?.colorDepth ?? 0,
+			height: screen?.height ?? 0,
+			pixelDepth: screen?.pixelDepth ?? 0,
+			width: screen?.width ?? 0
+		},
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		timezone,
+		title: document?.title ?? "",
+		url: redactLtUrl(location?.href ?? ""),
+		userAgent: navigator.userAgent ?? "",
+		vendor: navigator.vendor ?? "",
+		viewport: {
+			height: view.innerHeight || document?.documentElement?.clientHeight || 0,
+			width: view.innerWidth || document?.documentElement?.clientWidth || 0
+		}
+	};
+}
+function performanceInfo(view) {
+	const performance = view.performance;
+	if (!performance?.getEntriesByType) return;
+	const navigation = performance.getEntriesByType("navigation")[0];
+	if (!navigation) return;
+	const paint = (name) => performance.getEntriesByName?.(name)[0]?.startTime ?? null;
+	return {
+		domComplete: navigation.domComplete,
+		domContentLoaded: navigation.domContentLoadedEventEnd - navigation.domContentLoadedEventStart,
+		firstContentfulPaint: paint("first-contentful-paint"),
+		firstPaint: paint("first-paint"),
+		loadTime: navigation.loadEventEnd - navigation.loadEventStart,
+		navigationStart: navigation.fetchStart,
+		responseEnd: navigation.responseEnd
+	};
+}
+var LtRingBuffer = class {
+	capacity;
+	items = [];
+	constructor(capacity) {
+		this.capacity = capacity;
+	}
+	get size() {
+		return this.items.length;
+	}
+	push(item) {
+		this.items.push(item);
+		if (this.items.length > this.capacity) this.items.splice(0, this.items.length - this.capacity);
+	}
+	toArray(limit = this.capacity) {
+		return this.items.slice(-Math.max(0, limit)).map((item) => item && typeof item === "object" ? { ...item } : item);
+	}
+	last() {
+		return this.items[this.items.length - 1];
+	}
+	clear() {
+		this.items = [];
+	}
+};
+const LEVELS = [
+	"log",
+	"info",
+	"warn",
+	"error",
+	"debug"
+];
+const MAX_PART_LENGTH = 2e3;
+const MAX_STACK_LENGTH = 5e3;
+var LtConsoleCapture = class {
+	target;
+	buffer;
+	originals = null;
+	wrappers = {};
+	removeListeners = null;
+	constructor(capacity, target = console) {
+		this.target = target;
+		this.buffer = new LtRingBuffer(capacity);
+	}
+	get installed() {
+		return this.originals !== null;
+	}
+	install(view) {
+		if (this.originals) return;
+		const target = this.target;
+		this.originals = {};
+		for (const level of LEVELS) {
+			const original = target[level];
+			if (typeof original !== "function") continue;
+			this.originals[level] = original;
+			const wrapper = (...args) => {
+				original.apply(this.target, args);
+				try {
+					this.record(level, args);
+				} catch {}
+			};
+			this.wrappers[level] = wrapper;
+			target[level] = wrapper;
+		}
+		if (view) {
+			const onError = (event) => queueMicrotask(() => {
+				if (!event.defaultPrevented) this.push({
+					level: "error",
+					message: [redactLtText(truncateLt(event.message || "Error", MAX_PART_LENGTH))],
+					stack: stackOf(event.error),
+					timestamp: now()
+				});
+			});
+			const onRejection = (event) => queueMicrotask(() => {
+				if (!event.defaultPrevented) this.push({
+					level: "error",
+					message: [serialize(event.reason)],
+					stack: stackOf(event.reason),
+					timestamp: now()
+				});
+			});
+			view.addEventListener("error", onError);
+			view.addEventListener("unhandledrejection", onRejection);
+			this.removeListeners = () => {
+				view.removeEventListener("error", onError);
+				view.removeEventListener("unhandledrejection", onRejection);
+			};
+		}
+	}
+	uninstall() {
+		if (!this.originals) return;
+		const target = this.target;
+		for (const level of LEVELS) {
+			const original = this.originals[level];
+			if (original && target[level] === this.wrappers[level]) target[level] = original;
+		}
+		this.originals = null;
+		this.wrappers = {};
+		this.removeListeners?.();
+		this.removeListeners = null;
+	}
+	entries(limit) {
+		return this.buffer.toArray(limit);
+	}
+	get size() {
+		return this.buffer.size;
+	}
+	clear() {
+		this.buffer.clear();
+	}
+	record(level, args) {
+		const entry = {
+			level,
+			message: withoutStyleArguments(args).map((arg) => serialize(arg)).filter((part) => part.length > 0),
+			timestamp: now()
+		};
+		if (level === "error") {
+			const error = args.find((arg) => arg instanceof Error);
+			if (error) entry.stack = stackOf(error);
+		}
+		this.push(entry);
+	}
+	push(entry) {
+		this.buffer.push(entry);
+	}
+};
+function serialize(arg) {
+	let text;
+	if (typeof arg === "string") text = arg.replace(/%c/g, "").replace(/\s+/g, " ").trim();
+	else if (arg instanceof Error) text = arg.message;
+	else try {
+		text = JSON.stringify(arg, null, 2) ?? String(arg);
+	} catch {
+		text = String(arg);
+	}
+	return truncateLt(redactLtText(text.length > 2e4 ? text.slice(0, 2e4) : text), MAX_PART_LENGTH);
+}
+function withoutStyleArguments(args) {
+	const [first, ...rest] = args;
+	if (typeof first !== "string" || !first.includes("%c")) return args;
+	const styles = first.match(/%c/g)?.length ?? 0;
+	return [first, ...rest.filter((arg, index) => index >= styles || typeof arg !== "string")];
+}
+function stackOf(error) {
+	const stack = error?.stack;
+	return typeof stack === "string" ? truncateLt(redactLtText(stack), MAX_STACK_LENGTH) : void 0;
+}
+function now() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+const DEDUPE_MS = 1e3;
+function ltWrapErrorHandler(handler, listener) {
+	const hadOwn = Object.prototype.hasOwnProperty.call(handler, "handleError");
+	const original = handler.handleError;
+	const wrapped = function(error) {
+		try {
+			listener(error);
+		} catch {}
+		original.call(this, error);
+	};
+	handler.handleError = wrapped;
+	return () => {
+		if (handler.handleError !== wrapped) return;
+		if (hadOwn) handler.handleError = original;
+		else delete handler.handleError;
+	};
+}
+function toLtBugErrorInfo(error, componentName, view) {
+	const candidate = error;
+	const message = typeof error === "string" ? error : typeof candidate?.message === "string" && candidate.message ? candidate.message : String(error ?? "Unknown error");
+	const stack = typeof candidate?.stack === "string" ? candidate.stack : void 0;
+	return {
+		componentName,
+		message: truncateLt(redactLtText(message), 1e3),
+		stack: stack ? truncateLt(redactLtText(stack), 5e3) : void 0,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		url: view?.location?.href ? redactLtUrl(view.location.href) : void 0,
+		userAgent: view?.navigator?.userAgent
+	};
+}
+var LtErrorCapture = class {
+	onError;
+	seen = /* @__PURE__ */ new WeakSet();
+	lastMessage = null;
+	cleanups = [];
+	view = null;
+	constructor(onError) {
+		this.onError = onError;
+	}
+	get installed() {
+		return this.cleanups.length > 0;
+	}
+	install(handler, view) {
+		if (this.installed) return;
+		this.view = view;
+		if (handler) this.cleanups.push(ltWrapErrorHandler(handler, (error) => this.report(error, "ErrorHandler")));
+		if (view) {
+			const onError = (event) => this.report(event.error ?? event.message, "window");
+			const onRejection = (event) => this.report(event.reason, "unhandledrejection");
+			view.addEventListener("error", onError);
+			view.addEventListener("unhandledrejection", onRejection);
+			this.cleanups.push(() => {
+				view.removeEventListener("error", onError);
+				view.removeEventListener("unhandledrejection", onRejection);
+			});
+		}
+		if (!this.cleanups.length) this.cleanups.push(() => void 0);
+	}
+	uninstall() {
+		while (this.cleanups.length) this.cleanups.pop()?.();
+		this.view = null;
+	}
+	report(error, componentName) {
+		if (error && typeof error === "object") {
+			if (this.seen.has(error)) return;
+			this.seen.add(error);
+		}
+		const info = toLtBugErrorInfo(error, componentName, this.view);
+		const at = Date.now();
+		if (this.lastMessage && this.lastMessage.message === info.message && at - this.lastMessage.at < DEDUPE_MS) return;
+		this.lastMessage = {
+			at,
+			message: info.message
+		};
+		this.onError(info, error);
+	}
+};
+const INTERACTIVE = "a,button,input,label,select,summary,textarea,[role=\"button\"],[role=\"checkbox\"],[role=\"link\"],[role=\"menuitem\"],[role=\"option\"],[role=\"switch\"],[role=\"tab\"]";
+const DIALOG = "[role=\"dialog\"],[role=\"alertdialog\"],dialog[open]";
+const SENSITIVE_AUTOCOMPLETE = /(^|\s)(cc-csc|cc-exp|cc-exp-month|cc-exp-year|cc-number|current-password|new-password|one-time-code)(\s|$)/i;
+const SENSITIVE_NAME_PARTS = [
+	"card",
+	"credit",
+	"cvc",
+	"cvv",
+	"iban",
+	"pin",
+	"secret",
+	"ssn",
+	"token"
+];
+const MODIFIER_KEYS = /* @__PURE__ */ new Set([
+	"Alt",
+	"AltGraph",
+	"Control",
+	"Meta",
+	"OS",
+	"Shift"
+]);
+const ERROR_DEDUPE_MS = 1e3;
+function isLtSensitiveField(element) {
+	if (!element || typeof element.getAttribute !== "function") return false;
+	const tag = element.tagName.toLowerCase();
+	if (tag !== "input" && tag !== "textarea" && tag !== "select" && !element.isContentEditable) return false;
+	const type = (element.getAttribute("type") ?? "").toLowerCase();
+	if (tag === "input" && (type === "password" || type === "hidden")) return true;
+	if (SENSITIVE_AUTOCOMPLETE.test(element.getAttribute("autocomplete") ?? "")) return true;
+	return [element.getAttribute("name") ?? "", element.id ?? ""].some((name) => !!name && (isLtSensitiveKey(name) || SENSITIVE_NAME_PARTS.some((part) => name.toLowerCase().includes(part))));
+}
+var LtJourneyCapture = class {
+	options;
+	buffer;
+	cleanups = [];
+	lastUrl = null;
+	lastError = null;
+	view = null;
+	constructor(options) {
+		this.options = options;
+		this.buffer = new LtRingBuffer(options.maxEvents);
+	}
+	get installed() {
+		return this.view !== null;
+	}
+	install(view, options) {
+		if (this.view || !this.options.enabled) return;
+		this.view = view;
+		const o = this.options;
+		const listen = (target, type, handler, capture = true) => {
+			const listenerOptions = {
+				capture,
+				passive: true
+			};
+			target.addEventListener(type, handler, listenerOptions);
+			this.cleanups.push(() => target.removeEventListener(type, handler, listenerOptions));
+		};
+		if (o.captureClicks) listen(view, "click", (event) => {
+			const element = this.eventElement(event, INTERACTIVE);
+			if (element) {
+				const description = describe(element);
+				this.record("click", description.target, description);
+			}
+		});
+		if (o.captureNavigation) {
+			this.recordNavigation(view.location?.href ?? "");
+			if (options.listenToHistory) {
+				const onHistory = () => this.recordNavigation(view.location?.href ?? "");
+				listen(view, "popstate", onHistory, false);
+				listen(view, "hashchange", onHistory, false);
+			}
+		}
+		if (o.captureFormInteractions) {
+			listen(view, "submit", (event) => {
+				const element = this.eventElement(event);
+				if (element) {
+					const description = describe(element);
+					this.record("form_submit", description.target, description);
+				}
+			});
+			listen(view, "change", (event) => this.recordField("form_change", event));
+		}
+		if (o.captureInputChanges) listen(view, "input", this.throttle((event) => this.recordField("input_change", event)));
+		if (o.captureHover) listen(view, "mouseover", this.throttle((event) => {
+			const element = this.eventElement(event, INTERACTIVE);
+			if (element) {
+				const description = describe(element);
+				this.record("hover", description.target, description);
+			}
+		}));
+		if (o.captureScroll) listen(view, "scroll", this.throttle(() => this.record("scroll", "window", { scrollPosition: Math.round(view.scrollY || view.document?.documentElement?.scrollTop || 0) })), false);
+		if (o.captureKeyboard) listen(view, "keydown", (event) => this.recordKey(event), false);
+		if (o.captureErrors) {
+			listen(view, "error", (event) => {
+				const error = event;
+				if (error.message || error.error) this.recordError(error.error instanceof Error ? error.error.message : error.message, error.filename);
+			}, false);
+			listen(view, "unhandledrejection", (event) => this.recordError(reasonMessage(event.reason)), false);
+		}
+		if (o.captureModalEvents) this.observeDialogs(view);
+	}
+	uninstall() {
+		while (this.cleanups.length) this.cleanups.pop()?.();
+		this.view = null;
+		this.lastUrl = null;
+	}
+	record(type, target, metadata) {
+		if (!this.options.enabled) return;
+		this.buffer.push({
+			metadata,
+			target: truncateLt(redactLtText(target), 200),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			type
+		});
+	}
+	recordNavigation(url) {
+		if (!this.options.captureNavigation || !url || url === this.lastUrl) return;
+		const fromUrl = this.lastUrl;
+		this.lastUrl = url;
+		const toUrl = redactLtUrl(url);
+		this.record("navigation", toUrl, {
+			...fromUrl ? { fromUrl: redactLtUrl(fromUrl) } : {},
+			toUrl,
+			url: toUrl
+		});
+	}
+	recordError(message, source) {
+		if (!this.options.captureErrors) return;
+		const at = Date.now();
+		if (this.lastError && this.lastError.message === message && at - this.lastError.at < ERROR_DEDUPE_MS) return;
+		this.lastError = {
+			at,
+			message
+		};
+		this.record("error", "window", {
+			errorMessage: truncateLt(redactLtText(message || "Error"), 500),
+			...source ? { url: redactLtUrl(source) } : {}
+		});
+	}
+	entries(limit) {
+		return this.buffer.toArray(limit);
+	}
+	get size() {
+		return this.buffer.size;
+	}
+	clear() {
+		this.buffer.clear();
+	}
+	recordField(type, event) {
+		const element = this.eventElement(event);
+		if (!element || ![
+			"input",
+			"select",
+			"textarea"
+		].includes(element.tagName.toLowerCase())) return;
+		if (type === "input_change" && element.tagName.toLowerCase() === "select") return;
+		const description = describe(element);
+		let value;
+		if (this.options.captureInputValues && !isLtSensitiveField(element)) {
+			const raw = element.value;
+			value = typeof raw === "string" && raw ? truncateLt(redactLtText(raw.slice(0, 200)), 50) : void 0;
+		}
+		this.record(type, description.target, {
+			...description,
+			...value ? { value } : {}
+		});
+	}
+	recordKey(event) {
+		if (!(event.ctrlKey || event.metaKey || event.altKey) || MODIFIER_KEYS.has(event.key)) return;
+		if (event.altKey && event.key.length === 1) return;
+		const target = event.target;
+		if (target && typeof target.closest === "function") {
+			if (target.closest(`[data-lt-bug-ui]`)) return;
+			if (isEditable(target) && (isLtSensitiveField(target) || event.altKey || !(event.ctrlKey || event.metaKey))) return;
+		}
+		this.record("keyboard", event.key, {
+			altKey: event.altKey,
+			ctrlKey: event.ctrlKey,
+			key: event.key,
+			metaKey: event.metaKey,
+			shiftKey: event.shiftKey
+		});
+	}
+	eventElement(event, selector) {
+		const target = event.target;
+		if (!target || typeof target.closest !== "function" || target.closest(`[data-lt-bug-ui]`)) return null;
+		return (selector ? target.closest(selector) : null) ?? target;
+	}
+	observeDialogs(view) {
+		const Observer = view.MutationObserver;
+		const body = view.document?.body;
+		if (!Observer || !body) return;
+		const open = /* @__PURE__ */ new Set();
+		const dialogsIn = (node) => {
+			if (node.nodeType !== 1) return [];
+			const element = node;
+			return [...element.matches(DIALOG) ? [element] : [], ...Array.from(element.querySelectorAll(DIALOG))].filter((dialog) => !dialog.closest(`[${LT_BUG_UI_ATTRIBUTE}]`));
+		};
+		const observer = new Observer((mutations) => {
+			for (const mutation of mutations) {
+				mutation.addedNodes.forEach((node) => dialogsIn(node).forEach((dialog) => {
+					if (!open.has(dialog)) {
+						open.add(dialog);
+						this.record("modal_open", dialogLabel(dialog), { tag: dialog.tagName.toLowerCase() });
+					}
+				}));
+				mutation.removedNodes.forEach((node) => dialogsIn(node).forEach((dialog) => {
+					if (open.delete(dialog)) this.record("modal_close", dialogLabel(dialog), { tag: dialog.tagName.toLowerCase() });
+				}));
+			}
+		});
+		observer.observe(body, {
+			childList: true,
+			subtree: true
+		});
+		this.cleanups.push(() => observer.disconnect());
+	}
+	throttle(handler) {
+		const delay = this.options.throttleRate;
+		let last = 0;
+		let timer = null;
+		let pending = null;
+		this.cleanups.push(() => {
+			if (timer) clearTimeout(timer);
+		});
+		return (event) => {
+			const now = Date.now();
+			if (now - last >= delay) {
+				last = now;
+				handler(event);
+				return;
+			}
+			pending = event;
+			timer ??= setTimeout(() => {
+				timer = null;
+				last = Date.now();
+				if (pending) {
+					handler(pending);
+					pending = null;
+				}
+			}, delay - (now - last));
+		};
+	}
+};
+function describe(element) {
+	const tag = element.tagName.toLowerCase();
+	const id = element.id || void 0;
+	const classes = element.classList?.length ? Array.from(element.classList).slice(0, 10) : void 0;
+	const ownText = (element.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 50);
+	const label = element.getAttribute("aria-label") ?? element.getAttribute("title") ?? "";
+	const text = ownText || label ? redactLtText(ownText || label) : void 0;
+	let target = tag;
+	if (id) target += `#${id}`;
+	if (classes?.length) target += `.${classes.slice(0, 3).join(".")}`;
+	target = truncateLt(target, 120);
+	return {
+		classes,
+		element: target,
+		id,
+		tag,
+		target,
+		text
+	};
+}
+function dialogLabel(dialog) {
+	const labelledBy = dialog.getAttribute("aria-labelledby");
+	const labelled = labelledBy ? dialog.ownerDocument?.getElementById(labelledBy.split(/\s+/)[0] ?? "")?.textContent : null;
+	return truncateLt(redactLtText((dialog.getAttribute("aria-label") ?? labelled ?? dialog.querySelector("h1,h2,h3")?.textContent ?? dialog.tagName.toLowerCase()).replace(/\s+/g, " ").trim()), 80);
+}
+function isEditable(element) {
+	const tag = element.tagName.toLowerCase();
+	return tag === "input" || tag === "textarea" || tag === "select" || !!element.isContentEditable;
+}
+function reasonMessage(reason) {
+	return reason instanceof Error ? reason.message : typeof reason === "string" ? reason : String(reason);
+}
+const STATIC_EXTENSIONS = [
+	".css",
+	".eot",
+	".gif",
+	".ico",
+	".jpeg",
+	".jpg",
+	".js",
+	".map",
+	".mjs",
+	".png",
+	".svg",
+	".ttf",
+	".webp",
+	".woff",
+	".woff2"
+];
+const MAX_RESPONSE_BYTES = 1e6;
+var LtNetworkCapture = class {
+	ignorePaths;
+	paused = false;
+	buffer;
+	restore = null;
+	constructor(capacity, ignorePaths = []) {
+		this.ignorePaths = ignorePaths;
+		this.buffer = new LtRingBuffer(capacity);
+	}
+	get installed() {
+		return this.restore !== null;
+	}
+	install(view) {
+		if (this.restore) return;
+		const restorers = [];
+		if (typeof view.fetch === "function") restorers.push(this.wrapFetch(view));
+		const proto = view.XMLHttpRequest?.prototype;
+		if (proto && typeof proto.open === "function" && typeof proto.send === "function") restorers.push(this.wrapXhr(view, proto));
+		this.restore = () => restorers.forEach((restore) => restore());
+	}
+	uninstall() {
+		this.restore?.();
+		this.restore = null;
+	}
+	entries(limit) {
+		return this.buffer.toArray(limit);
+	}
+	get size() {
+		return this.buffer.size;
+	}
+	clear() {
+		this.buffer.clear();
+	}
+	shouldCapture(url, view) {
+		if (this.paused || /^(data|blob):/i.test(url)) return false;
+		let pathname;
+		try {
+			pathname = new URL(url, view.location?.href || "http://localhost/").pathname;
+		} catch {
+			return true;
+		}
+		const lower = pathname.toLowerCase();
+		if (STATIC_EXTENSIONS.some((extension) => lower.endsWith(extension))) return false;
+		return !this.ignorePaths.some((path) => pathname === path || pathname.endsWith(path));
+	}
+	wrapFetch(view) {
+		const originalFetch = view.fetch;
+		const wrapped = async (...args) => {
+			const [input, init] = args;
+			const url = fetchUrl(input);
+			if (!this.shouldCapture(url, view)) return originalFetch.apply(view, args);
+			const request = isRequestLike(input) ? input : void 0;
+			const method = String(init?.method ?? request?.method ?? "GET").toUpperCase();
+			const excludeBody = isLtBodyExcludedUrl(url);
+			const requestHeaders = redactLtHeaders(headersToRecord(request?.headers, init?.headers));
+			const requestBody = excludeBody ? void 0 : bodyText(init?.body);
+			const startTime = Date.now();
+			try {
+				const response = await originalFetch.apply(view, args);
+				const entry = {
+					duration: Date.now() - startTime,
+					method,
+					requestBody,
+					requestHeaders,
+					responseHeaders: redactLtHeaders(headersToRecord(response.headers)),
+					status: response.status,
+					statusText: response.statusText,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					type: "fetch",
+					url: redactLtUrl(url)
+				};
+				this.buffer.push(entry);
+				if (!excludeBody) readResponseBody(response, entry);
+				return response;
+			} catch (error) {
+				this.buffer.push({
+					duration: Date.now() - startTime,
+					error: redactLtText(error instanceof Error ? error.message : String(error)),
+					method,
+					requestBody,
+					requestHeaders,
+					status: 0,
+					statusText: "Network Error",
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					type: "fetch",
+					url: redactLtUrl(url)
+				});
+				throw error;
+			}
+		};
+		view.fetch = wrapped;
+		return () => {
+			if (view.fetch === wrapped) view.fetch = originalFetch;
+		};
+	}
+	wrapXhr(view, proto) {
+		const shouldCapture = (url) => this.shouldCapture(url, view);
+		const isPaused = () => this.paused;
+		const record = (entry) => this.buffer.push(entry);
+		const infos = /* @__PURE__ */ new WeakMap();
+		const originalOpen = proto.open;
+		const originalSend = proto.send;
+		const originalSetRequestHeader = proto.setRequestHeader;
+		const open = function(method, url, ...rest) {
+			const urlString = String(url);
+			infos.set(this, {
+				capture: shouldCapture(urlString),
+				headers: {},
+				method: String(method).toUpperCase(),
+				url: urlString
+			});
+			return originalOpen.call(this, method, url, ...rest);
+		};
+		const setRequestHeader = function(name, value) {
+			const info = infos.get(this);
+			if (info) info.headers[name] = value;
+			return originalSetRequestHeader.call(this, name, value);
+		};
+		const send = function(body) {
+			const info = infos.get(this);
+			if (!info?.capture || isPaused()) return originalSend.call(this, body);
+			const excludeBody = isLtBodyExcludedUrl(info.url);
+			const requestBody = excludeBody ? void 0 : bodyText(body);
+			const startTime = Date.now();
+			this.addEventListener("loadend", () => {
+				const readable = this.responseType === "" || this.responseType === "text";
+				record({
+					duration: Date.now() - startTime,
+					...this.status === 0 ? { error: "Network Error" } : {},
+					method: info.method,
+					requestBody,
+					requestHeaders: redactLtHeaders(info.headers),
+					responseBody: !excludeBody && readable && this.responseText ? redactLtBody(this.responseText) : void 0,
+					responseHeaders: redactLtHeaders(parseHeaderBlock(this.getAllResponseHeaders())),
+					status: this.status,
+					statusText: this.statusText,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					type: "xhr",
+					url: redactLtUrl(info.url)
+				});
+			}, { once: true });
+			return originalSend.call(this, body);
+		};
+		proto.open = open;
+		proto.send = send;
+		proto.setRequestHeader = setRequestHeader;
+		return () => {
+			if (proto.open === open) proto.open = originalOpen;
+			if (proto.send === send) proto.send = originalSend;
+			if (proto.setRequestHeader === setRequestHeader) proto.setRequestHeader = originalSetRequestHeader;
+		};
+	}
+};
+function isRequestLike(input) {
+	return typeof input === "object" && input !== null && !(input instanceof URL) && typeof input.url === "string";
+}
+function fetchUrl(input) {
+	if (typeof input === "string") return input;
+	if (input instanceof URL) return input.href;
+	return isRequestLike(input) ? input.url : String(input ?? "");
+}
+function headersToRecord(...sources) {
+	const result = {};
+	for (const source of sources) {
+		if (!source) continue;
+		try {
+			new Headers(source).forEach((value, name) => result[name.toLowerCase()] = value);
+		} catch {}
+	}
+	return result;
+}
+function bodyText(body) {
+	if (body === null || body === void 0) return;
+	if (typeof body === "string") return redactLtBody(body);
+	if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return redactLtBody(body.toString());
+	if (typeof FormData !== "undefined" && body instanceof FormData) return "[FormData]";
+	if (typeof Blob !== "undefined" && body instanceof Blob) return `[Blob ${body.size} bytes]`;
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return `[binary ${body.byteLength} bytes]`;
+	return "[body not recorded]";
+}
+function readResponseBody(response, entry) {
+	const type = (response.headers.get("content-type") ?? "").toLowerCase();
+	const length = Number(response.headers.get("content-length") ?? 0);
+	if (!(!type || /json|text\/|xml|javascript|x-www-form-urlencoded|graphql/.test(type)) || type.includes("event-stream") || length > MAX_RESPONSE_BYTES || response.bodyUsed) return;
+	let clone;
+	try {
+		clone = response.clone();
+	} catch {
+		return;
+	}
+	clone.text().then((text) => {
+		if (text) entry.responseBody = redactLtBody(text);
+	}, () => void 0);
+}
+function parseHeaderBlock(block) {
+	const result = {};
+	for (const line of (block ?? "").split(/\r?\n/)) {
+		const index = line.indexOf(":");
+		if (index > 0) result[line.slice(0, index).trim().toLowerCase()] = line.slice(index + 1).trim();
+	}
+	return result;
+}
+function startLtBugCapture(deps) {
+	const { options, view } = deps;
+	const consoleCapture = options.enableConsoleLogs ? new LtConsoleCapture(options.maxConsoleLogs, view.console ?? console) : null;
+	consoleCapture?.install(view);
+	const networkCapture = options.enableNetworkRequests ? new LtNetworkCapture(options.maxNetworkRequests, [options.endpoint]) : null;
+	networkCapture?.install(view);
+	const journeyCapture = options.enableUserJourney && options.userJourney.enabled ? new LtJourneyCapture(options.userJourney) : null;
+	journeyCapture?.install(view, { listenToHistory: !deps.router });
+	const routerSubscription = journeyCapture && deps.router && options.userJourney.captureNavigation ? deps.router.events.subscribe((event) => {
+		if (event instanceof NavigationEnd) journeyCapture.recordNavigation(absoluteUrl(event.urlAfterRedirects, deps.baseUri || view.location.href));
+	}) : null;
+	const errorCapture = options.enableErrorBoundary ? new LtErrorCapture((info) => {
+		journeyCapture?.recordError(info.message);
+		deps.onError(info);
+	}) : null;
+	errorCapture?.install(deps.errorHandler, view);
+	const engine = {
+		browserInfo: () => {
+			try {
+				return getLtBrowserInfo(view);
+			} catch {
+				return null;
+			}
+		},
+		buildReport: (form, attachments, includes) => buildLtBugReport(form, attachments, includes, {
+			browserInfo: options.enableBrowserInfo ? () => getLtBrowserInfo(view) : void 0,
+			consoleLogs: consoleCapture ? () => engine.consoleLogs() : void 0,
+			networkRequests: networkCapture ? () => engine.networkRequests() : void 0,
+			userInteractions: journeyCapture ? () => engine.userJourney() : void 0
+		}),
+		consoleLogs: () => consoleCapture?.entries(options.maxConsoleLogs) ?? [],
+		networkRequests: () => networkCapture?.entries(options.maxNetworkRequests) ?? [],
+		record: (type, target, metadata) => journeyCapture?.record(type, target, metadata),
+		recordError: (message) => journeyCapture?.recordError(message),
+		reportError: (error, source) => errorCapture ? errorCapture.report(error, source) : deps.onError(toLtBugErrorInfo(error, source, view)),
+		setNetworkPaused: (paused) => {
+			if (networkCapture) networkCapture.paused = paused;
+		},
+		stop: () => {
+			consoleCapture?.uninstall();
+			networkCapture?.uninstall();
+			journeyCapture?.uninstall();
+			errorCapture?.uninstall();
+			routerSubscription?.unsubscribe();
+		},
+		userJourney: () => journeyCapture?.entries(options.userJourney.maxEvents) ?? []
+	};
+	return engine;
+}
+function absoluteUrl(routerUrl, base) {
+	try {
+		return new URL(routerUrl.replace(/^\//, ""), base).href;
+	} catch {
+		return routerUrl;
+	}
+}
+export { startLtBugCapture };
+
+//# sourceMappingURL=lenne.tech-ng-base-bug-capture-engine-TkjMDdqj.mjs.map