@trustchex/react-native-sdk 1.381.0 → 1.464.0

package/android/src/main/java/com/trustchex/reactnativesdk/TrustchexSDKModule.kt

@@ -17,20 +17,14 @@ class TrustchexSDKModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   override fun enableKeepAwake() {
     UiThreadUtil.runOnUiThread {
-      val activity = currentActivity
-      activity?.runOnUiThread {
-        activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-      }
+      currentActivity?.window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
     }
   }
 
   @ReactMethod
   override fun disableKeepAwake() {
     UiThreadUtil.runOnUiThread {
-      val activity = currentActivity
-      activity?.runOnUiThread {
-        activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-      }
+      currentActivity?.window?.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
     }
   }
 

package/android/src/main/java/com/trustchex/reactnativesdk/camera/TrustchexCameraView.kt

@@ -8,6 +8,8 @@ import android.graphics.Matrix
 import android.graphics.Rect
 import android.graphics.YuvImage
 import android.util.Base64
+import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraManager
 import android.util.Size
 import android.widget.FrameLayout
 import androidx.annotation.OptIn
@@ -99,19 +101,8 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
         BarcodeScanning.getClient(
             BarcodeScannerOptions.Builder()
                 .setBarcodeFormats(
-                    Barcode.FORMAT_PDF417,
-                    Barcode.FORMAT_QR_CODE,
-                    Barcode.FORMAT_CODABAR,
                     Barcode.FORMAT_CODE_128,
-                    Barcode.FORMAT_CODE_39,
-                    Barcode.FORMAT_CODE_93,
-                    Barcode.FORMAT_EAN_13,
-                    Barcode.FORMAT_EAN_8,
-                    Barcode.FORMAT_ITF,
-                    Barcode.FORMAT_UPC_A,
-                    Barcode.FORMAT_UPC_E,
-                    Barcode.FORMAT_AZTEC,
-                    Barcode.FORMAT_DATA_MATRIX
+                    Barcode.FORMAT_QR_CODE
                 )
                 .build()
         )
@@ -165,7 +156,7 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
 
     private fun selectBestCamera(type: String): CameraSelector {
         if (type == "front") {
-            return CameraSelector.DEFAULT_FRONT_CAMERA
+            return selectWidestFrontCamera()
         }
 
         // For back camera, try to select Ultra Wide camera for document scanning
@@ -192,6 +183,62 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
         return CameraSelector.DEFAULT_BACK_CAMERA
     }
 
+    /**
+     * Select the front camera with the widest field of view.
+     * Many devices (e.g. Pixel 9a, Samsung S24) have multiple front cameras;
+     * the wider lens gives a better framing experience for face detection.
+     */
+    @OptIn(androidx.camera.camera2.interop.ExperimentalCamera2Interop::class)
+    private fun selectWidestFrontCamera(): CameraSelector {
+        try {
+            val provider = cameraProvider ?: return CameraSelector.DEFAULT_FRONT_CAMERA
+            val cameraManager = context.getSystemService(android.content.Context.CAMERA_SERVICE) as? CameraManager
+                ?: return CameraSelector.DEFAULT_FRONT_CAMERA
+
+            val frontCameras = provider.availableCameraInfos.filter { info ->
+                try {
+                    val c2Info = androidx.camera.camera2.interop.Camera2CameraInfo.from(info)
+                    val chars = cameraManager.getCameraCharacteristics(c2Info.cameraId)
+                    chars.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT
+                } catch (_: Exception) { false }
+            }
+
+            if (frontCameras.size <= 1) return CameraSelector.DEFAULT_FRONT_CAMERA
+
+            // Pick the camera with the shortest focal length (widest FoV)
+            var bestInfo: androidx.camera.core.CameraInfo? = null
+            var shortestFocal = Float.MAX_VALUE
+
+            for (info in frontCameras) {
+                try {
+                    val c2Info = androidx.camera.camera2.interop.Camera2CameraInfo.from(info)
+                    val chars = cameraManager.getCameraCharacteristics(c2Info.cameraId)
+                    val focalLengths = chars.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
+                    if (focalLengths != null && focalLengths.isNotEmpty()) {
+                        val minFocal = focalLengths.min()
+                        if (minFocal < shortestFocal) {
+                            shortestFocal = minFocal
+                            bestInfo = info
+                        }
+                    }
+                } catch (_: Exception) { /* skip */ }
+            }
+
+            if (bestInfo != null) {
+                val selectedInfo = bestInfo
+                return CameraSelector.Builder()
+                    .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
+                    .addCameraFilter { cameraInfos ->
+                        cameraInfos.filter { it == selectedInfo }.ifEmpty { cameraInfos }
+                    }
+                    .build()
+            }
+        } catch (_: Exception) {
+            // Fall back to default
+        }
+        return CameraSelector.DEFAULT_FRONT_CAMERA
+    }
+
     fun setTorchEnabled(enabled: Boolean) {
         torchEnabled = enabled
         camera?.cameraControl?.enableTorch(enabled)

package/android/src/main/java/com/trustchex/reactnativesdk/mlkit/MLKitModule.kt

@@ -30,7 +30,7 @@ class MLKitModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaM
     )
     private val barcodeScanner = BarcodeScanning.getClient(
         BarcodeScannerOptions.Builder()
-            .setBarcodeFormats(Barcode.FORMAT_PDF417, Barcode.FORMAT_QR_CODE)
+            .setBarcodeFormats(Barcode.FORMAT_CODE_128, Barcode.FORMAT_QR_CODE)
             .build()
     )
 

package/ios/Camera/TrustchexCameraView.swift

@@ -196,19 +196,8 @@ class TrustchexCameraView: UIView {
             let supportedTypes = metadataOutput.availableMetadataObjectTypes
             var typesToEnable: [AVMetadataObject.ObjectType] = []
 
-            if supportedTypes.contains(.pdf417) { typesToEnable.append(.pdf417) }
-            if supportedTypes.contains(.qr) { typesToEnable.append(.qr) }
             if supportedTypes.contains(.code128) { typesToEnable.append(.code128) }
-            if supportedTypes.contains(.code39) { typesToEnable.append(.code39) }
-            if supportedTypes.contains(.code39Mod43) { typesToEnable.append(.code39Mod43) }
-            if supportedTypes.contains(.code93) { typesToEnable.append(.code93) }
-            if supportedTypes.contains(.ean13) { typesToEnable.append(.ean13) }
-            if supportedTypes.contains(.ean8) { typesToEnable.append(.ean8) }
-            if supportedTypes.contains(.upce) { typesToEnable.append(.upce) }
-            if supportedTypes.contains(.interleaved2of5) { typesToEnable.append(.interleaved2of5) }
-            if supportedTypes.contains(.itf14) { typesToEnable.append(.itf14) }
-            if supportedTypes.contains(.aztec) { typesToEnable.append(.aztec) }
-            if supportedTypes.contains(.dataMatrix) { typesToEnable.append(.dataMatrix) }
+            if supportedTypes.contains(.qr) { typesToEnable.append(.qr) }
 
             metadataOutput.metadataObjectTypes = typesToEnable
         }
@@ -248,7 +237,15 @@ class TrustchexCameraView: UIView {
     // MARK: - Camera Selection
     private func selectBestCamera(for position: AVCaptureDevice.Position) -> AVCaptureDevice? {
         if position == .front {
-            return AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front)
+            // Prefer the widest front camera available for better face framing
+            let discovery = AVCaptureDevice.DiscoverySession(
+                deviceTypes: [.builtInUltraWideCamera, .builtInWideAngleCamera],
+                mediaType: .video,
+                position: .front
+            )
+            // DiscoverySession lists in the order of deviceTypes, so ultra-wide comes first if available
+            return discovery.devices.first
+                ?? AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front)
         }
 
         // For document scanning, prefer wide angle camera for all models

package/ios/MLKit/MLKitModule.swift

@@ -19,7 +19,7 @@ class MLKitModule: NSObject {
         return FaceDetector.faceDetector(options: options)
     }()
     private lazy var barcodeScanner: BarcodeScanner = {
-        let formats: BarcodeFormat = [.PDF417, .qrCode]
+        let formats: BarcodeFormat = [.code128, .qrCode]
         let options = BarcodeScannerOptions(formats: formats)
         return BarcodeScanner.barcodeScanner(options: options)
     }()

package/lib/module/Screens/Debug/BarcodeTestScreen.js

@@ -0,0 +1,308 @@
+"use strict";
+
+import React, { useState, useRef, useCallback } from 'react';
+import { View, StyleSheet, Text, ScrollView, StatusBar, TouchableOpacity } from 'react-native';
+import { SafeAreaView } from 'react-native-safe-area-context';
+import { TrustchexCamera } from "../../Shared/Components/TrustchexCamera.js";
+import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
+
+// ML Kit barcode format constants
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const BARCODE_FORMAT_NAMES = {
+  1: 'Code 128',
+  2: 'Code 39',
+  4: 'Code 93',
+  8: 'Codabar',
+  16: 'Data Matrix',
+  32: 'EAN-13',
+  64: 'EAN-8',
+  128: 'ITF',
+  256: 'QR Code',
+  512: 'UPC-A',
+  1024: 'UPC-E',
+  2048: 'PDF417',
+  4096: 'Aztec'
+};
+function formatName(format) {
+  return BARCODE_FORMAT_NAMES[format] ?? `Format(${format})`;
+}
+const BarcodeTestScreen = () => {
+  useKeepAwake();
+  const cameraRef = useRef(null);
+  const [barcodes, setBarcodes] = useState([]);
+  const [history, setHistory] = useState([]);
+  const [isPaused, setIsPaused] = useState(false);
+  const [cameraLayout, setCameraLayout] = useState({
+    width: 1,
+    height: 1
+  });
+  const [frameSize, setFrameSize] = useState({
+    width: 1080,
+    height: 1920
+  });
+  const handleCameraLayout = useCallback(e => {
+    const {
+      width,
+      height
+    } = e.nativeEvent.layout;
+    setCameraLayout({
+      width,
+      height
+    });
+  }, []);
+  const handleFrame = useCallback(event => {
+    if (isPaused) return;
+    const frame = event.nativeEvent.frame;
+    if (frame.width && frame.height) {
+      setFrameSize({
+        width: frame.width,
+        height: frame.height
+      });
+    }
+    if (frame.barcodes && frame.barcodes.length > 0) {
+      setBarcodes(frame.barcodes);
+      setHistory(prev => {
+        const incoming = frame.barcodes;
+        const next = [...prev];
+        for (const b of incoming) {
+          const alreadyRecent = next.slice(0, 5).some(h => h.rawValue === b.rawValue);
+          if (!alreadyRecent) {
+            next.unshift({
+              rawValue: b.rawValue,
+              displayValue: b.displayValue,
+              format: b.format,
+              timestamp: Date.now()
+            });
+          }
+        }
+        return next.slice(0, 30);
+      });
+    } else {
+      setBarcodes([]);
+    }
+  }, [isPaused]);
+  return /*#__PURE__*/_jsxs(View, {
+    style: styles.container,
+    children: [/*#__PURE__*/_jsx(StatusBar, {
+      barStyle: "light-content",
+      backgroundColor: "transparent",
+      translucent: true
+    }), /*#__PURE__*/_jsxs(View, {
+      style: styles.cameraWrapper,
+      onLayout: handleCameraLayout,
+      children: [/*#__PURE__*/_jsx(TrustchexCamera, {
+        ref: cameraRef,
+        style: StyleSheet.absoluteFill,
+        cameraType: "back",
+        enableFrameProcessing: true,
+        enableFaceDetection: false,
+        enableTextRecognition: false,
+        enableBarcodeScanning: true,
+        includeBase64: false,
+        targetFps: 15,
+        onFrameAvailable: handleFrame
+      }), barcodes.map((b, i) => {
+        const bb = b.boundingBox;
+        if (!bb) return null;
+        const scaleX = cameraLayout.width / frameSize.width;
+        const scaleY = cameraLayout.height / frameSize.height;
+        const left = bb.left * scaleX;
+        const top = bb.top * scaleY;
+        const width = (bb.right - bb.left) * scaleX;
+        const height = (bb.bottom - bb.top) * scaleY;
+        return /*#__PURE__*/_jsx(View, {
+          style: [styles.barcodeBoundingBox, {
+            left,
+            top,
+            width,
+            height
+          }],
+          children: /*#__PURE__*/_jsx(View, {
+            style: styles.barcodeBoxLabel,
+            children: /*#__PURE__*/_jsx(Text, {
+              style: styles.barcodeBoxLabelText,
+              children: formatName(b.format)
+            })
+          })
+        }, i);
+      })]
+    }), /*#__PURE__*/_jsx(SafeAreaView, {
+      style: styles.panel,
+      edges: ['bottom'],
+      children: /*#__PURE__*/_jsx(ScrollView, {
+        style: styles.scrollView,
+        children: /*#__PURE__*/_jsxs(View, {
+          style: styles.panelContent,
+          children: [/*#__PURE__*/_jsx(TouchableOpacity, {
+            style: styles.pauseButton,
+            onPress: () => setIsPaused(!isPaused),
+            children: /*#__PURE__*/_jsx(Text, {
+              style: styles.pauseButtonText,
+              children: isPaused ? 'Resume Processing' : 'Pause Processing'
+            })
+          }), /*#__PURE__*/_jsx(Text, {
+            style: styles.title,
+            children: "Barcode Scanner"
+          }), /*#__PURE__*/_jsx(Text, {
+            style: styles.sectionTitle,
+            children: "Live Detections"
+          }), barcodes.length === 0 ? /*#__PURE__*/_jsx(Text, {
+            style: styles.bodyText,
+            children: "No barcode in frame"
+          }) : barcodes.map((b, i) => /*#__PURE__*/_jsxs(View, {
+            style: styles.barcodeRow,
+            children: [/*#__PURE__*/_jsx(View, {
+              style: styles.formatBadge,
+              children: /*#__PURE__*/_jsx(Text, {
+                style: styles.formatBadgeText,
+                children: formatName(b.format)
+              })
+            }), /*#__PURE__*/_jsx(Text, {
+              style: styles.barcodeValue,
+              children: b.rawValue
+            })]
+          }, i)), /*#__PURE__*/_jsxs(Text, {
+            style: styles.sectionTitle,
+            children: ["History (", history.length, ")"]
+          }), history.length === 0 ? /*#__PURE__*/_jsx(Text, {
+            style: styles.bodyText,
+            children: "No barcodes detected yet"
+          }) : history.map((entry, i) => /*#__PURE__*/_jsxs(View, {
+            style: styles.historyRow,
+            children: [/*#__PURE__*/_jsxs(View, {
+              style: styles.historyMeta,
+              children: [/*#__PURE__*/_jsx(View, {
+                style: styles.formatBadge,
+                children: /*#__PURE__*/_jsx(Text, {
+                  style: styles.formatBadgeText,
+                  children: formatName(entry.format)
+                })
+              }), /*#__PURE__*/_jsx(Text, {
+                style: styles.historyTime,
+                children: new Date(entry.timestamp).toLocaleTimeString()
+              })]
+            }), /*#__PURE__*/_jsx(Text, {
+              style: styles.barcodeValue,
+              children: entry.rawValue
+            })]
+          }, i))]
+        })
+      })
+    })]
+  });
+};
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#000000'
+  },
+  cameraWrapper: {
+    flex: 2,
+    position: 'relative'
+  },
+  barcodeBoundingBox: {
+    position: 'absolute',
+    borderWidth: 2,
+    borderColor: '#00C853',
+    backgroundColor: 'rgba(0, 200, 83, 0.07)'
+  },
+  barcodeBoxLabel: {
+    position: 'absolute',
+    top: -14,
+    left: 0,
+    backgroundColor: '#00C853',
+    paddingHorizontal: 4,
+    paddingVertical: 1,
+    borderRadius: 2
+  },
+  barcodeBoxLabelText: {
+    color: '#000000',
+    fontSize: 8,
+    fontWeight: 'bold'
+  },
+  panel: {
+    flex: 1,
+    backgroundColor: 'rgba(0, 0, 0, 0.95)',
+    borderTopWidth: 2,
+    borderTopColor: '#00C853'
+  },
+  scrollView: {
+    flex: 1
+  },
+  panelContent: {
+    padding: 10
+  },
+  pauseButton: {
+    alignSelf: 'center',
+    borderWidth: 1,
+    borderColor: '#00C853',
+    borderRadius: 4,
+    paddingVertical: 6,
+    paddingHorizontal: 12,
+    marginBottom: 8
+  },
+  pauseButtonText: {
+    color: '#00C853',
+    fontSize: 10,
+    fontWeight: 'bold'
+  },
+  title: {
+    color: '#00C853',
+    fontSize: 12,
+    fontWeight: 'bold',
+    marginBottom: 8,
+    textAlign: 'center'
+  },
+  sectionTitle: {
+    color: '#00C853',
+    fontSize: 10,
+    fontWeight: 'bold',
+    marginTop: 6,
+    marginBottom: 4
+  },
+  bodyText: {
+    color: '#888888',
+    fontSize: 9,
+    fontFamily: 'monospace'
+  },
+  barcodeRow: {
+    marginBottom: 6
+  },
+  historyRow: {
+    marginBottom: 8,
+    borderBottomWidth: 1,
+    borderBottomColor: '#333333',
+    paddingBottom: 6
+  },
+  historyMeta: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    marginBottom: 2,
+    gap: 6
+  },
+  formatBadge: {
+    backgroundColor: '#00C853',
+    borderRadius: 3,
+    paddingHorizontal: 5,
+    paddingVertical: 2,
+    alignSelf: 'flex-start',
+    marginBottom: 2
+  },
+  formatBadgeText: {
+    color: '#000000',
+    fontSize: 8,
+    fontWeight: 'bold'
+  },
+  barcodeValue: {
+    color: '#FFFFFF',
+    fontSize: 9,
+    fontFamily: 'monospace',
+    lineHeight: 14
+  },
+  historyTime: {
+    color: '#888888',
+    fontSize: 8,
+    fontFamily: 'monospace'
+  }
+});
+export default BarcodeTestScreen;

package/lib/module/Screens/Debug/MRZTestScreen.js

@@ -5,19 +5,60 @@ import { View, StyleSheet, Text, ScrollView, StatusBar, TouchableOpacity } from
 import { SafeAreaView } from 'react-native-safe-area-context';
 import { TrustchexCamera } from "../../Shared/Components/TrustchexCamera.js";
 import mrzUtils from "../../Shared/Libs/mrz.utils.js";
+import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const MRZTestScreen = () => {
+  useKeepAwake();
   const cameraRef = useRef(null);
   const [mrzText, setMrzText] = useState('Waiting for MRZ...');
   const [mrzRawText, setMrzRawText] = useState('');
   const [mrzValid, setMrzValid] = useState(false);
   const [rawHistory, setRawHistory] = useState([]);
   const [isPaused, setIsPaused] = useState(false);
+  const [overlayBlocks, setOverlayBlocks] = useState([]);
+  const [cameraLayout, setCameraLayout] = useState({
+    width: 1,
+    height: 1
+  });
+  const [frameSize, setFrameSize] = useState({
+    width: 1080,
+    height: 1920
+  });
+  const handleCameraLayout = useCallback(e => {
+    const {
+      width,
+      height
+    } = e.nativeEvent.layout;
+    setCameraLayout({
+      width,
+      height
+    });
+  }, []);
   const handleFrame = useCallback(event => {
     if (isPaused) {
       return;
     }
     const frame = event.nativeEvent.frame;
+    if (frame.width && frame.height) {
+      setFrameSize({
+        width: frame.width,
+        height: frame.height
+      });
+    }
+    if (frame.textBlocks && frame.textBlocks.length > 0) {
+      const frameHeight = frame.height;
+      const bottomThreshold = frameHeight * 0.5;
+      const blocks = frame.textBlocks.map(block => {
+        const blockText = block.text || '';
+        return {
+          ...block,
+          isMrz: blockText.includes('<') && blockText.length >= 12 && (block.blockFrame ? block.blockFrame.y > bottomThreshold : false)
+        };
+      });
+      setOverlayBlocks(blocks);
+    } else {
+      setOverlayBlocks([]);
+    }
     if (frame.resultText) {
       setRawHistory(prev => {
         if (prev[0] === frame.resultText) {
@@ -62,17 +103,41 @@ const MRZTestScreen = () => {
       barStyle: "light-content",
       backgroundColor: "transparent",
       translucent: true
-    }), /*#__PURE__*/_jsx(TrustchexCamera, {
-      ref: cameraRef,
-      style: styles.camera,
-      cameraType: "back",
-      enableFrameProcessing: true,
-      enableFaceDetection: false,
-      enableTextRecognition: true,
-      enableBarcodeScanning: false,
-      includeBase64: false,
-      targetFps: 10,
-      onFrameAvailable: handleFrame
+    }), /*#__PURE__*/_jsxs(View, {
+      style: styles.cameraWrapper,
+      onLayout: handleCameraLayout,
+      children: [/*#__PURE__*/_jsx(TrustchexCamera, {
+        ref: cameraRef,
+        style: StyleSheet.absoluteFill,
+        cameraType: "back",
+        enableFrameProcessing: true,
+        enableFaceDetection: false,
+        enableTextRecognition: true,
+        enableBarcodeScanning: false,
+        includeBase64: false,
+        targetFps: 10,
+        onFrameAvailable: handleFrame
+      }), overlayBlocks.map((block, i) => {
+        const bf = block.blockFrame;
+        if (!bf) return null;
+        const scaleX = cameraLayout.width / frameSize.width;
+        const scaleY = cameraLayout.height / frameSize.height;
+        return /*#__PURE__*/_jsx(View, {
+          style: [styles.boundingBox, block.isMrz ? styles.boundingBoxMrz : styles.boundingBoxText, {
+            left: bf.x * scaleX,
+            top: bf.y * scaleY,
+            width: bf.width * scaleX,
+            height: bf.height * scaleY
+          }],
+          children: block.isMrz && /*#__PURE__*/_jsx(View, {
+            style: styles.blockLabel,
+            children: /*#__PURE__*/_jsx(Text, {
+              style: styles.blockLabelText,
+              children: "MRZ"
+            })
+          })
+        }, i);
+      })]
     }), /*#__PURE__*/_jsx(SafeAreaView, {
       style: styles.mrzPanel,
       edges: ['bottom'],
@@ -119,8 +184,35 @@ const styles = StyleSheet.create({
     flex: 1,
     backgroundColor: '#000000'
   },
-  camera: {
-    flex: 2
+  cameraWrapper: {
+    flex: 2,
+    position: 'relative'
+  },
+  boundingBox: {
+    position: 'absolute',
+    borderWidth: 1.5
+  },
+  boundingBoxText: {
+    borderColor: 'rgba(255, 255, 255, 0.25)'
+  },
+  boundingBoxMrz: {
+    borderColor: '#FFA500',
+    borderWidth: 2,
+    backgroundColor: 'rgba(255, 165, 0, 0.07)'
+  },
+  blockLabel: {
+    position: 'absolute',
+    top: -14,
+    left: 0,
+    backgroundColor: '#FFA500',
+    paddingHorizontal: 4,
+    paddingVertical: 1,
+    borderRadius: 2
+  },
+  blockLabelText: {
+    color: '#000000',
+    fontSize: 8,
+    fontWeight: 'bold'
   },
   mrzPanel: {
     flex: 1,