@faststats/web 0.6.0 → 0.8.0

package/README.md

@@ -2,3 +2,70 @@
 
 > [!IMPORTANT]
 > This repository is in early development and not intended for production use.
+
+The base SDK only handles analytics, identity, sessions, navigation, and consent.
+Error tracking, Web Vitals, and session replay are independent extensions, so
+applications only download the products they use.
+
+```ts
+import { init, track } from "@faststats/web";
+import { errorTracking } from "@faststats/web/error";
+import { outboundLinks } from "@faststats/web/outbound-links";
+import { sessionReplay } from "@faststats/web/replay";
+import { webVitals } from "@faststats/web/web-vitals";
+
+init({
+	siteKey: "site_123",
+	extensions: [
+		outboundLinks(),
+		errorTracking(),
+		webVitals({ attribution: true }),
+		sessionReplay({ recordConsole: true }),
+	],
+});
+
+track("checkout_completed", { total: 42 });
+```
+
+`init()` starts one shared client and is idempotent, making it safe to call from
+application bootstrap code. Calls made before initialization are ignored rather
+than buffered with stale context. Use `shutdown()` before initializing with new
+options.
+
+For multiple sites, tests, or framework integrations, create an independent
+client with explicit lifecycle control:
+
+```ts
+import { createClient } from "@faststats/web";
+
+const analytics = createClient({ siteKey: "site_123" });
+analytics.start();
+analytics.track("checkout_completed", { total: 42 });
+analytics.destroy();
+```
+
+Consent remains client-local: use `"anonymous"` for cookieless collection,
+`"granted"` for normal collection, or `"denied"` to keep the client dormant.
+
+### Custom extensions
+
+An extension registers only the lifecycle hooks it needs. Hook failures are
+isolated from analytics collection, asynchronous setup is safe during teardown,
+and cleanup receives `discard: true` when consent is revoked.
+
+```ts
+import type { AnalyticsExtension } from "@faststats/web";
+
+export function diagnostics(): AnalyticsExtension {
+	return {
+		name: "diagnostics",
+		setup(context) {
+			const off = context.on("pageChange", ({ url }) => {
+				console.debug("page changed", url, context.getSession());
+			});
+
+			return () => off();
+		},
+	};
+}
+```

package/dist/chunks/api-urls-DWk43fu6.js

@@ -0,0 +1,53 @@
+//#region src/utils/api-urls.ts
+const ANALYTICS_BASE = "https://metrics.faststats.dev";
+function resolveBaseUrl(input, fallback) {
+	return input?.replace(/\/+$/, "") || fallback;
+}
+const URLS = {
+	events: "/v1/web",
+	identify: "/v1/identify",
+	replay: "/v1/replay",
+	vitals: "/v1/vitals"
+};
+function sanitizeUrl(url, includeHash = false) {
+	try {
+		const parsed = new URL(url, location.href);
+		return `${parsed.origin}${parsed.pathname}${includeHash ? parsed.hash : ""}`;
+	} catch {
+		return url.split(includeHash ? "?" : /[?#]/, 1)[0] ?? "";
+	}
+}
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_term",
+	"utm_content"
+];
+function getReferrer() {
+	const raw = document.referrer;
+	if (!raw) return null;
+	try {
+		const pageOrigin = new URL(location.href).origin;
+		if (new URL(raw, location.href).origin === pageOrigin) return null;
+	} catch {}
+	return sanitizeUrl(raw);
+}
+function getPageContext(includeHash = false) {
+	const hash = includeHash ? location.hash : "";
+	const ctx = {
+		page: `${location.pathname}${hash}`,
+		url: sanitizeUrl(location.href, includeHash),
+		referrer: getReferrer(),
+		title: document.title || ""
+	};
+	if (!location.search) return ctx;
+	const sp = new URLSearchParams(location.search);
+	for (const key of UTM_KEYS) {
+		const value = sp.get(key);
+		if (value) ctx[key] = value;
+	}
+	return ctx;
+}
+//#endregion
+export { sanitizeUrl as a, resolveBaseUrl as i, URLS as n, getPageContext as r, ANALYTICS_BASE as t };

package/dist/chunks/extensions-DW7tJY0T.d.ts

@@ -0,0 +1,51 @@
+//#region src/utils/session-manager.d.ts
+type SessionContext = {
+  sessionId: string;
+  windowId: string;
+  sessionStart: number;
+};
+//#endregion
+//#region src/extensions.d.ts
+type ExtensionHooks = {
+  pageChange: {
+    url: string;
+  };
+  pageHide: {
+    persisted: boolean;
+    terminal: boolean;
+  };
+  pageShow: {
+    persisted: boolean;
+  };
+  consentChange: {
+    cookieless: boolean;
+  };
+  error: {
+    error: Error;
+  };
+};
+type ExtensionHook = keyof ExtensionHooks;
+type ExtensionHandler<K extends ExtensionHook> = (event: ExtensionHooks[K]) => void | Promise<void>;
+interface AnalyticsExtensionContext {
+  readonly siteKey: string;
+  readonly baseUrl: string;
+  readonly debug: boolean;
+  readonly trackHash: boolean;
+  readonly sdkName?: string;
+  readonly sdkVersion?: string;
+  isCookieless(): boolean;
+  getAnonymousId(): string;
+  getSession(): SessionContext;
+  capture(event: string, properties?: Record<string, unknown>): void;
+  on<K extends ExtensionHook>(hook: K, handler: ExtensionHandler<K>): () => void;
+  log(message: string, ...details: unknown[]): void;
+}
+interface AnalyticsExtension {
+  readonly name: string;
+  setup(context: AnalyticsExtensionContext): ExtensionCleanup | undefined | Promise<ExtensionCleanup | undefined>;
+}
+type ExtensionCleanup = (options: {
+  discard: boolean;
+}) => void;
+//#endregion
+export { ExtensionHook as a, ExtensionHandler as i, AnalyticsExtensionContext as n, ExtensionHooks as o, ExtensionCleanup as r, AnalyticsExtension as t };

package/dist/chunks/identifiers-KgQDX74Q.js

@@ -0,0 +1,21 @@
+import { c as removeStorageItem, l as setStorageItem, n as createId, s as getStorageItem } from "./send-data-DFZnsaL2.js";
+//#region src/utils/identifiers.ts
+const ANONYMOUS_ID_KEY = "faststats_anon_id_";
+function getOrCreateAnonymousId(siteKey) {
+	const key = `${ANONYMOUS_ID_KEY}${siteKey}`;
+	const existingId = getStorageItem("localStorage", key);
+	if (existingId) return existingId;
+	const newId = createId();
+	return setStorageItem("localStorage", key, newId) ? newId : "";
+}
+function getAnonymousId(siteKey, cookieless = false) {
+	if (cookieless) return "";
+	return getOrCreateAnonymousId(siteKey);
+}
+function resetAnonymousId(siteKey, cookieless) {
+	if (cookieless) return "";
+	if (!removeStorageItem("localStorage", `${ANONYMOUS_ID_KEY}${siteKey}`)) return "";
+	return getOrCreateAnonymousId(siteKey);
+}
+//#endregion
+export { resetAnonymousId as n, getAnonymousId as t };

package/dist/chunks/send-data-DFZnsaL2.js

@@ -0,0 +1,219 @@
+//#region src/utils/storage.ts
+function getStorageItem(name, key) {
+	try {
+		return globalThis[name]?.getItem(key) ?? null;
+	} catch {
+		return null;
+	}
+}
+function setStorageItem(name, key, value) {
+	try {
+		const storage = globalThis[name];
+		if (!storage) return false;
+		storage.setItem(key, value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function removeStorageItem(name, key) {
+	try {
+		const storage = globalThis[name];
+		if (!storage) return false;
+		storage.removeItem(key);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/utils/session-manager.ts
+const IDLE_MS = 18e5;
+const MAX_AGE_MS = 864e5;
+const SESSION_KEY = "faststats_session_";
+const NO_STORAGE = {};
+const memorySessions = /* @__PURE__ */ new Map();
+const rotationListeners = /* @__PURE__ */ new Map();
+function memoryKey(siteKey, cookieless) {
+	return `${siteKey}:${cookieless ? "memory" : "persistent"}`;
+}
+function storageScope() {
+	try {
+		return globalThis.localStorage ?? NO_STORAGE;
+	} catch {
+		return NO_STORAGE;
+	}
+}
+function readMemory(siteKey, cookieless) {
+	const entry = memorySessions.get(memoryKey(siteKey, cookieless));
+	return entry?.scope === storageScope() ? entry.session : null;
+}
+function writeMemory(siteKey, cookieless, session) {
+	memorySessions.set(memoryKey(siteKey, cookieless), {
+		scope: storageScope(),
+		session
+	});
+}
+function createId() {
+	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function readSession(siteKey) {
+	const memory = readMemory(siteKey, false);
+	const raw = getStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
+	if (!raw) return memory;
+	try {
+		const session = JSON.parse(raw);
+		return session.id ? session : memory;
+	} catch {}
+	return memory;
+}
+function writeSession(siteKey, session) {
+	if (!setStorageItem("localStorage", `${SESSION_KEY}${siteKey}`, JSON.stringify(session))) writeMemory(siteKey, false, session);
+}
+function clearSession(siteKey, cookieless) {
+	memorySessions.delete(memoryKey(siteKey, cookieless));
+	if (!cookieless) removeStorageItem("localStorage", `${SESSION_KEY}${siteKey}`);
+}
+function expired(session, now) {
+	return now - session.activity >= IDLE_MS || now - session.start >= MAX_AGE_MS;
+}
+function emitRotation(siteKey, cookieless, prev, next) {
+	for (const listener of rotationListeners.get(memoryKey(siteKey, cookieless)) ?? []) listener(prev, next);
+}
+function resolveSession(siteKey, cookieless, touch) {
+	const now = Date.now();
+	if (cookieless) {
+		let session = readMemory(siteKey, true) ?? void 0;
+		if (!session) {
+			session = {
+				id: createId(),
+				start: now,
+				activity: now
+			};
+			writeMemory(siteKey, true, session);
+		} else if (touch) session.activity = now;
+		return {
+			session,
+			rotatedFrom: null
+		};
+	}
+	const existing = readSession(siteKey);
+	if (existing && !expired(existing, now)) {
+		if (touch) {
+			existing.activity = now;
+			writeSession(siteKey, existing);
+		}
+		return {
+			session: existing,
+			rotatedFrom: null
+		};
+	}
+	const session = {
+		id: createId(),
+		start: now,
+		activity: now
+	};
+	writeSession(siteKey, session);
+	return {
+		session,
+		rotatedFrom: existing
+	};
+}
+function windowId(siteKey, cookieless, sessionId) {
+	if (cookieless) return sessionId;
+	const key = `faststats_window_id_${siteKey}`;
+	const existing = getStorageItem("sessionStorage", key);
+	if (existing) return existing;
+	const id = createId();
+	return setStorageItem("sessionStorage", key, id) ? id : sessionId;
+}
+function toContext(siteKey, session, cookieless, windowIdOverride) {
+	return {
+		sessionId: session.id,
+		windowId: windowIdOverride ?? windowId(siteKey, cookieless, session.id),
+		sessionStart: session.start
+	};
+}
+function getSessionContext(siteKey, cookieless = false) {
+	const { session, rotatedFrom } = resolveSession(siteKey, cookieless, false);
+	const next = toContext(siteKey, session, cookieless);
+	if (rotatedFrom) emitRotation(siteKey, cookieless, toContext(siteKey, rotatedFrom, cookieless, next.windowId), next);
+	return next;
+}
+function touchActivity(siteKey, cookieless = false) {
+	const { session, rotatedFrom } = resolveSession(siteKey, cookieless, true);
+	if (!rotatedFrom) return null;
+	const wid = windowId(siteKey, cookieless, session.id);
+	const rotation = {
+		prev: toContext(siteKey, rotatedFrom, cookieless, wid),
+		next: toContext(siteKey, session, cookieless, wid)
+	};
+	emitRotation(siteKey, cookieless, rotation.prev, rotation.next);
+	return rotation;
+}
+function resetSession(siteKey, cookieless = false) {
+	const previous = getSessionContext(siteKey, cookieless);
+	clearSession(siteKey, cookieless);
+	if (cookieless) {
+		const now = Date.now();
+		writeMemory(siteKey, true, {
+			id: createId(),
+			start: now,
+			activity: now
+		});
+	} else removeStorageItem("sessionStorage", `faststats_window_id_${siteKey}`);
+	const next = getSessionContext(siteKey, cookieless);
+	if (previous.sessionId !== next.sessionId) emitRotation(siteKey, cookieless, previous, next);
+	return next;
+}
+function onSessionRotated(siteKey, cookieless, listener) {
+	const key = memoryKey(siteKey, cookieless);
+	let listeners = rotationListeners.get(key);
+	if (!listeners) {
+		listeners = /* @__PURE__ */ new Set();
+		rotationListeners.set(key, listeners);
+	}
+	listeners.add(listener);
+	return () => {
+		listeners?.delete(listener);
+		if (listeners?.size === 0) rotationListeners.delete(key);
+	};
+}
+//#endregion
+//#region src/utils/send-data.ts
+async function sendData(options) {
+	const { url, data, contentType = "application/json", headers = {}, debug = false, debugPrefix = "[Analytics]", useBeacon = true, keepalive = true, signal } = options;
+	if (signal?.aborted) return false;
+	if (useBeacon && typeof globalThis.navigator?.sendBeacon === "function") try {
+		const beaconBody = data instanceof Blob || typeof Blob === "undefined" ? data : new Blob([data], { type: contentType });
+		if (globalThis.navigator.sendBeacon(url, beaconBody)) {
+			if (debug) console.log(`${debugPrefix} Sent via beacon`);
+			return true;
+		}
+	} catch {}
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			body: data,
+			headers: {
+				"Content-Type": contentType,
+				...headers
+			},
+			keepalive,
+			credentials: "omit",
+			signal
+		});
+		const success = response.ok;
+		if (debug) {
+			const message = success ? `${debugPrefix} Sent via fetch` : `${debugPrefix} Failed: ${response.status}`;
+			console[success ? "log" : "warn"](message);
+		}
+		return success;
+	} catch {
+		if (debug) console.warn(`${debugPrefix} Failed to send`);
+		return false;
+	}
+}
+//#endregion
+export { resetSession as a, removeStorageItem as c, onSessionRotated as i, setStorageItem as l, createId as n, touchActivity as o, getSessionContext as r, getStorageItem as s, sendData as t };

package/dist/error.d.ts

@@ -1,3 +1,4 @@
+import { t as AnalyticsExtension } from "./chunks/extensions-DW7tJY0T.js";
 //#region src/error.d.ts
 type ErrorEntry = {
   error: string;
@@ -9,11 +10,15 @@ interface ErrorTrackingOptions {
   siteKey: string;
   baseUrl?: string;
   debug?: boolean;
+  trackHash?: boolean;
+  cookieless?: boolean;
   flushInterval?: number;
   maxQueueSize?: number;
   sdkName?: string;
   sdkVersion?: string;
 }
+type ErrorTrackingExtensionOptions = Omit<ErrorTrackingOptions, "siteKey" | "baseUrl" | "debug" | "trackHash" | "cookieless" | "sdkName" | "sdkVersion">;
+declare function errorTracking(options?: ErrorTrackingExtensionOptions): AnalyticsExtension;
 declare class ErrorTracker {
   private readonly options;
   private readonly endpoint;
@@ -21,17 +26,17 @@ declare class ErrorTracker {
   private timer;
   private started;
   private flushing;
+  private cookieless;
   constructor(options: ErrorTrackingOptions);
-  private log;
+  setCookielessMode(cookieless: boolean): void;
   start(): void;
-  stop(): void;
+  stop(discard?: boolean): void;
   onPageHidden(persisted?: boolean): void;
   captureError(error: Error): void;
   private onError;
   private onRejection;
-  private addToQueue;
   private enqueue;
   private flush;
 }
 //#endregion
-export { ErrorEntry, ErrorTrackingOptions, ErrorTracker as default };
+export { ErrorEntry, ErrorTrackingExtensionOptions, ErrorTrackingOptions, ErrorTracker as default, errorTracking };

package/dist/error.js

@@ -1,13 +1,35 @@
-import { a as resolveBaseUrl, i as getPageContext, r as URLS, t as ANALYTICS_BASE } from "./chunks/api-urls-CaNa8upY.js";
-import { r as getSessionContext, t as sendData } from "./chunks/send-data-DjdbGDDc.js";
-import { t as getAnonymousId } from "./chunks/identifiers-cUymVK5H.js";
+import { i as resolveBaseUrl, n as URLS, r as getPageContext, t as ANALYTICS_BASE } from "./chunks/api-urls-DWk43fu6.js";
+import { r as getSessionContext, t as sendData } from "./chunks/send-data-DFZnsaL2.js";
+import { t as getAnonymousId } from "./chunks/identifiers-KgQDX74Q.js";
 //#region src/error.ts
 const SDK_NAME = "@faststats/web";
-const SDK_VERSION = "0.6.0";
-const EXTENSION_RE = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
+const SDK_VERSION = "0.8.0";
+function errorTracking(options = {}) {
+	return {
+		name: "error-tracking",
+		setup(context) {
+			const tracker = new ErrorTracker({
+				...options,
+				siteKey: context.siteKey,
+				baseUrl: context.baseUrl,
+				debug: context.debug,
+				trackHash: context.trackHash,
+				cookieless: context.isCookieless(),
+				sdkName: context.sdkName,
+				sdkVersion: context.sdkVersion
+			});
+			context.on("pageHide", ({ persisted }) => tracker.onPageHidden(persisted));
+			context.on("error", ({ error }) => tracker.captureError(error));
+			context.on("consentChange", ({ cookieless }) => tracker.setCookielessMode(cookieless));
+			tracker.start();
+			return ({ discard }) => tracker.stop(discard);
+		}
+	};
+}
+const EXTENSION_URL = /(?:^|\()(chrome|moz|ms-browser|safari-web)-extension:\/\//;
 function toEntry(kind, source, handled, fallback) {
 	if (source instanceof Error) return {
-		error: kind,
+		error: kind === "UnhandledRejection" ? kind : source.name.trim() || kind,
 		message: source.message || fallback,
 		handled,
 		stack: source.stack?.split("\n").map((line) => line.trim()).filter(Boolean)
@@ -18,26 +40,26 @@ function toEntry(kind, source, handled, fallback) {
 		handled
 	};
 }
-function entryKey({ error, message, handled }) {
-	return `${error}\0${message ?? ""}\0${handled}`;
-}
 function isExtensionError(filename, source) {
 	const stack = source instanceof Error ? source.stack ?? "" : "";
-	return EXTENSION_RE.test(`${filename}\n${stack}`);
+	return EXTENSION_URL.test(filename) || EXTENSION_URL.test(stack);
 }
 var ErrorTracker = class {
 	options;
 	endpoint;
-	queue = /* @__PURE__ */ new Map();
+	queue = [];
 	timer = null;
 	started = false;
 	flushing = false;
+	cookieless;
 	constructor(options) {
 		this.options = options;
 		this.endpoint = `${resolveBaseUrl(options.baseUrl, ANALYTICS_BASE)}${URLS.events}`;
+		this.cookieless = options.cookieless ?? false;
 	}
-	log(...args) {
-		if (this.options.debug) console.log("[ErrorTracker]", ...args);
+	setCookielessMode(cookieless) {
+		if (this.cookieless !== cookieless) this.queue = [];
+		this.cookieless = cookieless;
 	}
 	start() {
 		if (this.started || typeof window === "undefined") return;
@@ -45,21 +67,19 @@ var ErrorTracker = class {
 		window.addEventListener("error", this.onError);
 		window.addEventListener("unhandledrejection", this.onRejection);
 		this.timer = setInterval(() => void this.flush(), this.options.flushInterval ?? 5e3);
-		this.log("Started");
 	}
-	stop() {
+	stop(discard = false) {
 		if (!this.started || typeof window === "undefined") return;
 		this.started = false;
 		window.removeEventListener("error", this.onError);
 		window.removeEventListener("unhandledrejection", this.onRejection);
 		if (this.timer) clearInterval(this.timer);
 		this.timer = null;
-		this.flush();
-		this.log("Stopped");
+		if (discard) this.queue = [];
+		else this.flush();
 	}
 	onPageHidden(persisted = false) {
-		if (persisted) return;
-		this.flush();
+		if (!persisted) this.flush();
 	}
 	captureError(error) {
 		this.enqueue(toEntry("Error", error, true, error.message));
@@ -72,56 +92,66 @@ var ErrorTracker = class {
 		if (isExtensionError("", event.reason)) return;
 		this.enqueue(toEntry("UnhandledRejection", event.reason, false, "Unhandled promise rejection"));
 	};
-	addToQueue(entry, count = 1) {
-		const key = entryKey(entry);
-		const existing = this.queue.get(key);
-		if (existing) {
-			existing.count += count;
-			return false;
-		}
-		this.queue.set(key, {
-			...entry,
-			count
+	enqueue(error) {
+		const buildId = globalThis.__SOURCEMAPS_BUILD__?.buildId;
+		const userId = getAnonymousId(this.options.siteKey, this.cookieless);
+		const ctx = getSessionContext(this.options.siteKey, this.cookieless);
+		this.queue.push({
+			error,
+			context: {
+				token: this.options.siteKey,
+				...userId ? { userId } : {},
+				sessionId: ctx.sessionId,
+				windowId: ctx.windowId,
+				...typeof buildId === "string" && buildId.trim() ? { buildId } : {},
+				sdkName: this.options.sdkName ?? SDK_NAME,
+				sdkVersion: this.options.sdkVersion ?? SDK_VERSION,
+				event: "error",
+				...getPageContext(this.options.trackHash ?? false),
+				properties: {}
+			}
 		});
-		return true;
-	}
-	enqueue(entry) {
-		if (this.addToQueue(entry)) this.log("Captured:", entry);
-		if (this.queue.size >= (this.options.maxQueueSize ?? 50)) this.flush();
+		if (this.queue.length >= (this.options.maxQueueSize ?? 50)) this.flush();
 	}
 	async flush() {
-		if (this.flushing || this.queue.size === 0) return;
+		if (this.flushing || !this.queue.length) return;
 		this.flushing = true;
 		const batch = this.queue;
-		this.queue = /* @__PURE__ */ new Map();
-		const errors = [...batch.values()];
-		this.log("Flushing:", errors);
-		try {
-			const buildId = globalThis.__SOURCEMAPS_BUILD__?.buildId;
-			const userId = getAnonymousId();
-			const ctx = getSessionContext(this.options.siteKey);
-			if (!await sendData({
+		this.queue = [];
+		const groups = /* @__PURE__ */ new Map();
+		for (const item of batch) {
+			const key = JSON.stringify(item.context);
+			const group = groups.get(key) ?? {
+				context: item.context,
+				items: []
+			};
+			group.items.push(item);
+			groups.set(key, group);
+		}
+		const failed = await Promise.all([...groups.values()].map(async (group) => {
+			const errors = /* @__PURE__ */ new Map();
+			for (const { error } of group.items) {
+				const key = JSON.stringify(error);
+				const existing = errors.get(key);
+				if (existing) existing.count++;
+				else errors.set(key, {
+					...error,
+					count: 1
+				});
+			}
+			return await sendData({
 				url: this.endpoint,
 				data: JSON.stringify({
-					token: this.options.siteKey,
-					...userId ? { userId } : {},
-					sessionId: ctx.sessionId,
-					windowId: ctx.windowId,
-					...typeof buildId === "string" && buildId.trim() ? { buildId } : {},
-					sdkName: this.options.sdkName ?? SDK_NAME,
-					sdkVersion: this.options.sdkVersion ?? SDK_VERSION,
-					event: "error",
-					...getPageContext(),
-					properties: {},
-					errors
+					...group.context,
+					errors: [...errors.values()]
 				}),
 				debug: this.options.debug,
 				debugPrefix: "[ErrorTracker]"
-			})) for (const item of batch.values()) this.addToQueue(item, item.count);
-		} finally {
-			this.flushing = false;
-		}
+			}) ? [] : group.items;
+		}));
+		this.queue.unshift(...failed.flat());
+		this.flushing = false;
 	}
 };
 //#endregion
-export { ErrorTracker as default };
+export { ErrorTracker as default, errorTracking };