@flareapp/js 2.0.0-rc.1 → 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+## 2.0.0
+
+### Breaking changes
+
+- **Endpoint changed.** SDK now POSTs to `https://ingress.flareapp.io/v1/errors`. Success response is `201 Created`. Auth header is `x-api-token`.
+- **Wire format reshaped to match the server's canonical schema.**
+    - `Report` uses camelCase top-level fields (`exceptionClass`, `seenAtUnixNano`, `sourcemapVersionId`, `isLog`, `level`, `attributes`, `events`).
+    - `StackFrame` uses camelCase (`lineNumber`, `columnNumber`, `codeSnippet`, `isApplicationFrame`).
+    - `Context` is gone. User context is set via `addContext(name, value)` and `addContextGroup(group, value)`; both write into the flat `attributes` map under `context.custom` and `context.<group>`.
+    - Glows ride along as `php_glow`-typed entries in `events[]`.
+- **`report()` second argument** is now an `Attributes` map (was a freeform context object). The third argument (solution provider parameters) is removed.
+- **Config keys renamed:** `reportingUrl` → `ingestUrl`, `sourcemapVersion` → `sourcemapVersionId`.
+- **Deprecated trailing setters removed:** `flare.beforeEvaluate = …`, `flare.beforeSubmit = …`, `flare.stage = …`. Use `flare.configure({ … })`.
+- **`reportMessage` signature changed:** `reportMessage(message, level?, attributes?)`. The old `'Log INFO'` regex is gone, pass `level` directly.
+- **Solutions API removed:** `registerSolutionProvider`, `Solution`, `SolutionProvider`, `SolutionProviderExtraParameters` are all deleted.
+- **`flare.config` is now `Readonly<Config>`** and `flare.glows` is `readonly Glow[]`. Direct property mutation no longer works; use `configure()`.
+
+### New
+
+- **URL redaction.** Sensitive query-string parameters (`password`, `token`, `secret`, `authorization`, etc.) are automatically replaced with `[redacted]` in `url.full`, `url.query`, and `flare.entry_point.value` attributes. Configurable via `urlDenylist` (custom regex) and `replaceDefaultUrlDenylist` (boolean) config options.
+- `DEFAULT_URL_DENYLIST`, `redactFullPath`, and `resolveDenylist` are exported for direct use by framework adapters.
+- `setEntryPoint({ identifier?, name?, type? })` — mutable global setter for the entry-point handler. SPA framework adapters call this on every navigation.
+- `setSdkInfo({ name, version })` — overridable SDK identity (default `@flareapp/js` + client version). Integrations override it.
+- `setFramework({ name, version? })` — host framework attribution (e.g. React, Vue).
+- `code` field auto-populated from `error.code` when present (string, ≤64 chars).
+- Non-`Error` values passed to `report()` are coerced to `Error` instead of silently failing.
+- Browser context attributes (`url.full`, `url.query`, `browser.user_agent`, `browser.viewport.*`, cookies, request data) are auto-collected on each report.
+- New exported types: `SpanEvent`, `EntryPointHandler`, `Framework`, `SdkInfo`, `OverriddenGrouping`, `Attributes`, `AttributeValue`.
+- **`sampleRate` config option.** Number between `0` and `1` (default `1`). Controls what fraction of errors are reported. Applies to `report()`, `reportMessage()`, and `reportUnhandledRejection()`.
+
+### Notes
+
+- `seenAtUnixNano` is now real nanoseconds (`Date.now() * 1_000_000`).

package/README.md

@@ -1,9 +1,30 @@
-# The JavaScript client for Flare to catch frontend errors
+# @flareapp/js
 
-Read the JavaScript error tracking section in [the Flare documentation](https://flareapp.io/docs/javascript-error-tracking/installation) for more information.
+The core JavaScript/TypeScript client for [Flare](https://flareapp.io) error tracking. Captures frontend errors, parses
+stack traces, collects browser context, and reports everything to the Flare backend.
 
-React plugin: https://www.npmjs.com/package/@flareapp/react
+## Installation
 
-Vue plugin: https://www.npmjs.com/package/@flareapp/vue
+```bash
+npm install @flareapp/js
+```
 
-Webpack plugin: https://www.npmjs.com/package/@flareapp/flare-webpack-plugin-sourcemap
+## Quick start
+
+```js
+import { flare } from '@flareapp/js';
+
+flare.light('YOUR_FLARE_API_KEY');
+```
+
+That is all you need. The client automatically listens for uncaught exceptions and unhandled promise rejections,
+collects browser context, and sends error reports to Flare.
+
+## Documentation
+
+Full documentation on configuration, hooks, context, breadcrumbs, solution providers, and more is available
+at [flareapp.io/docs/javascript/general/installation](https://flareapp.io/docs/javascript/general/installation).
+
+## License
+
+The MIT License (MIT). Please see [License File](../../LICENSE.md) for more information.

package/dist/index.cjs

@@ -0,0 +1,603 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let error_stack_parser = require("error-stack-parser");
+error_stack_parser = __toESM(error_stack_parser);
+
+//#region src/browser/catchWindowErrors.ts
+function catchWindowErrors() {
+	if (typeof window === "undefined") return;
+	window.addEventListener("error", (event) => {
+		const flare = window.flare;
+		if (!flare) return;
+		if (event.error instanceof Error) Promise.resolve(flare.report(event.error)).catch(() => {});
+	});
+	window.addEventListener("unhandledrejection", (event) => {
+		const flare = window.flare;
+		if (!flare) return;
+		const reason = event.reason;
+		if (reason instanceof Error) {
+			Promise.resolve(flare.report(reason)).catch(() => {});
+			return;
+		}
+		if (hasStack$1(reason)) {
+			const error = new Error(describeRejectionReason(reason));
+			error.stack = reason.stack;
+			Promise.resolve(flare.report(error)).catch(() => {});
+			return;
+		}
+		Promise.resolve(flare.reportUnhandledRejection(describeRejectionReason(reason))).catch(() => {});
+	});
+}
+function describeRejectionReason(reason) {
+	if (typeof reason === "string") return reason;
+	if (reason && typeof reason === "object") {
+		const message = reason.message;
+		if (typeof message === "string") return message;
+		try {
+			return JSON.stringify(reason);
+		} catch {
+			return "Unhandled promise rejection (non-serializable reason)";
+		}
+	}
+	return String(reason);
+}
+function hasStack$1(value) {
+	return typeof value === "object" && value !== null && "stack" in value && typeof value.stack === "string";
+}
+
+//#endregion
+//#region src/env/index.ts
+const CLIENT_VERSION = typeof process !== "undefined" && true ? "2.0.0" : "?";
+const KEY = typeof FLARE_JS_KEY === "undefined" ? "" : FLARE_JS_KEY;
+const SOURCEMAP_VERSION = typeof FLARE_SOURCEMAP_VERSION === "undefined" ? "" : FLARE_SOURCEMAP_VERSION;
+
+//#endregion
+//#region src/util/assert.ts
+function assert(value, message, debug) {
+	if (debug && !value) console.error(`Flare JavaScript client v${CLIENT_VERSION}: ${message}`);
+	return !!value;
+}
+
+//#endregion
+//#region src/util/assertKey.ts
+function assertKey(key, debug) {
+	return assert(key, "The client was not yet initialised with an API key. Run client.light('<flare-project-key>') when you initialise your app. If you are running in dev mode and didn't run the light command on purpose, you can ignore this error.", debug);
+}
+
+//#endregion
+//#region src/util/extractCode.ts
+const MAX_CODE_LENGTH = 64;
+function extractCode(error) {
+	const code = error.code;
+	if (typeof code !== "string" || code.length === 0) return;
+	return code.slice(0, MAX_CODE_LENGTH);
+}
+
+//#endregion
+//#region src/util/flatJsonStringify.ts
+function flatJsonStringify(json) {
+	return JSON.stringify(decycle(json));
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function decycle(root) {
+	const inPath = /* @__PURE__ */ new WeakSet();
+	function clone(node) {
+		if (Array.isArray(node)) {
+			if (inPath.has(node)) return "[Circular]";
+			inPath.add(node);
+			const result = node.map(clone);
+			inPath.delete(node);
+			return result;
+		}
+		if (isPlainObject(node)) {
+			if (inPath.has(node)) return "[Circular]";
+			inPath.add(node);
+			const result = {};
+			for (const [k, v] of Object.entries(node)) result[k] = clone(v);
+			inPath.delete(node);
+			return result;
+		}
+		return node;
+	}
+	return clone(root);
+}
+
+//#endregion
+//#region src/util/glowsToEvents.ts
+function glowsToEvents(glows) {
+	return glows.map((glow) => ({
+		type: "php_glow",
+		startTimeUnixNano: Math.round(glow.microtime * 1e9),
+		endTimeUnixNano: null,
+		attributes: {
+			"glow.name": String(glow.name),
+			"glow.level": glow.messageLevel,
+			"glow.context": glow.metaData ?? {}
+		}
+	}));
+}
+
+//#endregion
+//#region src/util/now.ts
+function now() {
+	return Math.round(Date.now() / 1e3);
+}
+
+//#endregion
+//#region src/util/redactUrl.ts
+const DEFAULT_URL_DENYLIST = /password|passwd|pwd|token|secret|authorization|\bauth\b|bearer|oauth|credentials?|cookie|api[-_]?key|private[-_]?key|session|csrf|xsrf|\bpin\b|\bssn\b|card[-_]?number|\bcvv\b/i;
+function resolveDenylist(custom, replaceDefault = false, defaultDenylist = DEFAULT_URL_DENYLIST) {
+	if (!custom) return defaultDenylist;
+	if (replaceDefault) {
+		const safeFlags = custom.flags.replace(/[gy]/g, "");
+		return new RegExp(custom.source, safeFlags);
+	}
+	const flags = unionFlags(defaultDenylist.flags, custom.flags);
+	return new RegExp(`(?:${defaultDenylist.source})|(?:${custom.source})`, flags);
+}
+function unionFlags(a, b) {
+	const merged = /* @__PURE__ */ new Set();
+	for (const flag of a + b) {
+		if (flag === "g" || flag === "y") continue;
+		merged.add(flag);
+	}
+	return [...merged].join("");
+}
+function redactFullPath(fullPath, denylist = DEFAULT_URL_DENYLIST) {
+	const queryStart = fullPath.indexOf("?");
+	if (queryStart === -1) return fullPath;
+	const hashStart = fullPath.indexOf("#", queryStart);
+	const queryEnd = hashStart === -1 ? fullPath.length : hashStart;
+	const prefix = fullPath.slice(0, queryStart + 1);
+	const queryString = fullPath.slice(queryStart + 1, queryEnd);
+	const suffix = fullPath.slice(queryEnd);
+	return `${prefix}${queryString.split("&").map((pair) => {
+		if (pair === "") return pair;
+		const eq = pair.indexOf("=");
+		const rawKey = eq === -1 ? pair : pair.slice(0, eq);
+		const decodedKey = safeDecode(rawKey);
+		if (!denylist.test(decodedKey)) return pair;
+		return eq === -1 ? rawKey : `${rawKey}=[redacted]`;
+	}).join("&")}${suffix}`;
+}
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+
+//#endregion
+//#region src/api/Api.ts
+var Api = class {
+	report(report, url, key, reportBrowserExtensionErrors, debug = false) {
+		return fetch(url, {
+			method: "POST",
+			headers: {
+				"Accept": "application/json",
+				"Content-Type": "application/json",
+				"X-Api-Token": key ?? "",
+				"X-Report-Browser-Extension-Errors": JSON.stringify(reportBrowserExtensionErrors),
+				"X-Flare-Client-Version": "2"
+			},
+			body: flatJsonStringify(report)
+		}).then((response) => {
+			if (debug && response.status !== 201) console.error(`Received response with status ${response.status} from Flare`);
+		}, (error) => {
+			if (debug) console.error(error);
+		});
+	}
+};
+
+//#endregion
+//#region src/context/cookie.ts
+function cookie() {
+	if (!window.document.cookie) return {};
+	const cookies = {};
+	window.document.cookie.split("; ").forEach((rawCookie) => {
+		const idx = rawCookie.indexOf("=");
+		if (idx === -1) {
+			cookies[rawCookie] = "";
+			return;
+		}
+		const name = rawCookie.slice(0, idx);
+		cookies[name] = rawCookie.slice(idx + 1);
+	});
+	return { "http.request.cookies": cookies };
+}
+
+//#endregion
+//#region src/context/request.ts
+function request(urlDenylist) {
+	return {
+		"url.full": redactFullPath(window.location.href, urlDenylist),
+		"user_agent.original": window.navigator.userAgent,
+		"http.request.referrer": redactFullPath(window.document.referrer, urlDenylist),
+		"document.ready_state": window.document.readyState
+	};
+}
+
+//#endregion
+//#region src/context/requestData.ts
+function requestData(urlDenylist) {
+	if (!window.location.search) return {};
+	return { "url.query": redactFullPath(window.location.search, urlDenylist).replace(/^\?/, "") };
+}
+
+//#endregion
+//#region src/context/collectAttributes.ts
+function collectAttributes(urlDenylist) {
+	if (typeof window === "undefined") return {};
+	return {
+		...request(urlDenylist),
+		...requestData(urlDenylist),
+		...cookie()
+	};
+}
+
+//#endregion
+//#region src/stacktrace/fileReader.ts
+const cachedFiles = {};
+function getCodeSnippet(url, lineNumber, columnNumber) {
+	return new Promise((resolve) => {
+		if (!url || !lineNumber) return resolve({
+			codeSnippet: { 0: `Could not read from file: missing file URL or line number. URL: ${url} lineNumber: ${lineNumber}` },
+			trimmedColumnNumber: null
+		});
+		if (!isFetchableUrl(url)) return resolve({
+			codeSnippet: { 0: `Could not read from file: unsupported URL scheme. URL: ${url}` },
+			trimmedColumnNumber: null
+		});
+		readFile(url).then((fileText) => {
+			if (!fileText) return resolve({
+				codeSnippet: { 0: `Could not read from file: Error while opening file at URL ${url}` },
+				trimmedColumnNumber: null
+			});
+			return resolve(readLinesFromFile(fileText, lineNumber, columnNumber));
+		});
+	});
+}
+function isFetchableUrl(url) {
+	return /^https?:\/\//i.test(url);
+}
+function readFile(url) {
+	if (cachedFiles[url] !== void 0) return Promise.resolve(cachedFiles[url]);
+	return fetch(url).then((response) => {
+		if (response.status !== 200) return null;
+		return response.text();
+	}).then((text) => {
+		if (text !== null) cachedFiles[url] = text;
+		return text;
+	}).catch(() => null);
+}
+function readLinesFromFile(fileText, lineNumber, columnNumber, maxSnippetLineLength = 1e3, maxSnippetLines = 40) {
+	const codeSnippet = {};
+	let trimmedColumnNumber = null;
+	const lines = fileText.split("\n");
+	const errorLineIndex = lineNumber - 1;
+	const half = Math.floor(maxSnippetLines / 2);
+	for (let i = -half; i <= half; i++) {
+		const currentLineIndex = errorLineIndex + i;
+		if (currentLineIndex < 0 || !lines[currentLineIndex]) continue;
+		const displayLine = currentLineIndex + 1;
+		const line = lines[currentLineIndex];
+		if (line.length > maxSnippetLineLength) {
+			if (columnNumber && columnNumber > maxSnippetLineLength / 2) {
+				const start = columnNumber - Math.round(maxSnippetLineLength / 2);
+				codeSnippet[displayLine] = line.slice(start, start + maxSnippetLineLength);
+				if (displayLine === lineNumber) trimmedColumnNumber = Math.round(maxSnippetLineLength / 2);
+				continue;
+			}
+			codeSnippet[displayLine] = line.slice(0, maxSnippetLineLength) + "…";
+			continue;
+		}
+		codeSnippet[displayLine] = line;
+	}
+	return {
+		codeSnippet,
+		trimmedColumnNumber
+	};
+}
+
+//#endregion
+//#region src/stacktrace/createStackTrace.ts
+function createStackTrace(error, debug) {
+	return new Promise((resolve) => {
+		if (!hasStack(error)) return resolve([fallbackFrame("stacktrace missing")]);
+		let parsedFrames;
+		try {
+			parsedFrames = error_stack_parser.default.parse(error);
+		} catch (parseError) {
+			assert(false, "Couldn't parse stacktrace of below error:", debug);
+			if (debug) {
+				console.error(parseError);
+				console.error(error);
+			}
+			return resolve([fallbackFrame("stacktrace could not be parsed")]);
+		}
+		Promise.all(parsedFrames.map((frame) => {
+			return getCodeSnippet(frame.fileName, frame.lineNumber, frame.columnNumber).then((snippet) => ({
+				lineNumber: frame.lineNumber || 1,
+				columnNumber: frame.columnNumber || 1,
+				method: frame.functionName || "Anonymous or unknown function",
+				file: frame.fileName || "Unknown file",
+				codeSnippet: snippet.codeSnippet,
+				class: "",
+				isApplicationFrame: isApplicationFrame(frame.fileName)
+			}));
+		})).then(resolve);
+	});
+}
+function fallbackFrame(reason) {
+	return {
+		lineNumber: 0,
+		columnNumber: 0,
+		method: "unknown",
+		file: "unknown",
+		codeSnippet: { 0: `Could not read from file: ${reason}` },
+		class: "unknown"
+	};
+}
+function hasStack(err) {
+	if (!err || typeof err !== "object") return false;
+	const e = err;
+	const stack = e.stack ?? e.stacktrace ?? e["opera#sourceloc"];
+	return typeof stack === "string" && stack !== `${e.name}: ${e.message}`;
+}
+function isApplicationFrame(fileName) {
+	if (!fileName) return true;
+	if (/[/\\]node_modules[/\\]/.test(fileName)) return false;
+	if (/(^|[/\\])(vendor|vendors)[.~-][^/\\]*\.js/i.test(fileName)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/Flare.ts
+const DEFAULT_SDK_NAME = "@flareapp/js";
+var Flare = class {
+	_config = {
+		key: null,
+		version: "",
+		sourcemapVersionId: SOURCEMAP_VERSION,
+		stage: "",
+		maxGlowsPerReport: 30,
+		ingestUrl: "https://ingress.flareapp.io/v1/errors",
+		reportBrowserExtensionErrors: false,
+		debug: false,
+		urlDenylist: DEFAULT_URL_DENYLIST,
+		replaceDefaultUrlDenylist: false,
+		sampleRate: 1,
+		beforeEvaluate: (error) => error,
+		beforeSubmit: (report) => report
+	};
+	_glows = [];
+	pendingAttributes = {};
+	entryPoint = null;
+	sdkInfo = {
+		name: DEFAULT_SDK_NAME,
+		version: CLIENT_VERSION
+	};
+	framework = null;
+	constructor(api = new Api()) {
+		this.api = api;
+	}
+	get config() {
+		return this._config;
+	}
+	get glows() {
+		return this._glows;
+	}
+	light(key = KEY, debug) {
+		this._config.key = key;
+		if (debug !== void 0) this._config.debug = debug;
+		return this;
+	}
+	configure(config) {
+		this._config = {
+			...this._config,
+			...config
+		};
+		if (config.sampleRate !== void 0) this._config.sampleRate = Math.max(0, Math.min(1, config.sampleRate));
+		this._config.urlDenylist = resolveDenylist(config.urlDenylist, config.replaceDefaultUrlDenylist ?? this._config.replaceDefaultUrlDenylist);
+		return this;
+	}
+	async test() {
+		const report = await this.createReportFromError(/* @__PURE__ */ new Error("The Flare client is set up correctly!"));
+		if (!report) return;
+		return this.sendReport(report);
+	}
+	glow(name, level = "info", data = []) {
+		const time = now();
+		this._glows.push({
+			name,
+			messageLevel: level,
+			metaData: data,
+			time,
+			microtime: time
+		});
+		if (this._glows.length > this._config.maxGlowsPerReport) this._glows = this._glows.slice(this._glows.length - this._config.maxGlowsPerReport);
+		return this;
+	}
+	clearGlows() {
+		this._glows = [];
+		return this;
+	}
+	addContext(name, value) {
+		const existing = this.pendingAttributes["context.custom"] ?? {};
+		this.pendingAttributes["context.custom"] = {
+			...existing,
+			[name]: value
+		};
+		return this;
+	}
+	addContextGroup(groupName, value) {
+		this.pendingAttributes[`context.${groupName}`] = value;
+		return this;
+	}
+	setEntryPoint(handler) {
+		this.entryPoint = handler;
+		return this;
+	}
+	setSdkInfo(info) {
+		this.sdkInfo = info;
+		return this;
+	}
+	setFramework(framework) {
+		this.framework = framework;
+		return this;
+	}
+	async report(error, attributes = {}) {
+		if (this._config.sampleRate < 1 && Math.random() >= this._config.sampleRate) return;
+		const seenAtUnixNano = Date.now() * 1e6;
+		const coerced = error instanceof Error ? error : new Error(typeof error === "string" ? error : String(error));
+		const errorToReport = await this._config.beforeEvaluate(coerced);
+		if (!errorToReport) return;
+		const report = await this.createReportFromError(errorToReport, attributes, seenAtUnixNano);
+		if (!report) return;
+		return this.sendReport(report);
+	}
+	async reportUnhandledRejection(message, attributes = {}) {
+		if (Math.random() >= this._config.sampleRate) return;
+		const seenAtUnixNano = Date.now() * 1e6;
+		const report = this.buildReport({
+			exceptionClass: "UnhandledRejection",
+			message,
+			stacktrace: [],
+			isLog: false,
+			level: void 0,
+			extraAttributes: attributes,
+			code: void 0,
+			seenAtUnixNano
+		});
+		return this.sendReport(report);
+	}
+	async reportMessage(message, level, attributes = {}) {
+		if (this._config.sampleRate < 1 && Math.random() >= this._config.sampleRate) return;
+		const seenAtUnixNano = Date.now() * 1e6;
+		const stackTrace = await createStackTrace(/* @__PURE__ */ new Error(), this._config.debug);
+		stackTrace.shift();
+		const report = this.buildReport({
+			exceptionClass: "Log",
+			message,
+			stacktrace: stackTrace,
+			isLog: true,
+			level,
+			extraAttributes: attributes,
+			code: void 0,
+			seenAtUnixNano
+		});
+		return this.sendReport(report);
+	}
+	async createReportFromError(error, attributes = {}, seenAtUnixNano = Date.now() * 1e6) {
+		if (!assert(error, "No error provided.", this._config.debug)) return false;
+		const stacktrace = await createStackTrace(error, this._config.debug);
+		assert(stacktrace.length, "Couldn't generate stacktrace of this error: " + error, this._config.debug);
+		const exceptionClass = error.constructor && error.constructor.name ? error.constructor.name : "undefined";
+		return this.buildReport({
+			exceptionClass,
+			message: error.message,
+			stacktrace,
+			isLog: false,
+			level: void 0,
+			extraAttributes: attributes,
+			code: extractCode(error),
+			seenAtUnixNano
+		});
+	}
+	buildReport(input) {
+		const baseAttributes = {
+			"telemetry.sdk.language": "javascript",
+			"telemetry.sdk.name": this.sdkInfo.name,
+			"telemetry.sdk.version": this.sdkInfo.version,
+			"flare.language.name": "javascript",
+			"flare.entry_point.type": "web"
+		};
+		if (typeof window !== "undefined" && window?.location?.href) baseAttributes["flare.entry_point.value"] = redactFullPath(window.location.href, this._config.urlDenylist);
+		const handlerIdentifier = this.entryPoint?.identifier ?? (typeof window !== "undefined" && window?.location?.pathname ? window.location.pathname : void 0);
+		const handlerType = this.entryPoint?.type ?? (typeof window !== "undefined" && window ? "browser" : void 0);
+		if (handlerIdentifier !== void 0) baseAttributes["flare.entry_point.handler.identifier"] = handlerIdentifier;
+		if (handlerType !== void 0) baseAttributes["flare.entry_point.handler.type"] = handlerType;
+		if (this.entryPoint?.name !== void 0) baseAttributes["flare.entry_point.handler.name"] = this.entryPoint.name;
+		if (this.framework?.name) baseAttributes["flare.framework.name"] = this.framework.name;
+		if (this.framework?.version) baseAttributes["flare.framework.version"] = this.framework.version;
+		if (this._config.stage) baseAttributes["service.stage"] = this._config.stage;
+		if (this._config.version) baseAttributes["service.version"] = this._config.version;
+		const attributes = {
+			...baseAttributes,
+			...collectAttributes(this._config.urlDenylist),
+			...this.pendingAttributes,
+			...input.extraAttributes
+		};
+		const pendingCustom = this.pendingAttributes["context.custom"];
+		const extraCustom = input.extraAttributes["context.custom"];
+		if (pendingCustom && extraCustom && typeof pendingCustom === "object" && typeof extraCustom === "object" && !Array.isArray(pendingCustom) && !Array.isArray(extraCustom)) attributes["context.custom"] = {
+			...pendingCustom,
+			...extraCustom
+		};
+		const report = {
+			exceptionClass: input.exceptionClass,
+			message: input.message,
+			seenAtUnixNano: input.seenAtUnixNano,
+			stacktrace: input.stacktrace,
+			events: glowsToEvents(this._glows),
+			attributes
+		};
+		if (input.isLog) report.isLog = true;
+		if (input.level !== void 0) report.level = input.level;
+		if (this._config.sourcemapVersionId) report.sourcemapVersionId = this._config.sourcemapVersionId;
+		if (input.code !== void 0) report.code = input.code;
+		return report;
+	}
+	async sendReport(report) {
+		if (!assertKey(this._config.key, this._config.debug)) return;
+		const reportToSubmit = await this._config.beforeSubmit(report);
+		if (!reportToSubmit) return;
+		return this.api.report(reportToSubmit, this._config.ingestUrl, this._config.key, this._config.reportBrowserExtensionErrors, this._config.debug);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const flare = new Flare();
+if (typeof window !== "undefined" && window) {
+	window.flare = flare;
+	catchWindowErrors();
+}
+
+//#endregion
+exports.DEFAULT_URL_DENYLIST = DEFAULT_URL_DENYLIST;
+exports.Flare = Flare;
+exports.flare = flare;
+exports.redactFullPath = redactFullPath;
+exports.resolveDenylist = resolveDenylist;