@arfuhad/react-native-smart-camera 0.1.2 → 0.1.5

package/android/build.gradle

@@ -1,18 +1,10 @@
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
-apply plugin: 'maven-publish'
 
-group = 'expo.modules.smartcamera'
-version = '0.1.2'
+group = 'com.smartcamera'
+version = '0.1.4'
 
 buildscript {
-    def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-    if (expoModulesCorePlugin.exists()) {
-        apply from: expoModulesCorePlugin
-        applyKotlinExpoModulesCorePlugin()
-    }
-
-    // Simple fallback that allows building without expo-modules-core for lint
     repositories {
         mavenCentral()
         google()
@@ -23,23 +15,8 @@ buildscript {
     }
 }
 
-afterEvaluate {
-    publishing {
-        publications {
-            release(MavenPublication) {
-                from components.release
-            }
-        }
-        repositories {
-            maven {
-                url = mavenLocal().url
-            }
-        }
-    }
-}
-
 android {
-    namespace "expo.modules.smartcamera"
+    namespace "com.smartcamera"
     compileSdkVersion safeExtGet("compileSdkVersion", 34)
 
     defaultConfig {
@@ -47,12 +24,6 @@ android {
         targetSdkVersion safeExtGet("targetSdkVersion", 34)
     }
 
-    publishing {
-        singleVariant("release") {
-            withSourcesJar()
-        }
-    }
-
     lintOptions {
         abortOnError false
     }
@@ -65,6 +36,12 @@ android {
     kotlinOptions {
         jvmTarget = JavaVersion.VERSION_17.majorVersion
     }
+    
+    sourceSets {
+        main {
+            java.srcDirs = ['src/main/java']
+        }
+    }
 }
 
 repositories {
@@ -73,7 +50,6 @@ repositories {
 }
 
 dependencies {
-    implementation project(':expo-modules-core')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.22"
     
     // Kotlin Coroutines
@@ -83,12 +59,11 @@ dependencies {
     // Google ML Kit Face Detection
     implementation 'com.google.mlkit:face-detection:16.1.6'
     
-    // CameraX dependencies
-    def camerax_version = "1.3.0"
-    implementation "androidx.camera:camera-core:$camerax_version"
-    implementation "androidx.camera:camera-camera2:$camerax_version"
-    implementation "androidx.camera:camera-lifecycle:$camerax_version"
-    implementation "androidx.camera:camera-view:$camerax_version"
+    // VisionCamera Frame Processor API (compileOnly - provided by peer dependency)
+    compileOnly project(':react-native-vision-camera')
+    
+    // React Native
+    compileOnly "com.facebook.react:react-android:+"
 }
 
 def safeExtGet(prop, fallback) {

package/android/src/main/java/com/smartcamera/FaceDetectorFrameProcessorPlugin.kt

@@ -0,0 +1,324 @@
+package com.smartcamera
+
+import android.util.Log
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.face.Face
+import com.google.mlkit.vision.face.FaceContour
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetector
+import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.google.mlkit.vision.face.FaceLandmark
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+
+// Data class to track current options for comparison
+private data class DetectorConfig(
+    val performanceMode: String,
+    val landmarkMode: String,
+    val contourMode: String,
+    val classificationMode: String,
+    val minFaceSize: Float,
+    val trackingEnabled: Boolean,
+    val autoMode: Boolean,
+    val windowWidth: Float,
+    val windowHeight: Float,
+    val cameraFacing: String
+)
+
+class FaceDetectorFrameProcessorPlugin(proxy: VisionCameraProxy, options: Map<String, Any>?) : FrameProcessorPlugin() {
+    
+    companion object {
+        private const val TAG = "FaceDetectorPlugin"
+    }
+    
+    private var faceDetector: FaceDetector? = null
+    private var currentConfig: DetectorConfig? = null
+    
+    init {
+        Log.d(TAG, "FaceDetectorFrameProcessorPlugin initialized")
+        updateDetectorOptions(options ?: emptyMap())
+    }
+    
+    private fun updateDetectorOptions(options: Map<String, Any>) {
+        val performanceMode = options["performanceMode"] as? String ?: "fast"
+        val landmarkMode = options["landmarkMode"] as? String ?: "none"
+        val contourMode = options["contourMode"] as? String ?: "none"
+        val classificationMode = options["classificationMode"] as? String ?: "none"
+        val minFaceSize = (options["minFaceSize"] as? Number)?.toFloat() ?: 0.15f
+        val trackingEnabled = options["trackingEnabled"] as? Boolean ?: false
+        val autoMode = options["autoMode"] as? Boolean ?: false
+        val windowWidth = (options["windowWidth"] as? Number)?.toFloat() ?: 1.0f
+        val windowHeight = (options["windowHeight"] as? Number)?.toFloat() ?: 1.0f
+        val cameraFacing = options["cameraFacing"] as? String ?: "front"
+        
+        val newConfig = DetectorConfig(
+            performanceMode = performanceMode,
+            landmarkMode = landmarkMode,
+            contourMode = contourMode,
+            classificationMode = classificationMode,
+            minFaceSize = minFaceSize,
+            trackingEnabled = trackingEnabled,
+            autoMode = autoMode,
+            windowWidth = windowWidth,
+            windowHeight = windowHeight,
+            cameraFacing = cameraFacing
+        )
+        
+        // Only recreate detector if core options changed
+        if (currentConfig != null &&
+            currentConfig!!.performanceMode == newConfig.performanceMode &&
+            currentConfig!!.landmarkMode == newConfig.landmarkMode &&
+            currentConfig!!.contourMode == newConfig.contourMode &&
+            currentConfig!!.classificationMode == newConfig.classificationMode &&
+            currentConfig!!.minFaceSize == newConfig.minFaceSize &&
+            currentConfig!!.trackingEnabled == newConfig.trackingEnabled) {
+            // Only update non-detector options
+            currentConfig = newConfig
+            return
+        }
+        
+        val optionsBuilder = FaceDetectorOptions.Builder()
+        
+        when (performanceMode) {
+            "accurate" -> optionsBuilder.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+            else -> optionsBuilder.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
+        }
+        
+        when (landmarkMode) {
+            "all" -> optionsBuilder.setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
+            else -> optionsBuilder.setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+        }
+        
+        when (contourMode) {
+            "all" -> optionsBuilder.setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
+            else -> optionsBuilder.setContourMode(FaceDetectorOptions.CONTOUR_MODE_NONE)
+        }
+        
+        when (classificationMode) {
+            "all" -> optionsBuilder.setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
+            else -> optionsBuilder.setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
+        }
+        
+        optionsBuilder.setMinFaceSize(minFaceSize)
+        
+        if (trackingEnabled) {
+            optionsBuilder.enableTracking()
+        }
+        
+        faceDetector?.close()
+        faceDetector = FaceDetection.getClient(optionsBuilder.build())
+        currentConfig = newConfig
+        Log.d(TAG, "Face detector updated with new options")
+    }
+    
+    override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
+        if (arguments != null && arguments.isNotEmpty()) {
+            updateDetectorOptions(arguments)
+        }
+        
+        val detector = faceDetector ?: run {
+            Log.e(TAG, "Face detector not initialized")
+            return emptyList<Map<String, Any>>()
+        }
+        
+        val config = currentConfig ?: return emptyList<Map<String, Any>>()
+        
+        try {
+            val mediaImage = frame.image
+            val inputImage = InputImage.fromMediaImage(
+                mediaImage,
+                frame.orientation.toDegrees()
+            )
+            
+            val faces = Tasks.await(detector.process(inputImage))
+            
+            return faces.map { face -> 
+                faceToMap(
+                    face, 
+                    frame.width, 
+                    frame.height,
+                    config.autoMode,
+                    config.windowWidth,
+                    config.windowHeight,
+                    config.cameraFacing
+                ) 
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Face detection error: ${e.message}")
+            return emptyList<Map<String, Any>>()
+        }
+    }
+    
+    private fun faceToMap(
+        face: Face, 
+        frameWidth: Int, 
+        frameHeight: Int,
+        autoMode: Boolean,
+        windowWidth: Float,
+        windowHeight: Float,
+        cameraFacing: String
+    ): Map<String, Any> {
+        val result = mutableMapOf<String, Any>()
+        
+        // Calculate scale factors for autoMode
+        val scaleX = if (autoMode) windowWidth / frameWidth else 1.0f / frameWidth
+        val scaleY = if (autoMode) windowHeight / frameHeight else 1.0f / frameHeight
+        val mirrorX = autoMode && cameraFacing == "front"
+        
+        // Bounding box
+        val bounds = face.boundingBox
+        val x = if (mirrorX) {
+            windowWidth - (bounds.right * scaleX)
+        } else {
+            bounds.left * scaleX
+        }
+        
+        result["bounds"] = mapOf(
+            "x" to x.toDouble(),
+            "y" to (bounds.top * scaleY).toDouble(),
+            "width" to (bounds.width() * scaleX).toDouble(),
+            "height" to (bounds.height() * scaleY).toDouble()
+        )
+        
+        // Roll, pitch, yaw angles
+        result["rollAngle"] = face.headEulerAngleZ.toDouble()
+        result["pitchAngle"] = face.headEulerAngleX.toDouble()
+        result["yawAngle"] = face.headEulerAngleY.toDouble()
+        
+        // Classification probabilities
+        face.smilingProbability?.let { result["smilingProbability"] = it.toDouble() }
+        face.leftEyeOpenProbability?.let { result["leftEyeOpenProbability"] = it.toDouble() }
+        face.rightEyeOpenProbability?.let { result["rightEyeOpenProbability"] = it.toDouble() }
+        
+        // Tracking ID
+        face.trackingId?.let { result["trackingId"] = it }
+        
+        // Landmarks
+        val landmarks = mutableMapOf<String, Any>()
+        
+        face.getLandmark(FaceLandmark.LEFT_EYE)?.let {
+            landmarks["leftEye"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.RIGHT_EYE)?.let {
+            landmarks["rightEye"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.NOSE_BASE)?.let {
+            landmarks["noseBase"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.LEFT_CHEEK)?.let {
+            landmarks["leftCheek"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.RIGHT_CHEEK)?.let {
+            landmarks["rightCheek"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.MOUTH_LEFT)?.let {
+            landmarks["mouthLeft"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.MOUTH_RIGHT)?.let {
+            landmarks["mouthRight"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.MOUTH_BOTTOM)?.let {
+            landmarks["mouthBottom"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.LEFT_EAR)?.let {
+            landmarks["leftEar"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        face.getLandmark(FaceLandmark.RIGHT_EAR)?.let {
+            landmarks["rightEar"] = pointToMap(it.position.x, it.position.y, scaleX, scaleY, mirrorX, windowWidth)
+        }
+        
+        if (landmarks.isNotEmpty()) {
+            result["landmarks"] = landmarks
+        }
+        
+        // All contours (like reference package)
+        val contours = mutableMapOf<String, Any>()
+        
+        face.getContour(FaceContour.FACE)?.let { contour ->
+            contours["face"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.LEFT_EYEBROW_TOP)?.let { contour ->
+            contours["leftEyebrowTop"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.LEFT_EYEBROW_BOTTOM)?.let { contour ->
+            contours["leftEyebrowBottom"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.RIGHT_EYEBROW_TOP)?.let { contour ->
+            contours["rightEyebrowTop"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.RIGHT_EYEBROW_BOTTOM)?.let { contour ->
+            contours["rightEyebrowBottom"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.LEFT_EYE)?.let { contour ->
+            contours["leftEye"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.RIGHT_EYE)?.let { contour ->
+            contours["rightEye"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.UPPER_LIP_TOP)?.let { contour ->
+            contours["upperLipTop"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.UPPER_LIP_BOTTOM)?.let { contour ->
+            contours["upperLipBottom"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.LOWER_LIP_TOP)?.let { contour ->
+            contours["lowerLipTop"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.LOWER_LIP_BOTTOM)?.let { contour ->
+            contours["lowerLipBottom"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.NOSE_BRIDGE)?.let { contour ->
+            contours["noseBridge"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.NOSE_BOTTOM)?.let { contour ->
+            contours["noseBottom"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.LEFT_CHEEK)?.let { contour ->
+            contours["leftCheek"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        face.getContour(FaceContour.RIGHT_CHEEK)?.let { contour ->
+            contours["rightCheek"] = contour.points.map { p -> pointToMap(p.x, p.y, scaleX, scaleY, mirrorX, windowWidth) }
+        }
+        
+        if (contours.isNotEmpty()) {
+            result["contours"] = contours
+        }
+        
+        return result
+    }
+    
+    private fun pointToMap(
+        x: Float, 
+        y: Float, 
+        scaleX: Float, 
+        scaleY: Float,
+        mirrorX: Boolean,
+        windowWidth: Float
+    ): Map<String, Double> {
+        val scaledX = if (mirrorX) {
+            windowWidth - (x * scaleX)
+        } else {
+            x * scaleX
+        }
+        return mapOf(
+            "x" to scaledX.toDouble(),
+            "y" to (y * scaleY).toDouble()
+        )
+    }
+    
+    private fun com.mrousavy.camera.core.types.Orientation.toDegrees(): Int {
+        return when (this) {
+            com.mrousavy.camera.core.types.Orientation.PORTRAIT -> 0
+            com.mrousavy.camera.core.types.Orientation.LANDSCAPE_LEFT -> 90
+            com.mrousavy.camera.core.types.Orientation.PORTRAIT_UPSIDE_DOWN -> 180
+            com.mrousavy.camera.core.types.Orientation.LANDSCAPE_RIGHT -> 270
+        }
+    }
+    
+    protected fun finalize() {
+        faceDetector?.close()
+    }
+}
+

package/android/src/main/java/com/smartcamera/SmartCameraPackage.kt

@@ -0,0 +1,28 @@
+package com.smartcamera
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.mrousavy.camera.frameprocessors.FrameProcessorPluginRegistry
+
+class SmartCameraPackage : ReactPackage {
+    
+    companion object {
+        init {
+            // Register the frame processor plugin with VisionCamera
+            FrameProcessorPluginRegistry.addFrameProcessorPlugin("detectFaces") { proxy, options ->
+                FaceDetectorFrameProcessorPlugin(proxy, options)
+            }
+        }
+    }
+    
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
+

package/build/detection/blinkProcessor.js

@@ -18,6 +18,7 @@ const blinkStates = new Map();
  */
 export function processBlinkFromFaces(faces, lastBlinkTimestamp, debounceMs = 300) {
     'worklet';
+    var _a;
     if (faces.length === 0) {
         return null;
     }
@@ -32,7 +33,7 @@ export function processBlinkFromFaces(faces, lastBlinkTimestamp, debounceMs = 30
     const rightEyeOpen = face.rightEyeOpenProbability;
     const now = Date.now();
     // Get or create blink state for this face
-    const faceId = face.trackingId ?? 0;
+    const faceId = (_a = face.trackingId) !== null && _a !== void 0 ? _a : 0;
     let state = blinkStates.get(faceId);
     if (!state) {
         state = {

package/build/detection/blinkProcessor.js.map

@@ -1 +1 @@
-{"version":3,"file":"blinkProcessor.js","sourceRoot":"","sources":["../../src/detection/blinkProcessor.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAEjC;;GAEG;AACH,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAU/B,0CAA0C;AAC1C,MAAM,WAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAa,EACb,kBAA0B,EAC1B,aAAqB,GAAG;IAExB,SAAS,CAAC;IAEV,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sCAAsC;IACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAEtB,yCAAyC;IACzC,IACE,IAAI,CAAC,sBAAsB,KAAK,SAAS;QACzC,IAAI,CAAC,uBAAuB,KAAK,SAAS,EAC1C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,sBAAsB,CAAC;IAChD,MAAM,YAAY,GAAG,IAAI,CAAC,uBAAuB,CAAC;IAClD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEvB,0CAA0C;IAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC;IACpC,IAAI,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEpC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG;YACN,aAAa,EAAE,KAAK;YACpB,kBAAkB,EAAE,CAAC;SACtB,CAAC;QACF,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,qCAAqC;IACrC,MAAM,UAAU,GAAG,WAAW,GAAG,oBAAoB,IAAI,YAAY,GAAG,oBAAoB,CAAC;IAE7F,mCAAmC;IACnC,MAAM,QAAQ,GAAG,WAAW,GAAG,kBAAkB,IAAI,YAAY,GAAG,kBAAkB,CAAC;IAEvF,+CAA+C;IAC/C,MAAM,OAAO,GAAG,KAAK,CAAC,aAAa,IAAI,QAAQ,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,kBAAkB,CAAC,GAAG,UAAU,CAAC;IAEjG,eAAe;IACf,IAAI,UAAU,EAAE,CAAC;QACf,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC;IAC7B,CAAC;SAAM,IAAI,QAAQ,EAAE,CAAC;QACpB,KAAK,CAAC,aAAa,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED,IAAI,OAAO,EAAE,CAAC;QACZ,KAAK,CAAC,kBAAkB,GAAG,GAAG,CAAC;QAE/B,OAAO;YACL,SAAS,EAAE,GAAG;YACd,WAAW;YACX,YAAY;YACZ,OAAO,EAAE,IAAI;YACb,MAAM,EAAE,IAAI,CAAC,UAAU;SACxB,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,WAAW,CAAC,KAAK,EAAE,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,IAAU;IACpC,SAAS,CAAC;IAEV,IACE,IAAI,CAAC,sBAAsB,KAAK,SAAS;QACzC,IAAI,CAAC,uBAAuB,KAAK,SAAS,EAC1C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,sBAAsB;QACrC,SAAS,EAAE,IAAI,CAAC,uBAAuB;KACxC,CAAC;AACJ,CAAC","sourcesContent":["import type { Face, BlinkEvent } from '../types';\n\n/**\n * Threshold for considering an eye as closed\n */\nconst EYE_CLOSED_THRESHOLD = 0.4;\n\n/**\n * Threshold for considering an eye as open\n */\nconst EYE_OPEN_THRESHOLD = 0.6;\n\n/**\n * State for tracking blink across frames\n */\ninterface BlinkState {\n  wasEyesClosed: boolean;\n  lastBlinkTimestamp: number;\n}\n\n// Global blink state per face tracking ID\nconst blinkStates = new Map<number, BlinkState>();\n\n/**\n * Process faces to detect blinks\n * \n * @param faces - Array of detected faces\n * @param lastBlinkTimestamp - Timestamp of the last detected blink\n * @param debounceMs - Minimum time between blinks in milliseconds\n * @returns BlinkEvent if a blink was detected, null otherwise\n */\nexport function processBlinkFromFaces(\n  faces: Face[],\n  lastBlinkTimestamp: number,\n  debounceMs: number = 300\n): BlinkEvent | null {\n  'worklet';\n\n  if (faces.length === 0) {\n    return null;\n  }\n\n  // Use the first face (most prominent)\n  const face = faces[0];\n\n  // Ensure we have eye classification data\n  if (\n    face.leftEyeOpenProbability === undefined ||\n    face.rightEyeOpenProbability === undefined\n  ) {\n    return null;\n  }\n\n  const leftEyeOpen = face.leftEyeOpenProbability;\n  const rightEyeOpen = face.rightEyeOpenProbability;\n  const now = Date.now();\n\n  // Get or create blink state for this face\n  const faceId = face.trackingId ?? 0;\n  let state = blinkStates.get(faceId);\n\n  if (!state) {\n    state = {\n      wasEyesClosed: false,\n      lastBlinkTimestamp: 0,\n    };\n    blinkStates.set(faceId, state);\n  }\n\n  // Check if eyes are currently closed\n  const eyesClosed = leftEyeOpen < EYE_CLOSED_THRESHOLD && rightEyeOpen < EYE_CLOSED_THRESHOLD;\n\n  // Check if eyes are currently open\n  const eyesOpen = leftEyeOpen > EYE_OPEN_THRESHOLD && rightEyeOpen > EYE_OPEN_THRESHOLD;\n\n  // Detect blink: transition from closed to open\n  const isBlink = state.wasEyesClosed && eyesOpen && (now - state.lastBlinkTimestamp) > debounceMs;\n\n  // Update state\n  if (eyesClosed) {\n    state.wasEyesClosed = true;\n  } else if (eyesOpen) {\n    state.wasEyesClosed = false;\n  }\n\n  if (isBlink) {\n    state.lastBlinkTimestamp = now;\n\n    return {\n      timestamp: now,\n      leftEyeOpen,\n      rightEyeOpen,\n      isBlink: true,\n      faceId: face.trackingId,\n    };\n  }\n\n  return null;\n}\n\n/**\n * Reset blink state for all faces\n */\nexport function resetBlinkStates(): void {\n  blinkStates.clear();\n}\n\n/**\n * Get current eye state without blink detection\n * Useful for real-time eye tracking UI\n */\nexport function getEyeState(face: Face): { leftOpen: number; rightOpen: number } | null {\n  'worklet';\n\n  if (\n    face.leftEyeOpenProbability === undefined ||\n    face.rightEyeOpenProbability === undefined\n  ) {\n    return null;\n  }\n\n  return {\n    leftOpen: face.leftEyeOpenProbability,\n    rightOpen: face.rightEyeOpenProbability,\n  };\n}\n\n"]}
+{"version":3,"file":"blinkProcessor.js","sourceRoot":"","sources":["../../src/detection/blinkProcessor.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAEjC;;GAEG;AACH,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAU/B,0CAA0C;AAC1C,MAAM,WAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAa,EACb,kBAA0B,EAC1B,aAAqB,GAAG;IAExB,SAAS,CAAC;;IAEV,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sCAAsC;IACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAEtB,yCAAyC;IACzC,IACE,IAAI,CAAC,sBAAsB,KAAK,SAAS;QACzC,IAAI,CAAC,uBAAuB,KAAK,SAAS,EAC1C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,sBAAsB,CAAC;IAChD,MAAM,YAAY,GAAG,IAAI,CAAC,uBAAuB,CAAC;IAClD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEvB,0CAA0C;IAC1C,MAAM,MAAM,GAAG,MAAA,IAAI,CAAC,UAAU,mCAAI,CAAC,CAAC;IACpC,IAAI,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEpC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG;YACN,aAAa,EAAE,KAAK;YACpB,kBAAkB,EAAE,CAAC;SACtB,CAAC;QACF,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,qCAAqC;IACrC,MAAM,UAAU,GAAG,WAAW,GAAG,oBAAoB,IAAI,YAAY,GAAG,oBAAoB,CAAC;IAE7F,mCAAmC;IACnC,MAAM,QAAQ,GAAG,WAAW,GAAG,kBAAkB,IAAI,YAAY,GAAG,kBAAkB,CAAC;IAEvF,+CAA+C;IAC/C,MAAM,OAAO,GAAG,KAAK,CAAC,aAAa,IAAI,QAAQ,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,kBAAkB,CAAC,GAAG,UAAU,CAAC;IAEjG,eAAe;IACf,IAAI,UAAU,EAAE,CAAC;QACf,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC;IAC7B,CAAC;SAAM,IAAI,QAAQ,EAAE,CAAC;QACpB,KAAK,CAAC,aAAa,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED,IAAI,OAAO,EAAE,CAAC;QACZ,KAAK,CAAC,kBAAkB,GAAG,GAAG,CAAC;QAE/B,OAAO;YACL,SAAS,EAAE,GAAG;YACd,WAAW;YACX,YAAY;YACZ,OAAO,EAAE,IAAI;YACb,MAAM,EAAE,IAAI,CAAC,UAAU;SACxB,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,WAAW,CAAC,KAAK,EAAE,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,IAAU;IACpC,SAAS,CAAC;IAEV,IACE,IAAI,CAAC,sBAAsB,KAAK,SAAS;QACzC,IAAI,CAAC,uBAAuB,KAAK,SAAS,EAC1C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,sBAAsB;QACrC,SAAS,EAAE,IAAI,CAAC,uBAAuB;KACxC,CAAC;AACJ,CAAC"}

package/build/detection/faceDetector.d.ts

@@ -1,4 +1,4 @@
-import type { Frame } from 'react-native-vision-camera';
+import { type Frame } from 'react-native-vision-camera';
 import type { Face, FrameProcessorOptions } from '../types';
 /**
  * Detect faces in a camera frame
@@ -9,8 +9,8 @@ import type { Face, FrameProcessorOptions } from '../types';
  */
 export declare function detectFaces(frame: Frame, options?: Partial<FrameProcessorOptions>): Face[];
 /**
- * Register the face detection frame processor plugin
- * This is called during module initialization
+ * Check if the face detector plugin is available
+ * @returns true if the plugin is registered and available
  */
-export declare function registerFaceDetectorPlugin(): void;
+export declare function isFaceDetectorAvailable(): boolean;
 //# sourceMappingURL=faceDetector.d.ts.map

package/build/detection/faceDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"faceDetector.d.ts","sourceRoot":"","sources":["../../src/detection/faceDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAwB5D;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,IAAI,EAAE,CAc1F;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAIjD"}
+{"version":3,"file":"faceDetector.d.ts","sourceRoot":"","sources":["../../src/detection/faceDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAAE,IAAI,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAwB5D;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,IAAI,EAAE,CAmC1F;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD"}

package/build/detection/faceDetector.js

@@ -1,3 +1,9 @@
+import { VisionCameraProxy } from 'react-native-vision-camera';
+/**
+ * Initialize the face detector frame processor plugin
+ * This registers the native plugin with VisionCamera
+ */
+const plugin = VisionCameraProxy.initFrameProcessorPlugin('detectFaces', {});
 /**
  * Default face detection options
  */
@@ -22,12 +28,28 @@ const DEFAULT_OPTIONS = {
  */
 export function detectFaces(frame, options) {
     'worklet';
-    const mergedOptions = {
-        ...DEFAULT_OPTIONS,
-        ...options,
-    };
+    if (plugin == null) {
+        // Plugin not available - return empty array
+        // This can happen if the native module is not properly linked
+        return [];
+    }
+    const mergedOptions = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
     try {
-        return __detectFaces(frame, mergedOptions);
+        // Convert options to a format compatible with VisionCamera plugin API
+        const pluginOptions = {
+            performanceMode: mergedOptions.performanceMode,
+            landmarkMode: mergedOptions.landmarkMode,
+            contourMode: mergedOptions.contourMode,
+            classificationMode: mergedOptions.classificationMode,
+            minFaceSize: mergedOptions.minFaceSize,
+            trackingEnabled: mergedOptions.trackingEnabled,
+            cameraFacing: mergedOptions.cameraFacing,
+            autoMode: mergedOptions.autoMode,
+            windowWidth: mergedOptions.windowWidth,
+            windowHeight: mergedOptions.windowHeight,
+        };
+        const result = plugin.call(frame, pluginOptions);
+        return result !== null && result !== void 0 ? result : [];
     }
     catch (error) {
         // Return empty array on error in worklet context
@@ -35,12 +57,10 @@ export function detectFaces(frame, options) {
     }
 }
 /**
- * Register the face detection frame processor plugin
- * This is called during module initialization
+ * Check if the face detector plugin is available
+ * @returns true if the plugin is registered and available
  */
-export function registerFaceDetectorPlugin() {
-    // The native plugin registration happens automatically
-    // through the Expo module system
-    console.log('[SmartCamera] Face detector plugin registered');
+export function isFaceDetectorAvailable() {
+    return plugin != null;
 }
 //# sourceMappingURL=faceDetector.js.map

package/build/detection/faceDetector.js.map

@@ -1 +1 @@
-{"version":3,"file":"faceDetector.js","sourceRoot":"","sources":["../../src/detection/faceDetector.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,MAAM,eAAe,GAA0B;IAC7C,eAAe,EAAE,MAAM;IACvB,YAAY,EAAE,MAAM;IACpB,WAAW,EAAE,MAAM;IACnB,kBAAkB,EAAE,MAAM;IAC1B,WAAW,EAAE,IAAI;IACjB,eAAe,EAAE,KAAK;IACtB,YAAY,EAAE,OAAO;IACrB,QAAQ,EAAE,KAAK;IACf,WAAW,EAAE,GAAG;IAChB,YAAY,EAAE,GAAG;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,KAAY,EAAE,OAAwC;IAChF,SAAS,CAAC;IAEV,MAAM,aAAa,GAA0B;QAC3C,GAAG,eAAe;QAClB,GAAG,OAAO;KACX,CAAC;IAEF,IAAI,CAAC;QACH,OAAO,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IAC7C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,iDAAiD;QACjD,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B;IACxC,uDAAuD;IACvD,iCAAiC;IACjC,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;AAC/D,CAAC","sourcesContent":["import type { Frame } from 'react-native-vision-camera';\nimport type { Face, FrameProcessorOptions } from '../types';\n\n/**\n * Native face detection function placeholder\n * This will be implemented as a VisionCamera frame processor plugin\n */\ndeclare function __detectFaces(frame: Frame, options: FrameProcessorOptions): Face[];\n\n/**\n * Default face detection options\n */\nconst DEFAULT_OPTIONS: FrameProcessorOptions = {\n  performanceMode: 'fast',\n  landmarkMode: 'none',\n  contourMode: 'none',\n  classificationMode: 'none',\n  minFaceSize: 0.15,\n  trackingEnabled: false,\n  cameraFacing: 'front',\n  autoMode: false,\n  windowWidth: 1.0,\n  windowHeight: 1.0,\n};\n\n/**\n * Detect faces in a camera frame\n * \n * @param frame - The camera frame from VisionCamera\n * @param options - Face detection options\n * @returns Array of detected faces\n */\nexport function detectFaces(frame: Frame, options?: Partial<FrameProcessorOptions>): Face[] {\n  'worklet';\n\n  const mergedOptions: FrameProcessorOptions = {\n    ...DEFAULT_OPTIONS,\n    ...options,\n  };\n\n  try {\n    return __detectFaces(frame, mergedOptions);\n  } catch (error) {\n    // Return empty array on error in worklet context\n    return [];\n  }\n}\n\n/**\n * Register the face detection frame processor plugin\n * This is called during module initialization\n */\nexport function registerFaceDetectorPlugin(): void {\n  // The native plugin registration happens automatically\n  // through the Expo module system\n  console.log('[SmartCamera] Face detector plugin registered');\n}\n\n"]}
+{"version":3,"file":"faceDetector.js","sourceRoot":"","sources":["../../src/detection/faceDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAc,MAAM,4BAA4B,CAAC;AAG3E;;;GAGG;AACH,MAAM,MAAM,GAAG,iBAAiB,CAAC,wBAAwB,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;AAE7E;;GAEG;AACH,MAAM,eAAe,GAA0B;IAC7C,eAAe,EAAE,MAAM;IACvB,YAAY,EAAE,MAAM;IACpB,WAAW,EAAE,MAAM;IACnB,kBAAkB,EAAE,MAAM;IAC1B,WAAW,EAAE,IAAI;IACjB,eAAe,EAAE,KAAK;IACtB,YAAY,EAAE,OAAO;IACrB,QAAQ,EAAE,KAAK;IACf,WAAW,EAAE,GAAG;IAChB,YAAY,EAAE,GAAG;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,KAAY,EAAE,OAAwC;IAChF,SAAS,CAAC;IAEV,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;QACnB,4CAA4C;QAC5C,8DAA8D;QAC9D,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,aAAa,mCACd,eAAe,GACf,OAAO,CACX,CAAC;IAEF,IAAI,CAAC;QACH,sEAAsE;QACtE,MAAM,aAAa,GAA0D;YAC3E,eAAe,EAAE,aAAa,CAAC,eAAe;YAC9C,YAAY,EAAE,aAAa,CAAC,YAAY;YACxC,WAAW,EAAE,aAAa,CAAC,WAAW;YACtC,kBAAkB,EAAE,aAAa,CAAC,kBAAkB;YACpD,WAAW,EAAE,aAAa,CAAC,WAAW;YACtC,eAAe,EAAE,aAAa,CAAC,eAAe;YAC9C,YAAY,EAAE,aAAa,CAAC,YAAY;YACxC,QAAQ,EAAE,aAAa,CAAC,QAAQ;YAChC,WAAW,EAAE,aAAa,CAAC,WAAW;YACtC,YAAY,EAAE,aAAa,CAAC,YAAY;SACzC,CAAC;QAEF,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,CAA8B,CAAC;QAC9E,OAAO,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAC;IACtB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,iDAAiD;QACjD,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,MAAM,IAAI,IAAI,CAAC;AACxB,CAAC"}

package/build/detection/index.d.ts

@@ -1,4 +1,4 @@
-export { detectFaces, registerFaceDetectorPlugin } from './faceDetector';
+export { detectFaces, isFaceDetectorAvailable } from './faceDetector';
 export { processBlinkFromFaces, resetBlinkStates, getEyeState } from './blinkProcessor';
 export { detectFacesInImage } from './staticImageDetector';
 //# sourceMappingURL=index.d.ts.map

package/build/detection/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/build/detection/index.js

@@ -1,4 +1,4 @@
-export { detectFaces, registerFaceDetectorPlugin } from './faceDetector';
+export { detectFaces, isFaceDetectorAvailable } from './faceDetector';
 export { processBlinkFromFaces, resetBlinkStates, getEyeState } from './blinkProcessor';
 export { detectFacesInImage } from './staticImageDetector';
 //# sourceMappingURL=index.js.map

package/build/detection/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/detection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC","sourcesContent":["export { detectFaces, registerFaceDetectorPlugin } from './faceDetector';\nexport { processBlinkFromFaces, resetBlinkStates, getEyeState } from './blinkProcessor';\nexport { detectFacesInImage } from './staticImageDetector';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/detection/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/build/detection/staticImageDetector.d.ts

@@ -2,23 +2,23 @@ import type { Face, StaticImageOptions } from '../types';
 /**
  * Detect faces in a static image
  *
+ * NOTE: Static image detection is currently not supported in the frame processor-only version.
+ * This feature requires native module implementation.
+ * For real-time face detection, use the `detectFaces` function with VisionCamera frame processor.
+ *
  * @param options - Image source and detection options
  * @returns Promise resolving to array of detected faces
  *
  * @example
  * ```tsx
- * // Using require
- * const faces = await detectFacesInImage({
- *   image: require('./photo.jpg'),
- *   performanceMode: 'accurate',
- *   landmarkMode: 'all',
- * });
+ * // This feature is not yet implemented
+ * // For real-time detection, use:
+ * import { detectFaces } from '@arfuhad/react-native-smart-camera';
  *
- * // Using URI
- * const faces = await detectFacesInImage({
- *   image: { uri: 'https://example.com/photo.jpg' },
- *   classificationMode: 'all',
- * });
+ * const frameProcessor = useFrameProcessor((frame) => {
+ *   'worklet';
+ *   const faces = detectFaces(frame);
+ * }, []);
  * ```
  */
 export declare function detectFacesInImage(options: StaticImageOptions): Promise<Face[]>;

package/build/detection/staticImageDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staticImageDetector.d.ts","sourceRoot":"","sources":["../../src/detection/staticImageDetector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAczD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAYrF"}
+{"version":3,"file":"staticImageDetector.d.ts","sourceRoot":"","sources":["../../src/detection/staticImageDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAczD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAgBrF"}