vision-camera-face-detection 1.2.0

package/ios/VisionCameraFaceDetectionModule.swift

@@ -0,0 +1,105 @@
+import VisionCamera
+import MLKitFaceDetection
+import MLKitVision
+import CoreML
+import UIKit
+import AVFoundation
+import TensorFlowLite
+
+@objc(VisionCameraFaceDetectionModule)
+class VisionCameraFaceDetectionModule: NSObject {
+    
+    static var FaceDetectorOption: FaceDetectorOptions = {
+        let option = FaceDetectorOptions()
+        option.performanceMode = .accurate
+        return option
+    }()
+    
+    static var faceDetector = FaceDetector.faceDetector(options: FaceDetectorOption)
+
+    @objc(initTensor:withCount:withResolver:withRejecter:)
+    func initTensor(modelName: String, count: Int = 1, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Void {
+        // Construct the path to the model file.
+        guard let modelPath = Bundle.main.path(
+            forResource: modelName,
+            ofType: "tflite"
+        ) else {
+            print("Failed to load the model file with name: \(modelName).")
+            return
+        }
+        do {
+            var options = Interpreter.Options()
+            options.threadCount = count
+            interpreter = try Interpreter(modelPath: modelPath, options: options)
+            try interpreter?.allocateTensors()
+            resolve("initialization tflite success")
+        } catch let error {
+            print("Failed to create the interpreter with error: \(error.localizedDescription)")
+            reject("Error", "tflite error", error)
+            return
+        }
+    }
+    
+    @objc(detectFromBase64:withResolver:withRejecter:)
+    func detectFromBase64(imageString: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        guard let stringData = Data(base64Encoded: imageString) else {
+            print("Error base64 encoded")
+            return
+        }
+        guard let uiImage = UIImage(data: stringData) else {
+            print("UIImage can't created")
+            return
+        }
+        let image = VisionImage(image: uiImage)
+        image.orientation = .up
+        do {
+            var map: [String: Any] = [:]
+            let faces: [Face] =  try VisionCameraFaceDetectionModule.faceDetector.results(in: image)
+            if (!faces.isEmpty){
+                let face = faces.first
+                let faceFrame = face!.frame
+                guard let imageCrop = FaceHelper.getImageFaceFromUIImage(from: uiImage, rectImage: faceFrame) else {
+                    reject("imageCrop can't created", nil, nil)
+                    return
+                }
+                guard let pixelBuffer = FaceHelper.uiImageToPixelBuffer(image: imageCrop, size: inputWidth) else {
+                    reject("Failed to get pixelBuffer", nil, nil)
+                    return
+                }
+                guard let rgbData = FaceHelper.rgbDataFromBuffer(
+                    pixelBuffer,
+                    byteCount: batchSize * inputWidth * inputHeight * inputChannels,
+                    isModelQuantized: false
+                ) else {
+                    reject("Failed to convert the image buffer to RGB data.", nil, nil)
+                    return
+                }
+                // Copy the RGB data to the input `Tensor`.
+                try interpreter?.copy(rgbData, toInputAt: 0)
+                // Run inference by invoking the `Interpreter`.
+                try interpreter?.invoke()
+                // Get the output `Tensor` to process the inference results.
+                let outputTensor: Tensor? = try interpreter?.output(at: 0)
+                if ((outputTensor?.data) != nil) {
+                    let result: [Float] = [Float32](unsafeData: outputTensor!.data) ?? []
+                    map["message"] = "Successfully Get Face"
+                    map["data"] = result
+                    map["base64"] = FaceHelper.convertImageToBase64(image: imageCrop)
+                    resolve(map)
+                } else {
+                    map["message"] = "No Face"
+                    map["data"] = []
+                    map["base64"] = ""
+                    resolve(map)
+                }
+            } else {
+                map["message"] = "No Face"
+                map["data"] = []
+                map["base64"] = ""
+                resolve(map)
+            }
+        } catch {
+            reject("error: ", nil, error)
+        }
+    }
+}

package/ios/VisionCameraFaceDetectionPlugin.mm

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import <VisionCamera/Frame.h>
+
+#if __has_include("VisionCameraFaceDetection/VisionCameraFaceDetection-Swift.h")
+#import "VisionCameraFaceDetection/VisionCameraFaceDetection-Swift.h"
+#else
+#import "VisionCameraFaceDetection-Swift.h"
+#endif
+
+@interface VisionCameraFaceDetectionPlugin (FrameProcessorPluginLoader)
+@end
+
+@implementation VisionCameraFaceDetectionPlugin (FrameProcessorPluginLoader)
++ (void) load {
+  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"detectFaces"
+    withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
+    return [[VisionCameraFaceDetectionPlugin alloc] initWithProxy:proxy withOptions:options];
+  }];
+}
+@end

package/ios/VisionCameraFaceDetectionPlugin.swift

@@ -0,0 +1,341 @@
+import VisionCamera
+import Foundation
+import MLKitFaceDetection
+import MLKitVision
+import CoreML
+import UIKit
+import AVFoundation
+import SceneKit
+import TensorFlowLite
+
+@objc(VisionCameraFaceDetectionPlugin)
+public class VisionCameraFaceDetectionPlugin: FrameProcessorPlugin {
+    // device display data
+    private let screenBounds = UIScreen.main.bounds
+    
+    // detection props
+    private var autoScale = false
+    private var faceDetector: FaceDetector! = nil
+    private var runLandmarks = false
+    private var runClassifications = false
+    private var runContours = false
+    private var trackingEnabled = false
+    
+    public override init(
+        proxy: VisionCameraProxyHolder,
+        options: [AnyHashable : Any]! = [:]
+    ) {
+        super.init(proxy: proxy, options: options)
+        let config = getConfig(withArguments: options)
+        
+        // handle auto scaling
+        autoScale = config?["autoScale"] as? Bool == true
+        
+        // initializes faceDetector on creation
+        let minFaceSize = 0.15
+        let optionsBuilder = FaceDetectorOptions()
+        optionsBuilder.performanceMode = .fast
+        optionsBuilder.landmarkMode = .none
+        optionsBuilder.contourMode = .none
+        optionsBuilder.classificationMode = .none
+        optionsBuilder.minFaceSize = minFaceSize
+        optionsBuilder.isTrackingEnabled = false
+        
+        if config?["performanceMode"] as? String == "accurate" {
+            optionsBuilder.performanceMode = .accurate
+        }
+        
+        if config?["landmarkMode"] as? String == "all" {
+            runLandmarks = true
+            optionsBuilder.landmarkMode = .all
+        }
+        
+        if config?["classificationMode"] as? String == "all" {
+            runClassifications = true
+            optionsBuilder.classificationMode = .all
+        }
+        
+        if config?["contourMode"] as? String == "all" {
+            runContours = true
+            optionsBuilder.contourMode = .all
+        }
+        
+        let minFaceSizeParam = config?["minFaceSize"] as? Double
+        if minFaceSizeParam != nil && minFaceSizeParam != minFaceSize {
+            optionsBuilder.minFaceSize = CGFloat(minFaceSizeParam!)
+        }
+        
+        if config?["trackingEnabled"] as? Bool == true {
+            trackingEnabled = true
+            optionsBuilder.isTrackingEnabled = true
+        }
+        
+        faceDetector = FaceDetector.faceDetector(options: optionsBuilder)
+    }
+    
+    func getConfig(
+        withArguments arguments: [AnyHashable: Any]!
+    ) -> [String:Any]! {
+        if arguments.count > 0 {
+            let config = arguments.map { dictionary in
+                Dictionary(uniqueKeysWithValues: dictionary.map { (key, value) in
+                    (key as? String ?? "", value)
+                })
+            }
+            
+            return config
+        }
+        
+        return nil
+    }
+    
+    func processBoundingBox(
+        from face: Face,
+        sourceWidth: CGFloat,
+        sourceHeight: CGFloat,
+        orientation: UIImage.Orientation,
+        scaleX: CGFloat,
+        scaleY: CGFloat
+    ) -> [String:Any] {
+        let boundingBox = face.frame
+        let width = boundingBox.width * scaleX
+        let height = boundingBox.height * scaleY
+        let x = boundingBox.origin.y * scaleX
+        let y = boundingBox.origin.x * scaleY
+        
+        return [
+            "width": width,
+            "height": height,
+            "x": (-x + sourceWidth * scaleX) - width,
+            "y": y
+        ]
+    }
+    
+    func processLandmarks(
+        from face: Face,
+        scaleX: CGFloat,
+        scaleY: CGFloat
+    ) -> [String:[String: CGFloat?]] {
+        let faceLandmarkTypes = [
+            FaceLandmarkType.leftCheek,
+            FaceLandmarkType.leftEar,
+            FaceLandmarkType.leftEye,
+            FaceLandmarkType.mouthBottom,
+            FaceLandmarkType.mouthLeft,
+            FaceLandmarkType.mouthRight,
+            FaceLandmarkType.noseBase,
+            FaceLandmarkType.rightCheek,
+            FaceLandmarkType.rightEar,
+            FaceLandmarkType.rightEye
+        ]
+        
+        let faceLandmarksTypesStrings = [
+            "LEFT_CHEEK",
+            "LEFT_EAR",
+            "LEFT_EYE",
+            "MOUTH_BOTTOM",
+            "MOUTH_LEFT",
+            "MOUTH_RIGHT",
+            "NOSE_BASE",
+            "RIGHT_CHEEK",
+            "RIGHT_EAR",
+            "RIGHT_EYE"
+        ];
+        
+        var faceLandMarksTypesMap: [String: [String: CGFloat?]] = [:]
+        for i in 0..<faceLandmarkTypes.count {
+            let landmark = face.landmark(ofType: faceLandmarkTypes[i]);
+            let position = [
+                "x": landmark?.position.x ?? 0.0 * scaleX,
+                "y": landmark?.position.y ?? 0.0 * scaleY
+            ]
+            faceLandMarksTypesMap[faceLandmarksTypesStrings[i]] = position
+        }
+        
+        return faceLandMarksTypesMap
+    }
+    
+    func processFaceContours(
+        from face: Face,
+        scaleX: CGFloat,
+        scaleY: CGFloat
+    ) -> [String:[[String:CGFloat]]] {
+        let faceContoursTypes = [
+            FaceContourType.face,
+            FaceContourType.leftCheek,
+            FaceContourType.leftEye,
+            FaceContourType.leftEyebrowBottom,
+            FaceContourType.leftEyebrowTop,
+            FaceContourType.lowerLipBottom,
+            FaceContourType.lowerLipTop,
+            FaceContourType.noseBottom,
+            FaceContourType.noseBridge,
+            FaceContourType.rightCheek,
+            FaceContourType.rightEye,
+            FaceContourType.rightEyebrowBottom,
+            FaceContourType.rightEyebrowTop,
+            FaceContourType.upperLipBottom,
+            FaceContourType.upperLipTop
+        ]
+        
+        let faceContoursTypesStrings = [
+            "FACE",
+            "LEFT_CHEEK",
+            "LEFT_EYE",
+            "LEFT_EYEBROW_BOTTOM",
+            "LEFT_EYEBROW_TOP",
+            "LOWER_LIP_BOTTOM",
+            "LOWER_LIP_TOP",
+            "NOSE_BOTTOM",
+            "NOSE_BRIDGE",
+            "RIGHT_CHEEK",
+            "RIGHT_EYE",
+            "RIGHT_EYEBROW_BOTTOM",
+            "RIGHT_EYEBROW_TOP",
+            "UPPER_LIP_BOTTOM",
+            "UPPER_LIP_TOP"
+        ];
+        
+        var faceContoursTypesMap: [String:[[String:CGFloat]]] = [:]
+        for i in 0..<faceContoursTypes.count {
+            let contour = face.contour(ofType: faceContoursTypes[i]);
+            var pointsArray: [[String:CGFloat]] = []
+            
+            if let points = contour?.points {
+                for point in points {
+                    let currentPointsMap = [
+                        "x": point.x * scaleX,
+                        "y": point.y * scaleY,
+                    ]
+                    
+                    pointsArray.append(currentPointsMap)
+                }
+                
+                faceContoursTypesMap[faceContoursTypesStrings[i]] = pointsArray
+            }
+        }
+        
+        return faceContoursTypesMap
+    }
+    
+    func getOrientation(
+        orientation: UIImage.Orientation
+    ) -> UIImage.Orientation {
+        switch orientation {
+        case .up:
+            // device is landscape left
+            return .up
+        case .left:
+            // device is portrait
+            return .right
+        case .down:
+            // device is landscape right
+            return .down
+        case .right:
+            // device is upside-down
+            return .left
+        default:
+            return .up
+        }
+    }
+    
+    public override func callback(
+        _ frame: Frame,
+        withArguments arguments: [AnyHashable: Any]?
+    ) -> Any? {
+        var result: [Any] = []
+        
+        do {
+            // we need to invert sizes as frame is always -90deg rotated
+            let width = CGFloat(frame.height)
+            let height = CGFloat(frame.width)
+            let orientation = getOrientation(
+                orientation: frame.orientation
+            )
+            let image = VisionImage(buffer: frame.buffer)
+            image.orientation = orientation
+            
+            var scaleX:CGFloat
+            var scaleY:CGFloat
+            if autoScale {
+                scaleX = screenBounds.size.width / width
+                scaleY = screenBounds.size.height / height
+            } else {
+                scaleX = CGFloat(1)
+                scaleY = CGFloat(1)
+            }
+            
+            let faces: [Face] = try faceDetector!.results(in: image)
+            for face in faces {
+                guard let imageCrop = FaceHelper.getImageFaceFromBuffer(from: frame.buffer, rectImage: face.frame) else {
+                    return nil
+                }
+                guard let pixelBuffer = FaceHelper.uiImageToPixelBuffer(image: imageCrop, size: inputWidth) else {
+                    return nil
+                }
+                guard let rgbData = FaceHelper.rgbDataFromBuffer(
+                    pixelBuffer,
+                    byteCount: batchSize * inputWidth * inputHeight * inputChannels,
+                    isModelQuantized: false
+                ) else {
+                    return nil
+                }
+                try interpreter?.copy(rgbData, toInputAt: 0)
+                try interpreter?.invoke()
+                let outputTensor: Tensor? = try interpreter?.output(at: 0)
+                
+                var map: [String: Any] = [:]
+                if ((outputTensor?.data) != nil) {
+                    let result: [Float] = [Float32](unsafeData: outputTensor!.data) ?? []
+                    map["data"] = result
+                } else {
+                    map["data"] = []
+                }
+                
+                if runLandmarks {
+                    map["landmarks"] = processLandmarks(
+                        from: face,
+                        scaleX: scaleX,
+                        scaleY: scaleY
+                    )
+                }
+                
+                if runClassifications {
+                    map["leftEyeOpenProbability"] = face.leftEyeOpenProbability
+                    map["rightEyeOpenProbability"] = face.rightEyeOpenProbability
+                    map["smilingProbability"] = face.smilingProbability
+                }
+                
+                if runContours {
+                    map["contours"] = processFaceContours(
+                        from: face,
+                        scaleX: scaleX,
+                        scaleY: scaleY
+                    )
+                }
+                
+                if trackingEnabled {
+                    map["trackingId"] = face.trackingID
+                }
+                
+                map["rollAngle"] = face.headEulerAngleZ
+                map["pitchAngle"] = face.headEulerAngleX
+                map["yawAngle"] = face.headEulerAngleY
+                map["bounds"] = processBoundingBox(
+                    from: face,
+                    sourceWidth: width,
+                    sourceHeight: height,
+                    orientation: frame.orientation,
+                    scaleX: scaleX,
+                    scaleY: scaleY
+                )
+                
+                result.append(map)
+            }
+        } catch let error {
+            print("Error processing face detection: \(error)")
+        }
+        
+        return result
+    }
+}

package/lib/commonjs/Camera.cjs

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Camera = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _reactNativeVisionCamera = require("react-native-vision-camera");
+var _reactNativeWorkletsCore = require("react-native-worklets-core");
+var _FaceDetector = require("./FaceDetector.cjs");
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// types
+
+/**
+ * Create a Worklet function that persists between re-renders.
+ * The returned function can be called from both a Worklet context and the JS context, but will execute on a Worklet context.
+ *
+ * @param {function} func The Worklet. Must be marked with the `'worklet'` directive.
+ * @param {DependencyList} dependencyList The React dependencies of this Worklet.
+ * @returns {UseWorkletType} A memoized Worklet
+ */
+function useWorklet(func, dependencyList) {
+  const worklet = _react.default.useMemo(() => {
+    const context = _reactNativeWorkletsCore.Worklets.defaultContext;
+    return context.createRunAsync(func);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, dependencyList);
+  return worklet;
+}
+
+/**
+ * Create a Worklet function that runs the giver function on JS context.
+ * The returned function can be called from a Worklet to hop back to the JS thread.
+ *
+ * @param {function} func The Worklet. Must be marked with the `'worklet'` directive.
+ * @param {DependencyList} dependencyList The React dependencies of this Worklet.
+ * @returns {UseRunInJSType} a memoized Worklet
+ */
+function useRunInJS(func, dependencyList) {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return _react.default.useMemo(() => _reactNativeWorkletsCore.Worklets.createRunOnJS(func), dependencyList);
+}
+
+/**
+ * Vision camera wrapper
+ *
+ * @param {ComponentType} props Camera + face detection props
+ * @returns
+ */
+const Camera = exports.Camera = /*#__PURE__*/_react.default.forwardRef(({
+  faceDetectionOptions,
+  faceDetectionCallback,
+  ...props
+}, ref) => {
+  const {
+    detectFaces
+  } = (0, _FaceDetector.useFaceDetector)(faceDetectionOptions);
+  /**
+   * Is there an async task already running?
+   */
+  const isAsyncContextBusy = (0, _reactNativeWorkletsCore.useSharedValue)(false);
+
+  /**
+   * Throws logs/errors back on js thread
+   */
+  const logOnJs = _reactNativeWorkletsCore.Worklets.createRunOnJS((log, error) => {
+    if (error) {
+      console.error(log, error.message ?? JSON.stringify(error));
+    } else {
+      console.log(log);
+    }
+  });
+
+  /**
+   * Runs on detection callback on js thread
+   */
+  const runOnJs = useRunInJS(faceDetectionCallback, [faceDetectionCallback]);
+
+  /**
+   * Async context that will handle face detection
+   */
+  const runOnAsyncContext = useWorklet(frame => {
+    'worklet';
+
+    try {
+      const faces = detectFaces(frame);
+      // increment frame count so we can use frame on
+      // js side without frame processor getting stuck
+      frame.incrementRefCount();
+      runOnJs(faces, frame).finally(() => {
+        'worklet';
+
+        // finally decrement frame count so it can be dropped
+        frame.decrementRefCount();
+      });
+    } catch (error) {
+      logOnJs('Execution error:', error);
+    } finally {
+      frame.decrementRefCount();
+      isAsyncContextBusy.value = false;
+    }
+  }, [detectFaces, runOnJs]);
+
+  /**
+   * Detect faces on frame on an async context without blocking camera preview
+   *
+   * @param {Frame} frame Current frame
+   */
+  function runAsync(frame) {
+    'worklet';
+
+    if (isAsyncContextBusy.value) return;
+    // set async context as busy
+    isAsyncContextBusy.value = true;
+    // cast to internal frame and increment ref count
+    const internal = frame;
+    internal.incrementRefCount();
+    // detect faces in async context
+    runOnAsyncContext(internal);
+  }
+
+  /**
+   * Camera frame processor
+   */
+  const cameraFrameProcessor = (0, _reactNativeVisionCamera.useFrameProcessor)(frame => {
+    'worklet';
+
+    runAsync(frame);
+  }, [runOnAsyncContext]);
+
+  //
+  // use bellow when vision-camera's
+  // context creation issue is solved
+  //
+  // /**
+  //  * Runs on detection callback on js thread
+  //  */
+  // const runOnJs = useRunOnJS( faceDetectionCallback, [
+  //   faceDetectionCallback
+  // ] )
+
+  // const cameraFrameProcessor = useFrameProcessor( ( frame ) => {
+  //   'worklet'
+  //   runAsync( frame, () => {
+  //     'worklet'
+  //     runOnJs(
+  //       detectFaces( frame ),
+  //       frame
+  //     )
+  //   } )
+  // }, [ runOnJs ] )
+
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNativeVisionCamera.Camera, {
+    ...props,
+    ref: ref,
+    frameProcessor: cameraFrameProcessor,
+    pixelFormat: "yuv"
+  });
+});
+//# sourceMappingURL=Camera.cjs.map

package/lib/commonjs/Camera.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_reactNativeVisionCamera","_reactNativeWorkletsCore","_FaceDetector","_jsxRuntime","e","__esModule","default","useWorklet","func","dependencyList","worklet","React","useMemo","context","Worklets","defaultContext","createRunAsync","useRunInJS","createRunOnJS","Camera","exports","forwardRef","faceDetectionOptions","faceDetectionCallback","props","ref","detectFaces","useFaceDetector","isAsyncContextBusy","useSharedValue","logOnJs","log","error","console","message","JSON","stringify","runOnJs","runOnAsyncContext","frame","faces","incrementRefCount","finally","decrementRefCount","value","runAsync","internal","cameraFrameProcessor","useFrameProcessor","jsx","frameProcessor","pixelFormat"],"sourceRoot":"../../src","sources":["Camera.tsx"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/FaceDetector.cjs

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFaceDetector = useFaceDetector;
+var _react = require("react");
+var _reactNativeVisionCamera = require("react-native-vision-camera");
+/**
+ * Create a new instance of face detector plugin
+ *
+ * @param {FaceDetectionOptions | undefined} options Detection options
+ * @returns {FaceDetectorPlugin} Plugin instance
+ */
+function createFaceDetectorPlugin(options) {
+  const plugin = _reactNativeVisionCamera.VisionCameraProxy.initFrameProcessorPlugin('detectFaces', {
+    ...options
+  });
+  if (!plugin) {
+    throw new Error('Failed to load Frame Processor Plugin "detectFaces"!');
+  }
+  return {
+    detectFaces: frame => {
+      'worklet';
+
+      // @ts-ignore
+      return plugin.call(frame);
+    }
+  };
+}
+
+/**
+ * Use an instance of face detector plugin.
+ *
+ * @param {FaceDetectionOptions | undefined} options Detection options
+ * @returns {FaceDetectorPlugin} Memoized plugin instance that will be
+ * destroyed once the component using `useFaceDetector()` unmounts.
+ */
+function useFaceDetector(options) {
+  return (0, _react.useMemo)(() => createFaceDetectorPlugin(options), [options]);
+}
+//# sourceMappingURL=FaceDetector.cjs.map

package/lib/commonjs/FaceDetector.cjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactNativeVisionCamera","createFaceDetectorPlugin","options","plugin","VisionCameraProxy","initFrameProcessorPlugin","Error","detectFaces","frame","call","useFaceDetector","useMemo"],"sourceRoot":"../../src","sources":["FaceDetector.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,wBAAA,GAAAD,OAAA;AA0HA;AACA;AACA;AACA;AACA;AACA;AACA,SAASE,wBAAwBA,CAC/BC,OAA8B,EACV;EACpB,MAAMC,MAAM,GAAGC,0CAAiB,CAACC,wBAAwB,CAAC,aAAa,EAAE;IACvE,GAAGH;EACL,CAAC,CAAC;EAEF,IAAI,CAACC,MAAM,EAAE;IACX,MAAM,IAAIG,KAAK,CAAC,sDAAsD,CAAC;EACzE;EAEA,OAAO;IACLC,WAAW,EAAGC,KAAY,IAAa;MACrC,SAAS;;MACT;MACA,OAAOL,MAAM,CAACM,IAAI,CAACD,KAAK,CAAC;IAC3B;EACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,eAAeA,CAC7BR,OAA8B,EACV;EACpB,OAAO,IAAAS,cAAO,EAAC,MAAMV,wBAAwB,CAACC,OAAO,CAAC,EAAE,CAACA,OAAO,CAAC,CAAC;AACpE","ignoreList":[]}