@tinkoff/perfume 0.0.0-stage → 1.0.1

package/dist/index.js

@@ -0,0 +1,708 @@
+import { onCLS, onFCP, onFID, onINP, onLCP, onTTFB } from "web-vitals/attribution";
+//#region src/config.ts
+const config = {
+	isResourceTiming: false,
+	isElementTiming: false,
+	maxTime: 3e4,
+	reportOptions: {}
+};
+//#endregion
+//#region src/constants.ts
+const W = typeof window !== "undefined" ? window : {};
+const C = W.console;
+const WN = W.navigator;
+const WP = W.performance;
+const getDM = () => WN.deviceMemory;
+const getHC = () => WN.hardwareConcurrency;
+const M = "mark.";
+const S = "step.";
+//#endregion
+//#region src/isSupported.ts
+/**
+* True if the browser supports the Navigation Timing API,
+* User Timing API and the PerformanceObserver Interface.
+* In Safari, the User Timing API (performance.mark()) is not available,
+* so the DevTools timeline will not be annotated with marks.
+* Support: developer.mozilla.org/en-US/docs/Web/API/Performance/mark
+* Support: developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
+* Support: developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByType
+*/
+const isPerformanceSupported = () => WP && !!WP.getEntriesByType && !!WP.now && !!WP.mark;
+//#endregion
+//#region src/getNavigationTiming.ts
+/**
+* Navigation Timing API provides performance metrics for HTML documents.
+* w3c.github.io/navigation-timing/
+* developers.google.com/web/fundamentals/performance/navigation-and-resource-timing
+*/
+const getNavigationTiming = () => {
+	if (!isPerformanceSupported()) return {};
+	const n = WP.getEntriesByType("navigation")[0];
+	if (!n) return {};
+	const responseStart = n.responseStart;
+	const responseEnd = n.responseEnd;
+	return {
+		fetchTime: responseEnd - n.fetchStart,
+		workerTime: n.workerStart > 0 ? responseEnd - n.workerStart : 0,
+		totalTime: responseEnd - n.requestStart,
+		downloadTime: responseEnd - responseStart,
+		timeToFirstByte: responseStart - n.requestStart,
+		headerSize: n.transferSize - n.encodedBodySize || 0,
+		dnsLookupTime: n.domainLookupEnd - n.domainLookupStart,
+		redirectTime: n.redirectEnd - n.redirectStart
+	};
+};
+//#endregion
+//#region src/getNetworkInformation.ts
+let et = "4g";
+let sd = false;
+const getNetworkInformation = () => {
+	if ("connection" in WN) {
+		const dataConnection = WN.connection;
+		if (typeof dataConnection !== "object") return {};
+		et = dataConnection.effectiveType;
+		sd = !!dataConnection.saveData;
+		return {
+			downlink: dataConnection.downlink,
+			effectiveType: dataConnection.effectiveType,
+			rtt: dataConnection.rtt,
+			saveData: !!dataConnection.saveData
+		};
+	}
+	return {};
+};
+//#endregion
+//#region src/metrics.ts
+const metrics = {};
+const fcp = { value: 0 };
+const rt = { value: {
+	beacon: 0,
+	css: 0,
+	fetch: 0,
+	img: 0,
+	other: 0,
+	script: 0,
+	total: 0,
+	xmlhttprequest: 0
+} };
+const tbt = { value: 0 };
+const ntbt = { value: 0 };
+//#endregion
+//#region src/observeInstances.ts
+const perfObservers = {};
+//#endregion
+//#region src/onVisibilityChange.ts
+const visibility = {
+	isHidden: false,
+	didChange: false
+};
+/**
+* From visibilitychange listener it saves only when
+* the page gets hidden, because it's important to not
+* use the wrong "hidden" value when send timing or logging.
+*/
+const didVisibilityChange = function() {
+	visibility.isHidden = false;
+	if (document.hidden) {
+		visibility.isHidden = document.hidden;
+		visibility.didChange = true;
+	}
+};
+//#endregion
+//#region src/performanceObserver.ts
+/**
+* PerformanceObserver subscribes to performance events as they happen
+* and respond to them asynchronously.
+*/
+const po = (eventType, cb) => {
+	try {
+		const perfObserver = new PerformanceObserver((entryList) => {
+			cb(entryList.getEntries());
+		});
+		perfObserver.observe({
+			type: eventType,
+			buffered: true
+		});
+		return perfObserver;
+	} catch (e) {
+		C.warn("Perfume.js:", e);
+	}
+	return null;
+};
+//#endregion
+//#region src/isLowEnd.ts
+const getIsLowEndDevice = () => {
+	if (getHC() && getHC() <= 4) return true;
+	if (getDM() && getDM() <= 4) return true;
+	return false;
+};
+const getIsLowEndExperience = (et, sd) => {
+	switch (et) {
+		case "slow-2g": return true;
+		case "2g": return true;
+		case "3g": return true;
+		default: return getIsLowEndDevice() || sd;
+	}
+};
+//#endregion
+//#region src/getNavigatorInfo.ts
+/**
+* Information coming from window.navigator:
+* 1. Device Memory
+* 2. Hardware Concurency
+* 3. Status of the service worker:
+*    - controlled: a service worker is controlling the page
+*    - supported: the browser supports service worker
+*    - unsupported: the user's browser does not support service worker
+*/
+const getNavigatorInfo = () => {
+	if (WN) return {
+		deviceMemory: getDM() || 0,
+		hardwareConcurrency: getHC() || 0,
+		serviceWorkerStatus: "serviceWorker" in WN ? WN.serviceWorker.controller ? "controlled" : "supported" : "unsupported",
+		isLowEndDevice: getIsLowEndDevice(),
+		isLowEndExperience: getIsLowEndExperience(et, sd)
+	};
+	return {};
+};
+//#endregion
+//#region src/utils.ts
+const roundByFour = (num) => parseFloat(num.toFixed(4));
+const convertToKB = (bytes) => {
+	if (typeof bytes !== "number") return null;
+	return roundByFour(bytes / Math.pow(1024, 2));
+};
+/**
+* PushTask to requestIdleCallback
+*/
+const pushTask = (cb) => {
+	if ("requestIdleCallback" in W) W.requestIdleCallback(cb, { timeout: 3e3 });
+	else cb();
+};
+//#endregion
+//#region src/reportPerf.ts
+/**
+* Sends the User timing measure to analyticsTracker
+*/
+const reportPerf = (measureName, data, rating, attribution, navigationType) => {
+	const reportTask = () => {
+		if (!config.analyticsTracker) return;
+		if (visibility.isHidden && !["CLS", "INP"].includes(measureName)) return;
+		config.analyticsTracker({
+			attribution,
+			metricName: measureName,
+			data,
+			navigatorInformation: getNavigatorInfo(),
+			rating,
+			navigationType
+		});
+	};
+	if (["CLS", "INP"].includes(measureName)) reportTask();
+	else pushTask(reportTask);
+};
+//#endregion
+//#region src/totalBlockingTime.ts
+const initTotalBlockingTime = (performanceEntries) => {
+	performanceEntries.forEach((entry) => {
+		if (entry.name !== "self" || entry.startTime < fcp.value) return;
+		const blockingTime = entry.duration - 50;
+		if (blockingTime > 0) {
+			tbt.value += blockingTime;
+			ntbt.value += blockingTime;
+		}
+	});
+};
+//#endregion
+//#region src/types.ts
+let IThresholdTier = /* @__PURE__ */ function(IThresholdTier) {
+	IThresholdTier["instant"] = "instant";
+	IThresholdTier["quick"] = "quick";
+	IThresholdTier["moderate"] = "moderate";
+	IThresholdTier["slow"] = "slow";
+	IThresholdTier["unavoidable"] = "unavoidable";
+	return IThresholdTier;
+}({});
+//#endregion
+//#region src/vitalsScore.ts
+const rtScore = [100, 200];
+const tbtScore = [200, 600];
+const ntbtScore = [200, 600];
+const STEP_THRESHOLDS = {
+	["instant"]: {
+		vitalsThresholds: [100, 200],
+		maxOutlierThreshold: 1e4
+	},
+	["quick"]: {
+		vitalsThresholds: [200, 500],
+		maxOutlierThreshold: 1e4
+	},
+	["moderate"]: {
+		vitalsThresholds: [500, 1e3],
+		maxOutlierThreshold: 1e4
+	},
+	["slow"]: {
+		vitalsThresholds: [1e3, 2e3],
+		maxOutlierThreshold: 1e4
+	},
+	["unavoidable"]: {
+		vitalsThresholds: [2e3, 5e3],
+		maxOutlierThreshold: 2e4
+	}
+};
+const webVitalsScore = {
+	RT: rtScore,
+	TBT: tbtScore,
+	NTBT: ntbtScore
+};
+const getRating = (value, vitalsThresholds) => {
+	if (value <= vitalsThresholds[0]) return "good";
+	return value <= vitalsThresholds[1] ? "needsImprovement" : "poor";
+};
+const getVitalsScore = (measureName, value) => {
+	if (!webVitalsScore[measureName]) return null;
+	if (value <= webVitalsScore[measureName][0]) return "good";
+	return value <= webVitalsScore[measureName][1] ? "needsImprovement" : "poor";
+};
+//#endregion
+//#region src/log.ts
+const logData = (measureName, metric, attribution) => {
+	Object.keys(metric).forEach((key) => {
+		if (typeof metric[key] === "number") metric[key] = roundByFour(metric[key]);
+	});
+	reportPerf(measureName, metric, null, attribution || {});
+};
+/**
+* Dispatches the metric duration into internal logs
+* and the external time tracking service.
+*/
+const logMetric = ({ attribution, name, rating, value, navigationType }) => {
+	if (name === "FCP") fcp.value = value;
+	if (["FCP", "LCP"].includes(name) && !perfObservers[0]) perfObservers[0] = po("longtask", initTotalBlockingTime);
+	if ("FID" === name) setTimeout(() => {
+		if (visibility.didChange) return;
+		logMetric({
+			attribution,
+			name: "TBT",
+			rating: getVitalsScore("TBT", tbt.value),
+			value: tbt.value,
+			navigationType
+		});
+		logData("dataConsumption", rt.value);
+	}, 1e4);
+	const duration2Decimal = roundByFour(value);
+	if (duration2Decimal <= config.maxTime && duration2Decimal >= 0) reportPerf(name, duration2Decimal, rating, attribution, navigationType);
+};
+//#endregion
+//#region src/element-timing.ts
+const initElementTiming = (performanceEntries) => {
+	performanceEntries.forEach((entry) => {
+		if (entry.identifier) logMetric({
+			attribution: { identifier: entry.identifier },
+			name: "ET",
+			rating: null,
+			value: entry.startTime
+		});
+	});
+};
+//#endregion
+//#region src/resourceTiming.ts
+const initResourceTiming = (performanceEntries) => {
+	performanceEntries.forEach((entry) => {
+		if (config.isResourceTiming) logData("resourceTiming", entry);
+		if (entry.decodedBodySize && entry.initiatorType) {
+			const bodySize = entry.decodedBodySize / 1e3;
+			rt.value[entry.initiatorType] += bodySize;
+			rt.value.total += bodySize;
+		}
+	});
+};
+//#endregion
+//#region src/observe.ts
+const initPerformanceObserver = () => {
+	onTTFB((report) => {
+		if (report.value > 0) logMetric(report);
+	}, config.reportOptions.ttfb);
+	onCLS((report) => logMetric(report), config.reportOptions.cls);
+	onFCP((report) => logMetric(report), config.reportOptions.fcp);
+	onFID((report) => logMetric(report), config.reportOptions.fid);
+	onLCP((report) => logMetric(report), config.reportOptions.lcp);
+	onINP((report) => logMetric(report), config.reportOptions.inp);
+	if (config.isResourceTiming) po("resource", initResourceTiming);
+	if (config.isElementTiming) po("element", initElementTiming);
+};
+//#endregion
+//#region src/storageEstimate.ts
+/**
+* The estimate() method of the StorageManager interface asks the Storage Manager
+* for how much storage the app takes up (usage),
+* and how much space is available (quota).
+*/
+const reportStorageEstimate = (storageInfo) => {
+	const estimateUsageDetails = "usageDetails" in storageInfo ? storageInfo.usageDetails : {};
+	logData("storageEstimate", {
+		quota: convertToKB(storageInfo.quota),
+		usage: convertToKB(storageInfo.usage),
+		caches: convertToKB(estimateUsageDetails.caches),
+		indexedDB: convertToKB(estimateUsageDetails.indexedDB),
+		serviceWorker: convertToKB(estimateUsageDetails.serviceWorkerRegistrations)
+	});
+};
+//#endregion
+//#region src/steps/steps.ts
+const steps = {
+	finalMarkToStepsMap: {},
+	startMarkToStepsMap: {},
+	active: {},
+	/**
+	An internal data structure to represent the state of active steps.
+	In this data structure, the keys represent the navgiation index, starting at 0 - 
+	i.e - the initial app launch it's index 0, the first navigation is index 1 and so one.
+	The value of each navigation index is a Set of all the first marks for the currently active steps. 
+	When a start mark is hit - it will be added to this state. 
+	When a corresponding end mark is hit, the start mark previously added will be removed from this navigation state
+	Examples:
+	Example of the state when home is loading:
+	{
+	[0]: ['start_navigate_to_home_screen'] // load home - empty array since home has loaded
+	}
+	Example of the state during the navigation from home to assets
+	{
+	[0]: [] // load home - empty array since home has loaded
+	[1]: ['start_navigate_to_trade_screen']
+	}
+	*/
+	navigationSteps: {}
+};
+/**
+* This method allows to add new steps by passing the start mark
+*/
+const addActiveSteps = (startMark) => {
+	var _steps$startMarkToSte;
+	const newSteps = (_steps$startMarkToSte = steps.startMarkToStepsMap[startMark]) !== null && _steps$startMarkToSte !== void 0 ? _steps$startMarkToSte : [];
+	Object.keys(newSteps).forEach((step) => {
+		if (steps.active[step]) return;
+		steps.active[step] = true;
+	});
+};
+const resetNavigationSteps = () => {
+	steps.navigationSteps = {};
+};
+/**
+* Removes one step from active steps
+*/
+const removeActiveStep = (step) => {
+	delete steps.active[step];
+};
+const resetActiveSteps = () => {
+	steps.active = {};
+};
+const resetSteps = () => {
+	steps.startMarkToStepsMap = {};
+	steps.finalMarkToStepsMap = {};
+	resetActiveSteps();
+	resetNavigationSteps();
+};
+const getNavigationState = () => steps.navigationSteps;
+const getStepsFromNavigation = (navIndex) => {
+	var _navigationSteps$navI;
+	return (_navigationSteps$navI = getNavigationState()[navIndex]) !== null && _navigationSteps$navI !== void 0 ? _navigationSteps$navI : {};
+};
+//#endregion
+//#region src/steps/setStepsMap.ts
+const setStepsMap = () => {
+	if (!config.steps) return;
+	resetSteps();
+	Object.entries(config.steps).forEach(([step, { marks }]) => {
+		var _steps$startMarkToSte;
+		const startMark = marks[0];
+		const endMark = marks[1];
+		const currentStartMarks = (_steps$startMarkToSte = steps.startMarkToStepsMap[startMark]) !== null && _steps$startMarkToSte !== void 0 ? _steps$startMarkToSte : {};
+		currentStartMarks[step] = true;
+		steps.startMarkToStepsMap[startMark] = currentStartMarks;
+		if (!steps.finalMarkToStepsMap[endMark]) steps.finalMarkToStepsMap[endMark] = { [startMark]: [step] };
+		else {
+			const currentSteps = steps.finalMarkToStepsMap[endMark][startMark] || [];
+			currentSteps.push(step);
+			steps.finalMarkToStepsMap[endMark][startMark] = currentSteps;
+		}
+	});
+};
+//#endregion
+//#region src/initPerfume.ts
+/**
+* Perfume.js v9.4.1 (http://zizzamia.github.io/perfume)
+* Copyright 2022 Leonardo Zizzamia (https://github.com/Zizzamia/perfume.js/graphs/contributors)
+* Licensed under MIT (https://github.com/Zizzamia/perfume.js/blob/master/LICENSE)
+*
+* @license
+*/
+const initPerfume = (options = {}) => {
+	config.analyticsTracker = options.analyticsTracker;
+	config.isResourceTiming = !!options.resourceTiming;
+	config.isElementTiming = !!options.elementTiming;
+	config.maxTime = options.maxMeasureTime || config.maxTime;
+	config.reportOptions = options.reportOptions || config.reportOptions;
+	config.steps = options.steps;
+	config.onMarkStep = options.onMarkStep;
+	if (!isPerformanceSupported()) return;
+	if ("PerformanceObserver" in W) initPerformanceObserver();
+	if (typeof document.hidden !== "undefined") document.addEventListener("visibilitychange", didVisibilityChange);
+	const navigationTiming = getNavigationTiming();
+	logData("navigationTiming", navigationTiming);
+	if (navigationTiming.redirectTime) logMetric({
+		attribution: {},
+		name: `RT`,
+		rating: getVitalsScore("RT", navigationTiming.redirectTime),
+		value: navigationTiming.redirectTime
+	});
+	logData("networkInformation", getNetworkInformation());
+	if (WN && WN.storage && typeof WN.storage.estimate === "function") WN.storage.estimate().then(reportStorageEstimate).catch(() => {});
+	if (config.steps) setStepsMap();
+};
+//#endregion
+//#region src/measure.ts
+/**
+* Get the duration of the timing metric or -1
+* if there a measurement has not been made by the User Timing API
+*/
+const performanceMeasure = (measureName) => {
+	WP.measure(measureName, `mark_${measureName}_start`, `mark_${measureName}_end`);
+	const entry = WP.getEntriesByName(measureName).pop();
+	if (entry && entry.entryType === "measure") return entry.duration;
+	return -1;
+};
+//#endregion
+//#region src/steps/measureStep.ts
+const measureStep = (step, startMark, endMark) => {
+	const stepMetricName = S + step;
+	const startMarkExists = WP.getEntriesByName(M + startMark).length > 0;
+	if (!(WP.getEntriesByName("mark." + endMark).length > 0) || !startMarkExists || !config.steps || !config.steps[step]) return;
+	const { maxOutlierThreshold, vitalsThresholds } = STEP_THRESHOLDS[config.steps[step].threshold];
+	const stepMeasure = WP.measure(stepMetricName, M + startMark, M + endMark);
+	if (!stepMeasure) return;
+	const { duration } = stepMeasure;
+	if (duration <= maxOutlierThreshold) {
+		const score = getRating(duration, vitalsThresholds);
+		if (duration >= 0) {
+			reportPerf("userJourneyStep", duration, score, { stepName: step }, void 0);
+			WP.measure(`step.${step}_vitals_${score}`, {
+				start: stepMeasure.startTime + stepMeasure.duration,
+				end: stepMeasure.startTime + stepMeasure.duration,
+				detail: {
+					type: "stepVital",
+					duration
+				}
+			});
+		}
+	}
+};
+//#endregion
+//#region src/steps/navigationSteps.ts
+/**
+* We only report the active steps in the last 2 navigation step to prevent
+* Convert the steps.navigationSteps to an array of active steps.
+* "stale steps" from being reported.
+*
+* "stale steps" are defined as steps where the start mark was executed but the
+* corresponding end mark was never executed - thus leaving it as a "stale step"
+*/
+const getActiveStepsFromNavigationSteps = () => {
+	const navigationSteps = getNavigationState();
+	const { startMarkToStepsMap } = steps;
+	const numberOfSteps = Object.keys(navigationSteps).length;
+	if (numberOfSteps === 0) return {};
+	const activeSteps = {};
+	const currentNavIndex = numberOfSteps - 1;
+	const currentNavStep = getStepsFromNavigation(currentNavIndex);
+	Object.keys(currentNavStep).forEach((startMark) => {
+		var _startMarkToStepsMap$;
+		const ongoingSteps = (_startMarkToStepsMap$ = startMarkToStepsMap[startMark]) !== null && _startMarkToStepsMap$ !== void 0 ? _startMarkToStepsMap$ : [];
+		Object.keys(ongoingSteps).forEach((step) => {
+			activeSteps[step] = true;
+		});
+	});
+	if (numberOfSteps > 1) {
+		const prevNavStep = getStepsFromNavigation(currentNavIndex - 1);
+		Object.keys(prevNavStep).forEach((startMark) => {
+			var _startMarkToStepsMap$2;
+			const prevNavSteps = (_startMarkToStepsMap$2 = startMarkToStepsMap[startMark]) !== null && _startMarkToStepsMap$2 !== void 0 ? _startMarkToStepsMap$2 : [];
+			Object.keys(prevNavSteps).forEach((step) => {
+				activeSteps[step] = true;
+			});
+		});
+	}
+	return activeSteps;
+};
+const recordStartMark = (startMark) => {
+	const { navigationSteps } = steps;
+	const numberOfSteps = Object.keys(navigationSteps).length;
+	const lastNavIndex = (numberOfSteps > 0 ? numberOfSteps : 1) - 1;
+	const newCurrentMark = getStepsFromNavigation(lastNavIndex) || [];
+	newCurrentMark[startMark] = true;
+	navigationSteps[lastNavIndex] = newCurrentMark;
+};
+const recordEndMark = (endMark) => {
+	const { navigationSteps, finalMarkToStepsMap } = steps;
+	const navigationLength = Object.keys(navigationSteps).length;
+	if (navigationLength === 0) return;
+	const currentNavIndex = navigationLength - 1;
+	const ongoingNavStep = getStepsFromNavigation(currentNavIndex);
+	if (!ongoingNavStep || !finalMarkToStepsMap[endMark]) return;
+	const endMarkMap = finalMarkToStepsMap[endMark];
+	if (!endMarkMap) return;
+	/**
+	* loop through all steps where end mark is present and check if their start mark is present
+	* in the navigation state. If so, remove it to signal that the step has been completed
+	*/
+	Object.keys(endMarkMap).forEach((startMark) => {
+		if (ongoingNavStep[startMark]) {
+			const currentNavStep = getStepsFromNavigation(currentNavIndex) || {};
+			currentNavStep[startMark] = false;
+			navigationSteps[currentNavIndex] = currentNavStep;
+		}
+		if (navigationLength > 1) {
+			const lastNavIndex = currentNavIndex - 1;
+			const lastNavStep = getStepsFromNavigation(lastNavIndex);
+			if (lastNavStep[startMark]) {
+				lastNavStep[startMark] = false;
+				navigationSteps[lastNavIndex] = lastNavStep;
+			}
+		}
+	});
+};
+/**
+* An API consumers must use to update internal state based on page/screen navigations.
+* Internal state must be updated when the following are true
+* 1. Journey marks are hit
+* 2. Page navigations occur
+* This function ensures the 2nd case is covered to help prevent "stale"
+* steps that don't hit their final mark because the users navigates
+* backwards in journey.
+*/
+const trackUJNavigation = () => {
+	var _config$onMarkStep;
+	const navigationLength = Object.keys(steps.navigationSteps).length;
+	steps.navigationSteps[navigationLength] = {};
+	const activeSteps = getActiveStepsFromNavigationSteps();
+	(_config$onMarkStep = config.onMarkStep) === null || _config$onMarkStep === void 0 || _config$onMarkStep.call(config, "", Object.keys(activeSteps));
+};
+//#endregion
+//#region src/steps/measureSteps.ts
+const measureSteps = (mark) => {
+	var _config$onMarkStep;
+	if (steps.finalMarkToStepsMap[mark]) {
+		recordEndMark(mark);
+		const finalSteps = steps.finalMarkToStepsMap[mark];
+		Object.keys(finalSteps).forEach((startMark) => {
+			const possibleSteps = finalSteps[startMark];
+			possibleSteps.forEach(removeActiveStep);
+			Promise.all(possibleSteps.map(async (step) => {
+				await measureStep(step, startMark, mark);
+			})).catch(() => {});
+		});
+	} else {
+		recordStartMark(mark);
+		addActiveSteps(mark);
+	}
+	const navigationBasedActiveSteps = getActiveStepsFromNavigationSteps();
+	(_config$onMarkStep = config.onMarkStep) === null || _config$onMarkStep === void 0 || _config$onMarkStep.call(config, mark, Object.keys(navigationBasedActiveSteps));
+};
+//#endregion
+//#region src/steps/markStep.ts
+/**
+* Function which creates a step mark with a name generated
+* from the provided mark when called.
+*
+* The generated mark name has the following format:
+* `mark.${mark}`
+*
+*/
+const markStep = (mark) => {
+	if (!isPerformanceSupported()) return;
+	WP.mark(M + mark);
+	measureSteps(mark);
+};
+/**
+* Start performance measurement
+*/
+const start = (markName) => {
+	if (!isPerformanceSupported() || metrics[markName]) return;
+	metrics[markName] = true;
+	WP.mark(`mark_${markName}_start`);
+};
+/**
+* End performance measurement
+*/
+const end = (markName, customProperties = {}, doLogData = true) => {
+	if (!isPerformanceSupported() || !metrics[markName]) return;
+	WP.mark(`mark_${markName}_end`);
+	delete metrics[markName];
+	const measure = performanceMeasure(markName);
+	if (doLogData) logData(markName, roundByFour(measure), customProperties);
+};
+/**
+* Removes the named mark from the browser's performance entry buffer.
+*/
+const clear = (markName) => {
+	delete metrics[markName];
+	if (!WP.clearMarks) return;
+	WP.clearMarks(`mark_${markName}_start`);
+	WP.clearMarks(`mark_${markName}_end`);
+};
+//#endregion
+//#region src/steps/markStepOnce.ts
+/**
+* Function which creates a step mark with a name generated
+* from the provided mark if a mark with the same name does not
+* already exist when called.
+*
+* The generated mark name has the following format:
+* `mark.${mark}`
+*
+*/
+const markStepOnce = (mark) => {
+	if (WP.getEntriesByName("mark." + mark).length === 0) {
+		WP.mark(M + mark);
+		measureSteps(mark);
+	}
+};
+//#endregion
+//#region src/markNTBT.ts
+let ntbtTimeoutID = 0;
+/**
+* NTBT = Navigation Total Blocking Time
+*
+* This metric measures the amount of time the application may be blocked
+* from processing code during the 2s window after a user navigates
+* from page A to page B.
+*
+* Because this library is navigation agnostic, we have this method
+* to mark when the navigation starts.
+*
+* The NTBT metric is the summation of the blocking time of all long tasks
+* in the 2s window after this method is invoked.
+*
+* If this method is called before the 2s window ends; it will trigger a new
+* NTBT measurement and interrupt the previous one.
+*
+* Credit: Thank you Steven Lam for helping with this!
+*/
+const markNTBT = () => {
+	start("ntbt");
+	ntbt.value = 0;
+	clearTimeout(ntbtTimeoutID);
+	ntbtTimeoutID = setTimeout(() => {
+		end("ntbt", {}, false);
+		logMetric({
+			attribution: {},
+			name: `NTBT`,
+			rating: getVitalsScore("NTBT", ntbt.value),
+			value: ntbt.value
+		});
+		ntbt.value = 0;
+	}, 2e3);
+};
+//#endregion
+export { IThresholdTier, clear, end, initPerfume, markNTBT, markStep, markStepOnce, start, trackUJNavigation };
+
+//# sourceMappingURL=index.js.map