@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/BrowserStorageProvider-CuOW1Er2.esm.js

@@ -0,0 +1,55 @@
+//#region ../infra/src/providers/browser/BrowserStorageProvider.ts
+/**
+* Browser-based storage provider wrapping localStorage.
+* Handles JSON serialization/deserialization automatically.
+*/
+var BrowserStorageProvider = class {
+	/**
+	* Retrieves a value from localStorage.
+	* @param key - The storage key
+	* @returns The stored value or null if not found
+	* @throws Error if stored value is invalid JSON
+	*/
+	async get(key) {
+		try {
+			const item = localStorage.getItem(key);
+			if (item === null) return null;
+			return JSON.parse(item);
+		} catch (error) {
+			if (error instanceof SyntaxError) throw new Error(`Invalid JSON stored at key "${key}": ${error.message}`);
+			throw error;
+		}
+	}
+	/**
+	* Stores a value in localStorage.
+	* @param key - The storage key
+	* @param value - The value to store (will be serialized as JSON)
+	* @throws Error if value cannot be serialized or quota is exceeded
+	*/
+	async set(key, value) {
+		try {
+			const serialized = JSON.stringify(value);
+			localStorage.setItem(key, serialized);
+		} catch (error) {
+			if ((error instanceof DOMException || error.name === "QuotaExceededError") && error.name === "QuotaExceededError") throw new Error(`Storage quota exceeded for key "${key}"`);
+			if (error instanceof TypeError) throw new Error(`Failed to serialize value for key "${key}": ${error.message}`);
+			throw error;
+		}
+	}
+	/**
+	* Removes a value from localStorage.
+	* @param key - The storage key to remove
+	*/
+	async remove(key) {
+		localStorage.removeItem(key);
+	}
+	/**
+	* Clears all values from localStorage.
+	*/
+	async clear() {
+		localStorage.clear();
+	}
+};
+
+//#endregion
+export { BrowserStorageProvider as t };

package/dist/BrowserTimerProvider-DhNc_x02.esm.js

@@ -0,0 +1,22 @@
+//#region ../infra/src/providers/browser/BrowserTimerProvider.ts
+var BrowserTimerProvider = class BrowserTimerProvider {
+	static getInstance() {
+		if (!BrowserTimerProvider.instance) BrowserTimerProvider.instance = new BrowserTimerProvider();
+		return BrowserTimerProvider.instance;
+	}
+	setTimeout(callback, delayMs) {
+		return setTimeout(callback, delayMs);
+	}
+	setInterval(callback, delayMs) {
+		return setInterval(callback, delayMs);
+	}
+	clearTimeout(handle) {
+		clearTimeout(handle);
+	}
+	clearInterval(handle) {
+		clearInterval(handle);
+	}
+};
+
+//#endregion
+export { BrowserTimerProvider as t };

package/dist/ITimerCapability-C67ZRskg.esm.js

@@ -0,0 +1,7 @@
+//#region ../infra/src/capabilities/ITimerCapability.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { sleep as t };

package/dist/IpifyProvider-D7jx52AL.esm.js

@@ -0,0 +1,139 @@
+//#region ../infra/src/providers/browser/BrowserEnvironmentProvider.ts
+var BrowserEnvironmentProvider = class {
+	getScreenDimensions() {
+		if (typeof screen === "undefined") return {
+			width: 0,
+			height: 0
+		};
+		return {
+			width: screen.width,
+			height: screen.height
+		};
+	}
+	generateCanvasFingerprint() {
+		try {
+			if (typeof document === "undefined") return "";
+			const canvas = document.createElement("canvas");
+			const ctx = canvas.getContext("2d");
+			if (!ctx) return "";
+			ctx.textBaseline = "top";
+			ctx.font = "14px Arial";
+			ctx.fillText("fingerprint", 2, 2);
+			return canvas.toDataURL().slice(-50);
+		} catch {
+			return "";
+		}
+	}
+	getWebGLRenderer() {
+		try {
+			if (typeof document === "undefined") return "";
+			const canvas = document.createElement("canvas");
+			const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+			if (!gl) return "";
+			const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+			if (!debugInfo) return "";
+			return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || "";
+		} catch {
+			return "";
+		}
+	}
+	getWindowProperty(prop) {
+		if (typeof window === "undefined") return;
+		return window[prop];
+	}
+	getNavigatorProperty(prop) {
+		if (typeof navigator === "undefined") return;
+		return navigator[prop];
+	}
+	getNavigatorPrefixes() {
+		if (typeof navigator === "undefined") return {
+			webkit: false,
+			moz: false,
+			o: false,
+			ms: false
+		};
+		const nav = navigator;
+		return {
+			webkit: nav.webkitGetUserMedia !== void 0,
+			moz: nav.mozGetUserMedia !== void 0,
+			o: nav.oGetUserMedia !== void 0,
+			ms: nav.msGetUserMedia !== void 0
+		};
+	}
+	async fetchJson(url, timeoutMs = 3e3) {
+		try {
+			if (typeof fetch === "undefined") return null;
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+			const response = await fetch(url, { signal: controller.signal });
+			clearTimeout(timeoutId);
+			return await response.json();
+		} catch {
+			return null;
+		}
+	}
+	async enumerateVideoDeviceLabels() {
+		try {
+			if (typeof navigator === "undefined" || !navigator.mediaDevices?.enumerateDevices) return [];
+			return (await navigator.mediaDevices.enumerateDevices()).filter((device) => device.kind === "videoinput").map((device) => device.label);
+		} catch {
+			return [];
+		}
+	}
+	getTimestamp() {
+		return Date.now();
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/IpifyProvider.ts
+let cachedIp;
+let inFlightLookup;
+/**
+* Resets the module-level IP cache. Intended for tests and full session resets.
+*/
+function resetIpifyCache() {
+	cachedIp = void 0;
+	inFlightLookup = void 0;
+}
+async function fetchIpFromIpify() {
+	if (typeof fetch === "undefined") return "";
+	let timeoutId = 0;
+	const controller = new AbortController();
+	if (AbortSignal.timeout) {
+		const signal = AbortSignal.timeout(3e3);
+		return (await (await fetch("https://api.ipify.org?format=json", { signal })).json()).ip;
+	}
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => {
+			controller.abort();
+			reject(/* @__PURE__ */ new Error("Request timeout"));
+		}, 3e3);
+	});
+	const fetchPromise = fetch("https://api.ipify.org?format=json", { signal: controller.signal }).then((res) => res.json()).then((data) => data.ip);
+	const result = await Promise.race([fetchPromise, timeoutPromise]);
+	clearTimeout(timeoutId);
+	return result;
+}
+var IpifyProvider = class {
+	async getIp() {
+		if (cachedIp !== void 0) return cachedIp;
+		if (inFlightLookup) return inFlightLookup;
+		inFlightLookup = (async () => {
+			try {
+				const ip = await fetchIpFromIpify();
+				cachedIp = ip;
+				return ip;
+			} catch {
+				cachedIp = "";
+				return "";
+			} finally {
+				inFlightLookup = void 0;
+			}
+		})();
+		return inFlightLookup;
+	}
+};
+
+//#endregion
+export { resetIpifyCache as n, BrowserEnvironmentProvider as r, IpifyProvider as t };

package/dist/Manager-C8PrhBOx.d.ts

@@ -0,0 +1,19 @@
+//#region ../infra/src/manager/Manager.d.ts
+/**
+ * Base manager interface providing state access, subscriptions, and lifecycle control.
+ * @template TPublicState - The public state type exposed to consumers
+ */
+type Manager<TPublicState> = {
+  /** Returns the current mapped public state */
+  getState(): TPublicState;
+  /**
+   * Subscribes to state changes.
+   * @param listener - Callback invoked on every state change
+   * @returns Unsubscribe function to stop receiving updates
+   */
+  subscribe(listener: (state: TPublicState) => void): () => void;
+  /** Stops the underlying actor and cleans up resources */
+  stop(): void;
+};
+//#endregion
+export { Manager as t };

package/dist/MotionSensorProvider-4v7xkqAp.esm.js

@@ -0,0 +1,254 @@
+//#region ../infra/src/providers/browser/MotionSensorProvider.ts
+var MotionSensorProvider = class {
+	constructor(thresholds) {
+		this._isRunning = false;
+		this._hasPermission = true;
+		this.acl = null;
+		this.gyro = null;
+		this.minNumberOfFrames = 3;
+		this.maxFrequency = 60;
+		this.emptyParams = {
+			meanX: 0,
+			meanY: 0,
+			meanZ: 0,
+			m2X: 0,
+			m2Y: 0,
+			m2Z: 0,
+			cumulativeAbsErrorX: 0,
+			cumulativeAbsErrorY: 0,
+			cumulativeAbsErrorZ: 0,
+			ptsNum: 0
+		};
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+		this.deviceMotionListener = (event) => {
+			if (event.accelerationIncludingGravity) {
+				const accGrVal = {
+					x: event.accelerationIncludingGravity.x,
+					y: event.accelerationIncludingGravity.y,
+					z: event.accelerationIncludingGravity.z
+				};
+				if (this.checkFields(accGrVal)) {
+					this.paramsAccGrOld.ptsNum += 1;
+					this.updateParams(this.paramsAccGrOld, accGrVal);
+				}
+			}
+			if (event.acceleration) {
+				const accVal = {
+					x: event.acceleration.x,
+					y: event.acceleration.y,
+					z: event.acceleration.z
+				};
+				if (this.checkFields(accVal)) {
+					this.paramsAccOld.ptsNum += 1;
+					this.updateParams(this.paramsAccOld, accVal);
+				}
+			}
+			if (event.rotationRate) {
+				const gyroVal = {
+					x: event.rotationRate.alpha,
+					y: event.rotationRate.beta,
+					z: event.rotationRate.gamma
+				};
+				if (this.checkFields(gyroVal)) {
+					this.paramsGyroscopeOld.ptsNum += 1;
+					this.updateParams(this.paramsGyroscopeOld, gyroVal);
+				}
+			}
+		};
+		this.deviceOrientationListener = (event) => {
+			const orientationVal = {
+				x: event.alpha,
+				y: event.beta,
+				z: event.gamma
+			};
+			if (this.checkFields(orientationVal)) {
+				this.paramsOrientationOld.ptsNum += 1;
+				this.updateParams(this.paramsOrientationOld, orientationVal);
+			}
+		};
+		this.thresholds = {
+			accThreshold: thresholds?.accThreshold ?? .3,
+			gyroThreshold: thresholds?.gyroThreshold ?? .3,
+			accGrOldThreshold: thresholds?.accGrOldThreshold ?? .3,
+			accOldThreshold: thresholds?.accOldThreshold ?? .3,
+			gyroscopeOldThreshold: thresholds?.gyroscopeOldThreshold ?? 10,
+			orientationOldThreshold: thresholds?.orientationOldThreshold ?? 10,
+			maeAccThreshold: thresholds?.maeAccThreshold ?? .3,
+			maeGyroThreshold: thresholds?.maeGyroThreshold ?? .3,
+			maeAccGrOldThreshold: thresholds?.maeAccGrOldThreshold ?? .3,
+			maeAccOldThreshold: thresholds?.maeAccOldThreshold ?? .3,
+			maeGyroscopeOldThreshold: thresholds?.maeGyroscopeOldThreshold ?? 10,
+			maeOrientationOldThreshold: thresholds?.maeOrientationOldThreshold ?? 10
+		};
+	}
+	get isRunning() {
+		return this._isRunning;
+	}
+	get hasPermission() {
+		return this._hasPermission;
+	}
+	async requestPermission() {
+		if (typeof DeviceMotionEvent !== "undefined" && typeof DeviceMotionEvent.requestPermission === "function") {
+			sessionStorage.setItem("motionSensorsPermissionsRequested", String(true));
+			try {
+				if (await DeviceMotionEvent.requestPermission() !== "granted") {
+					this._hasPermission = false;
+					return "denied";
+				}
+				return "granted";
+			} catch {
+				this._hasPermission = false;
+				return "denied";
+			}
+		}
+		return "not-required";
+	}
+	initializeAccelerometer() {
+		if (!("Accelerometer" in window)) return;
+		try {
+			const AccelerometerConstructor = window.Accelerometer;
+			if (AccelerometerConstructor) {
+				this.acl = new AccelerometerConstructor({ frequency: this.maxFrequency });
+				this.acl.addEventListener("reading", () => this.updateAcc());
+			}
+		} catch {}
+	}
+	initializeGyroscope() {
+		if (!("Gyroscope" in window)) return;
+		try {
+			const GyroscopeConstructor = window.Gyroscope;
+			if (GyroscopeConstructor) {
+				this.gyro = new GyroscopeConstructor({ frequency: this.maxFrequency });
+				this.gyro.addEventListener("reading", () => this.updateGyro());
+			}
+		} catch {}
+	}
+	async start() {
+		if (this._isRunning || !this._hasPermission) return;
+		try {
+			this.initializeAccelerometer();
+			if (this.acl) this.acl.start();
+		} catch {}
+		try {
+			this.initializeGyroscope();
+			if (this.gyro) this.gyro.start();
+		} catch {}
+		window.addEventListener("devicemotion", this.deviceMotionListener);
+		window.addEventListener("deviceorientation", this.deviceOrientationListener);
+		this._isRunning = true;
+	}
+	stop() {
+		this._isRunning = false;
+		if (this.acl) this.acl.stop();
+		if (this.gyro) this.gyro.stop();
+		window.removeEventListener("devicemotion", this.deviceMotionListener);
+		window.removeEventListener("deviceorientation", this.deviceOrientationListener);
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+	}
+	updateAcc() {
+		if (!this._isRunning || !this.acl) return;
+		this.paramsAcc.ptsNum += 1;
+		const val = {
+			x: this.acl.x,
+			y: this.acl.y,
+			z: this.acl.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsAcc, val);
+	}
+	updateGyro() {
+		if (!this._isRunning || !this.gyro) return;
+		this.paramsGyro.ptsNum += 1;
+		const val = {
+			x: this.gyro.x,
+			y: this.gyro.y,
+			z: this.gyro.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsGyro, val);
+	}
+	check() {
+		if (!this._hasPermission) return "UNCLEAR";
+		const result = this.checkStability();
+		return result === null ? "UNCLEAR" : result ? "FAIL" : "PASS";
+	}
+	checkStability() {
+		if (!this._isRunning) return null;
+		const filteredStdChecks = [
+			this.gyro ? this.isBelowStdThreshold(this.paramsGyro, this.thresholds.gyroThreshold) : null,
+			this.acl ? this.isBelowStdThreshold(this.paramsAcc, this.thresholds.accThreshold) : null,
+			this.isBelowStdThreshold(this.paramsAccGrOld, this.thresholds.accGrOldThreshold),
+			this.isBelowStdThreshold(this.paramsAccOld, this.thresholds.accOldThreshold),
+			this.isBelowStdThreshold(this.paramsGyroscopeOld, this.thresholds.gyroscopeOldThreshold),
+			this.isBelowStdThreshold(this.paramsOrientationOld, this.thresholds.orientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalStdCheck = filteredStdChecks.length > 0 ? filteredStdChecks.every((check) => check) : null;
+		const filteredMaeChecks = [
+			this.gyro ? this.isBelowMaeThreshold(this.paramsGyro, this.thresholds.maeGyroThreshold) : null,
+			this.acl ? this.isBelowMaeThreshold(this.paramsAcc, this.thresholds.maeAccThreshold) : null,
+			this.isBelowMaeThreshold(this.paramsAccGrOld, this.thresholds.maeAccGrOldThreshold),
+			this.isBelowMaeThreshold(this.paramsAccOld, this.thresholds.maeAccOldThreshold),
+			this.isBelowMaeThreshold(this.paramsGyroscopeOld, this.thresholds.maeGyroscopeOldThreshold),
+			this.isBelowMaeThreshold(this.paramsOrientationOld, this.thresholds.maeOrientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalMaeCheck = filteredMaeChecks.length > 0 ? filteredMaeChecks.every((check) => check) : null;
+		return finalStdCheck === null ? finalMaeCheck === null ? null : finalMaeCheck : finalMaeCheck !== null ? finalStdCheck && finalMaeCheck : finalStdCheck;
+	}
+	updateParams(params, val) {
+		const deltaX = val.x - params.meanX;
+		const deltaY = val.y - params.meanY;
+		const deltaZ = val.z - params.meanZ;
+		params.meanX += deltaX / params.ptsNum;
+		params.meanY += deltaY / params.ptsNum;
+		params.meanZ += deltaZ / params.ptsNum;
+		params.m2X += deltaX * (val.x - params.meanX);
+		params.m2Y += deltaY * (val.y - params.meanY);
+		params.m2Z += deltaZ * (val.z - params.meanZ);
+		params.cumulativeAbsErrorX += Math.abs(val.x - params.meanX);
+		params.cumulativeAbsErrorY += Math.abs(val.y - params.meanY);
+		params.cumulativeAbsErrorZ += Math.abs(val.z - params.meanZ);
+	}
+	calculateStd(params) {
+		const variance = {
+			x: params.m2X / params.ptsNum,
+			y: params.m2Y / params.ptsNum,
+			z: params.m2Z / params.ptsNum
+		};
+		return {
+			x: Math.sqrt(variance.x),
+			y: Math.sqrt(variance.y),
+			z: Math.sqrt(variance.z)
+		};
+	}
+	calculateMae(params) {
+		return {
+			x: params.cumulativeAbsErrorX / params.ptsNum,
+			y: params.cumulativeAbsErrorY / params.ptsNum,
+			z: params.cumulativeAbsErrorZ / params.ptsNum
+		};
+	}
+	checkFields(point) {
+		return point.x !== null && point.y !== null && point.z !== null;
+	}
+	isBelowStdThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const std = this.calculateStd(params);
+		return std.x < threshold && std.y < threshold && std.z < threshold;
+	}
+	isBelowMaeThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const mae = this.calculateMae(params);
+		return mae.x < threshold && mae.y < threshold && mae.z < threshold;
+	}
+};
+
+//#endregion
+export { MotionSensorProvider as t };

package/dist/OpenViduRecordingProvider-CMu6XVdc.esm.js

@@ -0,0 +1,87 @@
+import { t as loadOpenVidu } from "./openviduLazy-Cok70ZSg.esm.js";
+
+//#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
+function createHiddenContainer() {
+	const id = `inc_rec_${Math.random().toString(36).slice(2)}`;
+	const existing = document.getElementById(id);
+	if (existing) return {
+		id,
+		element: existing
+	};
+	const div = document.createElement("div");
+	div.id = id;
+	div.style.display = "none";
+	document.body.appendChild(div);
+	return {
+		id,
+		element: div
+	};
+}
+var OpenViduRecordingProvider = class {
+	async connect(params) {
+		const { OpenVidu } = await loadOpenVidu();
+		const container = createHiddenContainer();
+		const ov = new OpenVidu();
+		const session = ov.initSession();
+		const videoTrack = params.stream.getVideoTracks()[0];
+		const audioTrack = params.stream.getAudioTracks()[0];
+		const hasAudio = audioTrack !== void 0;
+		const publisher = ov.initPublisher(container.id, {
+			publishAudio: hasAudio,
+			audioSource: hasAudio ? audioTrack : false,
+			videoSource: videoTrack ?? false,
+			frameRate: 30
+		});
+		session.on("exception", (event) => {
+			const e = event;
+			params.events?.onSessionException?.({
+				name: e?.name,
+				message: e?.message,
+				sessionId: session.sessionId
+			});
+		});
+		publisher.on("streamCreated", () => {
+			params.events?.onPublisherCreated?.({
+				sessionId: session.sessionId,
+				streamId: publisher.stream?.streamId
+			});
+		});
+		await session.connect(params.sessionToken);
+		params.events?.onSessionConnected?.(session.sessionId);
+		try {
+			await session.publish(publisher);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			params.events?.onPublisherError?.({
+				message,
+				sessionId: session.sessionId,
+				streamId: publisher.stream?.streamId
+			});
+			throw error;
+		}
+		return {
+			sessionId: session.sessionId,
+			publisher: {
+				getStreamId: () => publisher.stream?.streamId,
+				replaceVideoTrack: async (track) => {
+					await publisher.replaceTrack(track);
+				},
+				destroy: () => {}
+			},
+			disconnect: async () => {
+				try {
+					session.disconnect();
+					params.stream.getTracks().forEach((t) => {
+						t.stop();
+					});
+				} finally {
+					params.events?.onSessionDisconnected?.(session.sessionId);
+					if (container.element.parentNode) container.element.parentNode.removeChild(container.element);
+				}
+			}
+		};
+	}
+};
+
+//#endregion
+export { OpenViduRecordingProvider };

package/dist/StateMachine-BCQrZJhf.d.ts

@@ -0,0 +1,2 @@
+import { AnyStateMachine, StateMachine, fromPromise } from "xstate";
+export { StateMachine as n, fromPromise as r, AnyStateMachine as t };

package/dist/WasmUtilProvider-j98OJf-S.esm.js

@@ -0,0 +1,114 @@
+import { r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-C_DLEI40.esm.js";
+
+//#region ../infra/src/providers/wasm/WasmUtilProvider.ts
+var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
+	static async getInstance() {
+		if (WasmUtilProvider.instance) return WasmUtilProvider.instance;
+		if (WasmUtilProvider.initPromise) return WasmUtilProvider.initPromise;
+		WasmUtilProvider.initPromise = (async () => {
+			const instance = new WasmUtilProvider();
+			await instance.initializeBase({}, "selfie");
+			WasmUtilProvider.instance = instance;
+			return instance;
+		})();
+		return WasmUtilProvider.initPromise;
+	}
+	static resetInstance() {
+		WasmUtilProvider.instance = void 0;
+		WasmUtilProvider.initPromise = void 0;
+	}
+	constructor() {
+		super(void 0);
+	}
+	async initialize(config) {
+		if (this.initialized) return;
+		const pipeline = config.pipelines?.[0] ?? "selfie";
+		await this.initializeBase(config, pipeline);
+	}
+	async processFrame(_image) {
+		throw new Error("WasmUtilProvider does not support frame processing. Use encryptImage() instead.");
+	}
+	encryptImage(image) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.ens(image);
+	}
+	setSdkVersion(version) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkVersion(version);
+	}
+	setSdkPlatform(platform) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkPlatform(platform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setMotionStatus(status) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setMotionStatus(status);
+	}
+	setBackgroundMode(backgroundMode) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBackgroundMode(backgroundMode);
+	}
+	setZc(zc) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setZc(zc);
+	}
+	setInspectorOpened(opened) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setInspectorOpened(opened);
+	}
+	getMetadata() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getMetadata();
+	}
+	async analyzeFrame(image) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.analyzeFrame(image);
+	}
+	getCheck() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getCheck();
+	}
+	getPipelineState() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getPipelineState();
+	}
+	estimatePerformance() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.estimatePerformance();
+	}
+	isVirtualCamera(label) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.isVirtualCamera(label);
+	}
+	async prc() {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.prc();
+	}
+	async poc(output) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.poc(output);
+	}
+	ckvcks(data) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.ckvcks(data);
+	}
+	async getVersions() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getVersions();
+	}
+};
+
+//#endregion
+export { WasmUtilProvider as t };