@incodetech/core 0.0.0-dev-20260127-938ff95 → 0.0.0-dev-20260130-5bb04b9

package/dist/id-GPFS1Wo_.esm.js

@@ -1,1827 +0,0 @@
-import { d as addEvent, m as revokeObjectURL, n as eventModuleNames } from "./events-B8ZkhAZo.esm.js";
-import { C as createManager, D as isIOS, E as isDesktop, O as isIPhone14OrHigher, S as stopCameraStream, T as isAndroid, b as enumerateVideoDevices, c as OpenViduRecordingProvider, d as BrowserTimerProvider, h as StreamCanvasCapture, k as isSafari, m as StreamCanvasProcessingSession, n as DEFAULT_ID_CAPTURE_THRESHOLDS, t as DEFAULT_ID_CAPTURE_MODEL_VERSION, v as IncodeCanvas, x as requestCameraAccess, y as applyTrackConstraints } from "./src-XSoNGEQW.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-DkfbtsIJ.esm.js";
-import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
-import { c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-J6ffKmJL.esm.js";
-import { t as api } from "./api-DfRLAneb.esm.js";
-
-//#region ../infra/src/capabilities/ITimerCapability.ts
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-//#endregion
-//#region src/modules/id/idCameraStream.ts
-const BACK_CAMERA_KEYWORDS = [
-	"rear",
-	"back",
-	"rück",
-	"arrière",
-	"trasera",
-	"trás",
-	"traseira",
-	"posteriore",
-	"后面",
-	"後面",
-	"背面",
-	"后置",
-	"後置",
-	"背置",
-	"задней",
-	"الخلفية",
-	"후",
-	"arka",
-	"achterzijde",
-	"หลัง",
-	"baksidan",
-	"bagside",
-	"sau",
-	"bak",
-	"tylny",
-	"takakamera",
-	"belakang",
-	"אחורית",
-	"πίσω",
-	"spate",
-	"hátsó",
-	"zadní",
-	"darrere",
-	"zadná",
-	"задня",
-	"stražnja",
-	"बैक"
-];
-function isBackCameraLabel(label) {
-	const lowercaseLabel = label.toLowerCase();
-	return BACK_CAMERA_KEYWORDS.some((keyword) => lowercaseLabel.includes(keyword));
-}
-function classifyCamera(device, index, totalDevices) {
-	let cameraType;
-	if (device.label === "") cameraType = totalDevices === 1 || index + 1 <= totalDevices / 2 ? "front" : "back";
-	else cameraType = isBackCameraLabel(device.label) ? "back" : "front";
-	return {
-		deviceId: device.deviceId,
-		label: device.label,
-		cameraType
-	};
-}
-async function getCameras() {
-	const videoDevices = await enumerateVideoDevices();
-	const cameras = videoDevices.map((d, i) => classifyCamera(d, i, videoDevices.length));
-	if (cameras.length > 1 && !cameras.some((c) => c.cameraType === "back")) {
-		const resolutions = cameras.map((c) => {
-			const match = c.label.match(/\b([0-9]+)MP?\b/i);
-			return match ? parseInt(match[1], 10) : NaN;
-		});
-		let backCameraIndex = cameras.length - 1;
-		if (!resolutions.some(isNaN)) backCameraIndex = resolutions.lastIndexOf(Math.max(...resolutions));
-		cameras[backCameraIndex].cameraType = "back";
-	}
-	return cameras;
-}
-function selectMainCameraFromStream(track, cameras) {
-	const settings = track.getSettings();
-	const activeCamera = cameras.find((c) => c.deviceId === settings.deviceId || c.label !== "" && c.label === track.label);
-	if (!activeCamera) return void 0;
-	if ((settings.facingMode === "environment" || isBackCameraLabel(track.label)) && cameras.length > 1) {
-		cameras.forEach((camera) => {
-			if (camera.deviceId === activeCamera.deviceId) camera.cameraType = "back";
-			else if (!isBackCameraLabel(camera.label)) camera.cameraType = "front";
-		});
-		return cameras.filter((c) => c.cameraType === "back").sort((a, b) => a.label.localeCompare(b.label))[0];
-	}
-	if (cameras.length === 1) return activeCamera;
-}
-function getAndroidVideoConstraints(level) {
-	const base = {
-		resizeMode: "none",
-		facingMode: "environment"
-	};
-	switch (level) {
-		case 0: return {
-			...base,
-			height: { ideal: 720 },
-			aspectRatio: { ideal: 19.5 / 9 }
-		};
-		case 1: return {
-			...base,
-			width: {
-				min: 3200,
-				ideal: 3840,
-				max: 4096
-			},
-			height: {
-				min: 1800,
-				ideal: 2160,
-				max: 2400
-			}
-		};
-		case 2: return {
-			...base,
-			width: {
-				min: 1400,
-				ideal: 1920,
-				max: 2160
-			},
-			height: {
-				min: 900,
-				ideal: 1080,
-				max: 1440
-			}
-		};
-		case 3: return {
-			...base,
-			width: {
-				min: 640,
-				ideal: 640,
-				max: 800
-			},
-			height: {
-				min: 480,
-				ideal: 480,
-				max: 600
-			}
-		};
-		case 4: return {
-			...base,
-			width: {
-				min: 640,
-				ideal: 800,
-				max: 960
-			},
-			height: {
-				min: 480,
-				ideal: 480,
-				max: 480
-			}
-		};
-		default: return {};
-	}
-}
-async function getAndroidBackCameraStream(fallbackLevel = 0) {
-	if (fallbackLevel > 4) throw new Error("Failed to get camera after all fallback attempts");
-	try {
-		const initialStream = await requestCameraAccess({ video: getAndroidVideoConstraints(fallbackLevel) });
-		const track = initialStream.getVideoTracks()[0];
-		const mainCamera = selectMainCameraFromStream(track, await getCameras());
-		stopCameraStream(initialStream);
-		if (!mainCamera) throw new Error("Could not identify main camera");
-		let idealWidth = 1280;
-		let idealHeight = 720;
-		if (fallbackLevel > 1) {
-			const constraints = getAndroidVideoConstraints(fallbackLevel);
-			const width = constraints.width;
-			const height = constraints.height;
-			idealWidth = width?.ideal ?? 1280;
-			idealHeight = height?.ideal ?? 720;
-		}
-		return await requestCameraAccess({ video: {
-			deviceId: { exact: mainCamera.deviceId },
-			width: { ideal: idealWidth },
-			height: { ideal: idealHeight }
-		} });
-	} catch (error) {
-		const errorName = error instanceof Error ? error.name : "UnknownError";
-		const nextLevel = Math.min(fallbackLevel + 1, 4);
-		if (errorName === "NotReadableError") {
-			await sleep(300);
-			return getAndroidBackCameraStream(nextLevel);
-		}
-		if (errorName === "AbortError") {
-			await sleep(300);
-			return getAndroidBackCameraStream(fallbackLevel);
-		}
-		return getAndroidBackCameraStream(nextLevel);
-	}
-}
-async function applyIOSFocusHack(stream) {
-	const videoTrack = stream.getVideoTracks()[0];
-	try {
-		await applyTrackConstraints(videoTrack, { advanced: [{ focusDistance: 1 }] });
-	} catch {}
-}
-function getIOSConstraints() {
-	return {
-		audio: false,
-		video: {
-			resizeMode: "none",
-			facingMode: "environment",
-			height: { ideal: isIPhone14OrHigher() ? 1080 : 720 },
-			aspectRatio: { ideal: 19.5 / 9 }
-		}
-	};
-}
-async function getIOSCameraStream() {
-	const stream = await requestCameraAccess(getIOSConstraints());
-	await applyIOSFocusHack(stream);
-	return stream;
-}
-function getDesktopConstraints(options) {
-	const { deviceId } = options;
-	return {
-		audio: isSafari(),
-		video: {
-			facingMode: "user",
-			deviceId: deviceId ? { exact: deviceId } : void 0,
-			height: { ideal: 1080 },
-			width: { ideal: 1920 }
-		}
-	};
-}
-async function getDesktopCameraStream(options) {
-	return requestCameraAccess(getDesktopConstraints(options));
-}
-async function getIdCameraStream(deviceId) {
-	if (isIOS()) return getIOSCameraStream();
-	if (isAndroid()) return getAndroidBackCameraStream(0);
-	if (isDesktop()) return getDesktopCameraStream({ deviceId });
-	return getDesktopCameraStream({ deviceId });
-}
-
-//#endregion
-//#region src/modules/id/types.ts
-const ID_ERROR_CODES = {
-	UPLOAD_ERROR: "UPLOAD_ERROR",
-	CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED",
-	LOW_SHARPNESS: "LOW_SHARPNESS",
-	GLARE_DETECTED: "GLARE_DETECTED",
-	WRONG_DOCUMENT_SIDE: "WRONG_DOCUMENT_SIDE",
-	ID_TYPE_UNACCEPTABLE: "ID_TYPE_UNACCEPTABLE",
-	READABILITY_ISSUE: "READABILITY_ISSUE",
-	RETRY_EXHAUSTED_CONTINUE_TO_BACK: "RETRY_EXHAUSTED_CONTINUE_TO_BACK",
-	RETRY_EXHAUSTED_SKIP_BACK: "RETRY_EXHAUSTED_SKIP_BACK",
-	NO_MORE_TRIES: "NO_MORE_TRIES",
-	UNEXPECTED_ERROR: "UNEXPECTED_ERROR",
-	NO_TOKEN: "NO_TOKEN",
-	PERMISSION_DENIED: "PERMISSION_DENIED",
-	USER_CANCELLED: "USER_CANCELLED",
-	SERVER: "SERVER_ERROR"
-};
-
-//#endregion
-//#region src/modules/id/idCaptureServices.ts
-const SHARPNESS_THRESHOLD = 10;
-const GLARE_THRESHOLD = 10;
-const DEFAULT_ID_CAPTURE_THRESHOLDS$1 = {
-	blurThreshold: .2,
-	blurChangeThreshold: .2,
-	glareThreshold: .3,
-	clsThreshold: .98,
-	sideThreshold: .8,
-	iouThreshold: .8,
-	framesAggregationInterval: 3e3,
-	minFaceIdQualityScore: .62
-};
-const DEFAULT_ID_CAPTURE_SETTINGS = {
-	isFixedMask: false,
-	isIPhone14OrHigher: false,
-	idType: "",
-	blurCheckEnabled: false,
-	glareCheckEnabled: false,
-	faceQualityCheckEnabled: true,
-	iouCheckEnabled: true
-};
-async function initializeIdCapture(provider, config) {
-	await provider.initialize({});
-	provider.setThresholds({
-		...DEFAULT_ID_CAPTURE_THRESHOLDS$1,
-		...config.thresholds,
-		idDetectedTimeout: config.thresholds?.idDetectedTimeout ?? config.deviceIdleTimeout * 1e3,
-		autocaptureTimeout: config.thresholds?.autocaptureTimeout ?? config.autoCaptureTimeout * 1e3
-	});
-	if (config.settings) provider.setSettings({
-		...DEFAULT_ID_CAPTURE_SETTINGS,
-		...config.settings
-	});
-	return {
-		stream: await getIdCameraStream(),
-		provider
-	};
-}
-function stopStream(stream) {
-	for (const track of stream.getTracks()) track.stop();
-}
-function validateUploadResponse(response, sessionState) {
-	if (response.failReason === "ID_TYPE_UNACCEPTABLE") return {
-		error: true,
-		message: "ID type is not acceptable",
-		messageDescription: "Please use a valid ID type",
-		errorKey: ID_ERROR_CODES.ID_TYPE_UNACCEPTABLE
-	};
-	if (response.failReason === "WRONG_DOCUMENT_SIDE") return {
-		error: true,
-		message: "Wrong side of document",
-		messageDescription: response.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
-		errorKey: ID_ERROR_CODES.WRONG_DOCUMENT_SIDE
-	};
-	if (!response.classification) return {
-		error: true,
-		message: "ID classification failed",
-		errorKey: ID_ERROR_CODES.CLASSIFICATION_FAILED
-	};
-	const sharpnessThreshold = getDeviceClass() === "desktop" ? -1 : SHARPNESS_THRESHOLD;
-	if (response.sharpness !== void 0 && sharpnessThreshold >= 0 && response.sharpness < sharpnessThreshold) return {
-		error: true,
-		message: "Image is not sharp enough",
-		messageDescription: "Please ensure the image is clear and well-focused",
-		errorKey: ID_ERROR_CODES.LOW_SHARPNESS
-	};
-	if (response.glare !== void 0 && response.glare < GLARE_THRESHOLD && !sessionState?.skipGlareFront && !sessionState?.skipGlareBack) return {
-		error: true,
-		message: "Glare detected on ID",
-		messageDescription: "Please avoid bright reflections on your ID",
-		errorKey: ID_ERROR_CODES.GLARE_DETECTED
-	};
-}
-async function getExtraImages(params) {
-	const extraImages = params.ageAssurance ? [params.type === "back" ? "croppedBackID" : "croppedFrontID"] : [];
-	try {
-		const res = await api.post(endpoints.getImages, { images: ["croppedIDFace", ...extraImages] }, { signal: params.signal });
-		if (!res.ok) throw new Error(`Failed to get extra images: ${res.status}`);
-		return res.data ?? {
-			croppedIDFace: "",
-			croppedFrontID: "",
-			croppedBackID: ""
-		};
-	} catch {
-		return {
-			croppedIDFace: "",
-			croppedFrontID: "",
-			croppedBackID: ""
-		};
-	}
-}
-const getRealQualityValue = (value) => (1 - value) * 100;
-async function uploadIdImage(params) {
-	const { type, image, onProgress, signal, metadata, ageAssurance, glare, sharpness, shouldSkipGlareBack } = params;
-	addEvent({
-		code: "captureAttemptFinished",
-		module: eventModuleNames.id,
-		payload: { logs: [] }
-	});
-	const endpoint = type === "front" ? endpoints.frontId : endpoints.backId;
-	const body = {
-		base64Image: image,
-		metadata,
-		clientInfo: { deviceClass: getDeviceClass() }
-	};
-	const queryParams = { imageType: "id" };
-	if (shouldSkipGlareBack && type === "back") queryParams.glare = 0;
-	else if (glare !== void 0) queryParams.glare = getRealQualityValue(glare);
-	if (sharpness !== void 0) queryParams.sharpness = getRealQualityValue(sharpness);
-	try {
-		const res = await api.post(endpoint, body, {
-			signal,
-			query: queryParams,
-			onUploadProgress: onProgress
-		});
-		if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
-		const response = res.data;
-		const extraImages = await getExtraImages({
-			type,
-			ageAssurance,
-			signal
-		});
-		const fullResponse = {
-			...response,
-			originalImage: image,
-			frontIdImage: type === "front" ? image : void 0,
-			backIdImage: extraImages.croppedBackID,
-			...extraImages
-		};
-		onProgress?.(100);
-		return fullResponse;
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : "Unknown error";
-		throw new Error(`${ID_ERROR_CODES.UPLOAD_ERROR}: ${errorMessage}`);
-	}
-}
-function buildStandardResolution(width, height) {
-	return height > width ? {
-		width: 1080,
-		height: 1920
-	} : {
-		width: 1920,
-		height: 1080
-	};
-}
-function buildResolutionFromStream(stream) {
-	const track = stream.getVideoTracks()[0];
-	if (!track) return "1080x1920";
-	const settings = track.getSettings();
-	const width = settings.width;
-	const height = settings.height;
-	if (typeof width === "number" && typeof height === "number") {
-		const standard = buildStandardResolution(width, height);
-		return `${standard.width}x${standard.height}`;
-	}
-	return "1080x1920";
-}
-async function startRecordingSession(params) {
-	if (params.config.enableIdRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? new OpenViduRecordingProvider();
-	const clonedStream = params.stream.clone();
-	const hasAudio = clonedStream.getAudioTracks().length > 0;
-	const resolution = buildResolutionFromStream(clonedStream);
-	const session = await createRecordingSession(params.type);
-	const connection = await provider.connect({
-		sessionToken: session.token,
-		stream: clonedStream,
-		events: {
-			onSessionConnected: (sessionId) => {
-				addEvent({
-					code: streamingEvents.strSessionDidConnect,
-					module: eventModuleNames.id,
-					payload: {
-						message: "Recording session connected",
-						sessionId
-					}
-				});
-			},
-			onSessionDisconnected: (sessionId) => {
-				addEvent({
-					code: streamingEvents.strSessionDidDisconnect,
-					module: eventModuleNames.id,
-					payload: {
-						message: "Recording session disconnected",
-						sessionId
-					}
-				});
-			},
-			onSessionException: (event) => {
-				addEvent({
-					code: streamingEvents.strSessionDidFailWithError,
-					module: eventModuleNames.id,
-					payload: {
-						message: "Recording session failed due to an error",
-						eventName: event.name,
-						type: "OpenViduException",
-						errorMessage: event.message,
-						sessionId: event.sessionId
-					}
-				});
-			},
-			onPublisherCreated: (p) => {
-				addEvent({
-					code: streamingEvents.strStreamPublisherCreated,
-					module: eventModuleNames.id,
-					payload: {
-						message: "Recording publisher created",
-						sessionId: p.sessionId,
-						streamId: p.streamId
-					}
-				});
-			},
-			onPublisherError: (p) => {
-				addEvent({
-					code: streamingEvents.strStreamPublisherDidFailWithError,
-					module: eventModuleNames.id,
-					payload: {
-						message: "Recording publisher failed due to an error",
-						sessionId: p.sessionId,
-						streamId: p.streamId,
-						error: { message: p.message ?? "Unknown error" }
-					}
-				});
-			}
-		}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: params.type,
-		resolution,
-		hasAudio
-	});
-	addEvent({
-		code: streamingEvents.strStreamVideoCaptureStart,
-		module: eventModuleNames.id,
-		payload: {
-			message: "Recording capture started",
-			resolution,
-			videoRecordingId: session.videoRecordingId,
-			sessionId: session.sessionId,
-			streamId: connection.publisher.getStreamId()
-		}
-	});
-	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
-	};
-}
-function stopRecording(session) {
-	(async () => {
-		try {
-			addEvent({
-				code: streamingEvents.strStreamVideoCaptureStop,
-				module: eventModuleNames.id,
-				payload: {
-					message: "Recording capture stopped",
-					videoRecordingId: session.videoRecordingId,
-					sessionId: session.sessionId,
-					streamId: session.connection.publisher.getStreamId()
-				}
-			});
-			await stopRecording$1(session.videoRecordingId);
-			addEvent({
-				code: streamingEvents.strStreamPublisherDestroyed,
-				module: eventModuleNames.id,
-				payload: {
-					message: "Recording publisher destroyed",
-					sessionId: session.sessionId,
-					streamId: session.connection.publisher.getStreamId()
-				}
-			});
-		} finally {
-			await session.connection.disconnect();
-			addEvent({
-				code: streamingEvents.strSessionDidDisconnect,
-				module: eventModuleNames.id,
-				payload: {
-					message: "Recording session disconnected",
-					sessionId: session.sessionId
-				}
-			});
-		}
-	})();
-}
-async function processId(isSecondId = false, queueName = "", signal) {
-	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
-	const url = queueName ? `${endpoint}?queueName=${queueName}` : endpoint;
-	return { isDocumentExpired: (await api.post(url, {}, { signal })).data?.isDocumentExpired ?? false };
-}
-
-//#endregion
-//#region src/modules/id/idCaptureStateMachine.ts
-function getIdErrorCodeFromUnknown(error) {
-	if (error instanceof Error) {
-		const message = error.message;
-		return Object.values(ID_ERROR_CODES).find((value) => message.includes(value));
-	}
-}
-const _idCaptureMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		checkPermission: fromPromise(async () => {
-			return checkPermission();
-		}),
-		requestPermission: fromPromise(async () => {
-			return requestPermission();
-		}),
-		initializeCamera: fromPromise(async ({ input }) => {
-			return initializeIdCapture(input.provider, input.config);
-		}),
-		runDetection: fromCallback(({ input, sendBack }) => {
-			if (!input.frameCapturer || !input.provider) {
-				sendBack({
-					type: "DETECTION_UPDATE",
-					status: "error"
-				});
-				return () => {};
-			}
-			const provider = input.provider;
-			let session;
-			let currentCanvas = null;
-			let bestCanvas = null;
-			let storedQualityElements = {};
-			let isCapturing = false;
-			const timer = BrowserTimerProvider.getInstance();
-			let notificationTimeout = null;
-			let currentNotificationStatus = null;
-			const NOTIFICATION_DURATION_MS = 500;
-			const clearNotificationTimeout = () => {
-				if (notificationTimeout) {
-					timer.clearTimeout(notificationTimeout);
-					notificationTimeout = null;
-					currentNotificationStatus = null;
-				}
-			};
-			const sendNotification = (status) => {
-				if (notificationTimeout && currentNotificationStatus !== status) return;
-				if (notificationTimeout && currentNotificationStatus === status) timer.clearTimeout(notificationTimeout);
-				currentNotificationStatus = status;
-				sendBack({
-					type: "DETECTION_UPDATE",
-					status
-				});
-				notificationTimeout = timer.setTimeout(() => {
-					notificationTimeout = null;
-					currentNotificationStatus = null;
-					sendBack({
-						type: "DETECTION_UPDATE",
-						status: "detecting"
-					});
-				}, NOTIFICATION_DURATION_MS);
-			};
-			const canvas = input.frameCapturer.getLatestCanvas();
-			const windowDimensions = getWindowDimensions(canvas?.width() ?? 1280, canvas?.height() ?? 720);
-			const DEFAULT_GEOMETRY = {
-				areaDown: 25e3,
-				areaUp: 55e3,
-				areaIOSPassportUp: 3e4,
-				areaIOSPassportDown: 2e4,
-				widthIOSUp: 160,
-				widthIOSDown: 85,
-				widthDown: 110,
-				widthUp: 205
-			};
-			if (input.config.geometry) provider.setGeometry({
-				...input.config.geometry,
-				windowOuterWidth: windowDimensions.outerWidth,
-				windowOuterHeight: windowDimensions.outerHeight,
-				windowInnerWidth: windowDimensions.innerWidth,
-				windowInnerHeight: windowDimensions.innerHeight
-			});
-			else provider.setGeometry({
-				...DEFAULT_GEOMETRY,
-				windowOuterWidth: windowDimensions.outerWidth,
-				windowOuterHeight: windowDimensions.outerHeight,
-				windowInnerWidth: windowDimensions.innerWidth,
-				windowInnerHeight: windowDimensions.innerHeight
-			});
-			const idType = input.currentMode === "back" ? "BackId" : input.currentMode === "passport" || input.currentMode === "front" && input.config.onlyFront ? "Passport" : "FrontId";
-			provider.setSettings({
-				isFixedMask: input.config.settings?.isFixedMask ?? false,
-				isIPhone14OrHigher: input.config.settings?.isIPhone14OrHigher ?? false,
-				idType,
-				blurCheckEnabled: input.config.settings?.blurCheckEnabled ?? false,
-				glareCheckEnabled: input.config.settings?.glareCheckEnabled ?? false,
-				faceQualityCheckEnabled: input.config.settings?.faceQualityCheckEnabled ?? true,
-				iouCheckEnabled: input.config.settings?.iouCheckEnabled ?? true
-			});
-			const thresholds = {
-				...DEFAULT_ID_CAPTURE_THRESHOLDS,
-				...input.config.thresholds,
-				idDetectedTimeout: (input.config.deviceIdleTimeout ?? 10) * 1e3,
-				autocaptureTimeout: (input.config.autoCaptureTimeout ?? 5) * 1e3
-			};
-			provider.setThresholds(thresholds);
-			const modelType = input.config.modelVersion ?? DEFAULT_ID_CAPTURE_MODEL_VERSION;
-			provider.setModelType(modelType);
-			provider.setCallbacks({
-				onFarAway: () => {
-					if (!isCapturing) sendNotification("farAway");
-				},
-				onDetectionStarted: () => {},
-				onMaskChange: (_show, _mask, _top, orientation) => {
-					sendBack({
-						type: "ORIENTATION_CHANGE",
-						orientation
-					});
-				},
-				onBlur: () => {
-					if (!isCapturing) sendNotification("blur");
-				},
-				onGlare: () => {
-					if (!isCapturing) sendNotification("glare");
-				},
-				onIdNotDetected: () => {
-					if (!isCapturing) sendBack({
-						type: "DETECTION_UPDATE",
-						status: "idNotDetected"
-					});
-				},
-				onSwitchToManualCapture: () => {
-					isCapturing = false;
-					sendBack({
-						type: "DETECTION_UPDATE",
-						status: "manualCapture"
-					});
-				},
-				onCapturing: () => {
-					clearNotificationTimeout();
-					isCapturing = true;
-					sendBack({
-						type: "DETECTION_UPDATE",
-						status: "capturing"
-					});
-				},
-				onBestFrame: (blur, glare, orientation) => {
-					if (currentCanvas) {
-						bestCanvas = currentCanvas.clone();
-						storedQualityElements = {
-							glare,
-							sharpness: blur
-						};
-					}
-					if (orientation === "horizontal" || orientation === "vertical") sendBack({
-						type: "ORIENTATION_CHANGE",
-						orientation
-					});
-				},
-				onCapture: () => {
-					isCapturing = false;
-					if (bestCanvas) sendBack({
-						type: "DETECTION_SUCCESS",
-						canvas: bestCanvas,
-						qualityElements: storedQualityElements
-					});
-					else if (currentCanvas) sendBack({
-						type: "DETECTION_SUCCESS",
-						canvas: currentCanvas.clone(),
-						qualityElements: {}
-					});
-				},
-				onIdTypeChange: (idType$1) => {
-					sendBack({
-						type: "ID_TYPE_CHANGE",
-						idType: idType$1
-					});
-				},
-				onIdSideChange: (side) => {
-					if (isCapturing) return;
-					sendBack({
-						type: "ID_SIDE_CHANGE",
-						side
-					});
-				},
-				onCapturingCounterValueChange: (value) => {
-					sendBack({
-						type: "COUNTER_VALUE_CHANGE",
-						value
-					});
-				}
-			});
-			sendBack({
-				type: "DETECTION_UPDATE",
-				status: "detecting"
-			});
-			session = new StreamCanvasProcessingSession({
-				capturer: input.frameCapturer,
-				provider: {
-					processFrame: async (frame) => {
-						currentCanvas = IncodeCanvas.fromImageData(frame);
-						sendBack({
-							type: "DETECTION_FRAME",
-							frame
-						});
-						await provider.processFrame(frame);
-					},
-					reset: () => {
-						if (notificationTimeout) {
-							timer.clearTimeout(notificationTimeout);
-							notificationTimeout = null;
-							currentNotificationStatus = null;
-						}
-						currentCanvas = null;
-						bestCanvas = null;
-						storedQualityElements = {};
-						isCapturing = false;
-						provider.reset();
-					}
-				},
-				onFrame: (frame) => sendBack({
-					type: "DETECTION_FRAME",
-					frame
-				})
-			});
-			sendBack({
-				type: "DETECTION_RESET_READY",
-				reset: () => {
-					provider.reset();
-				}
-			});
-			return () => {
-				clearNotificationTimeout();
-				session?.dispose();
-			};
-		}),
-		uploadIdImage: fromPromise(async ({ input, signal }) => {
-			const image = input.canvas.getBase64Image();
-			if (!image) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
-			return uploadIdImage({
-				image,
-				type: input.type,
-				sendBase64: true,
-				glare: input.qualityElements?.glare,
-				sharpness: input.qualityElements?.sharpness,
-				ageAssurance: false,
-				signal,
-				onProgress: input.onProgress
-			});
-		}),
-		processId: fromPromise(async ({ input, signal }) => {
-			return processId(input.isSecondId, "", signal);
-		}),
-		startRecording: fromPromise(async ({ input }) => {
-			if (!input.stream) return;
-			const type = input.currentMode === "back" ? "backId" : "frontId";
-			return startRecordingSession({
-				config: input.config,
-				stream: input.stream,
-				existing: input.existing,
-				type
-			});
-		}),
-		checkMotionSensor: fromCallback(({ input, sendBack }) => {
-			if (!input.motionProvider) {
-				sendBack({
-					type: "MOTION_STATUS",
-					status: "UNCLEAR"
-				});
-				return () => {};
-			}
-			const timer = BrowserTimerProvider.getInstance();
-			const interval = timer.setInterval(() => {
-				sendBack({
-					type: "MOTION_STATUS",
-					status: input.motionProvider.check()
-				});
-			}, 500);
-			return () => timer.clearInterval(interval);
-		})
-	},
-	actions: {
-		stopMediaStream: assign(({ context }) => {
-			context.frameCapturer?.dispose();
-			if (context.stream) stopStream(context.stream);
-			return {
-				stream: void 0,
-				frameCapturer: void 0
-			};
-		}),
-		disposeProvider: ({ context }) => {
-			context.provider?.dispose?.();
-		},
-		resetForBackCapture: assign(({ context }) => {
-			context.frameCapturer?.dispose();
-			if (context.stream) stopStream(context.stream);
-			context.provider?.reset();
-			return {
-				stream: void 0,
-				frameCapturer: void 0,
-				detectionStatus: "idle",
-				counterValue: 0,
-				orientation: void 0,
-				resetDetection: void 0,
-				idType: void 0,
-				qualityElements: void 0,
-				debugFrame: void 0,
-				frameRect: void 0,
-				previewImageUrl: void 0,
-				uploadProgress: void 0,
-				manualCaptureTriggered: false
-			};
-		}),
-		prepareForBackCapture: assign(({ context }) => {
-			context.provider?.reset();
-			return {
-				detectionStatus: "idle",
-				counterValue: 0,
-				orientation: void 0,
-				resetDetection: void 0,
-				idType: void 0,
-				qualityElements: void 0,
-				debugFrame: void 0,
-				frameRect: void 0,
-				previewImageUrl: void 0,
-				uploadProgress: void 0,
-				manualCaptureTriggered: false
-			};
-		}),
-		setStreamAndCapturer: assign({
-			stream: ({ event }) => {
-				if ("output" in event) return event.output.stream;
-			},
-			provider: ({ event }) => {
-				if ("output" in event) return event.output.provider;
-			},
-			frameCapturer: ({ event }) => {
-				if ("output" in event) {
-					const output = event.output;
-					if (output.stream) return new StreamCanvasCapture(output.stream);
-				}
-			}
-		}),
-		trackTutorialId: () => {
-			addEvent({
-				code: "tutorialVideoStarted",
-				module: eventModuleNames.id,
-				payload: { tutorialFrontID: true }
-			});
-		},
-		trackContinue: () => {},
-		resetContext: assign(({ context }) => {
-			context.provider?.reset();
-			return {
-				stream: void 0,
-				provider: context.provider,
-				frameCapturer: void 0,
-				error: void 0,
-				detectionStatus: "idle",
-				counterValue: 0,
-				orientation: void 0,
-				capturedImages: {},
-				uploadResponse: void 0,
-				recordingSession: void 0,
-				attemptsRemaining: context.config.captureAttempts,
-				uploadError: void 0,
-				permissionResult: void 0,
-				resetDetection: void 0,
-				idType: void 0,
-				qualityElements: void 0,
-				previewImageUrl: void 0,
-				uploadProgress: void 0,
-				currentMode: context.config.onlyBack ? "back" : !context.config.enableId && context.config.enablePassport ? "passport" : "front",
-				selectedDocumentType: void 0,
-				manualCaptureTriggered: false
-			};
-		}),
-		resetDetection: ({ context }) => {
-			context.resetDetection?.();
-		},
-		captureImage: assign({ qualityElements: ({ event }) => {
-			if ("qualityElements" in event) return event.qualityElements;
-		} }),
-		storeCapturedCanvasInProvider: ({ context, event }) => {
-			let canvas = null;
-			if ("canvas" in event && event.canvas) canvas = event.canvas;
-			else canvas = context.frameCapturer?.getLatestCanvas() ?? null;
-			if (!canvas || !context.provider) return;
-			const canvasWidth = canvas.width();
-			const canvasHeight = canvas.height();
-			if (!canvasWidth || !canvasHeight) return;
-			const originalCanvas = canvas;
-			let frameRect;
-			const { innerWidth: viewportWidth, innerHeight: viewportHeight } = getWindowDimensions();
-			if (context.detectionArea) {
-				const scaleX = viewportWidth / canvasWidth;
-				const scaleY = viewportHeight / canvasHeight;
-				const scale = Math.max(scaleX, scaleY);
-				const displayedWidth = canvasWidth * scale;
-				const displayedHeight = canvasHeight * scale;
-				const offsetX = (viewportWidth - displayedWidth) / 2;
-				const offsetY = (viewportHeight - displayedHeight) / 2;
-				frameRect = {
-					x: (context.detectionArea.x - offsetX) / scale,
-					y: (context.detectionArea.y - offsetY) / scale,
-					w: context.detectionArea.width / scale,
-					h: context.detectionArea.height / scale
-				};
-			} else if (context.frameRect) {
-				const scaleX = viewportWidth / canvasWidth;
-				const scaleY = viewportHeight / canvasHeight;
-				const scale = Math.max(scaleX, scaleY);
-				const displayedWidth = canvasWidth * scale;
-				const displayedHeight = canvasHeight * scale;
-				const offsetX = (viewportWidth - displayedWidth) / 2;
-				const offsetY = (viewportHeight - displayedHeight) / 2;
-				frameRect = {
-					x: (context.frameRect.x - offsetX) / scale,
-					y: (context.frameRect.y - offsetY) / scale,
-					w: context.frameRect.w / scale,
-					h: context.frameRect.h / scale
-				};
-			} else {
-				const quadValue = (context.provider.getLastProcessResult?.())?.quad;
-				const hasQuad = !!quadValue;
-				const quadSize = quadValue?.size ? quadValue.size() : quadValue?.length ?? 0;
-				if (hasQuad && quadSize >= 4 && quadValue.get) {
-					const p0 = quadValue.get(0);
-					const p1 = quadValue.get(1);
-					const p2 = quadValue.get(2);
-					const p3 = quadValue.get(3);
-					const minX = Math.min(p0.x, p1.x, p2.x, p3.x);
-					const maxX = Math.max(p0.x, p1.x, p2.x, p3.x);
-					const minY = Math.min(p0.y, p1.y, p2.y, p3.y);
-					const maxY = Math.max(p0.y, p1.y, p2.y, p3.y);
-					frameRect = {
-						x: minX,
-						y: minY,
-						w: maxX - minX,
-						h: maxY - minY
-					};
-				} else {
-					const frameViewportWidth = Math.min(387, viewportWidth * .9);
-					const frameViewportHeight = frameViewportWidth / (35 / 22);
-					const frameViewportX = (viewportWidth - frameViewportWidth) / 2;
-					const frameViewportY = (viewportHeight - frameViewportHeight) / 2;
-					frameRect = {
-						x: canvasWidth * frameViewportX / viewportWidth,
-						y: canvasHeight * frameViewportY / viewportHeight,
-						w: canvasWidth * frameViewportWidth / viewportWidth,
-						h: canvasHeight * frameViewportHeight / viewportHeight
-					};
-				}
-			}
-			const transformedCanvas = context.provider.transformPerspective(originalCanvas, frameRect);
-			context.provider.setCapturedCanvases(originalCanvas, transformedCanvas);
-		},
-		captureLatestFrame: ({ context }) => {
-			context.frameCapturer?.getLatestCanvas();
-		},
-		clearUploadFailure: assign({
-			uploadError: () => void 0,
-			detectionStatus: () => "idle",
-			previewImageUrl: ({ context }) => {
-				if (context.previewImageUrl) revokeObjectURL(context.previewImageUrl);
-			},
-			uploadProgress: () => void 0
-		}),
-		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
-		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => {
-			if (!context.uploadResponse) return ID_ERROR_CODES.SERVER;
-			return validateUploadResponse(context.uploadResponse, {
-				skipGlareFront: context.uploadResponse.skipGlareFront,
-				skipGlareBack: context.uploadResponse.skipGlareBack
-			})?.errorKey ?? ID_ERROR_CODES.SERVER;
-		} }),
-		stopMediaRecording: ({ context }) => {
-			if (context.recordingSession) stopRecording(context.recordingSession);
-		},
-		clearRecordingSession: assign({ recordingSession: () => void 0 }),
-		setSelectedDocument: assign({ selectedDocumentType: ({ event }) => {
-			if ("documentType" in event) return event.documentType;
-		} }),
-		setCurrentMode: assign({ currentMode: ({ event, context }) => {
-			if ("documentType" in event) {
-				if (event.documentType === "passport") return "passport";
-				return "front";
-			}
-			if (event.type === "FRONT_COMPLETE") return "back";
-			return context.currentMode;
-		} }),
-		storeCapturedImage: assign({
-			capturedImages: ({ context, event }) => {
-				if (!context.currentMode) return context.capturedImages;
-				const transformedImage = (context.provider?.getCapturedCanvas())?.getBase64Image(1, true);
-				let fallbackImage = "";
-				if ("output" in event) fallbackImage = event.output.originalImage ?? "";
-				const imageData = { imageBase64: transformedImage ?? fallbackImage };
-				if (context.currentMode === "front" || context.currentMode === "passport") return {
-					...context.capturedImages,
-					front: imageData
-				};
-				return {
-					...context.capturedImages,
-					back: imageData
-				};
-			},
-			previewImageUrl: ({ context, event }) => {
-				const transformedCanvas = context.provider?.getCapturedCanvas();
-				if (transformedCanvas) {
-					transformedCanvas.updateBlob();
-					const blobData = transformedCanvas.getBlobData();
-					if (blobData?.url) return blobData.url;
-				}
-				if ("canvas" in event && event.canvas) {
-					const canvas = event.canvas;
-					canvas.updateBlob();
-					const blobData = canvas.getBlobData();
-					if (blobData?.url) return blobData.url;
-				}
-				return context.previewImageUrl;
-			}
-		}),
-		setDetectionStatus: assign({ detectionStatus: ({ event, context }) => {
-			if (event.type === "DETECTION_UPDATE") {
-				const newStatus = event.status;
-				const currentStatus = context.detectionStatus;
-				if ((newStatus === "blur" || newStatus === "glare") && (currentStatus === "wrongSide" || currentStatus === "farAway")) return currentStatus;
-				if ((newStatus === "wrongSide" || newStatus === "farAway") && (currentStatus === "blur" || currentStatus === "glare")) return newStatus;
-				return newStatus;
-			}
-			return "idle";
-		} }),
-		setCounterValue: assign({ counterValue: ({ event }) => {
-			if ("value" in event) return event.value;
-			return 0;
-		} }),
-		setIdType: assign({ idType: ({ event }) => {
-			if ("idType" in event) return event.idType;
-		} }),
-		setOrientation: assign({ orientation: ({ event }) => {
-			if ("orientation" in event) return event.orientation;
-		} }),
-		setFrameRect: assign({ frameRect: ({ event }) => {
-			if ("frameRect" in event) return event.frameRect;
-		} }),
-		setDetectionArea: assign({ detectionArea: ({ event }) => {
-			if ("detectionArea" in event) return event.detectionArea;
-		} }),
-		setMotionStatus: assign({ motionStatus: ({ event }) => {
-			if ("status" in event && event.type === "MOTION_STATUS") return event.status;
-		} })
-	},
-	guards: {
-		hasShowTutorial: ({ context }) => context.config.showTutorial,
-		hasShowDocumentChooser: ({ context }) => context.config.showDocumentChooserScreen ?? false,
-		isPermissionGranted: ({ event }) => {
-			if ("output" in event) return event.output === "granted";
-			return false;
-		},
-		isPermissionDeniedError: ({ event }) => {
-			if ("error" in event) {
-				const error = event.error;
-				return error?.name === "NotAllowedError" || error?.name === "PermissionDeniedError";
-			}
-			return false;
-		},
-		hasStream: ({ context }) => context.stream !== void 0,
-		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
-		hasCapturedImage: ({ context }) => {
-			return context.provider?.getCapturedCanvas() !== null;
-		},
-		hasUploadValidationError: ({ context }) => {
-			if (!context.uploadResponse) return false;
-			return validateUploadResponse(context.uploadResponse, {
-				skipGlareFront: context.uploadResponse.skipGlareFront,
-				skipGlareBack: context.uploadResponse.skipGlareBack
-			}) !== void 0;
-		},
-		isFrontMode: ({ context }) => context.currentMode === "front" || context.currentMode === "passport",
-		isOnlyFront: ({ context }) => context.config.onlyFront,
-		shouldContinueToBack: ({ context }) => {
-			if (context.currentMode === "passport") return false;
-			if (context.currentMode !== "front") return false;
-			if (context.config.onlyFront) return false;
-			if (context.config.onlyBack) return false;
-			if (!context.config.enableId && context.config.enablePassport) return false;
-			if (context.uploadResponse?.skipBackIdCapture) return false;
-			return true;
-		}
-	}
-}).createMachine({
-	id: "idCapture",
-	initial: "idle",
-	context: ({ input }) => {
-		const currentMode = input.config.onlyBack ? "back" : !input.config.enableId && input.config.enablePassport ? "passport" : "front";
-		return {
-			config: input.config,
-			currentMode,
-			selectedDocumentType: void 0,
-			stream: void 0,
-			provider: input.provider,
-			frameCapturer: void 0,
-			error: void 0,
-			detectionStatus: "idle",
-			counterValue: 0,
-			orientation: void 0,
-			capturedImages: {},
-			uploadResponse: void 0,
-			recordingSession: void 0,
-			attemptsRemaining: input.config.captureAttempts,
-			uploadError: void 0,
-			permissionResult: void 0,
-			resetDetection: void 0,
-			idType: void 0,
-			qualityElements: void 0,
-			debugFrame: void 0,
-			frameRect: void 0,
-			detectionArea: void 0,
-			previewImageUrl: void 0,
-			uploadProgress: void 0,
-			motionStatus: void 0,
-			manualCaptureTriggered: false
-		};
-	},
-	on: {
-		QUIT: { target: "#idCapture.closed" },
-		UPDATE_DETECTION_AREA: { actions: "setDetectionArea" }
-	},
-	states: {
-		idle: { on: { LOAD: [
-			{
-				target: "chooser",
-				guard: "hasShowDocumentChooser"
-			},
-			{
-				target: "tutorial",
-				guard: "hasShowTutorial"
-			},
-			{ target: "loading" }
-		] } },
-		chooser: { on: { SELECT_DOCUMENT: [{
-			target: "tutorial",
-			guard: "hasShowTutorial",
-			actions: ["setSelectedDocument", "setCurrentMode"]
-		}, {
-			target: "loading",
-			actions: ["setSelectedDocument", "setCurrentMode"]
-		}] } },
-		loading: { invoke: {
-			id: "checkPermissionLoading",
-			src: "checkPermission",
-			onDone: [{
-				target: "capture",
-				guard: "isPermissionGranted",
-				actions: assign({ permissionResult: ({ event }) => event.output })
-			}, {
-				target: "permissions",
-				actions: assign({ permissionResult: ({ event }) => event.output })
-			}],
-			onError: {
-				target: "permissions",
-				actions: assign({ permissionResult: () => "prompt" })
-			}
-		} },
-		tutorial: {
-			initial: "checkingPermission",
-			entry: "trackTutorialId",
-			states: {
-				checkingPermission: {
-					invoke: {
-						id: "checkPermissionTutorial",
-						src: "checkPermission",
-						onDone: [{
-							target: "initializingCamera",
-							guard: "isPermissionGranted",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						}, {
-							target: "ready",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						}]
-					},
-					on: { NEXT_STEP: {
-						target: "initializingCamera",
-						actions: "trackContinue"
-					} }
-				},
-				initializingCamera: {
-					initial: "booting",
-					invoke: {
-						id: "tutorialInitCamera",
-						src: "initializeCamera",
-						input: ({ context }) => {
-							if (!context.provider) throw new Error("Provider is required");
-							return {
-								provider: context.provider,
-								config: context.config
-							};
-						},
-						onDone: { actions: "setStreamAndCapturer" },
-						onError: [{
-							target: "ready",
-							guard: "isPermissionDeniedError",
-							actions: assign({ permissionResult: () => "denied" })
-						}, {
-							target: "ready",
-							actions: assign({ error: ({ event }) => String(event.error) })
-						}]
-					},
-					states: {
-						booting: {
-							always: [{
-								target: "#tutorialCameraReady",
-								guard: "hasStream"
-							}],
-							on: { NEXT_STEP: {
-								target: "waitingForStream",
-								actions: "trackContinue"
-							} }
-						},
-						waitingForStream: { always: [{
-							target: "#idCapture.capture",
-							guard: "hasStream"
-						}] }
-					}
-				},
-				cameraReady: {
-					id: "tutorialCameraReady",
-					on: { NEXT_STEP: {
-						target: "#idCapture.capture",
-						actions: "trackContinue"
-					} }
-				},
-				ready: { on: { NEXT_STEP: {
-					target: "waitingForPermission",
-					actions: "trackContinue"
-				} } },
-				waitingForPermission: { invoke: {
-					id: "checkPermissionWaiting",
-					src: "checkPermission",
-					onDone: [{
-						target: "#idCapture.capture",
-						guard: "isPermissionGranted",
-						actions: assign({ permissionResult: ({ event }) => event.output })
-					}, {
-						target: "#idCapture.permissions",
-						actions: assign({ permissionResult: ({ event }) => event.output })
-					}]
-				} }
-			}
-		},
-		permissions: {
-			initial: "idle",
-			states: {
-				idle: {
-					invoke: {
-						id: "checkPermissionIdle",
-						src: "checkPermission",
-						onDone: [
-							{
-								target: "#idCapture.capture",
-								guard: "isPermissionGranted",
-								actions: assign({ permissionResult: ({ event }) => event.output })
-							},
-							{
-								target: "denied",
-								guard: ({ event }) => event.output === "denied",
-								actions: assign({ permissionResult: ({ event }) => event.output })
-							},
-							{
-								target: "waitingForUser",
-								actions: assign({ permissionResult: ({ event }) => event.output })
-							}
-						],
-						onError: {
-							target: "waitingForUser",
-							actions: assign({ permissionResult: () => "prompt" })
-						}
-					},
-					on: {
-						REQUEST_PERMISSION: "requesting",
-						GO_TO_LEARN_MORE: "learnMore"
-					}
-				},
-				waitingForUser: { on: {
-					REQUEST_PERMISSION: "requesting",
-					GO_TO_LEARN_MORE: "learnMore"
-				} },
-				learnMore: { on: {
-					BACK: "idle",
-					REQUEST_PERMISSION: "requesting"
-				} },
-				requesting: { invoke: {
-					id: "requestPermission",
-					src: "requestPermission",
-					onDone: [
-						{
-							target: "#idCapture.capture",
-							guard: "isPermissionGranted",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						},
-						{
-							target: "denied",
-							guard: ({ event }) => event.output === "denied",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						},
-						{
-							target: "idle",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						}
-					],
-					onError: { target: "denied" }
-				} },
-				denied: { entry: assign({ permissionResult: () => "refresh" }) }
-			}
-		},
-		capture: {
-			initial: "checkingStream",
-			exit: ["stopMediaRecording", "clearRecordingSession"],
-			on: { SET_FRAME_RECT: { actions: "setFrameRect" } },
-			states: {
-				checkingStream: { always: [{
-					target: "detecting",
-					guard: "hasStream"
-				}, { target: "initializing" }] },
-				initializing: { invoke: {
-					id: "initializeCamera",
-					src: "initializeCamera",
-					input: ({ context }) => {
-						if (!context.provider) throw new Error("Provider is required");
-						return {
-							provider: context.provider,
-							config: context.config
-						};
-					},
-					onDone: {
-						target: "detecting",
-						actions: "setStreamAndCapturer"
-					},
-					onError: [{
-						target: "#idCapture.permissions",
-						guard: "isPermissionDeniedError",
-						actions: assign({ permissionResult: () => "denied" })
-					}, {
-						target: "#idCapture.error",
-						actions: assign({ error: ({ event }) => String(event.error) })
-					}]
-				} },
-				detecting: {
-					always: [{
-						target: "manualCaptureWaiting",
-						guard: ({ context }) => context.manualCaptureTriggered,
-						actions: assign({ detectionStatus: () => "manualCapture" })
-					}],
-					entry: [assign({ detectionStatus: () => "detecting" })],
-					invoke: [{
-						id: "startRecording",
-						src: "startRecording",
-						input: ({ context }) => ({
-							config: context.config,
-							stream: context.stream,
-							existing: context.recordingSession,
-							currentMode: context.currentMode
-						}),
-						onDone: { actions: assign({ recordingSession: ({ context, event }) => {
-							return event.output ?? context.recordingSession;
-						} }) },
-						onError: { actions: () => void 0 }
-					}, {
-						id: "runDetection",
-						src: "runDetection",
-						input: ({ context }) => ({
-							frameCapturer: context.frameCapturer,
-							provider: context.provider,
-							config: context.config,
-							currentMode: context.currentMode,
-							detectionArea: context.detectionArea ?? context.config.detectionArea
-						})
-					}],
-					on: {
-						DETECTION_UPDATE: { actions: "setDetectionStatus" },
-						DETECTION_FRAME: { actions: assign({ debugFrame: ({ event }) => event.frame }) },
-						DETECTION_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
-						DETECTION_SUCCESS: {
-							target: "capturing",
-							actions: assign({ qualityElements: ({ event }) => event.qualityElements })
-						},
-						MANUAL_CAPTURE: { target: "capturingManual" },
-						SWITCH_TO_MANUAL_CAPTURE: {
-							target: "manualCaptureWaiting",
-							actions: assign({
-								detectionStatus: () => "manualCapture",
-								manualCaptureTriggered: () => true
-							})
-						},
-						COUNTER_VALUE_CHANGE: { actions: "setCounterValue" },
-						ID_TYPE_CHANGE: { actions: "setIdType" },
-						ID_SIDE_CHANGE: { actions: assign({ detectionStatus: ({ event, context }) => {
-							const detectedSide = event.side?.toLowerCase() || "";
-							const currentMode = context.currentMode;
-							if (detectedSide === "wrong") return "wrongSide";
-							const isBackDetected = detectedSide.includes("back") && !detectedSide.includes("front");
-							const isFrontDetected = detectedSide.includes("front") && !detectedSide.includes("back");
-							if (currentMode === "front" && isBackDetected || currentMode === "back" && isFrontDetected) return "wrongSide";
-							if (currentMode === "front" && isFrontDetected || currentMode === "back" && isBackDetected || currentMode === "passport") return "detecting";
-							return "detecting";
-						} }) },
-						ORIENTATION_CHANGE: { actions: "setOrientation" }
-					}
-				},
-				manualCaptureWaiting: { on: { MANUAL_CAPTURE: { target: "capturingManual" } } },
-				capturing: {
-					entry: [
-						"captureImage",
-						"storeCapturedCanvasInProvider",
-						"storeCapturedImage"
-					],
-					always: [{
-						target: "uploading",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: assign(({ context }) => ({
-							uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}]
-				},
-				capturingManual: {
-					entry: [
-						"captureLatestFrame",
-						"storeCapturedCanvasInProvider",
-						"storeCapturedImage"
-					],
-					always: [{
-						target: "uploading",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: assign(({ context }) => ({
-							uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}]
-				},
-				uploading: {
-					entry: assign({ uploadProgress: () => 0 }),
-					invoke: {
-						id: "uploadIdImage",
-						src: "uploadIdImage",
-						input: ({ context, self }) => {
-							const canvas = context.provider?.getOriginalCapturedCanvas();
-							if (!canvas) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
-							return {
-								canvas,
-								type: context.currentMode === "back" ? "back" : "front",
-								qualityElements: context.qualityElements,
-								onProgress: (progress) => {
-									self.send({
-										type: "UPLOAD_PROGRESS",
-										progress
-									});
-								}
-							};
-						},
-						onDone: {
-							target: "validatingUpload",
-							actions: [assign({
-								uploadResponse: ({ event }) => event.output,
-								uploadProgress: () => 100
-							}), "storeCapturedImage"]
-						},
-						onError: {
-							target: "uploadError",
-							actions: assign(({ context, event }) => ({
-								uploadError: getIdErrorCodeFromUnknown(event.error) ?? ID_ERROR_CODES.UPLOAD_ERROR,
-								attemptsRemaining: context.attemptsRemaining - 1
-							}))
-						}
-					},
-					on: { UPLOAD_PROGRESS: { actions: assign({ uploadProgress: ({ event }) => event.progress }) } }
-				},
-				validatingUpload: { always: [{
-					target: "uploadError",
-					guard: "hasUploadValidationError",
-					actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
-				}, { target: "success" }] },
-				uploadError: { on: { CONTINUE_FROM_ERROR: [
-					{
-						target: "detecting",
-						guard: "hasAttemptsRemaining",
-						actions: [
-							"resetDetection",
-							"clearUploadFailure",
-							assign({ manualCaptureTriggered: () => false })
-						]
-					},
-					{
-						target: "#idCapture.frontFinished",
-						guard: "shouldContinueToBack"
-					},
-					{ target: "#idCapture.finished" }
-				] } },
-				success: { on: { NEXT_STEP: [{
-					target: "#idCapture.frontFinished",
-					guard: "shouldContinueToBack"
-				}, { target: "#idCapture.processing" }] } }
-			}
-		},
-		frontFinished: {
-			entry: ["stopMediaRecording", "prepareForBackCapture"],
-			on: { CONTINUE_TO_BACK: {
-				target: "capture",
-				actions: assign({ currentMode: () => "back" })
-			} }
-		},
-		processing: {
-			entry: "stopMediaStream",
-			invoke: {
-				id: "processId",
-				src: "processId",
-				input: ({ context }) => ({ isSecondId: context.config.isSecondId ?? false }),
-				onDone: [{
-					target: "expired",
-					guard: ({ event }) => event.output.isDocumentExpired
-				}, { target: "finished" }],
-				onError: { target: "finished" }
-			}
-		},
-		expired: { on: { RETRY_CAPTURE: [
-			{
-				target: "chooser",
-				guard: "hasShowDocumentChooser",
-				actions: ["resetContext"]
-			},
-			{
-				target: "tutorial",
-				guard: "hasShowTutorial",
-				actions: "resetContext"
-			},
-			{
-				target: "loading",
-				actions: "resetContext"
-			}
-		] } },
-		finished: {
-			entry: [
-				"stopMediaRecording",
-				"stopMediaStream",
-				"disposeProvider"
-			],
-			type: "final"
-		},
-		closed: {
-			entry: ["stopMediaStream", "disposeProvider"],
-			type: "final"
-		},
-		error: {
-			entry: ["stopMediaStream", "disposeProvider"],
-			on: { RESET: {
-				target: "idle",
-				actions: "resetContext"
-			} }
-		},
-		manualIdUpload: { on: { QUIT: { target: "closed" } } },
-		digitalIdUpload: { on: { QUIT: { target: "closed" } } }
-	}
-});
-const idCaptureMachine = _idCaptureMachine;
-
-//#endregion
-//#region src/modules/id/idCaptureActor.ts
-function createIdCaptureActor(options) {
-	return createActor(idCaptureMachine, { input: {
-		config: options.config,
-		provider: options.provider
-	} }).start();
-}
-
-//#endregion
-//#region src/modules/id/idCaptureManager.ts
-function getPermissionStatus(snapshot) {
-	if (!snapshot.matches("permissions")) return;
-	if (snapshot.matches({ permissions: "idle" })) return "idle";
-	if (snapshot.matches({ permissions: "waitingForUser" })) return "idle";
-	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
-	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
-	if (snapshot.matches({ permissions: "denied" })) return "denied";
-}
-function getCaptureStatus(snapshot) {
-	const matches = {
-		initializing: snapshot.matches({ capture: "initializing" }),
-		detecting: snapshot.matches({ capture: "detecting" }),
-		manualCaptureWaiting: snapshot.matches({ capture: "manualCaptureWaiting" }),
-		capturing: snapshot.matches({ capture: "capturing" }),
-		capturingManual: snapshot.matches({ capture: "capturingManual" }),
-		uploading: snapshot.matches({ capture: "uploading" }),
-		uploadError: snapshot.matches({ capture: "uploadError" }),
-		success: snapshot.matches({ capture: "success" })
-	};
-	if (matches.initializing) return "initializing";
-	if (matches.detecting || matches.manualCaptureWaiting) return "detecting";
-	if (matches.capturing || matches.capturingManual) return "capturing";
-	if (matches.uploading) return "uploading";
-	if (matches.uploadError) return "uploadError";
-	if (matches.success) return "success";
-}
-function getErrorMessage(errorCode) {
-	if (!errorCode) return void 0;
-	return {
-		UPLOAD_ERROR: "Upload failed",
-		CLASSIFICATION_FAILED: "ID classification failed",
-		LOW_SHARPNESS: "Image is not sharp enough",
-		GLARE_DETECTED: "Glare detected on ID",
-		WRONG_DOCUMENT_SIDE: "Wrong side of document",
-		ID_TYPE_UNACCEPTABLE: "ID type is not acceptable",
-		READABILITY_ISSUE: "ID readability issue",
-		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "Retry exhausted",
-		RETRY_EXHAUSTED_SKIP_BACK: "Retry exhausted",
-		NO_MORE_TRIES: "No more tries remaining",
-		UNEXPECTED_ERROR: "An unexpected error occurred",
-		NO_TOKEN: "No token available",
-		PERMISSION_DENIED: "Permission denied",
-		USER_CANCELLED: "User cancelled",
-		SERVER_ERROR: "Server error"
-	}[errorCode];
-}
-function getErrorDescription(errorCode, uploadResponse) {
-	if (!errorCode) return void 0;
-	return {
-		UPLOAD_ERROR: "Please try again",
-		CLASSIFICATION_FAILED: "Please ensure your ID is clearly visible",
-		LOW_SHARPNESS: "Please ensure the image is clear and well-focused",
-		GLARE_DETECTED: "Please avoid bright reflections on your ID",
-		WRONG_DOCUMENT_SIDE: uploadResponse?.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
-		ID_TYPE_UNACCEPTABLE: "Please use a valid ID type",
-		READABILITY_ISSUE: "Please ensure all text is clearly visible",
-		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "Continuing to back side capture",
-		RETRY_EXHAUSTED_SKIP_BACK: "Skipping back side capture",
-		NO_MORE_TRIES: "Maximum attempts reached",
-		UNEXPECTED_ERROR: "Please try again later",
-		NO_TOKEN: "Session expired",
-		PERMISSION_DENIED: "Camera permission is required",
-		USER_CANCELLED: "Capture was cancelled",
-		SERVER_ERROR: "Please try again later"
-	}[errorCode];
-}
-function mapState(snapshot) {
-	const { context } = snapshot;
-	if (snapshot.matches("idle")) return { status: "idle" };
-	if (snapshot.matches("chooser")) return { status: "chooser" };
-	if (snapshot.matches("loading")) return { status: "loading" };
-	if (snapshot.matches("tutorial")) return {
-		status: "tutorial",
-		selectedDocumentType: context.selectedDocumentType
-	};
-	if (snapshot.matches("closed")) return { status: "closed" };
-	if (snapshot.matches("permissions")) {
-		const permissionStatus = getPermissionStatus(snapshot);
-		if (permissionStatus === void 0) return {
-			status: "permissions",
-			permissionStatus: "idle"
-		};
-		return {
-			status: "permissions",
-			permissionStatus
-		};
-	}
-	if (snapshot.matches("capture")) {
-		const captureStatus = getCaptureStatus(snapshot);
-		const needsBackCapture = context.currentMode === "front" && !context.config.onlyFront && !context.config.onlyBack;
-		return {
-			status: "capture",
-			captureStatus: captureStatus ?? "initializing",
-			stream: context.stream,
-			detectionStatus: context.detectionStatus,
-			debugFrame: void 0,
-			attemptsRemaining: context.attemptsRemaining,
-			uploadError: context.uploadError,
-			currentMode: context.currentMode,
-			counterValue: context.counterValue,
-			orientation: context.orientation,
-			idType: context.idType,
-			previewImageUrl: context.previewImageUrl,
-			uploadProgress: context.uploadProgress ?? 0,
-			uploadErrorMessage: context.uploadError ? getErrorMessage(context.uploadError) : void 0,
-			uploadErrorDescription: context.uploadError ? getErrorDescription(context.uploadError, context.uploadResponse) : void 0,
-			needsBackCapture,
-			showCaptureButtonInAuto: context.config.showCaptureButtonInAuto ?? false,
-			canRetry: context.attemptsRemaining > 0
-		};
-	}
-	if (snapshot.matches("frontFinished")) return { status: "frontFinished" };
-	if (snapshot.matches("processing")) return { status: "processing" };
-	if (snapshot.matches("expired")) return { status: "expired" };
-	if (snapshot.matches("finished")) return { status: "finished" };
-	if (snapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Unknown error"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor }) {
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		selectDocument(documentType) {
-			actor.send({
-				type: "SELECT_DOCUMENT",
-				documentType
-			});
-		},
-		nextStep() {
-			actor.send({ type: "NEXT_STEP" });
-		},
-		requestPermission() {
-			actor.send({ type: "REQUEST_PERMISSION" });
-		},
-		goToLearnMore() {
-			actor.send({ type: "GO_TO_LEARN_MORE" });
-		},
-		back() {
-			actor.send({ type: "BACK" });
-		},
-		close() {
-			actor.send({ type: "QUIT" });
-		},
-		reset() {
-			actor.send({ type: "RESET" });
-		},
-		retryCapture() {
-			actor.send({ type: "RETRY_CAPTURE" });
-		},
-		continueFromError() {
-			actor.send({ type: "CONTINUE_FROM_ERROR" });
-		},
-		capture() {
-			actor.send({ type: "MANUAL_CAPTURE" });
-		},
-		switchToManualCapture() {
-			actor.send({ type: "SWITCH_TO_MANUAL_CAPTURE" });
-		},
-		continueToBack() {
-			actor.send({ type: "CONTINUE_TO_BACK" });
-		},
-		skipBack() {
-			actor.send({ type: "SKIP_BACK" });
-		},
-		updateDetectionArea(detectionArea) {
-			actor.send({
-				type: "UPDATE_DETECTION_AREA",
-				detectionArea
-			});
-		}
-	};
-}
-function createIdCaptureManager(options) {
-	return createManager({
-		actor: createIdCaptureActor(options),
-		mapState,
-		createApi
-	});
-}
-
-//#endregion
-export { processId as a, stopStream as c, ID_ERROR_CODES as d, initializeIdCapture as i, uploadIdImage as l, createIdCaptureActor as n, startRecordingSession as o, idCaptureMachine as r, stopRecording as s, createIdCaptureManager as t, validateUploadResponse as u };