react-native-usesense 1.0.0 → 2.1.0

package/ios/UseSenseModule.swift

@@ -2,11 +2,33 @@ import Foundation
 import React
 import UseSenseSDK
 
+/// React Native bridge for the UseSense iOS SDK.
+///
+/// Exposes five JS-callable methods — `initialize`, `startVerification`,
+/// `reset`, `isInitialized`, plus RCTEventEmitter `supportedEvents`/
+/// `startObserving`/`stopObserving` — that mirror the native SDK's
+/// public API without leaking any internal scoring data through the
+/// bridge.
+///
+/// The result payload returned from `startVerification` is the
+/// five-field redacted shape defined by the native SDK's
+/// `RedactedDecisionObject`: `sessionId`, `sessionType`, `identityId`,
+/// `decision` (`APPROVE` / `REJECT` / `MANUAL_REVIEW`), `timestamp`.
+/// Pillar scores (channel trust, liveness, matchsense risk) are
+/// intentionally NOT exposed — integrators must consume those via
+/// the signed webhook delivered to their backend, never from the
+/// client. Matches the behaviour of the native Android bridge at
+/// `android/src/main/java/com/usesense/reactnative/UseSenseModule.kt`
+/// and the Flutter plugin at `ios/Classes/UseSenseFlutterPlugin.swift`.
 @objc(UseSenseModule)
 class UseSenseModule: RCTEventEmitter {
 
+    private var client: UseSense?
+    private var eventUnsubscribe: (() -> Void)?
     private var hasListeners = false
 
+    // MARK: - RCTEventEmitter
+
     override func supportedEvents() -> [String]! {
         return ["UseSenseEvent"]
     }
@@ -20,129 +42,296 @@ class UseSenseModule: RCTEventEmitter {
     }
 
     @objc
-    func initialize(_ config: NSDictionary) {
-        guard let apiKey = config["apiKey"] as? String else {
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    // MARK: - Module methods
+
+    @objc
+    func initialize(_ config: NSDictionary,
+                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let apiKey = config["apiKey"] as? String, !apiKey.isEmpty else {
+            reject("invalid_config", "apiKey is required", nil)
             return
         }
 
-        let environment: UseSenseEnvironment = {
-            switch config["environment"] as? String {
-            case "production": return .production
-            case "sandbox": return .sandbox
-            default: return .sandbox
-            }
-        }()
+        let environment: Environment
+        switch config["environment"] as? String {
+        case "sandbox":
+            environment = .sandbox
+        case "production":
+            environment = .production
+        case "auto", nil:
+            environment = .auto
+        default:
+            environment = .auto
+        }
+
+        var brandingConfig: BrandingConfig? = nil
+        if let b = config["branding"] as? [String: Any] {
+            // iOS BrandingConfig accepts logoUrl, primaryColor, buttonRadius,
+            // fontFamily. Android-only fields (displayName, redirectUrl) are
+            // accepted by the JS API for cross-platform consistency but
+            // ignored here since the iOS SDK doesn't support them.
+            brandingConfig = BrandingConfig(
+                logoUrl: b["logoUrl"] as? String,
+                primaryColor: (b["primaryColor"] as? String) ?? "#4F7CFF",
+                buttonRadius: CGFloat((b["buttonRadius"] as? Int) ?? 10),
+                fontFamily: b["fontFamily"] as? String
+            )
+        }
+
+        let apiEndpoint = (config["apiEndpoint"] as? String)
+            ?? UseSenseConfig.defaultEndpoint
+
+        // v4.2: Optional on-device antispoof classifier flag (defaults to false;
+        // watchtower runs the classifier server-side when off).
+        let antispoofOnDeviceEnabled = (config["antispoofOnDeviceEnabled"] as? Bool) ?? false
+        // LiveSense v4 capture flow opt-in (zoom phase + frame phase tags).
+        let liveSenseV4Enabled = (config["liveSenseV4Enabled"] as? Bool) ?? false
+        let sdkOptions = SDKOptions(
+            antispoofOnDeviceEnabled: antispoofOnDeviceEnabled,
+            liveSenseV4Enabled: liveSenseV4Enabled
+        )
 
-        let useSenseConfig = UseSenseConfig(
+        let sdkConfig = UseSenseConfig(
+            apiEndpoint: apiEndpoint,
             apiKey: apiKey,
             environment: environment,
-            organizationId: config["organizationId"] as? String,
-            sessionType: (config["sessionType"] as? String) == "authentication" ? .authentication : .enrollment,
-            challengePolicy: {
-                switch config["challengePolicy"] as? String {
-                case "enhanced": return .enhanced
-                case "adaptive": return .adaptive
-                default: return .standard
-                }
-            }(),
-            enableAudio: config["enableAudio"] as? Bool ?? false,
-            timeout: config["timeout"] as? TimeInterval ?? 60000,
-            metadata: config["metadata"] as? [String: String]
+            branding: brandingConfig,
+            options: sdkOptions
         )
 
-        UseSense.initialize(config: useSenseConfig)
+        // Create (or replace) the client. If a previous client was
+        // active, its event subscription is disposed before we
+        // replace it so we don't accumulate stale listeners on
+        // repeated initialize() calls.
+        eventUnsubscribe?()
+        eventUnsubscribe = nil
+
+        let newClient = UseSense(config: sdkConfig)
+        eventUnsubscribe = newClient.onEvent { [weak self] event in
+            self?.emitEvent(event)
+        }
+        client = newClient
+
+        resolve(nil)
     }
 
     @objc
-    func startSession(_ options: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    func startVerification(_ request: NSDictionary,
+                           resolver resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let client = client else {
+            reject("sdk_not_initialized",
+                   "UseSense SDK is not initialized. Call initialize() first.",
+                   nil)
+            return
+        }
+
+        let sessionType: SessionType = (request["sessionType"] as? String) == "authentication"
+            ? .authentication
+            : .enrollment
+
+        // The native iOS `VerificationRequest` takes an `AnyCodableValue`
+        // map for metadata. RN can only pass plain JSON so we coerce
+        // every value to a string — matches what the Flutter plugin
+        // does over the Pigeon channel.
+        let rawMetadata = request["metadata"] as? [String: Any]
+        let metadata: [String: AnyCodableValue]? = rawMetadata?.mapValues { value in
+            if let s = value as? String { return .string(s) }
+            if let b = value as? Bool { return .bool(b) }
+            if let i = value as? Int { return .int(i) }
+            if let d = value as? Double { return .double(d) }
+            return .string(String(describing: value))
+        }
+
+        let nativeRequest = VerificationRequest(
+            sessionType: sessionType,
+            externalUserId: request["externalUserId"] as? String,
+            identityId: request["identityId"] as? String,
+            metadata: metadata
+        )
+
         DispatchQueue.main.async {
-            guard let viewController = RCTPresentedViewController() else {
-                reject("no_view_controller", "No view controller available", nil)
+            guard let rootVC = Self.topmostViewController() else {
+                reject("no_view_controller",
+                       "No view controller available to present the camera UI.",
+                       nil)
                 return
             }
 
-            let sessionType: SessionType = (options["sessionType"] as? String) == "authentication" ? .authentication : .enrollment
-            let identityId = options["identityId"] as? String
-
-            UseSense.startSession(
-                from: viewController,
-                sessionType: sessionType,
-                identityId: identityId
-            ) { result in
+            let session = client.startVerification(request: nativeRequest)
+            let vc = UseSenseViewController(session: session) { [weak rootVC] result in
+                // The view controller dismisses itself on the main
+                // thread before invoking this closure. We're safe to
+                // resolve/reject directly without hopping.
+                _ = rootVC
                 switch result {
-                case .success(let useSenseResult):
-                    let resultDict: [String: Any] = [
-                        "sessionId": useSenseResult.sessionId,
-                        "decision": useSenseResult.decision.rawValue,
-                        "channelTrustScore": useSenseResult.channelTrustScore,
-                        "livenessScore": useSenseResult.livenessScore,
-                        "matchSenseRiskScore": useSenseResult.matchSenseRiskScore,
-                        "presenceConfidence": useSenseResult.presenceConfidence,
-                        "reasons": useSenseResult.reasons,
-                        "ruleTriggered": useSenseResult.ruleTriggered as Any,
-                        "recommendedAction": useSenseResult.recommendedAction as Any,
-                        "sessionSignature": useSenseResult.sessionSignature,
-                    ]
-                    resolve(resultDict)
-
+                case .success(let decision):
+                    resolve(Self.redactedResultDict(decision))
                 case .failure(let error):
-                    reject(error.code, error.message, nil)
+                    if error.code == .userCancelled {
+                        reject("session_cancelled",
+                               "User cancelled the verification session.",
+                               nil)
+                    } else {
+                        reject(Self.bridgeErrorCode(error.code),
+                               error.message,
+                               error)
+                    }
                 }
             }
+            vc.modalPresentationStyle = .fullScreen
+            rootVC.present(vc, animated: true)
         }
     }
 
-    @objc
-    func cancelSession(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        UseSense.cancelSession()
-        resolve(nil)
-    }
+    // MARK: - LiveSense v4 (R-1)
 
+    /// Passthrough for the v4 zoom-motion capture. Resolves with the
+    /// opaque verdict; sub-scores never cross the bridge.
     @objc
-    func getSessionStatus(_ sessionId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        UseSense.getSessionStatus(sessionId: sessionId) { result in
-            switch result {
-            case .success(let status):
-                var dict: [String: Any] = ["status": status.status]
-                if let r = status.result {
-                    dict["result"] = [
-                        "sessionId": r.sessionId,
-                        "decision": r.decision.rawValue,
-                        "channelTrustScore": r.channelTrustScore,
-                        "livenessScore": r.livenessScore,
-                        "matchSenseRiskScore": r.matchSenseRiskScore,
-                        "presenceConfidence": r.presenceConfidence,
-                        "reasons": r.reasons,
-                        "sessionSignature": r.sessionSignature,
-                    ]
-                }
-                resolve(dict)
-            case .failure(let error):
-                reject(error.code, error.message, nil)
-            }
+    func startV4Verification(_ request: NSDictionary,
+                             resolver resolve: @escaping RCTPromiseResolveBlock,
+                             rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let sessionIdStr = request["sessionId"] as? String,
+              let sessionId = UUID(uuidString: sessionIdStr),
+              let sessionToken = request["sessionToken"] as? String,
+              let nonce = request["nonce"] as? String,
+              let apiBaseStr = request["apiBaseUrl"] as? String,
+              let apiBaseURL = URL(string: apiBaseStr) else {
+            reject("INVALID_REQUEST", "sessionId, sessionToken, nonce, apiBaseUrl required", nil)
+            return
         }
-    }
+        let environment = request["environment"] as? String ?? "production"
+        let displayName = request["displayName"] as? String
+        let client = UseSense(config: UseSenseConfig(apiKey: "v4-bridge"))
+        let config = LiveSenseV4Config(
+            sessionId: sessionId,
+            sessionToken: sessionToken,
+            nonce: nonce,
+            apiBaseURL: apiBaseURL,
+            environment: environment,
+            brandPrimaryColor: nil,
+            displayName: displayName
+        )
 
-    @objc
-    func subscribeToEvents() {
-        UseSense.onEvent { [weak self] event in
+        let delegate = V4BridgeDelegate(resolve: resolve, reject: reject, emit: { [weak self] body in
             guard let self = self, self.hasListeners else { return }
-            self.sendEvent(withName: "UseSenseEvent", body: event.toDictionary())
+            DispatchQueue.main.async { self.sendEvent(withName: "UseSenseEvent", body: body) }
+        })
+        let session = client.startV4Session(config: config, delegate: delegate)
+        delegate.retain(session)
+        do {
+            try session.start()
+        } catch {
+            reject("V4_FAILED", error.localizedDescription, error)
         }
     }
 
     @objc
-    func unsubscribeFromEvents() {
-        UseSense.removeEventListener()
+    func reset(_ resolve: @escaping RCTPromiseResolveBlock,
+               rejecter reject: @escaping RCTPromiseRejectBlock) {
+        eventUnsubscribe?()
+        eventUnsubscribe = nil
+        client?.reset()
+        client = nil
+        resolve(nil)
     }
 
     @objc
-    func getSdkVersion() -> String {
-        return UseSense.sdkVersion
+    func isInitialized(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(client != nil)
     }
 
-    @objc
-    override static func requiresMainQueueSetup() -> Bool {
-        return false
+    // MARK: - Private helpers
+
+    private func emitEvent(_ event: UseSenseEvent) {
+        guard hasListeners else { return }
+        let eventTypeString = Self.eventTypeString(event.type)
+        let body: [String: Any] = [
+            "type": eventTypeString,
+            "timestamp": Int64(event.timestamp.timeIntervalSince1970 * 1000),
+            "data": event.data ?? [:]
+        ]
+        DispatchQueue.main.async { [weak self] in
+            self?.sendEvent(withName: "UseSenseEvent", body: body)
+        }
+    }
+
+    /// Maps the SDK's `RedactedDecisionObject` into the exact five-field
+    /// dict the JS API exposes. Adding or returning anything beyond
+    /// these five fields would leak internal scoring data through the
+    /// bridge — do NOT add channel/liveness/matchsense scores here.
+    private static func redactedResultDict(_ decision: RedactedDecisionObject) -> [String: Any] {
+        return [
+            "sessionId": decision.sessionId,
+            "sessionType": decision.sessionType as Any,
+            "identityId": decision.identityId as Any,
+            "decision": decision.decision,
+            "timestamp": decision.timestamp,
+            // Convenience booleans computed on the native side so the
+            // JS consumer doesn't have to string-compare decision codes.
+            "isApproved": decision.isApproved,
+            "isRejected": decision.isRejected,
+            "isPendingReview": decision.isPendingReview
+        ]
+    }
+
+    private static func bridgeErrorCode(_ code: UseSenseErrorCode) -> String {
+        // Return the raw error code string (e.g. "NETWORK_ERROR"). JS
+        // consumers can key off this via UseSenseError.code. Matches the
+        // string-valued error codes the Flutter plugin emits.
+        return code.rawValue
+    }
+
+    private static func eventTypeString(_ type: UseSenseEventType) -> String {
+        // RN bridges typically emit UPPER_SNAKE_CASE event type strings.
+        // Map the SDK's enum cases to the same canonical form the
+        // Android bridge uses (event.type.name) so JS consumers can
+        // switch on a single constant set regardless of platform.
+        switch type {
+        case .sessionCreated: return "SESSION_CREATED"
+        case .permissionsRequested: return "PERMISSIONS_REQUESTED"
+        case .permissionsGranted: return "PERMISSIONS_GRANTED"
+        case .permissionsDenied: return "PERMISSIONS_DENIED"
+        case .captureStarted: return "CAPTURE_STARTED"
+        case .frameCaptured: return "FRAME_CAPTURED"
+        case .captureCompleted: return "CAPTURE_COMPLETED"
+        case .audioRecordStarted: return "AUDIO_RECORD_STARTED"
+        case .audioRecordCompleted: return "AUDIO_RECORD_COMPLETED"
+        case .challengeStarted: return "CHALLENGE_STARTED"
+        case .challengeCompleted: return "CHALLENGE_COMPLETED"
+        case .uploadStarted: return "UPLOAD_STARTED"
+        case .uploadProgress: return "UPLOAD_PROGRESS"
+        case .uploadCompleted: return "UPLOAD_COMPLETED"
+        case .completeStarted: return "COMPLETE_STARTED"
+        case .decisionReceived: return "DECISION_RECEIVED"
+        case .imageQualityCheck: return "IMAGE_QUALITY_CHECK"
+        case .error: return "ERROR"
+        @unknown default: return "UNKNOWN"
+        }
+    }
+
+    /// Walks the currently-presented view controller chain and returns
+    /// the topmost one — which is the correct presenter for a new
+    /// full-screen modal. `RCTPresentedViewController()` returns the
+    /// currently-displayed VC which may itself be a modal, so we
+    /// traverse to the leaf to avoid "already presenting" errors.
+    private static func topmostViewController() -> UIViewController? {
+        guard var top = UIApplication.shared.connectedScenes
+            .compactMap({ ($0 as? UIWindowScene)?.keyWindow })
+            .first?
+            .rootViewController else {
+            return RCTPresentedViewController()
+        }
+        while let presented = top.presentedViewController {
+            top = presented
+        }
+        return top
     }
 }

package/ios/V4BridgeDelegate.swift

@@ -0,0 +1,62 @@
+//
+//  V4BridgeDelegate.swift
+//  react-native-usesense
+//
+//  Phase 1 ticket R-1. Adapter that translates LiveSenseV4Delegate
+//  callbacks into React Native promise resolve/reject + bridge events.
+//
+
+import Foundation
+import UseSenseSDK
+
+final class V4BridgeDelegate: NSObject, LiveSenseV4Delegate {
+    private let resolve: (Any?) -> Void
+    private let reject: (String, String?, Error?) -> Void
+    private let emit: ([String: Any]) -> Void
+    private var strongSession: LiveSenseV4Session?
+    private var didFinish = false
+
+    init(resolve: @escaping (Any?) -> Void,
+         reject: @escaping (String, String?, Error?) -> Void,
+         emit: @escaping ([String: Any]) -> Void) {
+        self.resolve = resolve
+        self.reject = reject
+        self.emit = emit
+    }
+
+    func retain(_ session: LiveSenseV4Session) {
+        strongSession = session
+    }
+
+    func sessionDidComplete(verdict: V4Verdict) {
+        if didFinish { return }
+        didFinish = true
+        let body: [String: Any?] = [
+            "session_id": verdict.sessionId,
+            "verdict": verdict.verdict.rawValue,
+            "confidence": verdict.confidence.rawValue,
+            "assurance_level_achieved": verdict.assuranceLevelAchieved,
+            "capture_channel": "rn",
+            "match_sense_embedding_id": verdict.matchSenseEmbeddingId,
+            "timestamp": verdict.timestamp
+        ]
+        resolve(body.compactMapValues { $0 })
+        strongSession = nil
+    }
+
+    func sessionDidFail(error: Error) {
+        if didFinish { return }
+        didFinish = true
+        reject("V4_FAILED", error.localizedDescription, error)
+        strongSession = nil
+    }
+
+    func sessionPhaseDidChange(phase: LiveSenseV4Phase) {
+        let body: [String: Any] = [
+            "type": "V4_PHASE_CHANGE",
+            "phase": phase.rawValue,
+            "timestamp": Int64(Date().timeIntervalSince1970 * 1000)
+        ]
+        emit(body)
+    }
+}

package/lib/commonjs/flows.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseSenseFlows = exports.FlowError = void 0;
+var _reactNative = require("react-native");
+/**
+ * React Native wrapper for the UseSense Flows runner.
+ *
+ * Coexists with the existing Sessions API (`UseSense.startSession`, etc.);
+ * this is a parallel surface, not a replacement. See `guides/flows/sessions-vs-flows`
+ * in the API docs for when to use which.
+ *
+ * Usage:
+ *
+ *   import { UseSenseFlows, FlowError } from 'react-native-usesense';
+ *
+ *   try {
+ *     const result = await UseSenseFlows.runFlow({ flowRunId, sdkToken });
+ *     console.log(result.outcome); // 'APPROVE' | 'REJECT' | 'MANUAL_REVIEW' | null
+ *   } catch (e) {
+ *     if (e instanceof FlowError) {
+ *       // e.code: 'token_expired' | 'token_invalid' | ...
+ *     }
+ *   }
+ */
+
+const LINKING_ERROR = `react-native-usesense (flows): the native module could not be found.\n\n` + _reactNative.Platform.select({
+  ios: `iOS: run \`cd ios && pod install\` and rebuild the app.`,
+  android: `Android: rebuild the app after installing the package.`,
+  default: ''
+});
+
+// Lazy lookup so this module doesn't throw at import time on platforms that
+// haven't been re-linked yet. The Sessions module mirrors this pattern.
+function nativeModule() {
+  const m = _reactNative.NativeModules.UseSenseFlowsModule;
+  if (!m) throw new Error(LINKING_ERROR);
+  return m;
+}
+
+/**
+ * Server-driven flow run state. Host apps see only the terminal ones via
+ * `FlowRunResult`; intermediate states drive the runner internally.
+ */
+
+/** Terminal outcome of a flow run. */
+
+/**
+ * Uniform error taxonomy across every SDK. See `guides/flows/errors` in the
+ * API docs for per-code recovery patterns.
+ */
+
+const FLOW_ERROR_CODES = ['token_expired', 'token_invalid', 'network_unavailable', 'permission_denied', 'provider_unavailable', 'cancelled', 'unsupported_action', 'invalid_input', 'unknown'];
+function normaliseCode(code) {
+  return typeof code === 'string' && FLOW_ERROR_CODES.includes(code) ? code : 'unknown';
+}
+
+/** Result returned to the host app's `runFlow` promise on terminal state. */
+
+/**
+ * Typed error thrown by `runFlow` when the native runner reports a failure.
+ * Mirrors the web / iOS / Android / Flutter SDKs so host apps catch one
+ * taxonomy regardless of platform.
+ */
+class FlowError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'FlowError';
+    this.code = code;
+  }
+}
+
+/** Options for `UseSenseFlows.runFlow`. */
+exports.FlowError = FlowError;
+/**
+ * Public entry point for the Flows runner. Sessions APIs are untouched;
+ * this is a parallel namespace.
+ */
+const UseSenseFlows = exports.UseSenseFlows = {
+  /**
+   * Run an operator-authored Flow inside the host app. Resolves with a
+   * [FlowRunResult] when the run reaches a terminal state (completed,
+   * cancelled, errored, abandoned). Rejects with a [FlowError] on transport
+   * / token / unsupported-action faults.
+   */
+  async runFlow(options) {
+    try {
+      const native = await nativeModule().runFlow(options.flowRunId, options.sdkToken, options.apiBaseUrl ?? null);
+      return {
+        flowRunId: native.flowRunId,
+        state: native.state,
+        outcome: native.outcome
+      };
+    } catch (e) {
+      // RN bridge errors are surfaced as `Error` with `.code` and `.message`
+      // properties when the native side calls `reject(code, message, null)`.
+      const code = normaliseCode(e.code);
+      const message = e.message ?? 'Flow failed';
+      throw new FlowError(code, message);
+    }
+  }
+};
+//# sourceMappingURL=flows.js.map

package/lib/commonjs/flows.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","LINKING_ERROR","Platform","select","ios","android","default","nativeModule","m","NativeModules","UseSenseFlowsModule","Error","FLOW_ERROR_CODES","normaliseCode","code","includes","FlowError","constructor","message","name","exports","UseSenseFlows","runFlow","options","native","flowRunId","sdkToken","apiBaseUrl","state","outcome","e"],"sourceRoot":"../../src","sources":["flows.ts"],"mappings":";;;;;;AAqBA,IAAAA,YAAA,GAAAC,OAAA;AArBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,MAAMC,aAAa,GACjB,0EAA0E,GAC1EC,qBAAQ,CAACC,MAAM,CAAC;EACdC,GAAG,EAAE,yDAAyD;EAC9DC,OAAO,EAAE,wDAAwD;EACjEC,OAAO,EAAE;AACX,CAAC,CAAC;;AAEJ;AACA;AACA,SAASC,YAAYA,CAAA,EAAG;EACtB,MAAMC,CAAC,GAAGC,0BAAa,CAACC,mBAAmB;EAC3C,IAAI,CAACF,CAAC,EAAE,MAAM,IAAIG,KAAK,CAACV,aAAa,CAAC;EACtC,OAAOO,CAAC;AACV;;AAEA;AACA;AACA;AACA;;AAWA;;AAGA;AACA;AACA;AACA;;AAeA,MAAMI,gBAA0C,GAAG,CACjD,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,WAAW,EACX,oBAAoB,EACpB,eAAe,EACf,SAAS,CACD;AAEV,SAASC,aAAaA,CAACC,IAAa,EAAiB;EACnD,OAAO,OAAOA,IAAI,KAAK,QAAQ,IAAKF,gBAAgB,CAAuBG,QAAQ,CAACD,IAAI,CAAC,GACpFA,IAAI,GACL,SAAS;AACf;;AAEA;;AAaA;AACA;AACA;AACA;AACA;AACO,MAAME,SAAS,SAASL,KAAK,CAAC;EAEnCM,WAAWA,CAACH,IAAmB,EAAEI,OAAe,EAAE;IAChD,KAAK,CAACA,OAAO,CAAC;IACd,IAAI,CAACC,IAAI,GAAG,WAAW;IACvB,IAAI,CAACL,IAAI,GAAGA,IAAI;EAClB;AACF;;AAEA;AAAAM,OAAA,CAAAJ,SAAA,GAAAA,SAAA;AAQA;AACA;AACA;AACA;AACO,MAAMK,aAAa,GAAAD,OAAA,CAAAC,aAAA,GAAG;EAC3B;AACF;AACA;AACA;AACA;AACA;EACE,MAAMC,OAAOA,CAACC,OAAuB,EAA0B;IAC7D,IAAI;MACF,MAAMC,MAAM,GAAG,MAAMjB,YAAY,CAAC,CAAC,CAACe,OAAO,CACzCC,OAAO,CAACE,SAAS,EACjBF,OAAO,CAACG,QAAQ,EAChBH,OAAO,CAACI,UAAU,IAAI,IACxB,CAAC;MACD,OAAO;QACLF,SAAS,EAAED,MAAM,CAACC,SAAS;QAC3BG,KAAK,EAAEJ,MAAM,CAACI,KAAK;QACnBC,OAAO,EAAEL,MAAM,CAACK;MAClB,CAAC;IACH,CAAC,CAAC,OAAOC,CAAC,EAAE;MACV;MACA;MACA,MAAMhB,IAAI,GAAGD,aAAa,CAAEiB,CAAC,CAAuBhB,IAAI,CAAC;MACzD,MAAMI,OAAO,GAAIY,CAAC,CAA0BZ,OAAO,IAAI,aAAa;MACpE,MAAM,IAAIF,SAAS,CAACF,IAAI,EAAEI,OAAO,CAAC;IACpC;EACF;AACF,CAAC","ignoreList":[]}