@incodetech/core 2.4.1-agentic.5 → 2.4.1-agentic.6

package/dist/tri.esm-DgtAka_v.esm.js

@@ -0,0 +1,2145 @@
+const e = class t {
+	constructor() {
+		this.t = !1;
+	}
+	static get instance() {
+		return t.i || (t.i = new t()), t.i;
+	}
+	get DEBUG() {
+		return this.t;
+	}
+	set DEBUG(t) {
+		this.t = t;
+	}
+	warn(t, e, ...n) {
+		this.t && this.o("warn", t, e, ...n);
+	}
+	error(t, e, ...n) {
+		this.t && this.o("error", t, e, ...n);
+	}
+	info(t, e, ...n) {
+		this.t && this.o("info", t, e, ...n);
+	}
+	fatal(t, e, n, ...i) {
+		this.o(t, e, n, ...i);
+	}
+	o(t, e, n, ...i) {
+		const r = e ? `[${e}]` : "", s = console?.[t];
+		s && s(`[IncodeTRI]${r} ${n}`, ...i);
+	}
+}.instance;
+const i = {
+	"fpSignalsLib.js": "1f626062235d1ff29a29b7bb884cd10ef94e8e02b9f23437bcea950632cfa5ea",
+	"fpSignalsLib.wasm": "e4c4a6b85995f38df0b11b459a670786e2786cc4e7e41535aa6977d81eb9fad7",
+	"fpSignalsLibSimd.js": "4b7ae308c1354368e9e48a719923806b70d1ed2c97dd05a6214f991039099c0e",
+	"fpSignalsLibSimd.wasm": "0d93b31577808d232ed2494825c09c071d0b5f0278c8070c3fc9dfe91af025f7"
+};
+var r = class extends Error {
+	constructor(t, e) {
+		super(e), this.name = "FpSignalsLoadError", this.reason = t;
+	}
+};
+async function s(t) {
+	const e = new URL(t).pathname.split("/").pop() ?? "", n = i[e];
+	if (!n) throw new r("integrity-mismatch", `fpSignals: no digest for ${e}`);
+	const s = globalThis.crypto?.subtle;
+	if (!s) throw new r("no-crypto-subtle", "fpSignals: crypto.subtle is unavailable, so the files cannot be verified. Serve the page over HTTPS.");
+	const o = await async function(t, e) {
+		try {
+			const e = await fetch(t);
+			if (!e.ok) throw new Error(`HTTP ${e.status}`);
+			return new Uint8Array(await e.arrayBuffer());
+		} catch (t) {
+			throw new r("network-or-csp", `fpSignals: ${e} could not be fetched: ${String(t)}`);
+		}
+	}(t, e);
+	if (function(t) {
+		let e = "";
+		for (const n of new Uint8Array(t)) e += n.toString(16).padStart(2, "0");
+		return e;
+	}(await s.digest("SHA-256", o)) !== n) throw new r("integrity-mismatch", `fpSignals: ${e} does not match the pinned build`);
+	return o;
+}
+var o;
+async function a(t) {
+	const e = t.replace(/\.wasm($|\?)/, ".js$1"), n = await async function(t) {
+		const e = await s(t), n = URL.createObjectURL(new Blob([e], { type: "text/javascript" }));
+		try {
+			return await import(
+				/* @vite-ignore */
+				/* webpackIgnore: true */
+				n
+);
+		} catch (t) {
+			throw new r("network-or-csp", `fpSignals: the verified glue could not be imported: ${String(t)}`);
+		} finally {
+			URL.revokeObjectURL(n);
+		}
+	}(e), i = n.Module ?? n.default;
+	if (!i) throw new Error(`Failed to import Module from ${e}`);
+	const o = await s(t), a = window.wasmArrayBuffer;
+	window.wasmArrayBuffer = o;
+	try {
+		return await i({ wasmBinary: o });
+	} finally {
+		window.wasmArrayBuffer = a;
+	}
+}
+(function(t) {
+	t[t.Device = 1] = "Device", t[t.Behaviour = 2] = "Behaviour", t[t.PID = 3] = "PID";
+})(o || (o = {}));
+var c = class {
+	constructor() {
+		this.wasmModule = null, this.signalsApi = null, this.usedSimd_ = !1;
+	}
+	async initialize(t, n, i = !0) {
+		if (this.signalsApi) return;
+		const r = i && !!n;
+		try {
+			this.wasmModule = await a(r ? n : t), this.usedSimd_ = r;
+		} catch (n) {
+			if (!r) throw n;
+			e.warn("FpSignals", "SIMD init error:", n), this.wasmModule = await a(t), this.usedSimd_ = !1;
+		}
+		this.signalsApi = new this.wasmModule.FpSignals();
+	}
+	get usedSimd() {
+		return this.usedSimd_;
+	}
+	isReady() {
+		return null !== this.signalsApi;
+	}
+	setHostInfo(t, e) {
+		this.api().shi(t, e);
+	}
+	async collect() {
+		const t = this.api();
+		for (; !t.ppf();) await new Promise((t) => setTimeout(t, 0));
+	}
+	setBehaviourCollectionEnabled(t) {
+		this.api().sbc(t);
+	}
+	getSignals(t) {
+		return this.api().gsd(t);
+	}
+	hasMethod(t) {
+		return "function" == typeof this.signalsApi?.[t];
+	}
+	getSignalsWithReason(t, e) {
+		const n = this.api();
+		return "function" == typeof n.gsr ? n.gsr(t, e) : n.gsd(t);
+	}
+	getBufferFill() {
+		const t = this.api();
+		if ("function" != typeof t.gbf) return null;
+		const e = t.gbf();
+		return "number" == typeof e && Number.isFinite(e) ? e : null;
+	}
+	setNextSequence(t) {
+		const e = this.api();
+		return "function" == typeof e.ssq && (e.ssq(t), !0);
+	}
+	setTabId(t) {
+		const e = this.api();
+		return "function" == typeof e.sti && (e.sti(t), !0);
+	}
+	setCapturePolicy(t) {
+		const e = this.api();
+		return "function" == typeof e.scp && (e.scp(JSON.stringify(t)), !0);
+	}
+	setUrlSanitizer(t) {
+		const e = this.api();
+		return "function" == typeof e.sus && (e.sus(t), !0);
+	}
+	addCustomEvent(t, e) {
+		const n = this.api();
+		return "function" == typeof n.ace && (n.ace(t, e), !0);
+	}
+	freeResources() {
+		this.signalsApi && (this.signalsApi.delete(), this.signalsApi = null), this.wasmModule = null;
+	}
+	api() {
+		if (!this.signalsApi) throw new Error("FpSignals has not been initialized");
+		return this.signalsApi;
+	}
+};
+function l(t, e) {
+	return !t || (t[e]?.enabled ?? !1);
+}
+function u(t, e, n) {
+	let i = t, r = e;
+	if ("devicepixelratiochange" === e) {
+		const t = window.devicePixelRatio;
+		i = window.matchMedia(`(resolution: ${t}dppx)`), r = "change";
+	}
+	i.addEventListener(r, n, {
+		capture: !0,
+		passive: !0
+	});
+}
+function h(t, e, n) {
+	let i = t, r = e;
+	if ("devicepixelratiochange" === e) {
+		const t = window.devicePixelRatio;
+		i = window.matchMedia(`(resolution: ${t}dppx)`), r = "change";
+	}
+	i.removeEventListener(r, n, { capture: !0 });
+}
+const f = globalThis.setTimeout.bind(globalThis);
+const d = globalThis.clearTimeout.bind(globalThis);
+function p(t, n) {
+	try {
+		return t();
+	} catch (t) {
+		e.warn("utils", "safeSync swallowed error:", t);
+	}
+}
+async function y(t) {
+	try {
+		return await t();
+	} catch (t) {
+		e.warn("utils", "safeAsync swallowed error:", t);
+	}
+}
+function v(t) {
+	return (e) => p(() => t(e));
+}
+function w(t) {
+	return (...n) => {
+		try {
+			t(...n);
+		} catch (t) {
+			e.warn("utils", "safeTimer swallowed error:", t);
+		}
+	};
+}
+function g(t, e) {
+	return f(w(t), e);
+}
+function m(t) {
+	if (null !== t) try {
+		d(t);
+	} catch (t) {
+		e.warn("utils", "safeClearTimeout swallowed error:", t);
+	}
+}
+const b = {
+	pointer: { events: {
+		pointer: ["pointerButtons"],
+		click: ["clicks"],
+		dblclick: ["dblclicks"],
+		contextmenu: ["contextmenus"]
+	} },
+	pointermove: { all: ["pointerMoves"] },
+	hover: { all: ["hover"] },
+	focus: { all: ["focus"] },
+	input: { all: ["input"] },
+	keystroke: { all: ["keys"] },
+	clipboard: { events: {
+		paste: ["paste"],
+		cut: ["cut"],
+		copy: ["copy"]
+	} },
+	form: { events: {
+		submit: ["submit"],
+		invalid: ["invalid"],
+		snapshot: ["snapshots"]
+	} },
+	change: { all: ["change"] },
+	selection: { all: ["selection"] },
+	scroll: { all: ["scroll"] },
+	wheel: { all: ["wheel"] },
+	viewportresize: { all: ["resize"] },
+	viewport: { events: {
+		orientationchange: ["screenOrientation"],
+		devicepixelratiochange: ["devicePixelRatio"]
+	} },
+	sensors: { events: {
+		motion: ["deviceMotion"],
+		orientation: ["deviceOrientation"],
+		light: ["ambientLight"]
+	} },
+	visibility: { all: ["visibility"] },
+	screen: { all: ["screenChanges"] },
+	networkconnection: { all: ["online"] }
+};
+const k = ["pointerButtons", "pointerMoves"];
+function S(t, e) {
+	return !0 === t[e]?.enabled;
+}
+function T(t, e, n) {
+	const i = t[e];
+	if (!i || !i.enabled) return !1;
+	return ("events" in i ? i.events : void 0)?.[n]?.enabled ?? !0;
+}
+function _(t) {
+	const e = [];
+	for (const n of Object.keys(b)) {
+		const i = b[n];
+		if ("all" in i) S(t, n) || e.push(...i.all);
+		else for (const r of Object.keys(i.events)) T(t, n, r) || e.push(...i.events[r]);
+	}
+	let n = !0;
+	for (const t of k) e.includes(t) || (n = !1);
+	return n && e.push("touch"), e;
+}
+let I = null;
+const E = /* @__PURE__ */ new Set([
+	"xmlhttprequest",
+	"fetch",
+	"beacon",
+	"navigation",
+	"script",
+	"link",
+	"css",
+	"img",
+	"iframe",
+	"video",
+	"audio"
+]);
+const A = /* @__PURE__ */ new Set([
+	"xmlhttprequest",
+	"fetch",
+	"beacon"
+]);
+function C(t, e) {
+	return e ? t : null;
+}
+function R(t, e) {
+	const n = t.responseStart > 0, i = n ? t.transferSize : null, r = n ? t.encodedBodySize : null, s = n ? t.decodedBodySize : null, o = n && t.nextHopProtocol || null, a = n && void 0 !== t.deliveryType ? t.deliveryType : null, c = t.responseStatus, l = void 0 !== c && 0 !== c ? c : null, u = {
+		name: "network_request",
+		timestamp: Date.now(),
+		performanceTime: t.startTime + t.duration,
+		url: e(t.name),
+		initiatorType: (h = t.initiatorType, E.has(h) ? h : "other"),
+		startTime: t.startTime,
+		durationMs: t.duration,
+		fetchStart: t.fetchStart,
+		domainLookupStart: C(t.domainLookupStart, n),
+		domainLookupEnd: C(t.domainLookupEnd, n),
+		connectStart: C(t.connectStart, n),
+		connectEnd: C(t.connectEnd, n),
+		secureConnectionStart: C(t.secureConnectionStart, n),
+		requestStart: C(t.requestStart, n),
+		responseStart: C(t.responseStart, n),
+		responseEnd: t.responseEnd,
+		transferSize: i,
+		encodedBodySize: r,
+		decodedBodySize: s,
+		nextHopProtocol: o,
+		deliveryType: a,
+		responseStatus: l
+	};
+	var h;
+	return Object.assign(u, function(t, e) {
+		return {
+			dnsLookupMs: C(t.domainLookupEnd - t.domainLookupStart, e),
+			tcpConnectMs: C(t.connectEnd - t.connectStart, e),
+			tlsHandshakeMs: C(t.connectEnd > 0 && t.secureConnectionStart > 0 ? t.connectEnd - t.secureConnectionStart : 0, e),
+			ttfbMs: C(t.responseStart - t.requestStart, e),
+			responseDownloadMs: C(t.responseEnd - t.responseStart, e)
+		};
+	}(t, n)), u;
+}
+function M() {}
+function $(t, e, n, i, r) {
+	return {
+		name: "navigation",
+		timestamp: Date.now(),
+		ts: performance.now(),
+		phase: t,
+		type: e,
+		from: n.from,
+		to: n.to,
+		timeOrigin: i,
+		timing: r
+	};
+}
+function P(t, e) {
+	if (t.firstElementChild) return t.firstElementChild;
+	let n = t;
+	for (; null !== n && n !== e;) {
+		if (n.nextElementSibling) return n.nextElementSibling;
+		n = n.parentElement;
+	}
+	return null;
+}
+function x(t, e) {
+	switch (t) {
+		case "FORM":
+			e.formCount++;
+			break;
+		case "INPUT":
+			e.inputCount++;
+			break;
+		case "BUTTON":
+			e.buttonCount++;
+			break;
+		case "A":
+			e.linkCount++;
+			break;
+		case "SELECT":
+			e.selectCount++;
+			break;
+		case "TEXTAREA":
+			e.textareaCount++;
+			break;
+		case "IFRAME":
+			e.iframeCount++;
+			break;
+		case "SCRIPT":
+			e.scriptCount++;
+			break;
+		case "IMG": e.imageCount++;
+	}
+}
+function z(t) {
+	let e = null, n = null, i = null;
+	function r() {
+		if (m(e), e = null, m(i), i = null, null !== n) {
+			const t = n;
+			n = null, p(() => window.cancelIdleCallback?.(t));
+		}
+	}
+	return {
+		schedule: function(s, o, a) {
+			r();
+			const c = function(t) {
+				if (!t) return null;
+				try {
+					return new URL(t, location.href).pathname;
+				} catch {
+					return null;
+				}
+			}(a);
+			e = g(() => {
+				e = null, function(t) {
+					const e = window;
+					"function" != typeof e.requestIdleCallback ? i = g(() => {
+						i = null, t();
+					}, 0) : n = e.requestIdleCallback(w(() => {
+						n = null, t();
+					}), { timeout: 2e3 });
+				}(() => function(e, n, i) {
+					const r = function(t = 2e4) {
+						const e = {
+							textLength: 0,
+							interactiveCount: 0,
+							scrollHeight: 0,
+							innerHeight: 0,
+							nodeCount: 0,
+							formCount: 0,
+							inputCount: 0,
+							buttonCount: 0,
+							linkCount: 0,
+							selectCount: 0,
+							textareaCount: 0,
+							iframeCount: 0,
+							scriptCount: 0,
+							imageCount: 0,
+							truncated: !1
+						}, n = document.documentElement;
+						let i = n;
+						for (; null !== i;) {
+							if (e.nodeCount >= t) {
+								e.truncated = !0;
+								break;
+							}
+							e.nodeCount++, x(i.tagName, e), i = P(i, n);
+						}
+						return e.textLength = document.body?.textContent?.length ?? 0, e.interactiveCount = document.querySelectorAll("input,button,a,select,textarea").length, e.scrollHeight = document.documentElement?.scrollHeight ?? 0, e.innerHeight = window.innerHeight, e;
+					}(), s = {
+						name: "page_complexity",
+						timestamp: Date.now(),
+						ts: performance.now(),
+						phase: e,
+						type: n,
+						path: i,
+						...r
+					};
+					t.push(s);
+				}(s, o, c));
+			}, "load" === s ? 1500 : 500);
+		},
+		dispose: r
+	};
+}
+function B() {
+	return function() {};
+}
+const L = {
+	pointer: {
+		create: B,
+		layer: "behavioral",
+		events: [
+			"pointer",
+			"click",
+			"dblclick",
+			"contextmenu"
+		]
+	},
+	pointermove: {
+		create: B,
+		layer: "behavioral"
+	},
+	focus: {
+		create: B,
+		layer: "behavioral"
+	},
+	input: {
+		create: B,
+		layer: "behavioral"
+	},
+	keystroke: {
+		create: B,
+		layer: "behavioral"
+	},
+	clipboard: {
+		create: B,
+		layer: "behavioral",
+		events: [
+			"paste",
+			"cut",
+			"copy"
+		]
+	},
+	form: {
+		create: B,
+		layer: "behavioral",
+		events: [
+			"submit",
+			"invalid",
+			"snapshot"
+		]
+	},
+	change: {
+		create: B,
+		layer: "behavioral"
+	},
+	selection: {
+		create: B,
+		layer: "behavioral"
+	},
+	tab: {
+		create: B,
+		layer: "session",
+		events: ["state", "count"]
+	},
+	visibility: {
+		create: B,
+		layer: "session"
+	},
+	navigation: {
+		create: function(t) {
+			let e = t.sanitizeUrl(document.referrer || "");
+			const n = z(t);
+			function i(i) {
+				t.push(i), e = i.to ?? "", n && "hide" !== i.phase && n.schedule(i.phase, i.type, i.to);
+			}
+			const r = v(() => {
+				const [e] = performance.getEntriesByType("navigation");
+				var n;
+				i($("load", e?.type ?? "navigate", {
+					from: document.referrer ? t.sanitizeUrl(document.referrer) : null,
+					to: t.sanitizeUrl(location.href)
+				}, performance.timeOrigin, e ? {
+					fetchStart: (n = e).fetchStart,
+					domainLookupStart: n.domainLookupStart,
+					domainLookupEnd: n.domainLookupEnd,
+					connectStart: n.connectStart,
+					connectEnd: n.connectEnd,
+					requestStart: n.requestStart,
+					responseStart: n.responseStart,
+					responseEnd: n.responseEnd,
+					domInteractive: n.domInteractive,
+					domContentLoadedEventStart: n.domContentLoadedEventStart,
+					domContentLoadedEventEnd: n.domContentLoadedEventEnd,
+					domComplete: n.domComplete,
+					loadEventStart: n.loadEventStart,
+					loadEventEnd: n.loadEventEnd,
+					redirectCount: n.redirectCount,
+					transferSize: n.transferSize,
+					encodedBodySize: n.encodedBodySize,
+					decodedBodySize: n.decodedBodySize
+				} : void 0));
+			}), s = v((n) => {
+				const r = n;
+				if (null === r.navigationType) return;
+				const s = t.sanitizeUrl(location.href);
+				s !== e && i($("change", r.navigationType, {
+					from: e,
+					to: s
+				}, performance.timeOrigin));
+			}), o = v(() => c("traverse")), a = v(() => c("hashchange"));
+			function c(n) {
+				const r = t.sanitizeUrl(location.href);
+				"hashchange" === n && r === e || i($("change", n, {
+					from: e,
+					to: r
+				}, performance.timeOrigin));
+			}
+			const l = history.pushState, f = history.replaceState, d = function(...t) {
+				const e = l.apply(this, t);
+				return p(() => c("push")), e;
+			}, y = function(...t) {
+				const e = f.apply(this, t);
+				return p(() => c("replace")), e;
+			};
+			return window.navigation ? u(window.navigation, "currententrychange", s) : (history.pushState = d, history.replaceState = y, u(window, "popstate", o), u(window, "hashchange", a)), "complete" === document.readyState ? r(new Event("load")) : u(window, "load", r), () => {
+				n?.dispose(), window.navigation ? h(window.navigation, "currententrychange", s) : (history.pushState === d && (history.pushState = l), history.replaceState === y && (history.replaceState = f), h(window, "popstate", o), h(window, "hashchange", a)), h(window, "load", r);
+			};
+		},
+		layer: "session"
+	},
+	networkconnection: {
+		create: B,
+		layer: "session"
+	},
+	scroll: {
+		create: B,
+		layer: "behavioral"
+	},
+	viewportresize: {
+		create: B,
+		layer: "behavioral"
+	},
+	viewport: {
+		create: B,
+		layer: "behavioral",
+		events: ["orientationchange", "devicepixelratiochange"]
+	},
+	sensors: {
+		create: B,
+		layer: "behavioral",
+		events: [
+			"motion",
+			"orientation",
+			"light"
+		]
+	},
+	"network-request": {
+		create: function(t) {
+			var n;
+			const i = function(t, n, i, r = A) {
+				if ("undefined" == typeof PerformanceObserver) return M;
+				let s = null;
+				try {
+					s = new PerformanceObserver((e) => {
+						for (const s of e.getEntries()) {
+							const e = s;
+							r.has(e.initiatorType) && (n(e.name) || t(R(e, i)));
+						}
+					}), s.observe({
+						type: "resource",
+						buffered: !0
+					});
+				} catch {
+					return e.warn("network-request", "PerformanceObserver failed to start"), M;
+				}
+				return function() {
+					s?.disconnect(), s = null;
+				};
+			}(function(e) {
+				p(() => t.push(e));
+			}, (n = t.ignoredOrigins, function(t) {
+				try {
+					return n.has(new URL(t).origin);
+				} catch {
+					return !1;
+				}
+			}), t.sanitizeUrl);
+			return function() {
+				i();
+			};
+		},
+		layer: "session"
+	},
+	screen: {
+		create: B,
+		layer: "session"
+	},
+	wheel: {
+		create: B,
+		layer: "behavioral"
+	},
+	hover: {
+		create: B,
+		layer: "behavioral"
+	},
+	fpsignals: {
+		create: function(t, i = "off", s) {
+			const a = l(s, "device"), f = l(s, "pid"), d = l(s, "behaviour"), g = performance.now(), m = new c();
+			let b, k = !1, S = !1, T = null, E = null, A = null, C = null, R = null, M = !1, $ = !1, P = null;
+			const x = new Promise(function(t) {
+				b = t;
+			});
+			function z() {
+				const e = t.getTabId();
+				e && e !== P && m.setTabId(e) && (P = e);
+			}
+			function B(e, n) {
+				if (!S || !m.isReady()) return null;
+				z();
+				const i = t.peekNextSequence(), r = m.setNextSequence(i), s = [];
+				let o = !1;
+				try {
+					const s = n ? m.getSignalsWithReason(e, n) : m.getSignals(e);
+					return o = function(e, n, i) {
+						if (!e) return !1;
+						const r = {
+							name: "fp_signals",
+							timestamp: Date.now(),
+							signals: e
+						};
+						return n && (r.reason = n), void 0 !== i && (r.seq = i), t.push(r), !0;
+					}(s, n, r ? i : void 0), o ? s : null;
+				} finally {
+					!o && s.length > 0 && p(() => {});
+				}
+			}
+			function L(t) {
+				return !!d && null !== B(o.Behaviour, t);
+			}
+			function q(t) {
+				return p(() => B(t)) ?? null;
+			}
+			function D() {
+				null !== A && clearInterval(A), null !== C && clearTimeout(C), A = null, C = null;
+			}
+			function O(t = "partial") {
+				return !(!a || M || $ || !S || !m.isReady() || !m.hasMethod("gsr") || null === B(o.Device, t) || (M = !0, D(), 0));
+			}
+			function F() {
+				a && m.hasMethod("gsr") && (A = setInterval(w(function() {
+					O();
+				}), 250), C = setTimeout(w(D), 5e3));
+			}
+			function j() {
+				if (!S || !m.isReady()) return;
+				const t = m.getBufferFill();
+				null !== t && t >= .5 && L("fill");
+			}
+			function U() {}
+			function N() {
+				m.setUrlSanitizer(null);
+			}
+			I = x;
+			const H = v((e) => {
+				("click" !== e.type || e.target instanceof Element && e.target.closest("[data-tri-flush]")) && (L("click" === e.type ? "flush-click" : "submit"), t.flush());
+			}), J = t.registerBehaviourReader ? t.registerBehaviourReader(function(t) {
+				const e = p(() => O("partial-now")) ?? !1, n = p(() => L(t)) ?? !1;
+				return e || n;
+			}) : null;
+			return y(async () => {
+				const s = await ("object" != typeof WebAssembly || null === WebAssembly ? Promise.resolve("no-webassembly") : new Promise(function(t) {
+					let i = !1;
+					R = function() {
+						i || (i = !0, clearTimeout(s), t("timeout"));
+					};
+					const s = setTimeout(w(function() {
+						i || (i = !0, t("timeout"));
+					}), 3e4);
+					function o(e) {
+						i ? null === e && p(() => m.freeResources()) : (i = !0, clearTimeout(s), t(e));
+					}
+					m.initialize("https://cdn.incodesmile.com/ml-wasm-kit-release/v2.14.54-pre1-fpsignals9/fpSignals/fpSignalsLib.wasm", "https://cdn.incodesmile.com/ml-wasm-kit-release/v2.14.54-pre1-fpsignals9/fpSignals/fpSignalsLibSimd.wasm").then(function() {
+						o(null);
+					}, function(t) {
+						e.warn("fpSignals", "module failed to load:", t), o(function(t) {
+							return t instanceof r ? t.reason : "instantiate-failed";
+						}(t));
+					});
+				}));
+				if (k || p(() => function(e) {
+					const n = null === e, i = {
+						name: "fp_signals_load",
+						timestamp: Date.now(),
+						loadMs: Math.max(0, performance.now() - g),
+						simd: n && m.usedSimd,
+						ok: n
+					};
+					null !== e && (i.reason = e), t.push(i);
+				}(s)), null !== s) return;
+				if (k) return void m.freeResources();
+				if (S = !0, p(() => m.setHostInfo(t.host.platform, t.host.version)), p(z), p(() => m.setUrlSanitizer(function(e) {
+					return t.sanitizeUrl(e);
+				})), p(() => {
+					return m.setCapturePolicy({
+						v: 2,
+						element: t.captureElementLevel,
+						content: i,
+						ignore: ["[data-tri-ignore]"],
+						redact: ["[data-tri-redact]"],
+						redactAttrsAttribute: "data-tri-redact-attrs",
+						interactive: ["[data-tri-interactive]"],
+						off: (e = t.collectorSelection) ? _(e) : []
+					});
+					var e;
+				}), p(U), d && (p(() => m.setBehaviourCollectionEnabled(!0)), T = setInterval(w(function() {
+					L("interval");
+				}), 2e3), m.hasMethod("gbf") && (E = setInterval(w(j), 1e3)), u(document, "submit", H), u(document, "click", H)), !a && !f) return;
+				if (p(F), await m.collect(), $ = !0, D(), k) return;
+				const c = a ? q(o.Device) : null, l = f ? q(o.PID) : null;
+				b({
+					pid: l,
+					device: c
+				});
+			}).then(function() {
+				b(null);
+			}), function() {
+				k = !0, R?.(), b(null), I === x && (I = null), null !== T && clearInterval(T), null !== E && clearInterval(E), D(), h(document, "submit", H), h(document, "click", H), J?.(), p(() => {}), p(() => {
+					L("stop");
+				}), p(() => {}), S && p(N), p(() => m.freeResources());
+			};
+		},
+		layer: "device-fingerprinting",
+		events: [
+			"device",
+			"pid",
+			"behaviour"
+		]
+	}
+};
+const q = Object.keys(L);
+const D = [
+	/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+	/^0b[01]+$/i,
+	/^0o[0-7]+$/i,
+	/^0x[0-9a-f]+$/i,
+	/^[a-z][a-z0-9]{1,12}:[A-Za-z0-9+/=_-]{6,}$/i,
+	/^[a-z]{2,8}_(?=.*\d)[A-Za-z0-9]{3,}$/,
+	/^\d{4,}$/,
+	/@/,
+	/^[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{10,}$/,
+	/^[A-Za-z0-9_-]{20,}={0,2}$/,
+	/^[0-9a-f]{7,}$/i
+];
+function O(t) {
+	try {
+		const e = new URL(t, location.href);
+		e.username = "", e.password = "", e.hash = "";
+		const n = [...e.searchParams.keys()], i = n.length > 0 ? "?" + n.map((t) => `${encodeURIComponent(t)}=<redacted>`).join("&") : "";
+		e.search = "", e.pathname = e.pathname.split("/").map((t) => "" !== t && function(t) {
+			for (const e of D) if (e.test(t)) return !0;
+			return !1;
+		}(t) ? ":param" : t).join("/");
+		const r = e.origin + e.pathname + i;
+		return r.length > 2048 ? r.slice(0, 2048) : r;
+	} catch {
+		return "";
+	}
+}
+const F = "idle";
+const j = "ready";
+const U = "started";
+const N = "collection-disabled";
+const H = "init-failed";
+const J = {
+	flush: {
+		intervalMs: 2e3,
+		maxIntervalMs: 3e4,
+		size: 50,
+		backoffFailureThreshold: 2
+	},
+	queue: { size: 100 }
+};
+const K = "redact";
+function V() {
+	const t = {};
+	for (const e of q) t[e] = W(e, void 0, !0);
+	return t;
+}
+function Z(t) {
+	const e = {};
+	for (const n of q) e[n] = W(n, void 0, t[L[n].layer] ?? !1);
+	return e;
+}
+function G(t) {
+	for (const n of Object.keys(t)) -1 === q.indexOf(n) && e.fatal("warn", "SDK", `collectors has an unknown key '${n}' — ignored. Known collectors: ${q.join(", ")}.`);
+	const n = {};
+	for (const e of q) {
+		const i = t[e];
+		n[e] = W(e, i, i?.enabled ?? !1);
+	}
+	return n;
+}
+function W(t, e, n) {
+	const i = L[t]?.events ?? [];
+	if (0 === i.length) return { enabled: n };
+	const r = e?.events, s = {};
+	for (const t of i) s[t] = { enabled: r?.[t] ?? !0 };
+	return {
+		enabled: n,
+		events: s
+	};
+}
+function X(t) {
+	if (!t) return null;
+	const e = t.split(".")[1], n = atob(e.replace(/-/g, "+").replace(/_/g, "/"));
+	return JSON.parse(n);
+}
+const Q = function(t, e = 30) {
+	if (!t) return !0;
+	const n = X(t);
+	return !n || "number" != typeof n.exp || 1e3 * n.exp <= Date.now() + 1e3 * e;
+};
+async function Y(t, e) {
+	return globalThis.navigator && "locks" in globalThis.navigator && "request" in globalThis.navigator.locks && "query" in globalThis.navigator.locks ? navigator.locks.request(t, { mode: "exclusive" }, async () => y(e)) : y(e);
+}
+function tt(t) {
+	function e() {
+		return globalThis.window && globalThis.window[t] && void 0 !== globalThis.window[t];
+	}
+	return {
+		get: function(n) {
+			if (!e()) return null;
+			try {
+				const e = window[t].getItem(n) ?? "null";
+				return "null" === e ? null : JSON.parse(e);
+			} catch {
+				return null;
+			}
+		},
+		set: function(n, i) {
+			e() && p(() => window[t].setItem(n, JSON.stringify(i)));
+		},
+		remove: function(n) {
+			e() && p(() => window[t].removeItem(n));
+		},
+		key: function(n) {
+			return e() ? window[t].key(n) : null;
+		},
+		get length() {
+			return e() ? window[t].length : 0;
+		}
+	};
+}
+const et = tt("localStorage");
+const nt = tt("sessionStorage");
+const it = "__tri";
+const rt = `${it}_activity_token`;
+const st = `${it}_activity_id`;
+const ot = `${it}_activity_status`;
+const at = "__tri_activity_lock";
+var ct = class {
+	constructor(t) {
+		this.context = t, this.l = null, this.u = null, this.h = null, this.p = null, this.m = null, this.k = !1;
+	}
+	getToken() {
+		return this.l;
+	}
+	getActivityId() {
+		return this.u ?? "";
+	}
+	isActive() {
+		return "ACTIVE" === this.h && null !== this.l;
+	}
+	async start() {
+		return this.k = !0, this.p || (this.p = this.S()), this.p;
+	}
+	async stop() {
+		const t = this.T();
+		this.m = t;
+		try {
+			await t;
+		} finally {
+			this.m === t && (this.m = null);
+		}
+	}
+	async T() {
+		this.k = !1, this.h = "INACTIVE", this._(null), this.p = null, this.l && await this.context.stopActivity(), this.I(null);
+	}
+	async refresh() {
+		if (!this.k) return;
+		const t = this.l;
+		await Y(at, async () => {
+			if (this.l && this.l !== t && !Q(this.l) && "ACTIVE" === this.h) return;
+			const e = this.A();
+			e && e.token !== t && !Q(e.token) && "ACTIVE" === e.activityStatus ? this.I(e) : (this.C(), await this.R());
+		});
+	}
+	async S() {
+		try {
+			if (this.m && await this.m, this.l && !Q(this.l)) return;
+			await Y(at, async () => {
+				await this.R();
+			});
+		} finally {
+			this.p = null;
+		}
+	}
+	async R() {
+		const t = this.A();
+		if (t && !Q(t.token) && "ACTIVE" === t.activityStatus) return void this.I(t);
+		t && this.C();
+		const e = await this.context.startActivity();
+		if (!e.ok) return;
+		if (!e.data.token) return;
+		const n = e.data;
+		this.I(n), this.M(n);
+	}
+	A() {
+		const [t, e, n] = [
+			et.get(rt),
+			et.get(st),
+			et.get(ot)
+		];
+		return t && e && n ? {
+			token: t,
+			activityId: e,
+			activityStatus: n
+		} : ((t || e || n) && this.C(), null);
+	}
+	M(t) {
+		et.set(rt, t.token), et.set(st, t.activityId), et.set(ot, t.activityStatus);
+	}
+	C() {
+		this._(null), this.I(null);
+	}
+	_(t) {
+		if (!t) return et.remove(rt), et.remove(st), void et.remove(ot);
+		et.set(rt, t.token), et.set(st, t.activityId), et.set(ot, t.activityStatus);
+	}
+	I(t) {
+		if (!t) return this.l = null, this.u = null, void (this.h = null);
+		this.l = t.token, this.u = t.activityId, this.h = t.activityStatus;
+	}
+};
+const lt = [
+	401,
+	403,
+	409
+];
+const ut = Object.freeze({
+	tab: 80,
+	navigation: 80,
+	page_complexity: 80,
+	fp_signals: 80,
+	fp_signals_load: 80,
+	network_request: 60
+});
+function ht(t) {
+	return ut[t.name];
+}
+const ft = Object.freeze({
+	tri: "/events/capture",
+	"fp-signals": "/events/capture/fp-signals"
+});
+const dt = /* @__PURE__ */ new Map([["fp_signals", "fp-signals"]]);
+function pt(t) {
+	return dt.get(t.name) ?? "tri";
+}
+const yt = new Array(256);
+for (let t = 0; t < 256; t++) yt[t] = (t + 256).toString(16).slice(1);
+const vt = /* @__PURE__ */ new Uint8Array(16);
+function wt(t) {
+	return yt[t[0]] + yt[t[1]] + yt[t[2]] + yt[t[3]] + "-" + yt[t[4]] + yt[t[5]] + "-" + yt[t[6]] + yt[t[7]] + "-" + yt[t[8]] + yt[t[9]] + "-" + yt[t[10]] + yt[t[11]] + yt[t[12]] + yt[t[13]] + yt[t[14]] + yt[t[15]];
+}
+function gt() {
+	return crypto.randomUUID();
+}
+function mt() {
+	return crypto.getRandomValues(vt), vt[6] = 15 & vt[6] | 64, vt[8] = 63 & vt[8] | 128, wt(vt);
+}
+function bt() {
+	for (let t = 0; t < 16; t++) vt[t] = 256 * Math.random() | 0;
+	return vt[6] = 15 & vt[6] | 64, vt[8] = 63 & vt[8] | 128, wt(vt);
+}
+const kt = function() {
+	if ("undefined" != typeof crypto) {
+		if ("function" == typeof crypto.randomUUID) return gt;
+		if ("function" == typeof crypto.getRandomValues) return mt;
+	}
+	return bt;
+}();
+function St() {
+	return kt();
+}
+var Tt = class {
+	constructor(t, e) {
+		this.$ = t, this.P = e, this.B = [], this.L = null, this.q = [], this.D = null, this.k = !1, this.O = !0, this.F = 0, this.j = 0, this.U = 0, this.N = function(t = 0) {
+			let e = t;
+			return {
+				peek: function() {
+					return e;
+				},
+				next: function() {
+					return e++;
+				},
+				claim: function(t) {
+					return !(!Number.isInteger(t) || t < e || (e = t + 1, 0));
+				}
+			};
+		}(), this.H = null, this.J = !1, this.K = t.flush.intervalMs;
+	}
+	peekNextSequence() {
+		return this.N.peek();
+	}
+	push(t) {
+		this.k ? (this.V(t), this.H && this.Z(this.H, t) || (this.G(t), this.W())) : e.warn("Transport", "push() called before start() — event dropped");
+	}
+	setEventRouter(t) {
+		this.H = t;
+	}
+	getEventRouter() {
+		return this.H;
+	}
+	requeue(t) {
+		if (0 !== t.length) if (this.k) {
+			for (const e of t) this.G(e);
+			this.W();
+		} else e.warn("Transport", "requeue() called before start() — events dropped", t.length);
+	}
+	Z(t, n) {
+		try {
+			return !0 === t.route(n);
+		} catch (t) {
+			return e.warn("Transport", "event router threw — event queued:", t), !1;
+		}
+	}
+	G(t) {
+		this.B.length < this.X() ? this.B.push(t) : this.Y(t);
+	}
+	holdCapacityFlush(t) {
+		const e = this.J;
+		this.J = !0;
+		try {
+			t();
+		} finally {
+			this.J = e;
+		}
+	}
+	W() {
+		if (this.O) return this.B.length >= this.$.flush.size && !this.J ? (m(this.L), this.L = null, void this.flush("capacity")) : void this.tt();
+	}
+	flush(t) {
+		if (this.k && this.P.isActivityActive()) try {
+			if ("lifecycle" === t) return void this.et();
+			if (0 === this.B.length) return;
+			if ("submit" === t && !this.O) return;
+			const n = "submit" === t;
+			for (const i of this.nt(!1, n)) {
+				const r = this.it(i, t, n ? this.rt() : void 0);
+				r && (n ? this.st(r) : this.P.ingest(r, !1)).then((t) => this.ot(t, r)).catch(() => {
+					e.warn("Transport", "ingest threw unexpectedly — batch dropped");
+				});
+			}
+			this.B.length > 0 && this.tt();
+		} catch (t) {
+			e.warn("Transport", "flush() threw unexpectedly:", t);
+		}
+	}
+	start() {
+		this.k || (this.k = !0, this.O = "undefined" == typeof navigator || navigator.onLine);
+	}
+	stop() {
+		if (!this.k) return Promise.resolve();
+		m(this.L), this.L = null, m(this.D), this.D = null;
+		const t = this.et();
+		return this.k = !1, this.q = [], t;
+	}
+	onConnectionChange() {
+		const t = "undefined" == typeof navigator || navigator.onLine;
+		if (t !== this.O) {
+			if (this.O = t, !this.O) return m(this.L), this.L = null, m(this.D), void (this.D = null);
+			this.B.length > 0 && this.tt(), this.q.length > 0 && this.ct();
+		}
+	}
+	tt() {
+		this.k && this.O && null === this.L && (this.L = g(() => {
+			this.L = null, this.flush("interval");
+		}, this.K));
+	}
+	ct() {
+		this.k && this.O && null === this.D && (this.D = g(() => {
+			this.D = null, this.lt();
+		}, this.K));
+	}
+	lt() {
+		if (!this.k || !this.O || 0 === this.q.length || !this.P.isActivityActive()) return;
+		const t = this.q.shift();
+		this.P.ingest(t.batch, !1).then((e) => this.ut(e, t)).catch(() => {
+			e.warn("Transport", "retry drain ingest threw unexpectedly — batch dropped"), this.q.length > 0 && this.ct();
+		});
+	}
+	ht(t, n) {
+		this.q.length >= 5 && (this.q.shift(), e.warn("Transport", "retry queue full — oldest batch evicted")), this.q.push({
+			batch: t,
+			attempts: n
+		}), this.ct();
+	}
+	ot(t, e) {
+		this.k && this.P.isActivityActive() && (t.ok ? this.ft() : this.dt(t) && this.ht(e, 1));
+	}
+	ut(t, n) {
+		if (this.k && this.P.isActivityActive()) {
+			if (t.ok) return this.ft(), void (this.q.length > 0 && this.ct());
+			if (this.dt(t)) {
+				if (n.attempts >= 3) return this.yt(), e.warn("Transport", "batch dropped after MAX_RETRY_ATTEMPTS", n.batch.batchId), void (this.q.length > 0 && this.ct());
+				this.yt(), this.ht(n.batch, n.attempts + 1);
+			} else this.q.length > 0 && this.ct();
+		}
+	}
+	yt() {
+		this.F++, this.F % this.$.flush.backoffFailureThreshold === 0 && (this.K = Math.min(2 * this.K, this.$.flush.maxIntervalMs));
+	}
+	ft() {
+		this.F = 0, this.K = this.$.flush.intervalMs;
+	}
+	X() {
+		return this.$.queue.size * (this.O ? 1 : 2);
+	}
+	async et() {
+		if (!this.P.isActivityActive()) return Promise.resolve();
+		if (this.H) {
+			let t = [];
+			try {
+				t = this.H.release();
+			} catch (t) {
+				e.warn("Transport", "event router release threw:", t);
+			}
+			for (const e of t) this.G(e);
+		}
+		if (!this.O) return;
+		const t = [];
+		let n = this.rt();
+		for (const i of this.nt(!0, !0)) {
+			const r = this.it(i, "lifecycle", n);
+			r && (n -= _t(r.events), t.push(this.st(r).then((t) => this.ot(t, r)).catch(() => {
+				e.warn("Transport", "lifecycle ingest threw — batch dropped");
+			})));
+		}
+		const i = [];
+		for (const r of this.q) {
+			const s = _t(r.batch.events);
+			s > n ? i.push(r) : (n -= s, t.push(this.st(r.batch).then((t) => this.ut(t, r)).catch(() => {
+				e.warn("Transport", "lifecycle retry ingest threw — batch dropped");
+			})));
+		}
+		return this.q = i, Promise.allSettled(t).then(() => {});
+	}
+	rt() {
+		return Math.max(0, 49152 - this.U);
+	}
+	st(t) {
+		const e = _t(t.events);
+		return this.U += e, this.P.ingest(t, !0).finally(() => {
+			this.U -= e;
+		});
+	}
+	V(t) {
+		void 0 !== t.seq && this.N.claim(t.seq) || (void 0 !== t.seq && e.warn("Transport", "event carried a seq that was already used — restamped", t.seq), t.seq = this.N.next());
+	}
+	Y(t) {
+		const e = ht(t);
+		for (let n = 0; n < this.B.length; n++) if (ht(this.B[n]) < e) {
+			for (let t = n; t < this.B.length - 1; t++) this.B[t] = this.B[t + 1];
+			this.B.length -= 1, this.B.push(t);
+			return;
+		}
+	}
+	it(t, e, n) {
+		const i = "lifecycle" === e, r = this.vt(t, i, i ? 200 : this.$.flush.size, n);
+		return 0 === r.length ? null : {
+			activityId: "",
+			batchId: St(),
+			batchSequence: this.j++,
+			clientTimestamp: Date.now(),
+			schemaVersion: "0.1.0",
+			sdkVersion: "0.5.1",
+			sdkPlatform: "web",
+			tabId: this.P.getTabId(),
+			events: r
+		};
+	}
+	vt(t, e, n, i) {
+		const r = /* @__PURE__ */ new Set();
+		let s = 0;
+		for (let o = 0; o < this.B.length && r.size < n; o++) {
+			const n = e ? this.B.length - 1 - o : o, a = this.B[n];
+			if (pt(a) === t) {
+				if (void 0 !== i) {
+					const t = It(a);
+					if (s + t > i) continue;
+					s += t;
+				}
+				r.add(n);
+			}
+		}
+		if (0 === r.size) return [];
+		const o = [], a = [];
+		for (let t = 0; t < this.B.length; t++) r.has(t) ? o.push(this.B[t]) : a.push(this.B[t]);
+		return this.B = a, o;
+	}
+	nt(t, e = !1) {
+		const n = [];
+		for (let e = 0; e < this.B.length; e++) {
+			const i = pt(this.B[t ? this.B.length - 1 - e : e]);
+			n.includes(i) || n.push(i);
+		}
+		if (e) {
+			const t = n.indexOf("fp-signals");
+			t > 0 && (n.splice(t, 1), n.unshift("fp-signals"));
+		}
+		return n;
+	}
+	dt(t) {
+		if (t.ok) return !1;
+		switch (t.kind) {
+			case "timeout":
+			case "server":
+			case "rate_limited":
+			case "network": return !0;
+			default: return !1;
+		}
+	}
+};
+function _t(t) {
+	let e = 0;
+	for (let n = 0; n < t.length; n++) e += It(t[n]);
+	return e;
+}
+function It(t) {
+	try {
+		return JSON.stringify(t).length + 1;
+	} catch {
+		return 0;
+	}
+}
+const Et = "tri:bcast:";
+const At = "function" == typeof BroadcastChannel ? BroadcastChannel : function() {
+	if ("undefined" == typeof Storage || "undefined" == typeof window) return !1;
+	try {
+		const t = "__tri_bcast_probe__";
+		localStorage.setItem(t, "1");
+		const e = "1" === localStorage.getItem(t);
+		return localStorage.removeItem(t), e;
+	} catch {
+		return !1;
+	}
+}() ? class {
+	constructor(t) {
+		this.seq = 0, this.closed = !1, this.listeners = /* @__PURE__ */ new Set(), this.onStorageEvent = (t) => {
+			if (this.closed) return;
+			if (!t.key || !t.key.startsWith(`${Et}${this.channelName}:`)) return;
+			if (null === t.newValue) return;
+			let e;
+			p(() => et.remove(t.key));
+			try {
+				e = JSON.parse(t.newValue);
+			} catch {
+				return;
+			}
+			const n = { data: e };
+			for (const t of this.listeners) p(() => t(n));
+		}, this.channelName = t, this.senderId = St(), window.addEventListener("storage", this.onStorageEvent);
+	}
+	postMessage(t) {
+		if (this.closed) return;
+		const e = `${Et}${this.channelName}:${this.senderId}:${this.seq++}`;
+		p(() => {
+			et.set(e, t), et.remove(e);
+		});
+	}
+	addEventListener(t, e) {
+		this.listeners.add(e);
+	}
+	removeEventListener(t, e) {
+		this.listeners.delete(e);
+	}
+	close() {
+		this.closed || (this.closed = !0, window.removeEventListener("storage", this.onStorageEvent), this.listeners.clear());
+	}
+} : class {
+	constructor(t) {
+		e.warn("BroadcastChannel", "BroadcastChannel is unavailable and localStorage is not writable in this context. Cross-tab discovery is disabled; tab count will always be reported as 1.");
+	}
+	postMessage(t) {}
+	addEventListener(t, e) {}
+	removeEventListener(t, e) {}
+	close() {}
+};
+const Ct = "__tri_tabId";
+var Rt = class {
+	constructor(t) {
+		this.context = t, this.wt = "", this.k = !1, this.gt = null, this.bt = null, this.kt = null, this.St = /* @__PURE__ */ new Map(), this.Tt = -1, this._t = null;
+	}
+	async start() {
+		this.k || (this.k = !0, this.wt = this.It(), this.Et(), this.At({
+			type: "hello",
+			tabId: this.wt,
+			ts: Date.now()
+		}), this.Ct(), this.Rt("active"), this.Mt());
+	}
+	stop() {
+		this.k && (this.k = !1, this.Rt("inactive"), this.At({
+			type: "bye",
+			tabId: this.wt,
+			ts: Date.now()
+		}), this.$t(this.Pt()), this.xt(), this.zt(), this.Bt());
+	}
+	getTabId() {
+		return this.wt;
+	}
+	queryTabsNumber() {
+		return this.St.size + 1;
+	}
+	Et() {
+		try {
+			this.gt = new At("__tri_tab_channel"), this._t = this.Lt.bind(this), this.gt.addEventListener("message", this._t);
+		} catch (t) {
+			e.warn("TabManager", "failed to open broadcast channel:", t);
+		}
+	}
+	Bt() {
+		try {
+			if (!this.gt) return;
+			this._t && this.gt.removeEventListener("message", this._t), this.gt.close();
+		} catch {} finally {
+			this.gt = null, this._t = null;
+		}
+	}
+	Ct() {
+		this.bt = setInterval(() => {
+			const t = Date.now();
+			this.At({
+				type: "heartbeat",
+				tabId: this.wt,
+				ts: t
+			});
+		}, 1e3);
+	}
+	xt() {
+		null != this.bt && (clearInterval(this.bt), this.bt = null);
+	}
+	Mt() {
+		null != this.kt && clearTimeout(this.kt), this.kt = setTimeout(() => {
+			this.kt = null;
+			const t = this.Pt() + 1;
+			t !== this.Tt && (this.Tt = t, this.$t(t));
+		}, 1e3);
+	}
+	zt() {
+		null != this.kt && (clearTimeout(this.kt), this.kt = null);
+	}
+	At(t) {
+		try {
+			if (!this.gt) return;
+			this.gt.postMessage(t);
+		} catch {
+			e.warn("TabManager", "failed to broadcast message:", t);
+		}
+	}
+	Lt(t) {
+		const { type: e, tabId: n } = t.data;
+		if (n === this.wt) return;
+		const i = Date.now();
+		"hello" === e ? (this.At({
+			type: "ack",
+			tabId: this.wt,
+			ts: i,
+			to: n
+		}), this.St.set(n, i)) : "heartbeat" === e || "ack" === e ? this.St.set(n, i) : "bye" === e && this.St.delete(n);
+	}
+	$t(t) {
+		this.context.events.count && this.context.push({
+			name: "tab",
+			type: "count",
+			tabId: this.wt,
+			timestamp: Date.now(),
+			ts: performance.now(),
+			value: t
+		});
+	}
+	Rt(t) {
+		this.context.events.state && this.context.push({
+			name: "tab",
+			type: "state",
+			tabId: this.wt,
+			timestamp: Date.now(),
+			ts: performance.now(),
+			value: t
+		});
+	}
+	It() {
+		const t = nt.get(Ct);
+		if (t) return t;
+		const e = St();
+		return nt.set(Ct, e), e;
+	}
+	Pt(t = Date.now()) {
+		let e = 0;
+		for (const [n, i] of this.St.entries()) t - i >= 3e3 ? this.St.delete(n) : e++;
+		return e;
+	}
+};
+const Mt = globalThis.CompressionStream;
+const $t = globalThis.Response;
+const Pt = globalThis.Blob;
+const xt = new TextEncoder();
+let zt = null;
+async function Bt(t) {
+	const n = await async function(t) {
+		if ("function" != typeof Mt) return null;
+		try {
+			const e = xt.encode(t), n = new Pt([e]).stream().pipeThrough(new Mt("gzip"));
+			return await new $t(n).arrayBuffer();
+		} catch (t) {
+			return e.warn("compression", "Native gzip failed:", t), null;
+		}
+	}(t);
+	return null !== n ? n : async function(t) {
+		try {
+			const n = await function() {
+				if (null === zt) {
+					const t = function(t, n = 1e4) {
+						let i = null;
+						const r = new Promise((t) => {
+							i = g(() => {
+								e.warn("import", `Import timed out after ${n}ms`), t(null);
+							}, n);
+						}), s = Promise.resolve().then(t).catch((t) => (e.warn("import", "Import failed:", t), null));
+						return Promise.race([s, r]).finally(() => {
+							m(i);
+						});
+					}(() => import("./browser-pQZA35G2-DJEJnmCd.esm.js"), 1e4);
+					zt = t, t.then((e) => {
+						null === e && g(() => {
+							zt === t && (zt = null);
+						}, 1e4);
+					});
+				}
+				return zt;
+			}();
+			if (null === n) return null;
+			const { gzipSync: i } = n, r = i(xt.encode(t));
+			return r.buffer.slice(r.byteOffset, r.byteOffset + r.byteLength);
+		} catch (t) {
+			return e.warn("compression", "fflate gzip failed:", t), null;
+		}
+	}(t);
+}
+function Lt(t, e) {
+	const n = [JSON.stringify(t)];
+	for (let t = 0; t < e.length; t++) try {
+		n.push(JSON.stringify(e[t]));
+	} catch {}
+	return n.join("\n");
+}
+function qt(t) {
+	const e = { Accept: "application/json" };
+	return t?.hasBody && ("json" === t.contentType ? e["Content-Type"] = "application/json" : "ndjson" === t.contentType && (e["Content-Type"] = "application/x-ndjson"), "gzip" === t.contentEncoding && (e["Content-Encoding"] = "gzip")), t?.token && (e.Authorization = `Bearer ${t.token}`), t?.profileId && (e["x-profile-id"] = t.profileId), t?.api?.version && (e["x-api-version"] = t.api.version), t?.customHeaders && Object.entries(t.customHeaders).forEach(([t, n]) => {
+		e[t] = n;
+	}), e;
+}
+const Dt = "function" == typeof globalThis.fetch ? globalThis.fetch.bind(globalThis) : void 0;
+function Ot(t) {
+	"undefined" != typeof document && "function" == typeof globalThis.fetch || e.warn("FalconService", "createFalconServiceManager called in a non-browser environment — all requests will resolve with { ok: false, kind: 'network' }.");
+	const n = function(t) {
+		const e = t?.timeout, n = t?.baseUrl ?? "", i = t?.api;
+		async function r(t, r, s) {
+			if (void 0 === Dt) return {
+				ok: !1,
+				kind: "network"
+			};
+			const o = n ? `${n}${r}` : r, a = new AbortController();
+			let c = null, l = !1;
+			c = g(() => {
+				l = !0, a.abort();
+			}, e);
+			const u = s?.signal;
+			let h, f = () => {};
+			if (u) if (u.aborted) a.abort();
+			else {
+				const t = () => a.abort();
+				u.addEventListener("abort", t, { once: !0 }), f = () => u.removeEventListener("abort", t);
+			}
+			if (null != s && "body" in s && null != s.body) {
+				const t = function(t) {
+					if (null == t) return {
+						ok: !0,
+						body: void 0
+					};
+					if ("string" == typeof t || t instanceof ArrayBuffer || ArrayBuffer.isView(t) || t instanceof Blob || t instanceof FormData || t instanceof URLSearchParams || t instanceof ReadableStream) return {
+						ok: !0,
+						body: t
+					};
+					try {
+						return {
+							ok: !0,
+							body: JSON.stringify(t)
+						};
+					} catch {
+						return { ok: !1 };
+					}
+				}(s.body);
+				if (!t.ok) return m(c), f(), {
+					ok: !1,
+					kind: "serialize"
+				};
+				h = t.body;
+			}
+			try {
+				const e = await Dt(o, {
+					method: t,
+					headers: qt({
+						token: s?.token,
+						profileId: s?.profileId,
+						contentType: s?.contentType,
+						contentEncoding: s?.contentEncoding,
+						api: i,
+						hasBody: void 0 !== h,
+						customHeaders: s?.customHeaders
+					}),
+					body: h,
+					signal: a.signal,
+					keepalive: s?.keepalive
+				});
+				if (!e.ok) return 429 === (d = e.status) ? {
+					ok: !1,
+					kind: "rate_limited",
+					status: d
+				} : d >= 400 && d < 500 ? {
+					ok: !1,
+					kind: "client",
+					status: d
+				} : {
+					ok: !1,
+					kind: "server",
+					status: d
+				};
+				if (204 === e.status) return {
+					ok: !0,
+					data: void 0,
+					status: 204
+				};
+				try {
+					return {
+						ok: !0,
+						data: await e.json(),
+						status: e.status
+					};
+				} catch {
+					return a.signal.aborted ? l ? {
+						ok: !1,
+						kind: "timeout"
+					} : {
+						ok: !1,
+						kind: "abort"
+					} : {
+						ok: !1,
+						kind: "parse",
+						status: e.status
+					};
+				}
+			} catch {
+				return l ? {
+					ok: !1,
+					kind: "timeout"
+				} : a.signal.aborted ? {
+					ok: !1,
+					kind: "abort"
+				} : {
+					ok: !1,
+					kind: "network"
+				};
+			} finally {
+				m(c), f();
+			}
+			var d;
+		}
+		return {
+			post: async function(t, e) {
+				return r("POST", t, e);
+			},
+			get: async function(t, e) {
+				return r("GET", t, e);
+			}
+		};
+	}({
+		baseUrl: `${t.api.url}/api/v1`,
+		timeout: 1e4,
+		api: { version: t.api.version }
+	}), i = function(t) {
+		const { getToken: n, refresh: i } = t;
+		let r = null;
+		return { withAuth: async function(t, s) {
+			if (r) {
+				const e = await r;
+				if (e) return t(e);
+			}
+			const o = n() ?? "", a = await t(o);
+			if ((c = a).ok || !("rejected" === c.kind || "client" === c.kind && lt.includes(c.status)) || !1 === s?.refreshable) return a;
+			var c;
+			const l = await (r || (r = async function() {
+				try {
+					return await i(), n();
+				} catch (t) {
+					return e.warn("AuthMiddleware", "auth refresh failed", t), null;
+				}
+			}().finally(() => {
+				r = null;
+			}), r));
+			return l && l !== o ? t(l) : a;
+		} };
+	}(t), r = () => ({ profileId: t.getProfileId() ?? void 0 });
+	return { api: {
+		ingest: async function(e, s) {
+			return i.withAuth(async (i) => {
+				const { events: o, ...a } = e, c = {
+					...a,
+					activityId: t.getActivityId()
+				};
+				let l, u = !1;
+				try {
+					if (s) l = Lt(c, o);
+					else {
+						const t = await async function(t, e) {
+							const n = Lt(t, e), i = await Bt(n);
+							return i ? {
+								type: "gzip",
+								body: i
+							} : {
+								type: "ndjson",
+								body: n
+							};
+						}(c, o);
+						l = t.body, u = "gzip" === t.type;
+					}
+				} catch {
+					return {
+						ok: !1,
+						kind: "serialize"
+					};
+				}
+				const h = await n.post(function(t) {
+					return t.length > 0 ? ft[pt(t[0])] : ft.tri;
+				}(o), {
+					body: l,
+					token: i,
+					keepalive: s,
+					contentType: "ndjson",
+					contentEncoding: u ? "gzip" : void 0,
+					...r()
+				});
+				return function(t) {
+					return t.ok && !0 === t.data?.malformedBatch;
+				}(h) ? {
+					ok: !1,
+					kind: "rejected",
+					status: h.status
+				} : h;
+			}, { refreshable: !s });
+		},
+		reportEvent: async function(t) {
+			return i.withAuth((e) => n.post("/events/report-event", {
+				body: t,
+				token: e,
+				contentType: "json",
+				...r()
+			}));
+		},
+		startActivity: async function() {
+			return n.post("/events/start-activity", {
+				token: t.getSdkToken(),
+				...r()
+			});
+		},
+		stopActivity: async function() {
+			return i.withAuth((t) => n.post("/events/end-activity", {
+				token: t,
+				keepalive: !0,
+				...r()
+			}), { refreshable: !1 });
+		},
+		collectionStatus: async function() {
+			return n.get("/sdk/collection-status", {
+				token: t.getSdkToken(),
+				...r()
+			});
+		},
+		linkInterview: async function(e) {
+			const s = t.getToken();
+			return s && !Q(s) || await t.refresh(), i.withAuth((t) => n.post("/events/link-interview", {
+				token: t,
+				contentType: "json",
+				...r(),
+				customHeaders: { "X-Incode-Hardware-Id": e }
+			}), { refreshable: !1 });
+		}
+	} };
+}
+var Ft = class {
+	constructor(t) {
+		this.context = t;
+	}
+	stop() {}
+	async report(t, n) {
+		const i = {
+			name: t,
+			metadata: n,
+			timestamp: Date.now(),
+			activityId: this.context.getActivityId() ?? ""
+		};
+		try {
+			const r = await this.context.reportEvent(i);
+			if (r.ok) return r;
+			e.warn("EventReport", "Failed to report event:", t, n, "with result:", r);
+		} catch (i) {
+			e.warn("EventReport", "Failed to report event:", t, n, "with error:", i);
+		}
+	}
+};
+async function jt(t, n) {
+	const { collectors: i, sdk: r } = t;
+	let s = null, o = null, a = null, c = null;
+	try {
+		s = Ot({
+			api: {
+				version: r.api.version,
+				url: r.api.url
+			},
+			getSdkToken: () => r.token,
+			getProfileId: () => n.getProfileId(),
+			getToken: () => o?.getToken() ?? null,
+			refresh: async () => o?.refresh() ?? Promise.resolve(),
+			getActivityId: () => o?.getActivityId() ?? ""
+		});
+		const t = await s.api.collectionStatus();
+		if (!t.ok || !0 !== t.data.eventsCollectionEnabled) return { status: "collection-disabled" };
+		o = new ct({
+			startActivity: () => s.api.startActivity(),
+			stopActivity: () => s.api.stopActivity()
+		}), a = new Tt(J, {
+			ingest: (t, e) => s.api.ingest(t, e),
+			getTabId: () => c?.getTabId() ?? "unknown",
+			isActivityActive: () => o?.isActive() ?? !1
+		});
+		const l = i.tab;
+		c = new Rt({
+			push: (t) => a?.push(t),
+			events: {
+				state: l.enabled && l.events.state.enabled,
+				count: l.enabled && l.events.count.enabled
+			}
+		});
+		const f = /* @__PURE__ */ new Set();
+		try {
+			f.add(new URL(r.api.url).origin);
+		} catch {}
+		const d = function(t, e, n = "off") {
+			const i = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), s = {
+				...t,
+				registerBehaviourReader: function(t) {
+					return r.add(t), function() {
+						r.delete(t);
+					};
+				},
+				collectorSelection: e
+			};
+			function o(t) {
+				if (i.has(t)) return;
+				const r = L[t];
+				if (!r || !function(t, e) {
+					return e[t]?.enabled ?? !1;
+				}(t, e)) return;
+				const o = e[t], a = r.create(s, n, o && "events" in o ? o.events : void 0);
+				i.set(t, a);
+			}
+			return {
+				start: o,
+				stopCollector: function(t) {
+					const e = i.get(t);
+					e && (e(), i.delete(t));
+				},
+				stop: function() {
+					for (const [, t] of i) t();
+					i.clear();
+				},
+				isRunning: function(t) {
+					return i.has(t);
+				},
+				autocapture: function() {
+					for (const t of q) o(t);
+				},
+				readBehaviour: function(t) {
+					let e = !1;
+					for (const n of r) p(() => n(t)) && (e = !0);
+					return e;
+				}
+			};
+		}({
+			push: (t) => a?.push(t),
+			flush: () => a?.flush("submit"),
+			sanitizeUrl: r.sanitizeUrl,
+			ignoredOrigins: f,
+			host: r.host,
+			getTabId: () => c?.getTabId() ?? "",
+			captureElementLevel: r.capture?.element ?? K,
+			peekNextSequence: () => a?.peekNextSequence() ?? 0,
+			registerEventRouter: (t) => (a?.setEventRouter(t), function() {
+				a?.getEventRouter() === t && a.setEventRouter(null);
+			}),
+			requeueEvents: (t) => a?.requeue(t)
+		}, i, r.capture?.content), y = function(t) {
+			let e = !1;
+			function n(e) {
+				p(() => t.isActivityActive()) && (p(() => t.holdCapacityFlush(function() {
+					p(() => t.readBehaviour(e)), "pagehide" === e && p(() => t.stopTab());
+				})), p(() => t.flush()), "pagehide" === e && (t.getShouldSkipStopActivity() || t.stopActivity()));
+			}
+			const i = v((t) => {
+				"hidden" === document.visibilityState && n("hidden");
+			}), r = v((t) => {
+				n("pagehide");
+			}), s = v((t) => {
+				n("beforeunload");
+			}), o = v((e) => {
+				e.persisted && t.resume();
+			}), a = v(() => t.onConnectionChange());
+			return {
+				start: function() {
+					u(document, "visibilitychange", i), u(window, "pagehide", r), function() {
+						if ("undefined" == typeof navigator) return !1;
+						const t = navigator.userAgentData;
+						return t && "boolean" == typeof t.mobile ? !t.mobile : !/Mobi|Android|iPhone|iPad|iPod/i.test(navigator.userAgent ?? "");
+					}() && !/Firefox\//.test(navigator.userAgent ?? "") && (u(window, "beforeunload", s), e = !0), u(window, "pageshow", o), u(window, "online", a), u(window, "offline", a);
+				},
+				stop: function() {
+					h(document, "visibilitychange", i), h(window, "pagehide", r), e && (h(window, "beforeunload", s), e = !1), h(window, "pageshow", o), h(window, "online", a), h(window, "offline", a);
+				},
+				onHide: n
+			};
+		}({
+			readBehaviour: (t) => d.readBehaviour(t),
+			isActivityActive: () => o?.isActive() ?? !1,
+			holdCapacityFlush: (t) => {
+				a ? a.holdCapacityFlush(t) : t();
+			},
+			flush: () => a?.flush("lifecycle"),
+			stopActivity: async () => o?.stop(),
+			stopTab: () => c?.stop(),
+			getShouldSkipStopActivity: () => (c?.queryTabsNumber() ?? 0) > 1,
+			onConnectionChange: () => a?.onConnectionChange(),
+			resume: async () => {
+				try {
+					await o?.start(), await c?.start();
+				} catch (t) {
+					e.warn("IncodeTRI", "resume after bfcache restore failed:", t);
+				}
+			}
+		}), w = new Ft({
+			getActivityId: () => o?.getActivityId() ?? "",
+			reportEvent: (t) => s.api.reportEvent(t)
+		});
+		return {
+			status: "ready",
+			managers: {
+				falconServiceManager: s,
+				activityManager: o,
+				transportManager: a,
+				tabManager: c,
+				lifecycleManager: y,
+				collectorManager: d,
+				eventReportManager: w
+			}
+		};
+	} catch (t) {
+		return e.warn("IncodeTRI", "setup() failed during construction:", t), { status: "init-failed" };
+	}
+}
+let Ut = class t {
+	constructor() {
+		this.qt = 0, this.Dt = null, this.Ot = F;
+	}
+	static get instance() {
+		return t.i || (t.i = new t()), t.i;
+	}
+	async setup(t) {
+		if (this.Ot !== F) return e.fatal("error", "setup()", `cannot set up from state '${this.Ot}' — call reset() (or reload) first. Ignoring.`), H;
+		try {
+			const n = function(t) {
+				if ("undefined" == typeof document) return e.fatal("error", "IncodeTRI", "TRI is not available in a non-browser environment."), null;
+				if (!t?.token) return e.fatal("error", "SDK", "token is required."), null;
+				if (!t.apiURL) return e.fatal("error", "SDK", "Couldn't initialise SDK — apiURL isn't provided."), null;
+				const { element: n, content: i } = t.capture ?? {}, r = {
+					token: t.token,
+					capture: {
+						element: n ?? K,
+						content: i ?? "off"
+					},
+					api: {
+						version: t.apiVersion ?? "1.0",
+						url: t.apiURL
+					},
+					sanitizeUrl: (o = t.sanitizeUrl, o ? function(t) {
+						return p(() => o(t, O)) ?? O(t);
+					} : O),
+					host: (s = t.host, "string" == typeof s?.platform && "" !== s.platform && "string" == typeof s.version && "" !== s.version ? {
+						platform: s.platform,
+						version: s.version
+					} : (void 0 !== s && e.warn("SDK", "host needs a non-empty platform and version — reporting TRI itself."), {
+						platform: "tri-web",
+						version: "0.5.1"
+					})),
+					DEBUG: t.DEBUG ?? !1
+				};
+				var s, o;
+				return void 0 === t.collectors && void 0 === t.layers ? {
+					sdk: r,
+					collectors: V()
+				} : void 0 !== t.collectors ? {
+					sdk: r,
+					collectors: G(t.collectors)
+				} : {
+					sdk: r,
+					collectors: Z(t.layers)
+				};
+			}(t);
+			if (!n) return this.Ot = H, H;
+			e.DEBUG = n.sdk.DEBUG;
+			const i = await jt(n, { getProfileId: () => null });
+			return "collection-disabled" === i.status ? (e.fatal("warn", "setup()", "Collection is disabled for the provided API Key."), this.Ot = N, N) : "init-failed" === i.status ? (this.Ot = H, H) : (this.Dt = i.managers, this.Ot = j, !1 !== t.autostart ? this.start() : j);
+		} catch (t) {
+			return e.warn("setup()", "failed:", t), this.Ot = H, H;
+		}
+	}
+	async start() {
+		if (this.Ot === F) return e.warn("start()", "start() requires a prior successful setup() — ignoring."), this.Ot;
+		if (this.Ot !== j) return e.fatal("warn", "start()", "TRI is either already started or isn't ready — ignoring."), this.Ot;
+		this.Ot = "starting";
+		const t = ++this.qt;
+		return await this.S(t), this.Ot;
+	}
+	async stop() {
+		e.warn("stop()", "called");
+		const t = this.Dt;
+		return t ? (++this.qt, t.lifecycleManager.stop(), t.collectorManager.stop(), t.tabManager.stop(), t.eventReportManager.stop(), this.Ot = j, this.Ft(t)) : Promise.resolve(this.Ot);
+	}
+	async reset() {
+		const t = this.stop();
+		return this.Ot = F, this.Dt = null, t.then(() => this.Ot);
+	}
+	async Ft(t) {
+		return await function(t) {
+			let e = null;
+			const n = new Promise((t) => {
+				e = g(t, 2e3);
+			});
+			return Promise.race([t.finally(() => m(e)), n]);
+		}(Promise.resolve(t.transportManager.stop())), await t.activityManager.stop(), this.Ot;
+	}
+	async S(t) {
+		const n = this.Dt;
+		if (n) {
+			try {
+				if (await n.activityManager.start(), t !== this.qt) return;
+				if (n.transportManager.start(), await n.tabManager.start(), t !== this.qt) return;
+				n.lifecycleManager.start(), n.collectorManager.autocapture();
+			} catch (n) {
+				e.warn("start()", "failed during monitoring start:", n), t === this.qt && (this.Ot = j);
+				return;
+			}
+			t === this.qt && (this.Ot = U);
+		}
+	}
+	async linkInterview(t) {
+		if (this.Ot !== U || !this.Dt) return e.warn("linkInterview()", "linkInterview() called before start() completed — ignoring."), !1;
+		if (!t) return e.warn("linkInterview()", "linkInterview() called without sessionToken — ignoring."), !1;
+		try {
+			return (await this.Dt.falconServiceManager.api.linkInterview(t)).ok;
+		} catch (t) {
+			return e.warn("linkInterview()", "failed:", t), !1;
+		}
+	}
+	async getFpSignals() {
+		if (this.Ot !== U) return e.warn("getFpSignals()", "getFpSignals() called before start() completed — ignoring."), null;
+		try {
+			return await (I ?? Promise.resolve(null));
+		} catch (t) {
+			return e.warn("getFpSignals()", "failed:", t), null;
+		}
+	}
+	addFpSignals(t) {
+		const n = this.Dt;
+		if (this.Ot !== U || !n) return e.warn("addFpSignals()", "addFpSignals() called before start() completed — ignoring."), !1;
+		if (n.collectorManager.isRunning("fpsignals")) return e.warn("addFpSignals()", "the fpsignals collector is on and sends its own results — ignoring."), !1;
+		if ("string" != typeof t || !t) return e.warn("addFpSignals()", "signals is empty — ignoring."), !1;
+		try {
+			return n.transportManager.push({
+				name: "fp_signals",
+				timestamp: Date.now(),
+				signals: t
+			}), !0;
+		} catch (t) {
+			return e.warn("addFpSignals()", "failed:", t), !1;
+		}
+	}
+	getActivityId() {
+		const t = this.Dt;
+		if (this.Ot !== U || !t) return e.warn("getActivityId()", "getActivityId() called before start() completed — returning null."), null;
+		try {
+			const { activityManager: e } = t;
+			return e.isActive() && e.getActivityId() || null;
+		} catch (t) {
+			return e.warn("getActivityId()", "failed:", t), null;
+		}
+	}
+};
+async function Nt(t, e) {
+	const n = e?.apiURL ?? "https://falcon-ingest-k8s.stage.incodetest.com", i = e?.timeout ?? 1e4, r = new AbortController();
+	let s = null, o = !1, a = () => {};
+	i && (s = g(() => {
+		o = !0, r.abort();
+	}, i));
+	const c = e?.signal;
+	if (c) if (c.aborted) r.abort();
+	else {
+		const t = () => r.abort();
+		c.addEventListener("abort", t, { once: !0 }), a = () => c.removeEventListener("abort", t);
+	}
+	try {
+		const e = await fetch(`${n}/api/v1/sdk/init`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				"x-api-key": t,
+				"x-api-version": "1.0"
+			},
+			signal: r.signal
+		});
+		if (!e.ok) {
+			let t = e.statusText;
+			try {
+				const n = await e.json();
+				n.errorMessage && (t = n.errorMessage);
+			} catch {}
+			return {
+				token: null,
+				expiresAt: null,
+				tokenType: null,
+				eventsCollectionEnabled: !1,
+				error: {
+					status: e.status,
+					message: t
+				}
+			};
+		}
+		const i = await e.json();
+		return {
+			token: i.token,
+			expiresAt: i.expiresAt,
+			tokenType: i.tokenType,
+			eventsCollectionEnabled: !0,
+			error: null
+		};
+	} catch (t) {
+		throw new Error((o ? "[TRI] createSession timed out" : "[TRI] Failed to create session:") + " " + t.message);
+	} finally {
+		m(s), a();
+	}
+}
+Ut.i = null;
+const Ht = Ut.instance;
+//#endregion
+export { Nt as createSession, Ht as default };