@vpmedia/simplify 1.74.0 → 1.76.0

package/dist/index.js

@@ -0,0 +1,1119 @@
+import { addBreadcrumb, captureException, captureMessage } from "@sentry/browser";
+//#region src/const/http_status.ts
+const HTTP_100_CONTINUE = 100;
+const HTTP_101_SWITCHING_PROTOCOLS = 101;
+const HTTP_102_PROCESSING = 102;
+const HTTP_103_EARLY_HINTS = 103;
+const HTTP_200_OK = 200;
+const HTTP_201_CREATED = 201;
+const HTTP_202_ACCEPTED = 202;
+const HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203;
+const HTTP_204_NO_CONTENT = 204;
+const HTTP_205_RESET_CONTENT = 205;
+const HTTP_206_PARTIAL_CONTENT = 206;
+const HTTP_207_MULTI_STATUS = 207;
+const HTTP_208_ALREADY_REPORTED = 208;
+const HTTP_226_IM_USED = 226;
+const HTTP_300_MULTIPLE_CHOICES = 300;
+const HTTP_301_MOVED_PERMANENTLY = 301;
+const HTTP_302_FOUND = 302;
+const HTTP_303_SEE_OTHER = 303;
+const HTTP_304_NOT_MODIFIED = 304;
+const HTTP_305_USE_PROXY = 305;
+const HTTP_306_RESERVED = 306;
+const HTTP_307_TEMPORARY_REDIRECT = 307;
+const HTTP_308_PERMANENT_REDIRECT = 308;
+const HTTP_400_BAD_REQUEST = 400;
+const HTTP_401_UNAUTHORIZED = 401;
+const HTTP_402_PAYMENT_REQUIRED = 402;
+const HTTP_403_FORBIDDEN = 403;
+const HTTP_404_NOT_FOUND = 404;
+const HTTP_405_METHOD_NOT_ALLOWED = 405;
+const HTTP_406_NOT_ACCEPTABLE = 406;
+const HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407;
+const HTTP_408_REQUEST_TIMEOUT = 408;
+const HTTP_409_CONFLICT = 409;
+const HTTP_410_GONE = 410;
+const HTTP_411_LENGTH_REQUIRED = 411;
+const HTTP_412_PRECONDITION_FAILED = 412;
+const HTTP_413_CONTENT_TOO_LARGE = 413;
+const HTTP_414_URI_TOO_LONG = 414;
+const HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415;
+const HTTP_416_RANGE_NOT_SATISFIABLE = 416;
+const HTTP_417_EXPECTATION_FAILED = 417;
+const HTTP_418_IM_A_TEAPOT = 418;
+const HTTP_421_MISDIRECTED_REQUEST = 421;
+const HTTP_422_UNPROCESSABLE_CONTENT = 422;
+const HTTP_423_LOCKED = 423;
+const HTTP_424_FAILED_DEPENDENCY = 424;
+const HTTP_425_TOO_EARLY = 425;
+const HTTP_426_UPGRADE_REQUIRED = 426;
+const HTTP_428_PRECONDITION_REQUIRED = 428;
+const HTTP_429_TOO_MANY_REQUESTS = 429;
+const HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431;
+const HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451;
+const HTTP_499_CLIENT_CLOSED_CONNECTION = 499;
+const HTTP_500_INTERNAL_SERVER_ERROR = 500;
+const HTTP_501_NOT_IMPLEMENTED = 501;
+const HTTP_502_BAD_GATEWAY = 502;
+const HTTP_503_SERVICE_UNAVAILABLE = 503;
+const HTTP_504_GATEWAY_TIMEOUT = 504;
+const HTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505;
+const HTTP_506_VARIANT_ALSO_NEGOTIATES = 506;
+const HTTP_507_INSUFFICIENT_STORAGE = 507;
+const HTTP_508_LOOP_DETECTED = 508;
+const HTTP_510_NOT_EXTENDED = 510;
+const HTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511;
+const HTTP_STATUS_MAP = {
+	[100]: "HTTP_100_CONTINUE",
+	[101]: "HTTP_101_SWITCHING_PROTOCOLS",
+	[102]: "HTTP_102_PROCESSING",
+	[103]: "HTTP_103_EARLY_HINTS",
+	[200]: "HTTP_200_OK",
+	[201]: "HTTP_201_CREATED",
+	[202]: "HTTP_202_ACCEPTED",
+	[203]: "HTTP_203_NON_AUTHORITATIVE_INFORMATION",
+	[204]: "HTTP_204_NO_CONTENT",
+	[205]: "HTTP_205_RESET_CONTENT",
+	[206]: "HTTP_206_PARTIAL_CONTENT",
+	[207]: "HTTP_207_MULTI_STATUS",
+	[208]: "HTTP_208_ALREADY_REPORTED",
+	[226]: "HTTP_226_IM_USED",
+	[300]: "HTTP_300_MULTIPLE_CHOICES",
+	[301]: "HTTP_301_MOVED_PERMANENTLY",
+	[302]: "HTTP_302_FOUND",
+	[303]: "HTTP_303_SEE_OTHER",
+	[304]: "HTTP_304_NOT_MODIFIED",
+	[305]: "HTTP_305_USE_PROXY",
+	[306]: "HTTP_306_RESERVED",
+	[307]: "HTTP_307_TEMPORARY_REDIRECT",
+	[308]: "HTTP_308_PERMANENT_REDIRECT",
+	[400]: "HTTP_400_BAD_REQUEST",
+	[401]: "HTTP_401_UNAUTHORIZED",
+	[402]: "HTTP_402_PAYMENT_REQUIRED",
+	[403]: "HTTP_403_FORBIDDEN",
+	[404]: "HTTP_404_NOT_FOUND",
+	[405]: "HTTP_405_METHOD_NOT_ALLOWED",
+	[406]: "HTTP_406_NOT_ACCEPTABLE",
+	[407]: "HTTP_407_PROXY_AUTHENTICATION_REQUIRED",
+	[408]: "HTTP_408_REQUEST_TIMEOUT",
+	[409]: "HTTP_409_CONFLICT",
+	[410]: "HTTP_410_GONE",
+	[411]: "HTTP_411_LENGTH_REQUIRED",
+	[412]: "HTTP_412_PRECONDITION_FAILED",
+	[413]: "HTTP_413_CONTENT_TOO_LARGE",
+	[414]: "HTTP_414_URI_TOO_LONG",
+	[415]: "HTTP_415_UNSUPPORTED_MEDIA_TYPE",
+	[416]: "HTTP_416_RANGE_NOT_SATISFIABLE",
+	[417]: "HTTP_417_EXPECTATION_FAILED",
+	[418]: "HTTP_418_IM_A_TEAPOT",
+	[421]: "HTTP_421_MISDIRECTED_REQUEST",
+	[422]: "HTTP_422_UNPROCESSABLE_CONTENT",
+	[423]: "HTTP_423_LOCKED",
+	[424]: "HTTP_424_FAILED_DEPENDENCY",
+	[425]: "HTTP_425_TOO_EARLY",
+	[426]: "HTTP_426_UPGRADE_REQUIRED",
+	[428]: "HTTP_428_PRECONDITION_REQUIRED",
+	[429]: "HTTP_429_TOO_MANY_REQUESTS",
+	[431]: "HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE",
+	[451]: "HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS",
+	[499]: "HTTP_499_CLIENT_CLOSED_CONNECTION",
+	[500]: "HTTP_500_INTERNAL_SERVER_ERROR",
+	[501]: "HTTP_501_NOT_IMPLEMENTED",
+	[502]: "HTTP_502_BAD_GATEWAY",
+	[503]: "HTTP_503_SERVICE_UNAVAILABLE",
+	[504]: "HTTP_504_GATEWAY_TIMEOUT",
+	[505]: "HTTP_505_HTTP_VERSION_NOT_SUPPORTED",
+	[506]: "HTTP_506_VARIANT_ALSO_NEGOTIATES",
+	[507]: "HTTP_507_INSUFFICIENT_STORAGE",
+	[508]: "HTTP_508_LOOP_DETECTED",
+	[510]: "HTTP_510_NOT_EXTENDED",
+	[511]: "HTTP_511_NETWORK_AUTHENTICATION_REQUIRED"
+};
+//#endregion
+//#region src/logging/AbstractLogHandler.ts
+var AbstractLogHandler = class {
+	level;
+	/**
+	* Abstract log handler.
+	*/
+	constructor(level) {
+		this.level = level;
+	}
+	/**
+	* Emit log record.
+	*/
+	emit(_logger, _timestamp, _level, _message, _extra, _error) {
+		throw new Error("Not implemented.");
+	}
+};
+//#endregion
+//#region src/logging/const.ts
+const LOG_LEVEL_SILENT = 0;
+const LOG_LEVEL_FATAL = 1;
+const LOG_LEVEL_ERROR = 2;
+const LOG_LEVEL_WARNING = 3;
+const LOG_LEVEL_INFO = 4;
+const LOG_LEVEL_DEBUG = 5;
+const LOG_LEVEL_NAME_SILENT = "silent";
+const LOG_LEVEL_NAME_FATAL = "fatal";
+const LOG_LEVEL_NAME_ERROR = "error";
+const LOG_LEVEL_NAME_WARNING = "warning";
+const LOG_LEVEL_NAME_INFO = "info";
+const LOG_LEVEL_NAME_DEBUG = "debug";
+const LOG_LEVEL_NAMES = [
+	LOG_LEVEL_NAME_SILENT,
+	LOG_LEVEL_NAME_FATAL,
+	LOG_LEVEL_NAME_ERROR,
+	LOG_LEVEL_NAME_WARNING,
+	LOG_LEVEL_NAME_INFO,
+	LOG_LEVEL_NAME_DEBUG
+];
+//#endregion
+//#region src/logging/util.ts
+/**
+* Format log message.
+*/
+const formatLogMessage = (logger, timestamp, _level, message) => `${timestamp} [${logger.name}] ${message}`;
+/**
+* Get log level name.
+*/
+const getLogLevelName = (level) => LOG_LEVEL_NAMES[level];
+/**
+* Returns the application environment identifier.
+*/
+const getAppEnvironment = () => {
+	let appEnvironment = "local";
+	try {
+		const { env } = import.meta;
+		if (env?.["VITE_APP_ENVIRONMENT"]) appEnvironment = env["VITE_APP_ENVIRONMENT"];
+	} catch {}
+	try {
+		if (process.env["APP_ENVIRONMENT"]) appEnvironment = process.env["APP_ENVIRONMENT"];
+	} catch {}
+	return appEnvironment;
+};
+//#endregion
+//#region src/logging/ConsoleLogHandler.ts
+const CONSOLE_FUNCTIONS = [
+	null,
+	console.error,
+	console.error,
+	console.warn,
+	console.info,
+	console.debug
+];
+var ConsoleLogHandler = class extends AbstractLogHandler {
+	/**
+	* Console log handler.
+	*/
+	constructor(level = 5) {
+		super(level);
+	}
+	/**
+	* Emit log record.
+	*/
+	emit(logger, timestamp, level, message, extra, error) {
+		if (logger.level < level) return;
+		const logMessage = formatLogMessage(logger, timestamp, level, message);
+		const consoleFunction = CONSOLE_FUNCTIONS[level];
+		if (consoleFunction === null || consoleFunction === void 0) return;
+		if (error) {
+			extra === void 0 ? consoleFunction(logMessage, error) : consoleFunction(logMessage, error, extra);
+			if (error.cause) consoleFunction("Error cause", error.cause);
+			return;
+		}
+		extra === void 0 ? consoleFunction(logMessage) : consoleFunction(logMessage, extra);
+	}
+};
+//#endregion
+//#region src/util/query.ts
+const urlSearchParams = new URLSearchParams(globalThis.location?.search);
+function sanitizeURLParam(input) {
+	if (!input) return input;
+	return input.replaceAll(/[^\w-]/giu, "");
+}
+/**
+* Get a URL parameter value.
+*/
+function getURLParam(key, defaultValue, isSanitize) {
+	if (!key) return defaultValue ?? null;
+	const paramValue = urlSearchParams.get(key);
+	if (paramValue === null || paramValue === void 0) return defaultValue ?? null;
+	if (isSanitize !== false) return sanitizeURLParam(paramValue);
+	return paramValue;
+}
+//#endregion
+//#region src/logging/Logger.ts
+const ROOT_LOGGER_NAME = "root";
+var Logger = class Logger {
+	static handlers = [];
+	name;
+	level;
+	/**
+	* Creates a new Logger instance.
+	*/
+	constructor(name = ROOT_LOGGER_NAME) {
+		this.name = name ?? ROOT_LOGGER_NAME;
+		const appEnvironment = getAppEnvironment();
+		const defaultLevel = appEnvironment === "production" || appEnvironment === "release" ? 0 : 5;
+		const paramLevel = getURLParam(`log_${this.name.toLowerCase()}`, getURLParam("log_all", defaultLevel.toString())) ?? defaultLevel.toString();
+		this.level = Number.parseInt(paramLevel, 10);
+	}
+	static addHandler = (handler) => {
+		Logger.handlers.push(handler);
+	};
+	static emit = (logger, level, message, extra, error) => {
+		const timestamp = Date.now();
+		for (const handler of Logger.handlers) if (handler.level >= level) handler.emit(logger, timestamp, level, message, extra, error);
+	};
+	debug(message, extra) {
+		Logger.emit(this, 5, message, extra);
+	}
+	info(message, extra) {
+		Logger.emit(this, 4, message, extra);
+	}
+	warn(message, extra) {
+		Logger.emit(this, 3, message, extra);
+	}
+	warning(message, extra) {
+		Logger.emit(this, 3, message, extra);
+	}
+	error(message, extra) {
+		Logger.emit(this, 2, message, extra);
+	}
+	exception(message, error, extra) {
+		Logger.emit(this, 1, message, extra, error);
+	}
+};
+//#endregion
+//#region src/logging/OpenTelemetryLogHandler.ts
+var OpenTelemetryLogHandler = class extends AbstractLogHandler {
+	emitter;
+	/**
+	* Open Telemetry log handler.
+	*/
+	constructor(level, emitter) {
+		super(level);
+		this.emitter = emitter;
+	}
+	/**
+	* Emit log record.
+	*/
+	emit(logger, timestamp, level, message, extra, error) {
+		if (!this.emitter) return;
+		this.emitter(logger, timestamp, level, message, extra, error);
+	}
+};
+//#endregion
+//#region src/logging/SentryLogHandler.ts
+var SentryLogHandler = class extends AbstractLogHandler {
+	/**
+	* Sentry log handler.
+	*/
+	constructor(level = 5) {
+		super(level);
+	}
+	/**
+	* Emit log record.
+	*/
+	emit(logger, _timestamp, level, message, extra, error) {
+		const levelName = getLogLevelName(level);
+		const logMessage = `[${logger.name}] ${message}`;
+		addBreadcrumb({
+			type: "default",
+			category: "console",
+			message: logMessage,
+			level: levelName,
+			data: extra ?? void 0
+		});
+		if (error) extra?.tags ? captureException(error, { tags: extra.tags }) : captureException(error);
+		else if (level === 3) extra?.tags ? captureMessage(logMessage, {
+			level: "warning",
+			tags: extra.tags
+		}) : captureMessage(logMessage, { level: "warning" });
+	}
+};
+//#endregion
+//#region src/pagelifecycle/const.ts
+const PAGE_LIFECYCLE_STATE_HIDDEN = "hidden";
+const PAGE_LIFECYCLE_STATE_ACTIVE = "active";
+const PAGE_LIFECYCLE_STATE_PASSIVE = "passive";
+const PAGE_LIFECYCLE_STATE_FROZEN = "frozen";
+const PAGE_LIFECYCLE_STATE_TERMINATED = "terminated";
+const PAGE_LIFECYCLE_STATES = new Set([
+	PAGE_LIFECYCLE_STATE_ACTIVE,
+	PAGE_LIFECYCLE_STATE_FROZEN,
+	PAGE_LIFECYCLE_STATE_HIDDEN,
+	PAGE_LIFECYCLE_STATE_PASSIVE,
+	PAGE_LIFECYCLE_STATE_TERMINATED
+]);
+const DOCUMENT_STATE_DOM_LOADED = "domLoaded";
+const DOCUMENT_STATE_FULLY_LOADED = "fullyLoaded";
+const DOCUMENT_STATE_COMPLETE = "complete";
+const DOCUMENT_STATE_INTERACTIVE = "interactive";
+const DOCUMENT_STATE_LOADING = "loading";
+const DOCUMENT_STATES = new Set([
+	DOCUMENT_STATE_COMPLETE,
+	DOCUMENT_STATE_DOM_LOADED,
+	DOCUMENT_STATE_FULLY_LOADED,
+	DOCUMENT_STATE_INTERACTIVE,
+	DOCUMENT_STATE_LOADING
+]);
+const PAGE_LIFECYCLE_STATE_CHANGE_EVENT = "pageLifecycleStateChange";
+const DOCUMENT_STATE_CHANGE_EVENT = "documentStateChange";
+//#endregion
+//#region src/pagelifecycle/typedef.ts
+const TYPEDEF = true;
+//#endregion
+//#region src/util/event_emitter.ts
+/**
+* Internal listener wrapper that stores metadata
+* about a registered event listener.
+*/
+var Listener = class {
+	fn;
+	context;
+	once;
+	constructor(fn, context, once = false) {
+		this.fn = fn;
+		this.context = context;
+		this.once = once;
+	}
+};
+/**
+* Event emitter implementation inspired by Node.js/EventEmitter3.
+*/
+var EventEmitter = class {
+	#events;
+	constructor() {
+		this.#events = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Get all registered event names.
+	*/
+	eventNames() {
+		return [...this.#events.keys()];
+	}
+	/**
+	* Get all listener functions registered for an event.
+	*/
+	listeners(event) {
+		const listeners = this.#events.get(event);
+		return listeners ? listeners.map((l) => l.fn) : [];
+	}
+	/**
+	* Get the number of listeners registered for an event.
+	*/
+	listenerCount(event) {
+		const listeners = this.#events.get(event);
+		return listeners ? listeners.length : 0;
+	}
+	/**
+	* Emit an event, invoking all registered listeners.
+	*/
+	emit(event, ...args) {
+		const listeners = this.#events.get(event);
+		if (!listeners || listeners.length === 0) return false;
+		for (const listener of [...listeners]) {
+			listener.fn.apply(listener.context, args);
+			if (listener.once) this.off(event, listener.fn, listener.context);
+		}
+		return true;
+	}
+	#addListener(event, fn, context, once) {
+		if (typeof fn !== "function") throw new TypeError("Listener must be a function");
+		const listener = new Listener(fn, context ?? this, once);
+		const listeners = this.#events.get(event);
+		if (listeners) listeners.push(listener);
+		else this.#events.set(event, [listener]);
+		return this;
+	}
+	/**
+	* Register a persistent listener for an event.
+	*/
+	on(event, fn, context) {
+		return this.#addListener(event, fn, context, false);
+	}
+	/**
+	* Register a one-time listener for an event.
+	*/
+	once(event, fn, context) {
+		return this.#addListener(event, fn, context, true);
+	}
+	/**
+	* Remove a specific listener, or all listeners for an event.
+	*/
+	off(event, fn, context) {
+		if (!this.#events.has(event)) return this;
+		if (!fn) {
+			this.#events.delete(event);
+			return this;
+		}
+		const filtered = this.#events.get(event).filter((listener) => {
+			if (listener.fn !== fn) return true;
+			if (context !== void 0 && listener.context !== context) return true;
+			return false;
+		});
+		if (filtered.length > 0) this.#events.set(event, filtered);
+		else this.#events.delete(event);
+		return this;
+	}
+	/**
+	* Remove all listeners from the emitter,
+	* or all listeners for a specific event.
+	*/
+	removeAllListeners(event) {
+		if (event === void 0) this.#events.clear();
+		else this.#events.delete(event);
+		return this;
+	}
+};
+//#endregion
+//#region src/pagelifecycle/util.ts
+/**
+* Page lifecycle helper.
+* @see https://developer.chrome.com/docs/web-platform/page-lifecycle-api
+*/
+const logger$2 = new Logger("pagelifecycle");
+const eventEmitter = new EventEmitter();
+let currentPageLifecycleState = null;
+let currentDocumentState = null;
+let isInitialized = false;
+const callbacks = {};
+/**
+* Run callbacks for a specific state change.
+*/
+const processCallbacks = (state) => {
+	const stateCallbacks = callbacks[state];
+	if (!stateCallbacks) return;
+	for (const callback of stateCallbacks) callback();
+	stateCallbacks.length = 0;
+};
+/**
+* Detects the current page lifecycle state.
+*/
+const detectPageLifecycleState = () => {
+	if (document.visibilityState === "hidden") return PAGE_LIFECYCLE_STATE_HIDDEN;
+	if (document.hasFocus()) return PAGE_LIFECYCLE_STATE_ACTIVE;
+	return PAGE_LIFECYCLE_STATE_PASSIVE;
+};
+/**
+* Handles page lifecycle state change.
+*/
+const onPageLifecycleStateChange = (nextState) => {
+	const previousState = currentPageLifecycleState;
+	if (nextState !== previousState) {
+		currentPageLifecycleState = nextState;
+		const eventData = {
+			previousState,
+			nextState
+		};
+		logger$2.info(PAGE_LIFECYCLE_STATE_CHANGE_EVENT, eventData);
+		eventEmitter.emit(PAGE_LIFECYCLE_STATE_CHANGE_EVENT, eventData);
+		processCallbacks(currentPageLifecycleState);
+	}
+};
+/**
+* Handles document state change.
+*/
+const onDocumentStateChange = (nextState) => {
+	const previousState = currentDocumentState;
+	if (nextState !== previousState) {
+		currentDocumentState = nextState;
+		const eventData = {
+			previousState,
+			nextState
+		};
+		logger$2.info(DOCUMENT_STATE_CHANGE_EVENT, eventData);
+		eventEmitter.emit(DOCUMENT_STATE_CHANGE_EVENT, eventData);
+		processCallbacks(currentDocumentState);
+	}
+};
+/**
+* Initialize page lifecycle observer.
+*/
+const initPageLifecycle = () => {
+	if (isInitialized) return;
+	logger$2.info("initPageLifecycle");
+	onPageLifecycleStateChange(detectPageLifecycleState());
+	onDocumentStateChange(document.readyState);
+	const options = { capture: true };
+	document.addEventListener("visibilitychange", () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
+	globalThis.addEventListener("pageshow", () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
+	globalThis.addEventListener("focus", () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
+	globalThis.addEventListener("blur", () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
+	document.addEventListener("resume", () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
+	document.addEventListener("freeze", () => onPageLifecycleStateChange(PAGE_LIFECYCLE_STATE_FROZEN), options);
+	globalThis.addEventListener("pagehide", (event) => onPageLifecycleStateChange(event.persisted ? PAGE_LIFECYCLE_STATE_FROZEN : PAGE_LIFECYCLE_STATE_TERMINATED), options);
+	document.addEventListener("DOMContentLoaded", () => onDocumentStateChange(DOCUMENT_STATE_DOM_LOADED), options);
+	document.addEventListener("readystatechange", () => onDocumentStateChange(document.readyState), options);
+	globalThis.addEventListener("load", () => onDocumentStateChange(DOCUMENT_STATE_FULLY_LOADED), options);
+	isInitialized = true;
+};
+/**
+* Returns the current page lifecycle state.
+*/
+const getPageLifecycleState = () => currentPageLifecycleState;
+/**
+* Returns the current document state.
+*/
+const getDocumentState = () => currentDocumentState;
+/**
+* Returns the event emitter instance.
+*/
+const getPageLifecycleEventEmitter = () => {
+	if (!isInitialized) initPageLifecycle();
+	return eventEmitter;
+};
+/**
+* Returns the page lifecycle observer initialized state.
+*/
+const isPageLifecycleInitialized = () => isInitialized;
+/**
+* Add callback for a specific state change.
+*/
+const addPageLifecycleCallback = (state, callback) => {
+	const stateCallbacks = callbacks[state] ?? [];
+	stateCallbacks.push(callback);
+	callbacks[state] = stateCallbacks;
+};
+//#endregion
+//#region src/typecheck/TypeCheckError.ts
+var TypeCheckError = class extends TypeError {
+	value;
+	/**
+	* Creates a new `TypeCheckError` instance.
+	*/
+	constructor(message, options) {
+		super(message, options);
+		this.name = "TypeCheckError";
+		this.value = options?.value;
+	}
+};
+//#endregion
+//#region src/util/string.ts
+/**
+* Add leading zeros to a value to ensure it has a minimum width.
+*/
+const addLeadingZero = (value, size = 2) => {
+	if (value === null || value === void 0) return null;
+	let str = value.toString();
+	while (str.length < size) str = `0${str}`;
+	return str;
+};
+/**
+* Capitalize a string.
+*/
+const capitalize = (value) => {
+	if (value === null || value === void 0) return null;
+	if (!value || value.length === 0) return value;
+	const normValue = value.toLowerCase();
+	return normValue.charAt(0).toUpperCase() + normValue.slice(1);
+};
+/**
+* Converts underscore case string to camel case.
+*/
+const underscoreToCamelCase = (value) => value.replaceAll(/(_\w)/gu, (m) => m[1].toUpperCase());
+/**
+* Saves text file.
+*/
+const saveAsFile = (filename, text) => {
+	const element = document.createElement("a");
+	element.setAttribute("href", `data:text/plain;charset=utf-8,${encodeURIComponent(text)}`);
+	element.setAttribute("download", filename);
+	element.style.display = "none";
+	document.body.append(element);
+	element.click();
+	element.remove();
+};
+/**
+* Get type from value in human readable format.
+*/
+const getTypeFromValue = (value) => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+/**
+* Get value in human readable format.
+*/
+const getDisplayValue = (value) => {
+	if (typeof value === "string") return `"${value}"`;
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+};
+//#endregion
+//#region src/util/number.ts
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+const PRECISION = 12;
+const EPSILON = 1e-11;
+/**
+* Converts degrees to radians.
+*/
+const deg2rad = (degrees) => {
+	if (!Number.isFinite(degrees)) throw new TypeCheckError("Argument degrees must be a finite number", { value: degrees });
+	return degrees * DEG_TO_RAD;
+};
+/**
+* Converts radians to degrees.
+*/
+const rad2deg = (radians) => {
+	if (!Number.isFinite(radians)) throw new TypeCheckError("Argument radians must be a finite number", { value: radians });
+	return radians * RAD_TO_DEG;
+};
+/**
+* Returns random integer in range.
+*/
+const getRandomInt = (min, max) => {
+	if (!Number.isFinite(min)) throw new TypeCheckError("Argument min must be finite number", { value: min });
+	if (!Number.isFinite(max)) throw new TypeCheckError("Argument max must be finite number", { value: max });
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+/**
+* Normalizes floating point precision (e.g. 0.20000000000000004 → 0.2).
+*/
+const fixFloatPrecision = (value) => {
+	const parsedValue = typeof value === "string" ? Number(value) : value;
+	if (parsedValue === null || parsedValue === void 0 || !Number.isFinite(parsedValue)) return NaN;
+	return Math.abs(parsedValue) < EPSILON ? 0 : Number(parsedValue.toPrecision(PRECISION));
+};
+const isGreater = (value, min) => value > min;
+const isGreaterOrEqual = (value, min) => value >= min;
+const isLess = (value, min) => value < min;
+const isLessOrEqual = (value, min) => value <= min;
+const isInRange = (value, min, max) => value >= min && value <= max;
+const isEqual = (value, expected) => value === expected;
+//#endregion
+//#region src/util/validate.ts
+/**
+* Validates `value` as `boolean`.
+*/
+const isBoolean = (value) => typeof value === "boolean";
+/**
+* Validates `value` as `number`.
+*/
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+* Validates `value` as positive `number`.
+*/
+const isPositiveNumber = (value) => isNumber(value) && value > 0;
+/**
+* Validates `value` as non-negative `number`.
+*/
+const isNonNegativeNumber = (value) => isNumber(value) && value >= 0;
+/**
+* Validates `value` as `integer`.
+*/
+const isInteger = (value) => isNumber(value) && Number.isInteger(value);
+/**
+* Validates `value` as positive `integer`.
+*/
+const isPositiveInteger = (value) => isInteger(value) && value > 0;
+/**
+* Validates `value` as non-negative `integer`.
+*/
+const isNonNegativeInteger = (value) => isInteger(value) && value >= 0;
+/**
+* Validates `value` as `string`.
+*/
+const isString = (value) => typeof value === "string";
+/**
+* Validates `value` as `array`.
+*/
+const isArray = (value) => Array.isArray(value);
+/**
+* Validates `value` as `null`.
+*/
+const isNull = (value) => value === null;
+/**
+* Validates `value` as `undefined`.
+*/
+const isUndefined = (value) => value === void 0;
+/**
+* Validates `value` as `null` or `undefined`.
+*/
+const isNullOrUndefined = (value) => isNull(value) || isUndefined(value);
+/**
+* Validates `value` as plain `object`.
+*/
+const isPlainObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+/**
+* Validates `value` as `function`.
+*/
+const isFunction = (value) => typeof value === "function";
+/**
+* Validates `value` as `type`.
+*/
+const isInstance = (value, type) => isFunction(type) && value instanceof type;
+/**
+* Validates `value` as `enum`.
+*/
+const isEnum = (value, choices) => {
+	if (!isString(value) && !isNumber(value)) return false;
+	return isArray(choices) && choices.includes(value) || isPlainObject(choices) && Object.values(choices).includes(value) || isInstance(choices, Set) && choices.has(value);
+};
+/**
+* Type check an array of values using a validator.
+*/
+const isArrayOf = (values, validator) => {
+	if (!isArray(values)) return false;
+	for (const value of values) if (!validator(value)) return false;
+	return true;
+};
+/**
+* Type check a plain object of values using a validator.
+*/
+const isPlainObjectOf = (record, validator) => {
+	if (!isPlainObject(record)) return false;
+	for (const value of Object.values(record)) if (!validator(value)) return false;
+	return true;
+};
+/**
+* Refine a base validator with an extra condition.
+*/
+const refineValidator = (base, predicate, name = null) => {
+	const refinedValidator = (value) => base(value) && predicate(value);
+	Object.defineProperty(refinedValidator, "name", { value: isString(name) ? name : `${base.name}Refined` });
+	return refinedValidator;
+};
+/**
+* Logical OR of two validators.
+*/
+const isAnyOf = (a, b) => (value) => a(value) || b(value);
+const isNumberGreater = (min) => refineValidator(isNumber, (value) => isGreater(value, min));
+const isNumberGreaterOrEqual = (min) => refineValidator(isNumber, (value) => isGreaterOrEqual(value, min));
+const isNumberLess = (min) => refineValidator(isNumber, (value) => isLess(value, min));
+const isNumberLessOrEqual = (min) => refineValidator(isNumber, (value) => isLessOrEqual(value, min));
+const isNumberInRange = (min, max) => refineValidator(isNumber, (value) => isInRange(value, min, max));
+const isNumberEqual = (expected) => refineValidator(isNumber, (value) => isEqual(value, expected));
+const isIntegerGreater = (min) => refineValidator(isInteger, (value) => isGreater(value, min));
+const isIntegerGreaterOrEqual = (min) => refineValidator(isInteger, (value) => isGreaterOrEqual(value, min));
+const isIntegerLess = (min) => refineValidator(isInteger, (value) => isLess(value, min));
+const isIntegerLessOrEqual = (min) => refineValidator(isInteger, (value) => isLessOrEqual(value, min));
+const isIntegerInRange = (min, max) => refineValidator(isInteger, (value) => isInRange(value, min, max));
+const isIntegerEqual = (expected) => refineValidator(isInteger, (value) => isEqual(value, expected));
+const isStringLengthGreater = (min) => refineValidator(isString, (value) => isGreater(value.length, min));
+const isStringLengthGreaterOrEqual = (min) => refineValidator(isString, (value) => isGreaterOrEqual(value.length, min));
+const isStringLengthLess = (min) => refineValidator(isString, (value) => isLess(value.length, min));
+const isStringLengthLessOrEqual = (min) => refineValidator(isString, (value) => isLessOrEqual(value.length, min));
+const isStringLengthInRange = (min, max) => refineValidator(isString, (value) => isInRange(value.length, min, max));
+const isStringLengthEqual = (expected) => refineValidator(isString, (value) => isEqual(value.length, expected));
+const isArrayLengthGreater = (min) => refineValidator(isArray, (value) => isGreater(value.length, min));
+const isArrayLengthGreaterOrEqual = (min) => refineValidator(isArray, (value) => isGreaterOrEqual(value.length, min));
+const isArrayLengthLess = (min) => refineValidator(isArray, (value) => isLess(value.length, min));
+const isArrayLengthLessOrEqual = (min) => refineValidator(isArray, (value) => isLessOrEqual(value.length, min));
+const isArrayLengthInRange = (min, max) => refineValidator(isArray, (value) => isInRange(value.length, min, max));
+const isArrayLengthEqual = (expected) => refineValidator(isArray, (value) => isEqual(value.length, expected));
+//#endregion
+//#region src/typecheck/util.ts
+/**
+* Get error message for validator exceptions.
+*/
+const getErrorMessage = (validatorName, value) => {
+	const displayValue = getDisplayValue(value);
+	const displayType = getTypeFromValue(value);
+	throw new TypeCheckError(`Validation failed: ${validatorName || "<anonymous>"} - ${displayValue} (${displayType})`);
+};
+/**
+* Type check a value using a validator.
+* @throws {TypeCheckError}
+*/
+const typeCheck = (value, validator) => {
+	if (!validator(value)) getErrorMessage(validator.name, value);
+	return value;
+};
+/**
+* Type check an array of values using a validator.
+* @throws {TypeCheckError}
+*/
+const typeCheckArray = (value, validator) => {
+	if (!isArrayOf(value, validator)) getErrorMessage(validator.name, value);
+	return value;
+};
+/**
+* Type check an enum.
+* @throws {TypeCheckError}
+*/
+const typeCheckEnum = (value, choices) => {
+	if (!isEnum(value, choices)) getErrorMessage("isEnum", value);
+	return value;
+};
+//#endregion
+//#region src/typecheck/TypeChecker.ts
+const logger$1 = new Logger("typechecker");
+/**
+* Export a single shared instance.
+*/
+const typeChecker = new class TypeChecker {
+	static #instance;
+	#swallowErrors = false;
+	constructor() {
+		if (TypeChecker.#instance === void 0) TypeChecker.#instance = this;
+	}
+	/**
+	* Enable or disable swallowing of TypeCheckErrors.
+	*/
+	setSwallowErrors(value) {
+		this.#swallowErrors = Boolean(value);
+	}
+	/**
+	* Type check a single value.
+	*/
+	check(value, validator) {
+		try {
+			return typeCheck(value, validator);
+		} catch (error) {
+			if (this.#swallowErrors && error instanceof TypeCheckError) {
+				logger$1.exception("check", error);
+				return value;
+			}
+			throw error;
+		}
+	}
+	/**
+	* Type check an array of values.
+	*/
+	checkArray(value, validator) {
+		try {
+			return typeCheckArray(value, validator);
+		} catch (error) {
+			if (this.#swallowErrors && error instanceof TypeCheckError) {
+				logger$1.exception("checkArray", error);
+				return value;
+			}
+			throw error;
+		}
+	}
+	/**
+	* Type check an enum.
+	*/
+	checkEnum(value, choices) {
+		try {
+			return typeCheckEnum(value, choices);
+		} catch (error) {
+			if (this.#swallowErrors && error instanceof TypeCheckError) {
+				logger$1.exception("checkEnum", error);
+				return value;
+			}
+			throw error;
+		}
+	}
+}();
+//#endregion
+//#region src/util/error.ts
+const DEFAULT_EXCLUDES = new Set(["stack"]);
+/**
+* Retrieves detailed information from an error object.
+*/
+const getErrorDetails = (error, excludes) => {
+	const errorDetails = {
+		name: error.name,
+		type: error.constructor?.name ?? typeof error
+	};
+	if (error.message) errorDetails.message = error.message;
+	if (error.cause) errorDetails.cause = error.cause;
+	for (const key of Object.getOwnPropertyNames(error)) if (!excludes?.includes(key) && !DEFAULT_EXCLUDES.has(key)) errorDetails[key] = error[key];
+	return errorDetails;
+};
+/**
+* Get typed error from an unknown type.
+*/
+const getTypedError = (error) => error instanceof Error ? error : new Error(String(error));
+//#endregion
+//#region src/util/async.ts
+/**
+* Returns a promise with delayed resolve.
+*/
+const delayPromise = (delayMS) => new Promise((resolve) => {
+	setTimeout(resolve, delayMS);
+});
+/**
+* Async method call retry helper.
+*/
+const retryAsync = async (method, numTries = 1, delayMs = 100) => {
+	for (let attempt = 0; attempt <= numTries; attempt += 1) try {
+		return await method();
+	} catch (error) {
+		if (attempt === numTries) throw getTypedError(error);
+		if (delayMs > 0) await delayPromise(delayMs);
+	}
+	throw new Error("Unknown error");
+};
+/**
+* Load JSON file using a fetch GET request.
+*/
+const loadJSON = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new DOMException(`Fetch error ${response.status}`, "FetchError");
+	return response.json();
+};
+//#endregion
+//#region src/util/fetch.ts
+const logger = new Logger("fetch");
+const HTTP_0_ANY = 0;
+var FetchError = class extends Error {
+	resource;
+	fetchOptions;
+	response;
+	cause;
+	/**
+	* Creates a new FetchError instance.
+	*/
+	constructor(message, resource, fetchOptions, response) {
+		super(message);
+		this.name = "FetchError";
+		this.resource = resource;
+		this.fetchOptions = fetchOptions;
+		this.response = response;
+		this.cause = response?.status ?? null;
+	}
+};
+/**
+* Fetch with retry.
+*/
+const fetchRetry = async (resource, fetchOptions, retryOptions) => {
+	const opts = {
+		timeout: Math.max(retryOptions?.timeout ?? 3e4, 1),
+		delay: Math.max(retryOptions?.delay ?? 1e3, 1),
+		numTries: Math.max(retryOptions?.numTries ?? 1, 1),
+		statusExcludes: retryOptions?.statusExcludes ?? [
+			401,
+			403,
+			405,
+			422
+		]
+	};
+	while (opts.numTries > 0) {
+		const isOnline = globalThis.navigator?.onLine;
+		logger.info("request", {
+			resource: String(resource),
+			fetchOptions,
+			retryOptions: { ...opts },
+			isOnline
+		});
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(new DOMException("Fetch timed out", "AbortError")), opts.timeout);
+		const options = {
+			...fetchOptions,
+			signal: controller.signal
+		};
+		try {
+			const response = await fetch(resource, options);
+			if (!response.ok) throw new FetchError(`Fetch error ${response.status}`, resource, options, response);
+			logger.info("response", { status: response.status });
+			return response;
+		} catch (error) {
+			const typedError = error instanceof Error ? error : new Error(String(error));
+			logger.debug("error", getErrorDetails(typedError));
+			opts.numTries -= 1;
+			if (opts.numTries === 0 || typedError instanceof FetchError && (opts.statusExcludes.includes(typedError.response?.status ?? -1) || opts.statusExcludes.includes(0))) throw error;
+			await delayPromise(opts.delay);
+			opts.delay *= 2;
+		} finally {
+			clearTimeout(timeoutId);
+		}
+	}
+	throw new Error("Fetch failed");
+};
+//#endregion
+//#region src/util/object.ts
+const PROHIBITED_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Purges object properties to free up memory.
+*/
+const purgeObject = (target) => {
+	if (!target) return;
+	for (const entry of Object.keys(target)) target[entry] = null;
+};
+/**
+* Merge two objects.
+*/
+const deepMerge = (target, source) => {
+	if (typeof target !== "object" || target === null) return source;
+	if (typeof source !== "object" || source === null) return target;
+	for (const key of Object.keys(source)) {
+		if (PROHIBITED_KEYS.has(key)) throw new SyntaxError(`Security violation error. Cannot use "${key}" as object key.`);
+		if (typeof source[key] === "object" && source[key] !== null) {
+			if (!target[key] || typeof target[key] !== "object") target[key] = {};
+			deepMerge(target[key], source[key]);
+		} else target[key] = source[key];
+	}
+	return target;
+};
+/**
+* Returns the sum value of an array of objects field.
+*/
+const getObjArrayPropSum = (arr, prop) => arr.reduce((accumulator, object) => accumulator + object[prop], 0);
+/**
+* Get object value by path.
+*/
+const getObjValueByPath = (obj, path) => {
+	if (!obj || !path) return null;
+	const keyParts = path.split(".");
+	const nextKey = keyParts[0];
+	if (keyParts.length === 1) return obj[nextKey] === void 0 ? null : obj[nextKey];
+	if (obj[nextKey] === void 0 || obj[nextKey] === null) return null;
+	return getObjValueByPath(obj[nextKey], keyParts.slice(1).join("."));
+};
+/**
+* Set object value by path.
+* @throws {SyntaxError} Error when illegal path value has been provided.
+*/
+const setObjValueByPath = (obj, path, value) => {
+	if (!obj || !path) return;
+	const keyParts = path.split(".");
+	const nextKey = keyParts[0];
+	if (PROHIBITED_KEYS.has(nextKey)) throw new SyntaxError(`Security violation error. Cannot use "${nextKey}" as parameter.`);
+	if (keyParts.length === 1) obj[nextKey] = value;
+	else {
+		if (obj[nextKey] === void 0 || obj[nextKey] === null) obj[nextKey] = {};
+		setObjValueByPath(obj[nextKey], keyParts.slice(1).join("."), value);
+	}
+};
+//#endregion
+//#region src/util/state.ts
+/**
+* Maps server data to client data.
+*/
+const serverDataToState = (data, isRecursive = false) => {
+	if (Array.isArray(data)) return data.map((entry) => serverDataToState(entry, isRecursive));
+	if (data !== null && typeof data === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(data)) {
+			const clientKey = underscoreToCamelCase(key);
+			result[clientKey] = isRecursive ? serverDataToState(value, isRecursive) : value;
+		}
+		return result;
+	}
+	return data;
+};
+//#endregion
+//#region src/util/uuid.ts
+/**
+* Convert a byte (0–255) to a 2-character hex string.
+*/
+const byteToHex = (byte) => (byte >>> 4).toString(16) + (byte & 15).toString(16);
+/**
+* UUIDv4 fallback generator (RFC 4122 compliant).
+*/
+const randomUUIDFallback = () => {
+	const bytes = crypto.getRandomValues ? crypto.getRandomValues(new Uint8Array(16)) : Array.from({ length: 16 }, () => Math.floor(Math.random() * 256));
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	let uuid = "";
+	for (let index = 0; index < bytes.length; index += 1) {
+		if (index === 4 || index === 6 || index === 8 || index === 10) uuid += "-";
+		uuid += byteToHex(bytes[index]);
+	}
+	return uuid;
+};
+/**
+* Crypto UUIDv4 wrapper with fallback.
+*/
+const uuidv4 = () => typeof crypto.randomUUID === "function" ? crypto.randomUUID() : randomUUIDFallback();
+//#endregion
+export { AbstractLogHandler, ConsoleLogHandler, DOCUMENT_STATES, DOCUMENT_STATE_CHANGE_EVENT, DOCUMENT_STATE_COMPLETE, DOCUMENT_STATE_DOM_LOADED, DOCUMENT_STATE_FULLY_LOADED, DOCUMENT_STATE_INTERACTIVE, DOCUMENT_STATE_LOADING, EventEmitter, FetchError, HTTP_0_ANY, HTTP_100_CONTINUE, HTTP_101_SWITCHING_PROTOCOLS, HTTP_102_PROCESSING, HTTP_103_EARLY_HINTS, HTTP_200_OK, HTTP_201_CREATED, HTTP_202_ACCEPTED, HTTP_203_NON_AUTHORITATIVE_INFORMATION, HTTP_204_NO_CONTENT, HTTP_205_RESET_CONTENT, HTTP_206_PARTIAL_CONTENT, HTTP_207_MULTI_STATUS, HTTP_208_ALREADY_REPORTED, HTTP_226_IM_USED, HTTP_300_MULTIPLE_CHOICES, HTTP_301_MOVED_PERMANENTLY, HTTP_302_FOUND, HTTP_303_SEE_OTHER, HTTP_304_NOT_MODIFIED, HTTP_305_USE_PROXY, HTTP_306_RESERVED, HTTP_307_TEMPORARY_REDIRECT, HTTP_308_PERMANENT_REDIRECT, HTTP_400_BAD_REQUEST, HTTP_401_UNAUTHORIZED, HTTP_402_PAYMENT_REQUIRED, HTTP_403_FORBIDDEN, HTTP_404_NOT_FOUND, HTTP_405_METHOD_NOT_ALLOWED, HTTP_406_NOT_ACCEPTABLE, HTTP_407_PROXY_AUTHENTICATION_REQUIRED, HTTP_408_REQUEST_TIMEOUT, HTTP_409_CONFLICT, HTTP_410_GONE, HTTP_411_LENGTH_REQUIRED, HTTP_412_PRECONDITION_FAILED, HTTP_413_CONTENT_TOO_LARGE, HTTP_414_URI_TOO_LONG, HTTP_415_UNSUPPORTED_MEDIA_TYPE, HTTP_416_RANGE_NOT_SATISFIABLE, HTTP_417_EXPECTATION_FAILED, HTTP_418_IM_A_TEAPOT, HTTP_421_MISDIRECTED_REQUEST, HTTP_422_UNPROCESSABLE_CONTENT, HTTP_423_LOCKED, HTTP_424_FAILED_DEPENDENCY, HTTP_425_TOO_EARLY, HTTP_426_UPGRADE_REQUIRED, HTTP_428_PRECONDITION_REQUIRED, HTTP_429_TOO_MANY_REQUESTS, HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE, HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS, HTTP_499_CLIENT_CLOSED_CONNECTION, HTTP_500_INTERNAL_SERVER_ERROR, HTTP_501_NOT_IMPLEMENTED, HTTP_502_BAD_GATEWAY, HTTP_503_SERVICE_UNAVAILABLE, HTTP_504_GATEWAY_TIMEOUT, HTTP_505_HTTP_VERSION_NOT_SUPPORTED, HTTP_506_VARIANT_ALSO_NEGOTIATES, HTTP_507_INSUFFICIENT_STORAGE, HTTP_508_LOOP_DETECTED, HTTP_510_NOT_EXTENDED, HTTP_511_NETWORK_AUTHENTICATION_REQUIRED, HTTP_STATUS_MAP, LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, LOG_LEVEL_INFO, LOG_LEVEL_NAMES, LOG_LEVEL_NAME_DEBUG, LOG_LEVEL_NAME_ERROR, LOG_LEVEL_NAME_FATAL, LOG_LEVEL_NAME_INFO, LOG_LEVEL_NAME_SILENT, LOG_LEVEL_NAME_WARNING, LOG_LEVEL_SILENT, LOG_LEVEL_WARNING, Logger, OpenTelemetryLogHandler, PAGE_LIFECYCLE_STATES, PAGE_LIFECYCLE_STATE_ACTIVE, PAGE_LIFECYCLE_STATE_CHANGE_EVENT, PAGE_LIFECYCLE_STATE_FROZEN, PAGE_LIFECYCLE_STATE_HIDDEN, PAGE_LIFECYCLE_STATE_PASSIVE, PAGE_LIFECYCLE_STATE_TERMINATED, SentryLogHandler, TYPEDEF, TypeCheckError, addLeadingZero, addPageLifecycleCallback, capitalize, deepMerge, deg2rad, delayPromise, fetchRetry, fixFloatPrecision, formatLogMessage, getDocumentState, getErrorDetails, getLogLevelName, getObjArrayPropSum, getObjValueByPath, getPageLifecycleEventEmitter, getPageLifecycleState, getRandomInt, getTypeFromValue, getTypedError, getURLParam, initPageLifecycle, isAnyOf, isArray, isArrayLengthEqual, isArrayLengthGreater, isArrayLengthGreaterOrEqual, isArrayLengthInRange, isArrayLengthLess, isArrayLengthLessOrEqual, isArrayOf, isBoolean, isEnum, isEqual, isFunction, isGreater, isGreaterOrEqual, isInRange, isInstance, isInteger, isIntegerEqual, isIntegerGreater, isIntegerGreaterOrEqual, isIntegerInRange, isIntegerLess, isIntegerLessOrEqual, isLess, isLessOrEqual, isNonNegativeInteger, isNonNegativeNumber, isNull, isNullOrUndefined, isNumber, isNumberEqual, isNumberGreater, isNumberGreaterOrEqual, isNumberInRange, isNumberLess, isNumberLessOrEqual, isPageLifecycleInitialized, isPlainObject, isPlainObjectOf, isPositiveInteger, isPositiveNumber, isString, isStringLengthEqual, isStringLengthGreater, isStringLengthGreaterOrEqual, isStringLengthInRange, isStringLengthLess, isStringLengthLessOrEqual, isUndefined, loadJSON, purgeObject, rad2deg, refineValidator, retryAsync, sanitizeURLParam, saveAsFile, serverDataToState, setObjValueByPath, typeCheck, typeCheckArray, typeCheckEnum, typeChecker, underscoreToCamelCase, uuidv4 };
+
+//# sourceMappingURL=index.js.map