preact-perf-tracker 0.1.0

package/dist/index.cjs

@@ -0,0 +1,744 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let preact = require("preact");
+
+//#region src/types.ts
+let ChangeType = /* @__PURE__ */ function(ChangeType) {
+	ChangeType[ChangeType["Props"] = 1] = "Props";
+	ChangeType[ChangeType["State"] = 2] = "State";
+	ChangeType[ChangeType["Context"] = 4] = "Context";
+	ChangeType[ChangeType["Force"] = 8] = "Force";
+	return ChangeType;
+}({});
+
+//#endregion
+//#region src/utils.ts
+function getDisplayName(vnode) {
+	const type = vnode.type;
+	if (typeof type === "string") return null;
+	if (typeof type === "function") {
+		const name = type.displayName || type.name || null;
+		if (name === "type" || name === "anonymous") return null;
+		return name;
+	}
+	return null;
+}
+function getComponentDOMNode(vnode) {
+	let dom = vnode.__e;
+	if (dom instanceof Element) return dom;
+	const children = vnode.__k;
+	if (children) for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (!child) continue;
+		if (child.__e instanceof Element) return child.__e;
+	}
+	return null;
+}
+function shallowDiff(prev, next) {
+	const changed = [];
+	if (!prev && !next) return changed;
+	if (!prev || !next) return Object.keys(next || prev || {});
+	const allKeys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+	for (const key of allKeys) {
+		if (key === "children") continue;
+		if (!Object.is(prev[key], next[key])) changed.push(key);
+	}
+	return changed;
+}
+function isComponentVNode(vnode) {
+	return typeof vnode.type === "function";
+}
+function snapshot(obj) {
+	if (!obj) return null;
+	return Object.assign({}, obj);
+}
+const now = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+
+//#endregion
+//#region src/instrumentation.ts
+const renderStartTimes = /* @__PURE__ */ new WeakMap();
+const defaultOptions = {
+	enabled: true,
+	log: false,
+	showToolbar: true,
+	animationSpeed: "fast"
+};
+/**
+* Whether our permanent hook wrappers have been installed.
+* Once installed they stay in place for the lifetime of the page;
+* `isHooked` toggles them between active / pass-through so that
+* libraries hooking *after* us are never clobbered on unhook.
+*/
+let hooksInstalled = false;
+let savedOriginalHooks = null;
+let activeOptions = { ...defaultOptions };
+const reportData = /* @__PURE__ */ new Map();
+const renderListeners = /* @__PURE__ */ new Set();
+let isHooked = false;
+let inCommit = false;
+function detectChanges(component, vnode, isMounting) {
+	const changes = [];
+	if (isMounting) return changes;
+	const prevProps = component.__prevProps;
+	const nextProps = vnode.props;
+	const changedPropKeys = shallowDiff(prevProps, nextProps);
+	for (const key of changedPropKeys) changes.push({
+		type: ChangeType.Props,
+		name: key,
+		prevValue: prevProps?.[key],
+		nextValue: nextProps[key]
+	});
+	const prevState = component.__prevState;
+	const nextState = component.__s ?? component.state;
+	if (prevState && nextState) {
+		const changedStateKeys = shallowDiff(prevState, nextState);
+		for (const key of changedStateKeys) changes.push({
+			type: ChangeType.State,
+			name: key,
+			prevValue: prevState[key],
+			nextValue: nextState[key]
+		});
+	}
+	if (component.__f) changes.push({
+		type: ChangeType.Force,
+		name: "forceUpdate"
+	});
+	return changes;
+}
+function emitRender(info) {
+	for (const listener of renderListeners) listener(info);
+}
+function onBeforeDiff(vnode) {
+	if (!activeOptions.enabled) return;
+	if (!inCommit) {
+		inCommit = true;
+		activeOptions.onCommitStart?.();
+	}
+}
+function onBeforeRender(vnode) {
+	if (!activeOptions.enabled) return;
+	if (!isComponentVNode(vnode)) return;
+	if (vnode.type === preact.Fragment) return;
+	const component = vnode.__c;
+	if (!component) return;
+	renderStartTimes.set(component, now());
+}
+function onDiffed(vnode) {
+	if (!activeOptions.enabled) return;
+	if (!isComponentVNode(vnode)) return;
+	if (vnode.type === preact.Fragment) return;
+	const component = vnode.__c;
+	if (!component) return;
+	const startTime = renderStartTimes.get(component);
+	const selfTime = startTime != null ? now() - startTime : 0;
+	renderStartTimes.delete(component);
+	const isMounting = component.__prevProps === void 0;
+	const changes = detectChanges(component, vnode, isMounting);
+	const componentName = getDisplayName(vnode) || "Anonymous";
+	const domNode = getComponentDOMNode(vnode);
+	const info = {
+		componentName,
+		phase: isMounting ? "mount" : "update",
+		selfTime,
+		changes,
+		timestamp: now(),
+		domNode
+	};
+	component.__prevProps = snapshot(vnode.props);
+	component.__prevState = snapshot(component.__s ?? component.state);
+	const type = vnode.type;
+	let entry = reportData.get(type);
+	if (!entry) {
+		entry = {
+			count: 0,
+			totalSelfTime: 0,
+			displayName: componentName,
+			type
+		};
+		reportData.set(type, entry);
+	}
+	entry.count++;
+	entry.totalSelfTime += selfTime;
+	if (activeOptions.log) logRender(info);
+	activeOptions.onRender?.(info);
+	emitRender(info);
+}
+function onCommit(_vnode, _commitQueue) {
+	if (!activeOptions.enabled) return;
+	if (inCommit) {
+		inCommit = false;
+		activeOptions.onCommitFinish?.();
+	}
+}
+function onUnmount(vnode) {
+	if (!activeOptions.enabled) return;
+	if (!isComponentVNode(vnode)) return;
+	if (vnode.type === preact.Fragment) return;
+	const componentName = getDisplayName(vnode) || "Anonymous";
+	const domNode = getComponentDOMNode(vnode);
+	const info = {
+		componentName,
+		phase: "unmount",
+		selfTime: 0,
+		changes: [],
+		timestamp: now(),
+		domNode
+	};
+	activeOptions.onRender?.(info);
+	emitRender(info);
+}
+function logRender(info) {
+	const parts = [
+		`%c[preact-perf-tracker]%c ${info.componentName}`,
+		"color: #8b5cf6; font-weight: bold",
+		"color: inherit"
+	];
+	const meta = [info.phase];
+	if (info.selfTime >= .01) meta.push(`${info.selfTime.toFixed(2)}ms`);
+	if (info.changes.length > 0) meta.push(info.changes.map((c) => `${c.type === 1 ? "prop" : c.type === 2 ? "state" : c.type === 4 ? "ctx" : "force"}:${c.name}`).join(", "));
+	parts[0] += ` (${meta.join(" · ")})`;
+	console.log(...parts);
+}
+/**
+* Install the Preact options hooks for render tracking.
+*
+* The wrappers are installed once and stay in place for the lifetime
+* of the page.  `isHooked` toggles them between "active" (running
+* our instrumentation) and "pass-through" (just forwarding to the
+* previously chained hook).  This avoids the destructive restore
+* that would clobber hooks installed by other libraries (e.g.
+* hooks / signals) that chain after us.
+*/
+function hookIntoPreact() {
+	if (isHooked) return;
+	isHooked = true;
+	if (hooksInstalled) return;
+	hooksInstalled = true;
+	const opts = preact.options;
+	savedOriginalHooks = {
+		__b: opts.__b,
+		__r: opts.__r,
+		diffed: opts.diffed,
+		__c: opts.__c,
+		unmount: opts.unmount
+	};
+	const prev__b = opts.__b;
+	opts.__b = (vnode) => {
+		if (isHooked) onBeforeDiff(vnode);
+		prev__b?.(vnode);
+	};
+	const prev__r = opts.__r;
+	opts.__r = (vnode) => {
+		if (isHooked) onBeforeRender(vnode);
+		prev__r?.(vnode);
+	};
+	const prevDiffed = opts.diffed;
+	opts.diffed = (vnode) => {
+		if (isHooked) onDiffed(vnode);
+		prevDiffed?.(vnode);
+	};
+	const prev__c = opts.__c;
+	opts.__c = (vnode, queue) => {
+		if (isHooked) onCommit(vnode, queue);
+		prev__c?.(vnode, queue);
+	};
+	const prevUnmount = opts.unmount;
+	opts.unmount = (vnode) => {
+		if (isHooked) onUnmount(vnode);
+		prevUnmount?.(vnode);
+	};
+}
+/**
+* Disable our instrumentation hooks.  The wrappers stay in the
+* options chain as transparent pass-throughs so that hooks installed
+* by other libraries after us are never lost.
+*/
+function unhookFromPreact() {
+	isHooked = false;
+}
+function getActiveOptions() {
+	return activeOptions;
+}
+function setActiveOptions(opts) {
+	Object.assign(activeOptions, opts);
+}
+function resetActiveOptions() {
+	activeOptions = { ...defaultOptions };
+}
+/**
+* Get render report for all tracked components, or a specific type.
+*/
+function getReport$1(type) {
+	if (type !== void 0) return reportData.get(type) ?? null;
+	return new Map(reportData);
+}
+function clearReport$1() {
+	reportData.clear();
+}
+/**
+* Register a listener that fires for every tracked render.
+*/
+function addRenderListener(fn) {
+	renderListeners.add(fn);
+}
+function removeRenderListener(fn) {
+	renderListeners.delete(fn);
+}
+/**
+* Get a sorted summary for quick insights (highest total self-time first).
+*/
+function getReportSummary$1(limit = 10) {
+	const normalizedLimit = Math.max(1, Math.floor(limit));
+	return Array.from(reportData.values()).map((entry) => ({
+		displayName: entry.displayName || "Anonymous",
+		count: entry.count,
+		totalSelfTime: entry.totalSelfTime,
+		avgSelfTime: entry.count > 0 ? entry.totalSelfTime / entry.count : 0
+	})).sort((a, b) => {
+		if (b.totalSelfTime !== a.totalSelfTime) return b.totalSelfTime - a.totalSelfTime;
+		return b.count - a.count;
+	}).slice(0, normalizedLimit);
+}
+
+//#endregion
+//#region src/overlay.ts
+const OUTLINE_DURATION_MS = 750;
+const FADE_SPEED = {
+	fast: 1.5,
+	slow: .6,
+	off: 999
+};
+function getOutlineColor(count) {
+	if (count <= 1) return "rgba(128, 90, 213, ALPHA)";
+	if (count <= 4) return "rgba(168, 85, 247, ALPHA)";
+	if (count <= 10) return "rgba(234, 88, 12, ALPHA)";
+	return "rgba(239, 68, 68, ALPHA)";
+}
+function borderWidthForTime(ms) {
+	if (ms < 1) return 1;
+	if (ms < 8) return 2;
+	if (ms < 16) return 3;
+	return 4;
+}
+const outlines = /* @__PURE__ */ new Map();
+let canvas = null;
+let ctx = null;
+let rafId = null;
+let isRunning = false;
+function ensureCanvas() {
+	if (canvas && ctx) return ctx;
+	canvas = document.createElement("canvas");
+	canvas.id = "preact-scan-overlay";
+	Object.assign(canvas.style, {
+		position: "fixed",
+		top: "0",
+		left: "0",
+		width: "100vw",
+		height: "100vh",
+		pointerEvents: "none",
+		zIndex: "2147483646"
+	});
+	document.documentElement.appendChild(canvas);
+	ctx = canvas.getContext("2d");
+	resizeCanvas();
+	window.addEventListener("resize", resizeCanvas);
+	return ctx;
+}
+function resizeCanvas() {
+	if (!canvas) return;
+	const dpr = window.devicePixelRatio || 1;
+	canvas.width = window.innerWidth * dpr;
+	canvas.height = window.innerHeight * dpr;
+	ctx?.scale(dpr, dpr);
+}
+function drawFrame() {
+	if (!ctx || !canvas) return;
+	const speed = FADE_SPEED[getActiveOptions().animationSpeed ?? "fast"] ?? 1.5;
+	const nowMs = performance.now();
+	ctx.clearRect(0, 0, canvas.width, canvas.height);
+	for (const [element, outline] of outlines) {
+		if (!element.isConnected) {
+			outlines.delete(element);
+			continue;
+		}
+		const elapsed = nowMs - outline.timestamp;
+		const progress = Math.min(elapsed / OUTLINE_DURATION_MS, 1);
+		outline.alpha = Math.max(0, 1 - progress * speed);
+		if (outline.alpha <= .01) {
+			outlines.delete(element);
+			continue;
+		}
+		const rect = element.getBoundingClientRect();
+		if (rect.width === 0 && rect.height === 0) continue;
+		outline.rect = rect;
+		drawOutline(outline);
+	}
+	if (outlines.size > 0) rafId = requestAnimationFrame(drawFrame);
+	else {
+		stopLoop();
+		ctx.clearRect(0, 0, canvas.width, canvas.height);
+	}
+}
+function drawOutline(outline) {
+	if (!ctx) return;
+	const { rect, alpha, color, count, name } = outline;
+	const resolvedColor = color.replace("ALPHA", String(alpha));
+	const borderWidth = borderWidthForTime(outline.selfTimeMs);
+	ctx.strokeStyle = resolvedColor;
+	ctx.lineWidth = borderWidth;
+	ctx.strokeRect(rect.x + borderWidth / 2, rect.y + borderWidth / 2, rect.width - borderWidth, rect.height - borderWidth);
+	ctx.fillStyle = color.replace("ALPHA", String(alpha * .08));
+	ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+	if (alpha > .3) {
+		const renderTimeLabel = outline.selfTimeMs >= .01 ? ` ${outline.selfTimeMs.toFixed(2)}ms` : "";
+		const label = count > 1 ? `${name} ×${count}${renderTimeLabel}` : `${name}${renderTimeLabel}`;
+		const fontSize = 10;
+		ctx.font = `600 ${fontSize}px ui-monospace, SFMono-Regular, Menlo, monospace`;
+		const textMetrics = ctx.measureText(label);
+		const padding = 3;
+		const labelHeight = fontSize + padding * 2;
+		const labelWidth = textMetrics.width + padding * 2;
+		let labelX = rect.x;
+		let labelY = rect.y - labelHeight - 1;
+		if (labelY < 0) labelY = rect.y + rect.height + 1;
+		ctx.fillStyle = color.replace("ALPHA", String(Math.min(alpha, .9)));
+		ctx.fillRect(labelX, labelY, labelWidth, labelHeight);
+		ctx.fillStyle = `rgba(255, 255, 255, ${alpha})`;
+		ctx.fillText(label, labelX + padding, labelY + fontSize + padding - 1);
+	}
+}
+function onRender(info) {
+	if (info.phase === "unmount") {
+		if (info.domNode) outlines.delete(info.domNode);
+		return;
+	}
+	const el = info.domNode;
+	if (!el) return;
+	const existing = outlines.get(el);
+	const count = existing ? existing.count + 1 : 1;
+	outlines.set(el, {
+		rect: el.getBoundingClientRect(),
+		alpha: 1,
+		color: getOutlineColor(count),
+		count,
+		name: info.componentName,
+		selfTimeMs: info.selfTime,
+		timestamp: performance.now()
+	});
+	ensureLoop();
+}
+function ensureLoop() {
+	if (isRunning) return;
+	isRunning = true;
+	ensureCanvas();
+	rafId = requestAnimationFrame(drawFrame);
+}
+function stopLoop() {
+	isRunning = false;
+	if (rafId != null) {
+		cancelAnimationFrame(rafId);
+		rafId = null;
+	}
+}
+function startOverlay() {
+	addRenderListener(onRender);
+}
+function stopOverlay() {
+	removeRenderListener(onRender);
+	stopLoop();
+	outlines.clear();
+	if (canvas) {
+		canvas.remove();
+		canvas = null;
+		ctx = null;
+	}
+	window.removeEventListener("resize", resizeCanvas);
+}
+
+//#endregion
+//#region src/toolbar.ts
+let rootContainer = null;
+let shadowRoot = null;
+let renderCount = 0;
+let fps = 0;
+let rendersPerSecond = 0;
+let frameCount = 0;
+let lastFpsTime = performance.now();
+let fpsRafId = null;
+let rendersThisSecond = 0;
+function updateFps() {
+	frameCount++;
+	const now = performance.now();
+	if (now - lastFpsTime >= 1e3) {
+		fps = frameCount;
+		rendersPerSecond = rendersThisSecond;
+		rendersThisSecond = 0;
+		frameCount = 0;
+		lastFpsTime = now;
+		updateDisplay();
+	}
+	fpsRafId = requestAnimationFrame(updateFps);
+}
+function notifyToolbarRender() {
+	renderCount++;
+	rendersThisSecond++;
+	updateDisplay();
+}
+const TOOLBAR_STYLES = `
+:host {
+  all: initial;
+}
+.toolbar {
+  position: fixed;
+  bottom: 12px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 2147483647;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 12px;
+  background: #0a0a0a;
+  border: 1px solid #27272a;
+  border-radius: 10px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 12px;
+  color: #e4e4e7;
+  box-shadow: 0 4px 24px rgba(0, 0, 0, 0.5);
+  user-select: none;
+  cursor: default;
+  line-height: 1;
+}
+.toolbar-title {
+  font-weight: 700;
+  color: #a78bfa;
+  padding-right: 4px;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+.toolbar-title svg {
+  width: 14px;
+  height: 14px;
+}
+.stat {
+  color: #a1a1aa;
+  padding: 0 4px;
+}
+.stat-value {
+  color: #e4e4e7;
+  font-weight: 600;
+}
+.separator {
+  width: 1px;
+  height: 14px;
+  background: #27272a;
+}
+.toggle-btn {
+  background: none;
+  border: 1px solid #3f3f46;
+  border-radius: 6px;
+  color: #e4e4e7;
+  padding: 3px 8px;
+  font-size: 11px;
+  font-family: inherit;
+  cursor: pointer;
+  transition: background 0.15s, border-color 0.15s;
+}
+.toggle-btn:hover {
+  background: #27272a;
+  border-color: #52525b;
+}
+.toggle-btn.active {
+  background: #7c3aed;
+  border-color: #8b5cf6;
+}
+`;
+function createToolbarDOM() {
+	rootContainer = document.createElement("div");
+	rootContainer.id = "preact-tracker-toolbar";
+	shadowRoot = rootContainer.attachShadow({ mode: "open" });
+	const style = document.createElement("style");
+	style.textContent = TOOLBAR_STYLES;
+	shadowRoot.appendChild(style);
+	const toolbar = document.createElement("div");
+	toolbar.className = "toolbar";
+	toolbar.innerHTML = `
+		<span class="toolbar-title">
+			<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+				<circle cx="12" cy="12" r="10"/>
+				<line x1="12" y1="8" x2="12" y2="12"/>
+				<line x1="12" y1="16" x2="12.01" y2="16"/>
+			</svg>
+			preact-perf-tracker
+		</span>
+		<span class="separator"></span>
+		<span class="stat">renders: <span class="stat-value" data-renders>0</span></span>
+		<span class="separator"></span>
+		<span class="stat">r/s: <span class="stat-value" data-rps>0</span></span>
+		<span class="separator"></span>
+		<span class="stat">fps: <span class="stat-value" data-fps>--</span></span>
+		<span class="separator"></span>
+		<span class="stat">hot: <span class="stat-value" data-hot>--</span></span>
+		<span class="separator"></span>
+		<button class="toggle-btn active" data-toggle>Enabled</button>
+		<button class="toggle-btn" data-reset>Reset</button>
+		<button class="toggle-btn" data-copy>Copy</button>
+	`;
+	const toggleBtn = toolbar.querySelector("[data-toggle]");
+	toggleBtn.addEventListener("click", () => {
+		const next = !getActiveOptions().enabled;
+		setActiveOptions({ enabled: next });
+		toggleBtn.textContent = next ? "Enabled" : "Disabled";
+		toggleBtn.classList.toggle("active", next);
+	});
+	toolbar.querySelector("[data-reset]").addEventListener("click", () => {
+		clearReport$1();
+		renderCount = 0;
+		rendersThisSecond = 0;
+		rendersPerSecond = 0;
+		updateDisplay();
+	});
+	const copyBtn = toolbar.querySelector("[data-copy]");
+	copyBtn.addEventListener("click", async () => {
+		const summary = getReportSummary$1(25);
+		const payload = JSON.stringify(summary, null, 2);
+		if (!navigator.clipboard?.writeText) return;
+		await navigator.clipboard.writeText(payload);
+		const old = copyBtn.textContent;
+		copyBtn.textContent = "Copied";
+		window.setTimeout(() => {
+			copyBtn.textContent = old;
+		}, 1200);
+	});
+	shadowRoot.appendChild(toolbar);
+	const legacyMarker = document.createElement("span");
+	legacyMarker.id = "preact-scan-toolbar";
+	legacyMarker.style.display = "none";
+	shadowRoot.appendChild(legacyMarker);
+	document.documentElement.appendChild(rootContainer);
+	return shadowRoot;
+}
+function updateDisplay() {
+	if (!shadowRoot) return;
+	const rendersEl = shadowRoot.querySelector("[data-renders]");
+	const rpsEl = shadowRoot.querySelector("[data-rps]");
+	const fpsEl = shadowRoot.querySelector("[data-fps]");
+	const hotEl = shadowRoot.querySelector("[data-hot]");
+	const hottest = getReportSummary$1(1)[0];
+	const hotLabel = hottest ? `${hottest.displayName} (${hottest.totalSelfTime.toFixed(1)}ms)` : "--";
+	if (rendersEl) rendersEl.textContent = String(renderCount);
+	if (rpsEl) rpsEl.textContent = String(rendersPerSecond);
+	if (fpsEl) fpsEl.textContent = String(fps);
+	if (hotEl) hotEl.textContent = hotLabel;
+}
+function createToolbar() {
+	if (rootContainer) return;
+	createToolbarDOM();
+	fpsRafId = requestAnimationFrame(updateFps);
+}
+function destroyToolbar() {
+	if (fpsRafId != null) {
+		cancelAnimationFrame(fpsRafId);
+		fpsRafId = null;
+	}
+	if (rootContainer) {
+		rootContainer.remove();
+		rootContainer = null;
+		shadowRoot = null;
+	}
+	renderCount = 0;
+	rendersThisSecond = 0;
+	rendersPerSecond = 0;
+	fps = 0;
+	frameCount = 0;
+	lastFpsTime = performance.now();
+}
+
+//#endregion
+//#region src/index.ts
+let started = false;
+const toolbarRenderListener = (_info) => {
+	notifyToolbarRender();
+};
+/**
+* Start tracking component renders.
+*
+* ```ts
+* import { install } from 'preact-perf-tracker';
+*
+* install({
+*   enabled: true,
+*   log: false,
+*   showToolbar: true,
+* });
+* ```
+*/
+function install(options = {}) {
+	resetActiveOptions();
+	setOptions(options);
+	const opts = getActiveOptions();
+	if (opts.enabled === false && opts.showToolbar !== true) return;
+	start();
+}
+/**
+* Update options at runtime.
+*/
+function setOptions(options) {
+	setActiveOptions(options);
+}
+/**
+* Get the current options.
+*/
+function getOptions() {
+	return getActiveOptions();
+}
+/**
+* Get a report of all tracked components, or a single component type.
+*/
+function getReport(type) {
+	return getReport$1(type);
+}
+/**
+* Get the top report entries sorted by total self-time.
+*/
+function getReportSummary(limit = 10) {
+	return getReportSummary$1(limit);
+}
+/**
+* Clear all accumulated report data.
+*/
+function clearReport() {
+	clearReport$1();
+}
+/**
+* Stop tracking and clean up all resources.
+*/
+function stop() {
+	if (!started) return;
+	started = false;
+	removeRenderListener(toolbarRenderListener);
+	unhookFromPreact();
+	stopOverlay();
+	destroyToolbar();
+}
+function start() {
+	if (started) return;
+	started = true;
+	hookIntoPreact();
+	addRenderListener(toolbarRenderListener);
+	startOverlay();
+	if (getActiveOptions().showToolbar !== false) {
+		if (typeof document !== "undefined") if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", () => createToolbar(), { once: true });
+		else createToolbar();
+	}
+}
+
+//#endregion
+exports.clearReport = clearReport;
+exports.getOptions = getOptions;
+exports.getReport = getReport;
+exports.getReportSummary = getReportSummary;
+exports.install = install;
+exports.setOptions = setOptions;
+exports.stop = stop;
+//# sourceMappingURL=index.cjs.map