@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/idCaptureManager-DMK0GIt3.esm.js

@@ -1,581 +0,0 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
-import { h as mapDigitalIdScreenName, t as idCaptureMachine } from "./idCaptureStateMachine-Bq0fVZXl.esm.js";
-
-//#region src/internal/idCapture/idCaptureManagerFactory.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";
-}
-/**
-* Returns an i18n key for the error title. The UI layer is responsible for
-* calling `t()` on the returned key.
-*
-* Passport-aware keys are emitted for error codes that have user-facing copy
-* specific to passports (e.g. CLASSIFICATION_FAILED → ".titlePassport").
-* Other codes fall back to the shared key.
-*/
-function getErrorTitleKey(errorCode, currentMode) {
-	if (!errorCode) return void 0;
-	const isPassport = currentMode === "passport";
-	if (errorCode === "CLASSIFICATION_FAILED") return isPassport ? "idv2.capture.processing.errors.classification.titlePassport" : "idv2.capture.processing.errors.classification.title";
-	return {
-		UPLOAD_ERROR: "idv2.capture.processing.errors.upload.title",
-		CLASSIFICATION_FAILED: "idv2.capture.processing.errors.classification.title",
-		LOW_SHARPNESS: "idv2.capture.processing.errors.sharpness.title",
-		GLARE_DETECTED: "idv2.capture.processing.errors.glare.title",
-		WRONG_DOCUMENT_SIDE: "idv2.capture.processing.errors.wrongSide.title",
-		ID_TYPE_UNACCEPTABLE: "idv2.capture.processing.errors.unacceptable.title",
-		READABILITY_ISSUE: "idv2.capture.processing.errors.readability.title",
-		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "idv2.capture.processing.errors.default.title",
-		RETRY_EXHAUSTED_SKIP_BACK: "idv2.capture.processing.errors.default.title",
-		NO_MORE_TRIES: "idv2.capture.processing.errors.default.title",
-		UNEXPECTED_ERROR: "idv2.capture.processing.errors.default.title",
-		NO_TOKEN: "idv2.capture.processing.errors.default.title",
-		PERMISSION_DENIED: "idv2.capture.processing.errors.default.title",
-		USER_CANCELLED: "idv2.capture.processing.errors.default.title",
-		SERVER_ERROR: "idv2.capture.processing.errors.default.title"
-	}[errorCode];
-}
-/**
-* Returns an i18n key for the error subtitle. The UI layer is responsible for
-* calling `t()` on the returned key.
-*
-* Passport-aware keys are emitted for error codes that have user-facing copy
-* specific to passports (e.g. CLASSIFICATION_FAILED → ".subtitlePassport").
-* Other codes fall back to the shared key.
-*/
-function getErrorSubtitleKey(errorCode, uploadResponse, currentMode) {
-	if (!errorCode) return void 0;
-	const isPassport = currentMode === "passport";
-	if (errorCode === "WRONG_DOCUMENT_SIDE") return uploadResponse?.side === "back" ? "idv2.capture.processing.errors.wrongSide.back.subtitle" : "idv2.capture.processing.errors.wrongSide.front.subtitle";
-	if (errorCode === "CLASSIFICATION_FAILED") return isPassport ? "idv2.capture.processing.errors.classification.subtitlePassport" : "idv2.capture.processing.errors.classification.subtitle";
-	return {
-		UPLOAD_ERROR: "idv2.capture.processing.errors.upload.subtitle",
-		CLASSIFICATION_FAILED: "idv2.capture.processing.errors.classification.subtitle",
-		LOW_SHARPNESS: "idv2.capture.processing.errors.sharpness.subtitle",
-		GLARE_DETECTED: "idv2.capture.processing.errors.glare.subtitle",
-		WRONG_DOCUMENT_SIDE: "idv2.capture.processing.errors.wrongSide.front.subtitle",
-		ID_TYPE_UNACCEPTABLE: "idv2.capture.processing.errors.unacceptable.subtitle",
-		READABILITY_ISSUE: "idv2.capture.processing.errors.readability.subtitle",
-		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "idv2.capture.processing.errors.default.subtitle",
-		RETRY_EXHAUSTED_SKIP_BACK: "idv2.capture.processing.errors.default.subtitle",
-		NO_MORE_TRIES: "idv2.capture.processing.errors.default.subtitle",
-		UNEXPECTED_ERROR: "idv2.capture.processing.errors.default.subtitle",
-		NO_TOKEN: "idv2.capture.processing.errors.default.subtitle",
-		PERMISSION_DENIED: "idv2.capture.processing.errors.default.subtitle",
-		USER_CANCELLED: "idv2.capture.processing.errors.default.subtitle",
-		SERVER_ERROR: "idv2.capture.processing.errors.default.subtitle"
-	}[errorCode];
-}
-function shouldCaptureBack(context) {
-	if (context.isDigitalUpload) return false;
-	if (!(context.currentMode === "front" || context.currentMode === "passport")) return false;
-	if (context.config.onlyBack) return false;
-	if (context.config.usSmartCapture && context.currentMode === "front") return false;
-	const serverSkipped = context.uploadResponse?.skipBackIdCapture === true;
-	const forceBackForNonPassport = context.config.alwaysCaptureBackOfId === true && context.currentMode !== "passport";
-	return !serverSkipped || forceBackForNonPassport;
-}
-function shouldCaptureFront(context) {
-	return context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
-}
-function mapCaptureState(snapshot, context) {
-	const captureStatus = getCaptureStatus(snapshot) ?? "initializing";
-	const { uploadError, uploadResponse } = context;
-	return {
-		status: "capture",
-		captureStatus,
-		stream: context.stream,
-		detectionStatus: context.detectionStatus,
-		debugFrame: void 0,
-		attemptsRemaining: context.attemptsRemaining,
-		uploadError,
-		currentMode: context.currentMode,
-		counterValue: context.counterValue,
-		orientation: context.orientation,
-		idType: context.idType,
-		previewImageUrl: context.previewImageUrl,
-		uploadProgress: context.uploadProgress ?? 0,
-		ageAssurance: context.config.ageAssurance === true,
-		uploadErrorMessage: uploadError ? getErrorTitleKey(uploadError, context.currentMode) : void 0,
-		uploadErrorDescription: uploadError ? getErrorSubtitleKey(uploadError, uploadResponse, context.currentMode) : void 0,
-		needsBackCapture: shouldCaptureBack(context),
-		needsFrontCapture: shouldCaptureFront(context),
-		showCaptureButtonInAuto: context.config.showCaptureButtonInAuto ?? false,
-		canRetry: context.attemptsRemaining > 0
-	};
-}
-function isLoadingPhase(snapshot) {
-	return snapshot.matches({ capture: "checkingStream" }) || snapshot.matches({ capture: "initializingDeepsight" }) || snapshot.matches({ capture: "initializing" }) || snapshot.matches({ permissions: "idle" });
-}
-function mapManualUploadState(snapshot) {
-	const { config } = snapshot.context;
-	const childSnapshot = snapshot.children["manualIdUpload"]?.getSnapshot();
-	const childCtx = childSnapshot?.context;
-	const childValue = childSnapshot?.value;
-	const phase = childValue === "retriesExhausted" ? "exhausted" : childValue === "uploadingFront" || childValue === "uploadingBack" || childValue === "uploadingPassport" ? "uploading" : "selecting";
-	const uploadingSide = childValue === "uploadingFront" ? "front" : childValue === "uploadingBack" ? "back" : childValue === "uploadingPassport" ? "passport" : void 0;
-	/**
-	* Server told us the document doesn't need a back side (e.g. passport-class
-	* docs, single-sided IDs). Treat the back slot as uploaded so the UI shows
-	* a green check rather than hiding the slot — matches v1's behavior and
-	* keeps both slots visible once the front has been processed.
-	*/
-	const backUploaded = (childCtx?.backUploaded ?? false) || (childCtx?.skipBackFromServer ?? false);
-	const idTabCanContinue = (childCtx?.frontUploaded ?? false) && backUploaded;
-	const canContinue = childCtx?.activeTab === "id" ? idTabCanContinue : childCtx?.passportUploaded ?? false;
-	return {
-		status: "manualUpload",
-		phase,
-		uploadingSide,
-		activeTab: childCtx?.activeTab ?? "id",
-		showIdTab: config.enableId ?? true,
-		showPassportTab: config.enablePassport ?? false,
-		showBackSlot: true,
-		frontFileName: childCtx?.frontFile?.name,
-		backFileName: childCtx?.backFile?.name,
-		passportFileName: childCtx?.passportFile?.name,
-		frontUploaded: childCtx?.frontUploaded ?? false,
-		backUploaded,
-		passportUploaded: childCtx?.passportUploaded ?? false,
-		canContinue,
-		retriesLeft: childCtx?.retriesLeft ?? snapshot.context.config.captureAttempts,
-		errorKey: childCtx?.errorMessage ?? null
-	};
-}
-function mapDigitalUploadState(snapshot) {
-	const childSnapshot = snapshot.children["digitalIdUpload"]?.getSnapshot();
-	const childCtx = childSnapshot?.context;
-	const childValue = childSnapshot?.value;
-	return {
-		status: "digitalIdUpload",
-		phase: (() => {
-			if (childValue === "tutorial") return "tutorial";
-			if (childValue === "selecting") return "selecting";
-			if (childValue === "reviewing") return "reviewing";
-			if (childValue === "success") return "success";
-			if (childValue === "error") return "error";
-			if (childValue === "fileTooLarge") return "fileTooLarge";
-			if (childValue === "retriesExhausted") return "exhausted";
-			if (childSnapshot?.matches({ uploading: "holding" })) return "holding";
-			if (childSnapshot?.matches({ uploading: "analyzing" })) return "uploading";
-			return "selecting";
-		})(),
-		file: childCtx?.file ?? null,
-		fileName: childCtx?.file?.name,
-		failReason: childCtx?.failReason ?? null,
-		attemptsRemaining: childCtx?.attemptsRemaining ?? snapshot.context.config.captureAttempts,
-		uploadProgress: childCtx?.uploadProgress ?? 0,
-		pickerRequestId: childCtx?.pickerRequestId ?? 0
-	};
-}
-function mapState(snapshot) {
-	const { context } = snapshot;
-	if (snapshot.matches("idle")) return { status: "idle" };
-	if (isLoadingPhase(snapshot)) return { status: "loading" };
-	if (snapshot.matches("chooser")) return {
-		status: "chooser",
-		availableDocumentTypes: context.availableDocumentTypes
-	};
-	if (snapshot.matches("loading")) return { status: "loading" };
-	if (snapshot.matches("tutorial")) return {
-		status: "tutorial",
-		selectedDocumentType: context.selectedDocumentType,
-		currentMode: context.currentMode
-	};
-	if (snapshot.matches("ageVerification")) return { status: "ageVerification" };
-	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")) return mapCaptureState(snapshot, context);
-	if (snapshot.matches("mandatoryConsent")) return {
-		status: "mandatoryConsent",
-		regulationType: context.uploadResponse?.regulationType ?? "Other"
-	};
-	if (snapshot.matches("frontFinished")) return { status: "frontFinished" };
-	if (snapshot.matches("backFinished")) return { status: "backFinished" };
-	if (snapshot.matches("processing")) return { status: "processing" };
-	if (snapshot.matches("expiredExhausted")) return { status: "expiredExhausted" };
-	if (snapshot.matches("expired")) {
-		const counter = context.expiredFromUpload ? context.expiredAttempts : context.processingExpiredAttempts;
-		return {
-			status: "expired",
-			attemptsRemaining: Math.max(0, context.config.captureAttempts - counter)
-		};
-	}
-	if (snapshot.matches("finished")) return { status: "finished" };
-	if (snapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Unknown error"
-	};
-	if (snapshot.matches("manualIdUpload")) return mapManualUploadState(snapshot);
-	if (snapshot.matches("digitalIdUpload")) return mapDigitalUploadState(snapshot);
-	return { status: "idle" };
-}
-function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
-	const snapshot = actor.getSnapshot();
-	if (snapshot.context.dependencies) snapshot.context.dependencies.trackCaptureAttemptFinished = trackCaptureAttemptFinished;
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		selectDocument(documentType) {
-			trackElementClicked?.(`selectDocument.${documentType}`);
-			actor.send({
-				type: "SELECT_DOCUMENT",
-				documentType
-			});
-		},
-		nextStep() {
-			trackElementClicked?.("nextStep");
-			actor.send({ type: "NEXT_STEP" });
-		},
-		requestPermission() {
-			trackElementClicked?.("requestPermission");
-			actor.send({ type: "REQUEST_PERMISSION" });
-		},
-		goToLearnMore() {
-			trackElementClicked?.("goToLearnMore");
-			actor.send({ type: "GO_TO_LEARN_MORE" });
-		},
-		back() {
-			trackElementClicked?.("back");
-			actor.send({ type: "BACK" });
-		},
-		close() {
-			trackElementClicked?.("close");
-			actor.send({ type: "QUIT" });
-		},
-		reset() {
-			actor.send({ type: "RESET" });
-		},
-		retryCapture() {
-			trackElementClicked?.("retryCapture");
-			actor.send({ type: "RETRY_CAPTURE" });
-		},
-		continueExhausted() {
-			trackElementClicked?.("continueExhausted");
-			actor.send({ type: "CONTINUE_EXHAUSTED" });
-		},
-		continueFromError() {
-			trackElementClicked?.("continueFromError");
-			actor.send({ type: "CONTINUE_FROM_ERROR" });
-		},
-		capture() {
-			trackElementClicked?.("capture");
-			actor.send({ type: "MANUAL_CAPTURE" });
-		},
-		switchToManualCapture() {
-			trackElementClicked?.("switchToManualCapture");
-			actor.send({ type: "SWITCH_TO_MANUAL_CAPTURE" });
-		},
-		continueToBack() {
-			trackElementClicked?.("continueToBack");
-			actor.send({ type: "CONTINUE_TO_BACK" });
-		},
-		continueToFront() {
-			trackElementClicked?.("continueToFront");
-			actor.send({ type: "CONTINUE_TO_FRONT" });
-		},
-		skipBack() {
-			trackElementClicked?.("skipBack");
-			actor.send({ type: "SKIP_BACK" });
-		},
-		acceptMandatoryConsent() {
-			trackElementClicked?.("acceptMandatoryConsent");
-			actor.send({ type: "CONSENT_ACCEPT" });
-		},
-		cancelMandatoryConsent() {
-			trackElementClicked?.("cancelMandatoryConsent");
-			actor.send({ type: "CONSENT_CANCEL" });
-		},
-		updateDetectionArea(detectionArea) {
-			actor.send({
-				type: "UPDATE_DETECTION_AREA",
-				detectionArea
-			});
-		},
-		manualUploadChangeTab(tab) {
-			trackElementClicked?.(`manualUpload.tab.${tab}`);
-			actor.send({
-				type: "MANUAL_UPLOAD_TAB_CHANGED",
-				tab
-			});
-		},
-		manualUploadSelectFile(side, file) {
-			trackElementClicked?.(`manualUpload.select.${side}`);
-			actor.send({
-				type: "MANUAL_UPLOAD_FILE_SELECTED",
-				side,
-				file
-			});
-		},
-		manualUploadContinue() {
-			trackElementClicked?.("manualUpload.continue");
-			actor.send({ type: "MANUAL_UPLOAD_CONTINUE" });
-		},
-		manualUploadReset() {
-			trackElementClicked?.("manualUpload.reset");
-			actor.send({ type: "MANUAL_UPLOAD_RESET" });
-		},
-		digitalUploadNextStep() {
-			trackElementClicked?.("digitalUpload.nextStep");
-			actor.send({ type: "DIGITAL_UPLOAD_NEXT_STEP" });
-		},
-		digitalUploadPickFile(file) {
-			trackElementClicked?.("digitalUpload.pickFile");
-			actor.send({
-				type: "DIGITAL_UPLOAD_FILE_PICKED",
-				file
-			});
-		},
-		digitalUploadConfirm() {
-			trackElementClicked?.("digitalUpload.confirmFile");
-			actor.send({ type: "DIGITAL_UPLOAD_CONFIRM" });
-		},
-		digitalUploadReplace() {
-			trackElementClicked?.("digitalUpload.replaceFile");
-			actor.send({ type: "DIGITAL_UPLOAD_REPLACE" });
-		},
-		digitalUploadRetry() {
-			trackElementClicked?.("digitalUpload.retry");
-			actor.send({ type: "DIGITAL_UPLOAD_RETRY" });
-		},
-		digitalUploadScanInstead() {
-			trackElementClicked?.("digitalUpload.scanInstead");
-			actor.send({ type: "DIGITAL_UPLOAD_SCAN_INSTEAD" });
-		},
-		digitalUploadChooseAnother() {
-			trackElementClicked?.("digitalUpload.chooseAnother");
-			actor.send({ type: "DIGITAL_UPLOAD_CHOOSE_ANOTHER" });
-		}
-	};
-}
-const FRONT_SCREENS = {
-	tutorial: "idCapture.tutorial.front",
-	capturePrefix: "idCapture.frontCapture",
-	analyzingPrefix: "idCapture.frontAnalyzing",
-	errorPrefix: "idCapture.frontCaptureError",
-	successPrefix: "idCapture.frontCaptureSuccess",
-	liveCueSide: "showfront"
-};
-const BACK_SCREENS = {
-	tutorial: "idCapture.tutorial.back",
-	capturePrefix: "idCapture.backCapture",
-	analyzingPrefix: "idCapture.backAnalyzing",
-	errorPrefix: "idCapture.backCaptureError",
-	successPrefix: "idCapture.backCaptureSuccess",
-	liveCueSide: "showback"
-};
-const PASSPORT_SCREENS = { tutorial: "idCapture.tutorial.passport" };
-function getSideScreens(mode) {
-	if (mode === "back") return BACK_SCREENS;
-	if (mode === "passport") return {
-		...FRONT_SCREENS,
-		...PASSPORT_SCREENS
-	};
-	return FRONT_SCREENS;
-}
-function getCaptureLiveCueScreen(screens, detectionStatus) {
-	switch (detectionStatus) {
-		case "wrongSide": return `${screens.capturePrefix}.livecue-${screens.liveCueSide}`;
-		case "blur": return `${screens.capturePrefix}.livecue-blur`;
-		case "farAway":
-		case "idNotDetected": return `${screens.capturePrefix}.livecue-align`;
-		case "glare": return `${screens.capturePrefix}.livecue-glare`;
-		case "offline": return `${screens.capturePrefix}.livecue-dark`;
-		case "manualCapture": return `${screens.capturePrefix}.manual`;
-		case "capturing": return `${screens.capturePrefix}.takingphoto`;
-		case "detecting":
-		case "idle":
-		default: return `${screens.capturePrefix}.default`;
-	}
-}
-function getCaptureErrorScreen(screens, errorCode) {
-	switch (errorCode) {
-		case "WRONG_DOCUMENT_SIDE": return `${screens.errorPrefix}.wrongside`;
-		case "GLARE_DETECTED": return `${screens.errorPrefix}.glare`;
-		case "LOW_SHARPNESS": return `${screens.errorPrefix}.blur`;
-		case "READABILITY_ISSUE": return `${screens.errorPrefix}.notreadable`;
-		case "ID_TYPE_UNACCEPTABLE":
-		case "CLASSIFICATION_FAILED": return `${screens.errorPrefix}.notaccepted`;
-		case "RETRY_EXHAUSTED_CONTINUE_TO_BACK":
-		case "RETRY_EXHAUSTED_SKIP_BACK":
-		case "NO_MORE_TRIES": return `${screens.errorPrefix}.failedExhausted`;
-		case "NO_TOKEN":
-		case "SERVER_ERROR": return `${screens.errorPrefix}.nointernet`;
-		case "UPLOAD_ERROR":
-		case "UNEXPECTED_ERROR":
-		case "PERMISSION_DENIED":
-		case "USER_CANCELLED":
-		default: return `${screens.errorPrefix}.failed`;
-	}
-}
-function getSuccessScreen(snapshot, screens) {
-	const { config } = snapshot.context;
-	if (config?.onlyBack === true || config?.showCaptureButtonInAuto === true) return `${screens.successPrefix}.captureonly`;
-	return `${screens.successPrefix}.default`;
-}
-function getCaptureSubstateScreen(snapshot, screens) {
-	const { value, context } = snapshot;
-	if (typeof value !== "object" || value === null) return void 0;
-	const captureValue = value.capture;
-	if (captureValue === void 0) return void 0;
-	if (typeof captureValue === "string") switch (captureValue) {
-		case "checkingStream":
-		case "initializing":
-		case "initializingDeepsight": return "idCapture.loader.preparingcamera";
-		case "detecting": return getCaptureLiveCueScreen(screens, context.detectionStatus);
-		case "manualCaptureWaiting": return `${screens.capturePrefix}.manual`;
-		case "capturing": return `${screens.capturePrefix}.takingphoto`;
-		case "capturingManual": return `${screens.capturePrefix}.manual`;
-		case "uploading":
-		case "validatingUpload": return `${screens.analyzingPrefix}.uploading`;
-		case "uploadError": return getCaptureErrorScreen(screens, context.uploadError);
-		case "success": return getSuccessScreen(snapshot, screens);
-	}
-	if (typeof captureValue === "object" && captureValue !== null) {
-		const substates = Object.keys(captureValue);
-		if (substates.includes("checkingStream") || substates.includes("initializing") || substates.includes("initializingDeepsight")) return "idCapture.loader.preparingcamera";
-		if (substates.includes("detecting")) return getCaptureLiveCueScreen(screens, context.detectionStatus);
-		if (substates.includes("manualCaptureWaiting")) return `${screens.capturePrefix}.manual`;
-		if (substates.includes("capturing")) return `${screens.capturePrefix}.takingphoto`;
-		if (substates.includes("capturingManual")) return `${screens.capturePrefix}.manual`;
-		if (substates.includes("uploading") || substates.includes("validatingUpload")) return `${screens.analyzingPrefix}.uploading`;
-		if (substates.includes("uploadError")) return getCaptureErrorScreen(screens, context.uploadError);
-		if (substates.includes("success")) return getSuccessScreen(snapshot, screens);
-	}
-	return `${screens.capturePrefix}.default`;
-}
-function getPermissionScreen(value) {
-	if (typeof value !== "object" || value === null) return "idCapture.permissions.default";
-	switch (value.permissions) {
-		case "requesting": return "idCapture.permissions.required";
-		case "denied": return "idCapture.permissions.quit";
-		case "learnMore": return "idCapture.commonissues.default";
-		case "idle":
-		case "waitingForUser":
-		default: return "idCapture.permissions.default";
-	}
-}
-function getIdCaptureScreenName(snapshot) {
-	const { value, context } = snapshot;
-	if (value === void 0 || value === null) return void 0;
-	const topLevel = typeof value === "string" ? value : typeof value === "object" ? Object.keys(value)[0] : void 0;
-	if (topLevel === void 0) return void 0;
-	const side = context.currentMode;
-	const screens = getSideScreens(side);
-	switch (topLevel) {
-		case "idle": return "idCapture.loader.default";
-		case "chooser": return "idCapture.documentchooser";
-		case "loading": return "idCapture.loader.default";
-		case "tutorial": return screens.tutorial;
-		case "ageVerification": return "idCapture.tutorial.ageverification";
-		case "permissions": return getPermissionScreen(value);
-		case "capture": return getCaptureSubstateScreen(snapshot, screens);
-		case "mandatoryConsent": return "idCapture.mandatoryConsent";
-		case "frontFinished": return "idCapture.flipid.showback";
-		case "backFinished": return "idCapture.flipid.showfront";
-		case "processing": return `${screens.analyzingPrefix}.processing`;
-		case "expired": return "idCapture.expired";
-		case "expiredExhausted": return "idCapture.expiredExhausted";
-		case "finished": return "idCapture.finished";
-		case "closed": return "idCapture.closed";
-		case "error": return "idCapture.error";
-		case "digitalIdUpload": {
-			const child = snapshot.children["digitalIdUpload"]?.getSnapshot();
-			const childContext = child?.context;
-			return mapDigitalIdScreenName(child?.value, childContext?.failReason ?? null);
-		}
-		default: return `idCapture.${topLevel}`;
-	}
-}
-function mapIdCaptureScreenName(snapshot) {
-	return getIdCaptureScreenName(snapshot);
-}
-function getIdCaptureErrorPayload(snapshot) {
-	const errorCode = snapshot.context.uploadError;
-	if (errorCode === void 0) return;
-	return { errorCode };
-}
-/**
-* Builds the public ID capture manager from an already-created actor.
-* Used by both `createIdCaptureManager` and `createIdCaptureOnlyManager`.
-*
-* The internal cast to `IdCaptureActor` narrows the union for `createManager`,
-* which is typed against the regular machine. Variants produced via
-* `idCaptureMachine.provide({...})` share the same context and event types,
-* so the cast is sound at runtime — only the actor implementation differs.
-*/
-function createIdCaptureManagerFromActor(actor) {
-	return createManager({
-		actor,
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.idCapture, {
-			getEventScreenName: mapIdCaptureScreenName,
-			getErrorPayload: getIdCaptureErrorPayload
-		})
-	});
-}
-
-//#endregion
-//#region src/modules/id/idCaptureActor.ts
-function createIdCaptureActor(options) {
-	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
-	return createActor(idCaptureMachine, { input: {
-		config: options.config,
-		dependencies
-	} }).start();
-}
-
-//#endregion
-//#region src/modules/id/idCaptureManager.ts
-/**
-* Creates a manager for the regular ID capture flow. The shared
-* `mapState`/`createApi`/state-types live in
-* `internal/idCapture/idCaptureManagerFactory.ts`; this file is a thin
-* wrapper that creates the actor and delegates to the factory.
-*
-* For the captureOnly flow (rich payload delivered locally via `onCapture`),
-* use `createIdCaptureOnlyManager`.
-*/
-function createIdCaptureManager(options) {
-	return createIdCaptureManagerFromActor(createIdCaptureActor(options));
-}
-
-//#endregion
-export { createIdCaptureActor as n, createIdCaptureManagerFromActor as r, createIdCaptureManager as t };