@simprints/simface-sdk 0.6.1 → 0.7.1

package/dist/services/camera.js

@@ -1,94 +1,123 @@
 /**
  * Camera capture service.
  *
- * Uses realtime face guidance with automatic capture when supported and falls
- * back to a simpler manual capture flow when the browser cannot support it.
+ * Plans capture explicitly as an ordered fallback chain:
+ * auto camera -> manual camera -> media picker.
  */
-import { assessFaceQuality, assessFaceQualityForVideo, getVideoDetector } from './face-detection.js';
-import { AUTO_CAPTURE_ANALYSIS_INTERVAL_MS, AUTO_CAPTURE_COUNTDOWN_MS, CAPTURE_GUIDE_MASK_PATH, CAPTURE_GUIDE_PATH, autoCaptureCompleteMessage, autoCaptureCountdownMessage, } from '../shared/auto-capture.js';
+import { CAPTURE_GUIDE_MASK_PATH, CAPTURE_GUIDE_PATH, } from '../shared/auto-capture.js';
+import { buildCapturePlan, normalizeCaptureOptions, resolveCaptureCapabilities, } from '../shared/capture-flow.js';
+import { CameraCaptureSessionController, } from '../shared/capture-session.js';
+import { CameraAccessError, blobToDataURL, blobToImage, captureFromFileInput, openUserFacingCameraStream, } from '../shared/capture-runtime.js';
 const CAPTURE_DIALOG_Z_INDEX = '2147483647';
 /**
- * Opens the device camera and returns a confirmed image Blob, or null if cancelled.
+ * Opens the configured capture presentation and returns a confirmed image Blob,
+ * or null if the user cancels.
  */
-export async function captureFromCamera() {
-    if (prefersNativeCameraCapture()) {
-        return captureFromFileInput();
+export async function captureFromCamera(options) {
+    const captureOptions = normalizeCaptureOptions(options);
+    if (captureOptions.presentation === 'embedded') {
+        return captureFromEmbeddedComponent(captureOptions);
     }
-    if (!navigator.mediaDevices?.getUserMedia) {
-        throw new Error('In-browser camera capture is not supported in this browser.');
+    const capabilities = await resolveCaptureCapabilities({
+        capturePreference: captureOptions.capturePreference,
+    });
+    const plan = buildCapturePlan(captureOptions, capabilities);
+    for (let index = 0; index < plan.steps.length; index += 1) {
+        const step = plan.steps[index];
+        if (step === 'media-picker') {
+            return captureFromFileInput();
+        }
+        try {
+            return await captureFromPopupCamera(step === 'auto-camera' ? 'auto' : 'manual');
+        }
+        catch (error) {
+            const hasMediaPickerFallback = plan.steps.slice(index + 1).includes('media-picker');
+            if (error instanceof CameraAccessError && hasMediaPickerFallback) {
+                return captureFromFileInput();
+            }
+            throw error;
+        }
     }
-    const mode = (await supportsRealtimeAutoCapture()) ? 'auto' : 'manual';
-    return captureFromMediaDevices(mode);
+    throw new Error('No supported capture strategy is available in this environment.');
 }
-async function supportsRealtimeAutoCapture() {
-    if (typeof window.requestAnimationFrame !== 'function' ||
-        typeof window.cancelAnimationFrame !== 'function') {
-        return false;
+async function captureFromEmbeddedComponent(options) {
+    await import('../components/simface-capture.js');
+    const host = resolveEmbeddedCaptureHost(options.container);
+    const usingExistingElement = host.tagName.toLowerCase() === 'simface-capture';
+    const element = (usingExistingElement
+        ? host
+        : document.createElement('simface-capture'));
+    if (!usingExistingElement) {
+        host.appendChild(element);
     }
-    if (!document.createElement('canvas').getContext('2d')) {
-        return false;
+    element.embedded = true;
+    element.label = options.label;
+    element.confirmLabel = options.confirmLabel;
+    element.capturePreference = options.capturePreference;
+    element.allowMediaPickerFallback = options.allowMediaPickerFallback;
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            element.removeEventListener('simface-captured', handleCaptured);
+            element.removeEventListener('simface-cancelled', handleCancelled);
+            element.removeEventListener('simface-error', handleError);
+            element.active = false;
+            if (!usingExistingElement) {
+                element.remove();
+            }
+        };
+        const handleCaptured = (event) => {
+            cleanup();
+            resolve(event.detail.imageBlob);
+        };
+        const handleCancelled = () => {
+            cleanup();
+            resolve(null);
+        };
+        const handleError = (event) => {
+            cleanup();
+            reject(new Error(event.detail.error));
+        };
+        element.addEventListener('simface-captured', handleCaptured);
+        element.addEventListener('simface-cancelled', handleCancelled);
+        element.addEventListener('simface-error', handleError);
+        void element.startCapture().catch((error) => {
+            cleanup();
+            reject(error instanceof Error ? error : new Error('Embedded capture failed.'));
+        });
+    });
+}
+function resolveEmbeddedCaptureHost(container) {
+    if (!container) {
+        throw new Error('Embedded capture requires a container element or selector.');
     }
-    try {
-        await getVideoDetector();
-        return true;
+    if (container instanceof HTMLElement) {
+        return container;
     }
-    catch {
-        return false;
+    const element = document.querySelector(container);
+    if (!element) {
+        throw new Error(`No element matched the embedded capture container selector "${container}".`);
     }
+    return element;
 }
-async function captureFromMediaDevices(initialMode) {
-    let stream;
-    try {
-        stream = await navigator.mediaDevices.getUserMedia({
-            video: { facingMode: { ideal: 'user' } },
-            audio: false,
-        });
-    }
-    catch (error) {
-        throw new Error(describeCameraError(error));
-    }
-    let streamStopped = false;
-    const stopStream = () => {
-        if (streamStopped) {
-            return;
-        }
-        streamStopped = true;
-        stream.getTracks().forEach((track) => track.stop());
-    };
+async function captureFromPopupCamera(initialMode) {
     return new Promise((resolve, reject) => {
         let settled = false;
-        let mode = initialMode;
         let overlay = null;
         let previewUrl = '';
-        let previewBlob = null;
-        let animationFrameId = null;
+        let stream = null;
+        let controller = null;
         let escapeHandler = null;
-        let lastAnalysisTimestamp = 0;
-        let analysisInFlight = false;
-        let previewActive = false;
-        let videoReady = false;
-        let countdownStartedAt = null;
-        let bestCaptureBlob = null;
-        let bestCaptureScore = -1;
-        let bestQualityResult = null;
-        const resetAutoCaptureState = (guideOverlay) => {
-            countdownStartedAt = null;
-            bestCaptureBlob = null;
-            bestCaptureScore = -1;
-            bestQualityResult = null;
-            guideOverlay.setProgress(0);
-        };
         const cleanup = () => {
-            if (animationFrameId !== null) {
-                window.cancelAnimationFrame(animationFrameId);
-            }
+            controller?.stop();
             if (escapeHandler) {
                 window.removeEventListener('keydown', escapeHandler);
             }
             if (previewUrl) {
                 URL.revokeObjectURL(previewUrl);
             }
-            stopStream();
+            if (stream) {
+                stream.getTracks().forEach((track) => track.stop());
+            }
             overlay?.remove();
         };
         const finalize = (value, error) => {
@@ -103,73 +132,6 @@ async function captureFromMediaDevices(initialMode) {
             }
             resolve(value);
         };
-        const renderCaptureMode = (video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay) => {
-            previewActive = false;
-            resetAutoCaptureState(guideOverlay);
-            if (previewUrl) {
-                URL.revokeObjectURL(previewUrl);
-                previewUrl = '';
-            }
-            previewBlob = null;
-            mediaContainer.replaceChildren(video, guideOverlay.wrapper);
-            if (videoReady) {
-                resumeVideoPreview(video);
-            }
-            title.textContent = mode === 'auto' ? 'Center your face' : 'Take a face photo';
-            copy.textContent =
-                mode === 'auto'
-                    ? 'Keep your face inside the oval. We will start a short countdown when the framing looks good and keep the best frame.'
-                    : 'Line up your face in the oval, then take a photo manually.';
-            feedback.textContent =
-                mode === 'auto'
-                    ? 'Looking for a single face in frame...'
-                    : 'When you are ready, press Take photo.';
-            setFeedbackState(feedback, mode === 'auto' ? 'neutral' : 'manual');
-            captureButton.style.display = mode === 'manual' ? 'inline-flex' : 'none';
-            captureButton.disabled = true;
-            actions.replaceChildren(cancelButton, captureButton);
-        };
-        const renderPreviewMode = (video, mediaContainer, title, copy, feedback, actions, cancelButton, confirmButton, retakeButton, blob, qualityResult, options) => {
-            previewActive = true;
-            countdownStartedAt = null;
-            if (previewUrl) {
-                URL.revokeObjectURL(previewUrl);
-            }
-            previewUrl = URL.createObjectURL(blob);
-            previewBlob = blob;
-            const image = document.createElement('img');
-            image.alt = 'Captured face preview';
-            image.src = previewUrl;
-            applyStyles(image, {
-                position: 'absolute',
-                inset: '0',
-                zIndex: '1',
-                width: '100%',
-                height: '100%',
-                objectFit: 'cover',
-            });
-            mediaContainer.replaceChildren(video, image);
-            title.textContent = 'Review your photo';
-            copy.textContent =
-                options?.copyText
-                    ?? (qualityResult?.passesQualityChecks === false
-                        ? 'The capture did not pass the checks. Retake the photo.'
-                        : 'Confirm this photo or retake it.');
-            feedback.textContent =
-                options?.feedbackText
-                    ?? qualityResult?.message
-                    ?? 'Review the captured image before continuing.';
-            setFeedbackState(feedback, options?.feedbackState
-                ?? (qualityResult
-                    ? qualityResult.passesQualityChecks
-                        ? 'success'
-                        : 'error'
-                    : 'manual'));
-            actions.replaceChildren(cancelButton, retakeButton);
-            if (qualityResult?.passesQualityChecks !== false) {
-                actions.append(confirmButton);
-            }
-        };
         try {
             overlay = document.createElement('div');
             overlay.setAttribute('data-simface-camera-overlay', 'true');
@@ -224,11 +186,11 @@ async function captureFromMediaDevices(initialMode) {
             video.autoplay = true;
             video.muted = true;
             video.playsInline = true;
-            video.srcObject = stream;
             applyStyles(video, {
                 width: '100%',
                 height: '100%',
                 objectFit: 'cover',
+                transform: 'scaleX(-1)',
             });
             const feedback = document.createElement('div');
             applyStyles(feedback, {
@@ -247,223 +209,144 @@ async function captureFromMediaDevices(initialMode) {
             cancelButton.dataset.simfaceAction = 'cancel';
             const captureButton = createActionButton('Take photo', 'primary');
             captureButton.dataset.simfaceAction = 'capture';
-            captureButton.style.display = mode === 'manual' ? 'inline-flex' : 'none';
-            captureButton.disabled = true;
-            const guideOverlay = createGuideOverlay();
             const confirmButton = createActionButton('Use photo', 'primary');
             confirmButton.dataset.simfaceAction = 'confirm';
             const retakeButton = createActionButton('Retake', 'secondary');
             retakeButton.dataset.simfaceAction = 'retake';
+            const guideOverlay = createGuideOverlay();
             panel.append(title, copy, mediaContainer, feedback, actions);
             overlay.append(panel);
             document.body.appendChild(overlay);
-            renderCaptureMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay);
             escapeHandler = (event) => {
                 if (event.key === 'Escape') {
                     finalize(null);
                 }
             };
+            window.addEventListener('keydown', escapeHandler);
             cancelButton.addEventListener('click', () => finalize(null));
-            confirmButton.addEventListener('click', async () => {
-                if (!previewBlob) {
-                    finalize(null, new Error('Failed to confirm the photo.'));
-                    return;
-                }
-                finalize(previewBlob);
+            captureButton.addEventListener('click', () => {
+                void controller?.takePhotoNow().catch((error) => {
+                    finalize(null, error instanceof Error ? error : new Error('Failed to capture an image.'));
+                });
             });
             retakeButton.addEventListener('click', () => {
-                renderCaptureMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay);
-                if (mode === 'manual' && videoReady) {
-                    captureButton.disabled = false;
-                }
-                if (mode === 'auto') {
-                    scheduleAutoCapture();
-                }
+                void controller?.retake().catch((error) => {
+                    finalize(null, error instanceof Error ? error : new Error('Failed to restart the capture.'));
+                });
             });
-            captureButton.addEventListener('click', async () => {
-                if (previewActive) {
-                    return;
-                }
+            confirmButton.addEventListener('click', () => {
                 try {
-                    const blob = await captureVideoFrame(video);
-                    const qualityResult = await assessCapturedBlobSafely(blob);
-                    renderPreviewMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, confirmButton, retakeButton, blob, qualityResult);
+                    const blob = controller?.confirm();
+                    finalize(blob ?? null);
                 }
                 catch (error) {
-                    finalize(null, error instanceof Error ? error : new Error('Failed to capture an image.'));
+                    finalize(null, error instanceof Error ? error : new Error('Failed to confirm the photo.'));
                 }
             });
-            window.addEventListener('keydown', escapeHandler);
-            waitForVideoReady(video)
-                .then(() => {
-                videoReady = true;
-                if (mode === 'manual') {
-                    captureButton.disabled = false;
-                    return;
-                }
-                scheduleAutoCapture();
-            })
-                .catch((error) => {
-                finalize(null, error instanceof Error ? error : new Error('Failed to start the camera preview.'));
+            controller = new CameraCaptureSessionController({
+                videoElement: video,
+                initialMode,
+                copy: {
+                    autoReadyMessage: 'Looking for a single face in frame...',
+                    manualReadyMessage: 'When you are ready, press Take photo.',
+                    autoUnavailableMessage: 'Automatic capture is unavailable in this browser. Use Take photo instead.',
+                    retakeReadyMessage: 'When you are ready, press Take photo.',
+                },
+                onStateChange: (state) => {
+                    renderPopupState({
+                        state,
+                        mediaContainer,
+                        video,
+                        title,
+                        copy,
+                        feedback,
+                        actions,
+                        cancelButton,
+                        captureButton,
+                        confirmButton,
+                        retakeButton,
+                        guideOverlay,
+                        setPreviewUrl(nextUrl) {
+                            if (previewUrl) {
+                                URL.revokeObjectURL(previewUrl);
+                            }
+                            previewUrl = nextUrl;
+                        },
+                    });
+                },
             });
-            function scheduleAutoCapture() {
-                if (settled || previewActive || mode !== 'auto') {
-                    return;
-                }
-                animationFrameId = window.requestAnimationFrame(async (timestamp) => {
-                    if (previewActive ||
-                        analysisInFlight ||
-                        timestamp - lastAnalysisTimestamp < AUTO_CAPTURE_ANALYSIS_INTERVAL_MS) {
-                        scheduleAutoCapture();
+            void (async () => {
+                try {
+                    stream = await openUserFacingCameraStream();
+                    if (settled) {
+                        stream.getTracks().forEach((track) => track.stop());
                         return;
                     }
-                    lastAnalysisTimestamp = timestamp;
-                    analysisInFlight = true;
-                    try {
-                        const qualityResult = await assessFaceQualityForVideo(video, timestamp);
-                        if (qualityResult.passesQualityChecks) {
-                            if (countdownStartedAt === null) {
-                                countdownStartedAt = timestamp;
-                            }
-                            if (qualityResult.captureScore > bestCaptureScore) {
-                                bestCaptureBlob = await captureVideoFrame(video);
-                                bestCaptureScore = qualityResult.captureScore;
-                                bestQualityResult = qualityResult;
-                            }
-                        }
-                        if (countdownStartedAt !== null) {
-                            const countdownProgress = Math.min((timestamp - countdownStartedAt) / AUTO_CAPTURE_COUNTDOWN_MS, 1);
-                            guideOverlay.setProgress(countdownProgress);
-                            feedback.textContent = autoCaptureCountdownMessage(timestamp, countdownStartedAt, qualityResult);
-                            setFeedbackState(feedback, qualityResult.passesQualityChecks ? 'success' : 'neutral');
-                            if (countdownProgress >= 1) {
-                                const blob = bestCaptureBlob ?? await captureVideoFrame(video);
-                                const previewQualityResult = bestCaptureBlob && bestQualityResult
-                                    ? bestQualityResult
-                                    : await assessCapturedBlobSafely(blob);
-                                renderPreviewMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, confirmButton, retakeButton, blob, previewQualityResult, {
-                                    copyText: 'Best frame captured. Review and confirm this photo.',
-                                    feedbackText: autoCaptureCompleteMessage(previewQualityResult),
-                                    feedbackState: previewQualityResult?.passesQualityChecks === false ? 'error' : 'success',
-                                });
-                                return;
-                            }
-                        }
-                        else {
-                            guideOverlay.setProgress(0);
-                            feedback.textContent = qualityResult.message;
-                            setFeedbackState(feedback, qualityResult.passesQualityChecks ? 'success' : 'neutral');
-                        }
-                    }
-                    catch (error) {
-                        mode = 'manual';
-                        renderCaptureMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay);
-                        captureButton.disabled = false;
-                        feedback.textContent = 'Automatic capture is unavailable in this browser. Use Take photo instead.';
-                        setFeedbackState(feedback, 'manual');
-                    }
-                    finally {
-                        analysisInFlight = false;
-                    }
-                    scheduleAutoCapture();
-                });
-            }
+                    video.srcObject = stream;
+                    await controller?.start();
+                }
+                catch (error) {
+                    finalize(null, error instanceof Error ? error : new Error('Failed to open the camera capture UI.'));
+                }
+            })();
         }
         catch (error) {
             finalize(null, error instanceof Error ? error : new Error('Failed to open the camera capture UI.'));
         }
     });
 }
-function captureFromFileInput() {
-    return new Promise((resolve) => {
-        const input = document.createElement('input');
-        input.type = 'file';
-        input.accept = 'image/*';
-        input.capture = 'user';
-        input.style.display = 'none';
-        input.addEventListener('change', () => {
-            const file = input.files?.[0] ?? null;
-            cleanup();
-            resolve(file);
+function renderPopupState(options) {
+    const { state, mediaContainer, video, title, copy, feedback, actions, cancelButton, captureButton, confirmButton, retakeButton, guideOverlay, setPreviewUrl, } = options;
+    guideOverlay.setProgress(state.phase === 'live' && state.mode === 'auto' ? state.countdownProgress : 0);
+    if (state.phase === 'preview') {
+        const nextPreviewUrl = URL.createObjectURL(state.previewBlob);
+        setPreviewUrl(nextPreviewUrl);
+        const image = document.createElement('img');
+        image.alt = 'Captured face preview';
+        image.src = nextPreviewUrl;
+        applyStyles(image, {
+            position: 'absolute',
+            inset: '0',
+            zIndex: '1',
+            width: '100%',
+            height: '100%',
+            objectFit: 'cover',
+            transform: 'scaleX(-1)',
         });
-        const handleFocus = () => {
-            setTimeout(() => {
-                if (!input.files?.length) {
-                    cleanup();
-                    resolve(null);
-                }
-            }, 500);
-        };
-        window.addEventListener('focus', handleFocus, { once: true });
-        function cleanup() {
-            window.removeEventListener('focus', handleFocus);
-            input.remove();
+        mediaContainer.replaceChildren(video, image);
+        title.textContent = 'Review your photo';
+        copy.textContent = state.qualityResult?.passesQualityChecks === false
+            ? 'The capture did not pass the checks. Retake the photo.'
+            : 'Confirm this photo or retake it.';
+        feedback.textContent = state.feedbackMessage;
+        setFeedbackState(feedback, state.feedbackTone);
+        actions.replaceChildren(cancelButton, retakeButton);
+        if (state.canConfirm) {
+            actions.append(confirmButton);
         }
-        document.body.appendChild(input);
-        input.click();
-    });
-}
-function prefersNativeCameraCapture() {
-    return /WhatsApp/i.test(navigator.userAgent);
-}
-async function waitForVideoReady(video) {
-    if (video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
-        await video.play();
         return;
     }
-    await new Promise((resolve, reject) => {
-        const handleReady = () => {
-            cleanup();
-            resolve();
-        };
-        const handleError = () => {
-            cleanup();
-            reject(new Error('Failed to start the camera preview.'));
-        };
-        const cleanup = () => {
-            video.removeEventListener('loadedmetadata', handleReady);
-            video.removeEventListener('error', handleError);
-        };
-        video.addEventListener('loadedmetadata', handleReady, { once: true });
-        video.addEventListener('error', handleError, { once: true });
-    });
-    await video.play();
-}
-function captureVideoFrame(video) {
-    if (!video.videoWidth || !video.videoHeight) {
-        return Promise.reject(new Error('Camera preview is not ready yet.'));
-    }
-    const canvas = document.createElement('canvas');
-    canvas.width = video.videoWidth;
-    canvas.height = video.videoHeight;
-    const context = canvas.getContext('2d');
-    if (!context) {
-        return Promise.reject(new Error('Failed to initialize camera capture.'));
-    }
-    context.drawImage(video, 0, 0, canvas.width, canvas.height);
-    return new Promise((resolve, reject) => {
-        canvas.toBlob((blob) => {
-            if (!blob) {
-                reject(new Error('Failed to capture an image.'));
-                return;
-            }
-            resolve(blob);
-        }, 'image/jpeg', 0.92);
-    });
-}
-function resumeVideoPreview(video) {
-    void video.play().catch(() => {
-        // Ignore resume failures here; capture flow already handles preview startup errors.
-    });
-}
-async function assessCapturedBlobSafely(blob) {
-    try {
-        const image = await blobToImage(blob);
-        return await assessFaceQuality(image);
+    mediaContainer.replaceChildren(video, guideOverlay.wrapper);
+    setPreviewUrl('');
+    if (state.mode === 'auto') {
+        title.textContent = state.phase === 'starting' ? 'Opening camera...' : 'Center your face';
+        copy.textContent = 'Keep your face inside the oval. We will start a short countdown when the framing looks good and keep the best frame.';
     }
-    catch {
-        return null;
+    else {
+        title.textContent = state.phase === 'starting' ? 'Opening camera...' : 'Take a face photo';
+        copy.textContent = 'Line up your face in the oval, then take a photo manually.';
     }
+    feedback.textContent = state.phase === 'starting'
+        ? 'Requesting camera access...'
+        : state.feedbackMessage;
+    setFeedbackState(feedback, state.phase === 'starting'
+        ? 'neutral'
+        : state.feedbackTone);
+    captureButton.style.display = state.phase === 'live' && state.mode === 'manual'
+        ? 'inline-flex'
+        : 'none';
+    captureButton.disabled = !(state.phase === 'live' && state.mode === 'manual');
+    actions.replaceChildren(cancelButton, captureButton);
 }
 function createActionButton(label, variant) {
     const button = document.createElement('button');
@@ -565,52 +448,5 @@ function setFeedbackState(element, state) {
 function applyStyles(element, styles) {
     Object.assign(element.style, styles);
 }
-function describeCameraError(error) {
-    if (error instanceof DOMException) {
-        switch (error.name) {
-            case 'NotAllowedError':
-            case 'SecurityError':
-                return 'Camera access was denied. Allow camera access and try again.';
-            case 'NotFoundError':
-                return 'No camera was found on this device.';
-            case 'NotReadableError':
-                return 'The camera is already in use by another application.';
-            default:
-                return error.message || 'Failed to access the camera.';
-        }
-    }
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return 'Failed to access the camera.';
-}
-/**
- * Loads a Blob as an HTMLImageElement for face detection analysis.
- */
-export function blobToImage(blob) {
-    return new Promise((resolve, reject) => {
-        const url = URL.createObjectURL(blob);
-        const img = new Image();
-        img.onload = () => {
-            URL.revokeObjectURL(url);
-            resolve(img);
-        };
-        img.onerror = () => {
-            URL.revokeObjectURL(url);
-            reject(new Error('Failed to load captured image'));
-        };
-        img.src = url;
-    });
-}
-/**
- * Creates a data URL from a Blob for display in an <img> tag.
- */
-export function blobToDataURL(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = () => reject(new Error('Failed to read image'));
-        reader.readAsDataURL(blob);
-    });
-}
+export { blobToImage, blobToDataURL };
 //# sourceMappingURL=camera.js.map