@stream-io/video-react-native-sdk 1.2.16 → 1.3.1

package/src/utils/push/{rxSubjects.ts → internal/rxSubjects.ts}

@@ -1,5 +1,5 @@
 import { BehaviorSubject } from 'rxjs';
-import { NonRingingPushEvent } from '../StreamVideoRN/types';
+import { NonRingingPushEvent } from '../../StreamVideoRN/types';
 
 /**
  * This rxjs subject is used to store the call cid of the accepted incoming call from push notification

package/src/utils/push/internal/utils.ts

@@ -0,0 +1,178 @@
+import {
+  Call,
+  RxUtils,
+  StreamVideoClient,
+  getLogger,
+} from '@stream-io/video-client';
+import type {
+  NonRingingPushEvent,
+  StreamVideoConfig,
+} from '../../StreamVideoRN/types';
+import { onNewCallNotification } from '../../internal/newNotificationCallbacks';
+import { pushUnsubscriptionCallbacks$ } from './rxSubjects';
+
+type PushConfig = NonNullable<StreamVideoConfig['push']>;
+
+type CanAddPushWSSubscriptionsRef = { current: boolean };
+
+/**
+ * This function is used to check if the call should be ended based on the push notification
+ * Useful for callkeep management to end the call if necessary (with reportEndCallWithUUID)
+ */
+export const shouldCallBeEnded = (
+  callFromPush: Call,
+  created_by_id: string | undefined,
+  receiver_id: string | undefined
+) => {
+  /* callkeep reasons for ending a call
+    FAILED: 1,
+    REMOTE_ENDED: 2,
+    UNANSWERED: 3,
+    ANSWERED_ELSEWHERE: 4,
+    DECLINED_ELSEWHERE: 5,
+    MISSED: 6
+  */
+  const callSession = callFromPush.state.session;
+  const rejected_by = callSession?.rejected_by;
+  const accepted_by = callSession?.accepted_by;
+  let mustEndCall = false;
+  let callkeepReason = 0;
+  if (created_by_id && rejected_by) {
+    if (rejected_by[created_by_id]) {
+      // call was cancelled by the caller
+      mustEndCall = true;
+      callkeepReason = 2;
+    }
+  } else if (receiver_id && rejected_by) {
+    if (rejected_by[receiver_id]) {
+      // call was rejected by the receiver in some other device
+      mustEndCall = true;
+      callkeepReason = 5;
+    }
+  } else if (receiver_id && accepted_by) {
+    if (accepted_by[receiver_id]) {
+      // call was accepted by the receiver in some other device
+      mustEndCall = true;
+      callkeepReason = 4;
+    }
+  }
+  return { mustEndCall, callkeepReason };
+};
+
+/* An action for the notification or callkeep and app does not have JS context setup yet, so we need to do two steps:
+  1. we need to create a new client and connect the user to decline the call
+  2. this is because the app is in background state and we don't have a client to get the call and do an action
+*/
+export const processCallFromPushInBackground = async (
+  pushConfig: PushConfig,
+  call_cid: string,
+  action: Parameters<typeof processCallFromPush>[2]
+) => {
+  let videoClient: StreamVideoClient | undefined;
+
+  try {
+    videoClient = await pushConfig.createStreamVideoClient();
+    if (!videoClient) {
+      return;
+    }
+  } catch (e) {
+    const logger = getLogger(['processCallFromPushInBackground']);
+    logger('error', 'failed to create video client', e);
+    return;
+  }
+  await processCallFromPush(videoClient, call_cid, action, pushConfig);
+};
+
+/**
+ * This function is used process the call from push notifications due to incoming call
+ * It does the following steps:
+ * 1. Get the call from the client if present or create a new call
+ * 2. Fetch the latest state of the call from the server if its not already in ringing state
+ * 3. Join or leave the call based on the user's action.
+ */
+export const processCallFromPush = async (
+  client: StreamVideoClient,
+  call_cid: string,
+  action: 'accept' | 'decline' | 'pressed' | 'backgroundDelivered',
+  pushConfig: PushConfig
+) => {
+  let callFromPush: Call;
+  try {
+    callFromPush = await client.onRingingCall(call_cid);
+  } catch (e) {
+    const logger = getLogger(['processCallFromPush']);
+    logger('error', 'failed to fetch call from push notification', e);
+    return;
+  }
+  // note: when action was pressed or delivered, we dont need to do anything as the only thing is to do is to get the call which adds it to the client
+  try {
+    if (action === 'accept') {
+      if (pushConfig.publishOptions) {
+        callFromPush.updatePublishOptions(pushConfig.publishOptions);
+      }
+      await callFromPush.join();
+    } else if (action === 'decline') {
+      await callFromPush.leave({ reject: true, reason: 'decline' });
+    }
+  } catch (e) {
+    const logger = getLogger(['processCallFromPush']);
+    logger(
+      'error',
+      `failed to process ${action} call from push notification`,
+      e
+    );
+  }
+};
+
+/**
+ * This function is used process the call from push notifications due to non ringing calls
+ * It does the following steps:
+ * 1. Get the call from the client if present or create a new call
+ * 2. Fetch the latest state of the call from the server
+ * 3. Call all the callbacks to inform the app about the call
+ */
+export const processNonIncomingCallFromPush = async (
+  client: StreamVideoClient,
+  call_cid: string,
+  nonRingingNotificationType: NonRingingPushEvent
+) => {
+  let callFromPush: Call;
+  try {
+    const _callFromPush = client.state.calls.find((c) => c.cid === call_cid);
+    if (_callFromPush) {
+      callFromPush = _callFromPush;
+    } else {
+      // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
+      const [callType, callId] = call_cid.split(':');
+      callFromPush = client.call(callType as string, callId as string);
+      await callFromPush.get();
+    }
+  } catch (e) {
+    const logger = getLogger(['processNonIncomingCallFromPush']);
+    logger('error', 'failed to fetch call from push notification', e);
+    return;
+  }
+  onNewCallNotification(callFromPush, nonRingingNotificationType);
+};
+
+/**
+ * This function is used to clear all the push related WS subscriptions
+ * note: events are subscribed in push for accept/decline through WS
+ */
+export const clearPushWSEventSubscriptions = () => {
+  const unsubscriptionCallbacks = RxUtils.getCurrentValue(
+    pushUnsubscriptionCallbacks$
+  );
+  if (unsubscriptionCallbacks) {
+    unsubscriptionCallbacks.forEach((cb) => cb());
+  }
+  pushUnsubscriptionCallbacks$.next(undefined);
+};
+
+/**
+ * This ref is used to check if the push WS subscriptions can be added
+ * It is used to avoid adding the push WS subscriptions when the client is connected to WS in the foreground
+ */
+export const canAddPushWSSubscriptionsRef: CanAddPushWSSubscriptionsRef = {
+  current: true,
+};

package/src/utils/push/ios.ts

@@ -1,41 +1,24 @@
 import { Platform } from 'react-native';
-import type {
-  NonRingingPushEvent,
-  StreamVideoConfig,
-} from '../StreamVideoRN/types';
-import {
-  pushAcceptedIncomingCallCId$,
-  voipPushNotificationCallCId$,
-  voipCallkeepCallOnForegroundMap$,
-  voipCallkeepAcceptedCallOnNativeDialerMap$,
-  pushNonRingingCallData$,
-} from './rxSubjects';
-import {
-  clearPushWSEventSubscriptions,
-  processCallFromPushInBackground,
-} from './utils';
+import type { StreamVideoConfig } from '../StreamVideoRN/types';
+import { pushNonRingingCallData$ } from './internal/rxSubjects';
 import {
+  ExpoNotification,
   getExpoNotificationsLib,
-  getNotifeeLibThrowIfNotInstalledForPush,
   getPushNotificationIosLib,
+  PushNotificationiOSType,
 } from './libs';
 import { StreamVideoClient, getLogger } from '@stream-io/video-client';
 import { setPushLogoutCallback } from '../internal/pushLogoutCallback';
+import { EventType, Event } from '@notifee/react-native';
+import { StreamVideoRN } from '../StreamVideoRN';
+import { StreamPushPayload } from './utils';
 
 type PushConfig = NonNullable<StreamVideoConfig['push']>;
 
-type StreamPayload =
-  | {
-      call_cid: string;
-      type: 'call.ring' | NonRingingPushEvent;
-      sender: string;
-    }
-  | undefined;
-
 let lastApnToken = { token: '', userId: '' };
 
 function processNonRingingNotificationStreamPayload(
-  streamPayload: StreamPayload
+  streamPayload: StreamPushPayload
 ) {
   if (
     streamPayload?.sender === 'stream.video' &&
@@ -48,87 +31,56 @@ function processNonRingingNotificationStreamPayload(
   }
 }
 
-export const iosCallkeepAcceptCall = (
-  call_cid: string | undefined,
-  callUUIDFromCallkeep: string
-) => {
-  if (!shouldProcessCallFromCallkeep(call_cid, callUUIDFromCallkeep)) {
-    return;
-  }
-  clearPushWSEventSubscriptions();
-  // to call end callkeep later if ended in app and not through callkeep
-  voipCallkeepAcceptedCallOnNativeDialerMap$.next({
-    uuid: callUUIDFromCallkeep,
-    cid: call_cid,
-  });
-  // to process the call in the app
-  pushAcceptedIncomingCallCId$.next(call_cid);
-  // no need to keep these references anymore
-  voipCallkeepCallOnForegroundMap$.next(undefined);
-};
-
-export const iosCallkeepRejectCall = async (
-  call_cid: string | undefined,
-  callUUIDFromCallkeep: string,
-  pushConfig: PushConfig
-) => {
-  if (!shouldProcessCallFromCallkeep(call_cid, callUUIDFromCallkeep)) {
-    return;
+export const oniOSExpoNotificationEvent = (event: ExpoNotification) => {
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (pushConfig) {
+    if (event.request.trigger.type === 'push') {
+      const streamPayload = event.request.trigger.payload
+        ?.stream as StreamPushPayload;
+      processNonRingingNotificationStreamPayload(streamPayload);
+    }
   }
-  clearPushWSEventSubscriptions();
-  // no need to keep these references anymore
-  voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
-  voipCallkeepCallOnForegroundMap$.next(undefined);
-  voipPushNotificationCallCId$.next(undefined);
-  await processCallFromPushInBackground(pushConfig, call_cid, 'decline');
 };
 
-/**
- * Helper function to determine if the answer/end call event from callkeep must be processed
- * Just checks if we have a valid call_cid and acts as a type guard for call_cid
- */
-const shouldProcessCallFromCallkeep = (
-  call_cid: string | undefined,
-  callUUIDFromCallkeep: string
-): call_cid is string => {
-  if (!call_cid || !callUUIDFromCallkeep) {
-    return false;
+export const oniOSNotifeeEvent = ({
+  event,
+}: {
+  event: Event;
+  isBackground: boolean;
+}) => {
+  if (Platform.OS !== 'ios') return;
+  const pushConfig = StreamVideoRN.getConfig().push;
+  const { type, detail } = event;
+  if (pushConfig && type === EventType.PRESS) {
+    const streamPayload = detail.notification?.data?.stream as
+      | StreamPushPayload
+      | undefined;
+    const result = processNonRingingNotificationStreamPayload(streamPayload);
+    if (result) {
+      pushConfig.onTapNonRingingCallNotification?.(result.cid, result.type);
+    }
   }
-  return true;
 };
 
-export const setupRemoteNotificationsHandleriOS = (pushConfig: PushConfig) => {
-  if (Platform.OS !== 'ios') {
+export function onPushNotificationiOSStreamVideoEvent(
+  notification: PushNotificationiOSType
+) {
+  const pushNotificationIosLib = getPushNotificationIosLib();
+  const data = notification.getData();
+  const streamPayload = data?.stream as StreamPushPayload;
+  const isClicked = data.userInteraction === 1;
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (!streamPayload || !isClicked || !pushConfig) {
+    notification.finish(pushNotificationIosLib.FetchResult.NoData);
     return;
   }
-  const notifeeLib = getNotifeeLibThrowIfNotInstalledForPush();
-
-  notifeeLib.default.onForegroundEvent(({ type, detail }) => {
-    if (type === notifeeLib.EventType.PRESS) {
-      const streamPayload = detail.notification?.data?.stream as
-        | StreamPayload
-        | undefined;
-      const result = processNonRingingNotificationStreamPayload(streamPayload);
-      if (result) {
-        pushConfig.onTapNonRingingCallNotification?.(result.cid, result.type);
-      }
-    }
-  });
-  if (pushConfig.isExpo) {
-    const Notifications = getExpoNotificationsLib();
-
-    // foreground handler (just to show the notifications on foreground)
-    Notifications.setNotificationHandler({
-      handleNotification: async () => {
-        return {
-          shouldShowAlert: true,
-          shouldPlaySound: true,
-          shouldSetBadge: false,
-        };
-      },
-    });
+  // listen to foreground notifications
+  const result = processNonRingingNotificationStreamPayload(streamPayload);
+  if (result) {
+    pushConfig.onTapNonRingingCallNotification?.(result.cid, result.type);
   }
-};
+  notification.finish(pushNotificationIosLib.FetchResult.NoData);
+}
 
 /** Send token to stream */
 export async function initIosNonVoipToken(
@@ -171,34 +123,16 @@ export async function initIosNonVoipToken(
         setDeviceToken(devicePushToken.data);
       }
     );
-    const subscriptionForReceive =
-      expoNotificationsLib.addNotificationReceivedListener((event) => {
-        // listen to foreground notifications
-        if (event.request.trigger.type === 'push') {
-          const streamPayload = event.request.trigger.payload
-            ?.stream as StreamPayload;
-          processNonRingingNotificationStreamPayload(streamPayload);
-        }
-      });
     setUnsubscribeListener(() => {
       subscription.remove();
-      subscriptionForReceive.remove();
     });
   } else {
     const pushNotificationIosLib = getPushNotificationIosLib();
     pushNotificationIosLib.addEventListener('register', (token) => {
       setDeviceToken(token);
     });
-    pushNotificationIosLib.addEventListener('notification', (notification) => {
-      const data = notification.getData();
-      const streamPayload = data?.stream as StreamPayload;
-      // listen to foreground notifications
-      processNonRingingNotificationStreamPayload(streamPayload);
-      notification.finish(pushNotificationIosLib.FetchResult.NoData);
-    });
     setUnsubscribeListener(() => {
       pushNotificationIosLib.removeEventListener('register');
-      pushNotificationIosLib.removeEventListener('notification');
     });
   }
 }

package/src/utils/push/libs/expoNotifications.ts

@@ -1,5 +1,9 @@
 export type ExpoNotificationsLib = typeof import('expo-notifications');
 
+import type { Notification } from 'expo-notifications';
+
+export type ExpoNotification = Notification;
+
 let expoNotificationsLib: ExpoNotificationsLib | undefined;
 
 try {

package/src/utils/push/libs/index.ts

@@ -1,5 +1,4 @@
 export * from './expoNotifications';
-export * from './expoTaskManager';
 export * from './firebaseMessaging';
 export * from './iosPushNotification';
 export * from './voipPushNotification';

package/src/utils/push/libs/iosPushNotification.ts

@@ -3,6 +3,10 @@ export type PushNotificationIosLib =
 
 let pushNotificationIosLib: PushNotificationIosLib | undefined;
 
+import type { PushNotification } from '@react-native-community/push-notification-ios';
+
+export type PushNotificationiOSType = PushNotification;
+
 try {
   pushNotificationIosLib =
     require('@react-native-community/push-notification-ios').default;

package/src/utils/push/utils.ts

@@ -1,178 +1,47 @@
-import {
-  Call,
-  getLogger,
-  RxUtils,
-  StreamVideoClient,
-} from '@stream-io/video-client';
-import type {
-  NonRingingPushEvent,
-  StreamVideoConfig,
-} from '../StreamVideoRN/types';
-import { onNewCallNotification } from '../internal/newNotificationCallbacks';
-import { pushUnsubscriptionCallbacks$ } from './rxSubjects';
-
-type PushConfig = NonNullable<StreamVideoConfig['push']>;
-
-type CanAddPushWSSubscriptionsRef = { current: boolean };
-
-/**
- * This function is used to check if the call should be ended based on the push notification
- * Useful for callkeep management to end the call if necessary (with reportEndCallWithUUID)
- */
-export const shouldCallBeEnded = (
-  callFromPush: Call,
-  created_by_id: string | undefined,
-  receiver_id: string | undefined
-) => {
-  /* callkeep reasons for ending a call
-    FAILED: 1,
-    REMOTE_ENDED: 2,
-    UNANSWERED: 3,
-    ANSWERED_ELSEWHERE: 4,
-    DECLINED_ELSEWHERE: 5,
-    MISSED: 6
-  */
-  const callSession = callFromPush.state.session;
-  const rejected_by = callSession?.rejected_by;
-  const accepted_by = callSession?.accepted_by;
-  let mustEndCall = false;
-  let callkeepReason = 0;
-  if (created_by_id && rejected_by) {
-    if (rejected_by[created_by_id]) {
-      // call was cancelled by the caller
-      mustEndCall = true;
-      callkeepReason = 2;
-    }
-  } else if (receiver_id && rejected_by) {
-    if (rejected_by[receiver_id]) {
-      // call was rejected by the receiver in some other device
-      mustEndCall = true;
-      callkeepReason = 5;
-    }
-  } else if (receiver_id && accepted_by) {
-    if (accepted_by[receiver_id]) {
-      // call was accepted by the receiver in some other device
-      mustEndCall = true;
-      callkeepReason = 4;
+import { Event } from '@notifee/react-native';
+import { FirebaseMessagingTypes } from './libs/firebaseMessaging';
+import { ExpoNotification } from './libs/expoNotifications';
+import { NonRingingPushEvent } from '../StreamVideoRN/types';
+import { PushNotificationiOSType } from './libs/iosPushNotification';
+
+export type StreamPushPayload =
+  | {
+      call_cid: string;
+      type: 'call.ring' | NonRingingPushEvent;
+      sender: string;
     }
-  }
-  return { mustEndCall, callkeepReason };
-};
-
-/* An action for the notification or callkeep and app does not have JS context setup yet, so we need to do two steps:
-  1. we need to create a new client and connect the user to decline the call
-  2. this is because the app is in background state and we don't have a client to get the call and do an action
-*/
-export const processCallFromPushInBackground = async (
-  pushConfig: PushConfig,
-  call_cid: string,
-  action: Parameters<typeof processCallFromPush>[2]
-) => {
-  let videoClient: StreamVideoClient | undefined;
-
-  try {
-    videoClient = await pushConfig.createStreamVideoClient();
-    if (!videoClient) {
-      return;
-    }
-  } catch (e) {
-    const logger = getLogger(['processCallFromPushInBackground']);
-    logger('error', 'failed to create video client', e);
-    return;
-  }
-  await processCallFromPush(videoClient, call_cid, action, pushConfig);
-};
-
-/**
- * This function is used process the call from push notifications due to incoming call
- * It does the following steps:
- * 1. Get the call from the client if present or create a new call
- * 2. Fetch the latest state of the call from the server if its not already in ringing state
- * 3. Join or leave the call based on the user's action.
- */
-export const processCallFromPush = async (
-  client: StreamVideoClient,
-  call_cid: string,
-  action: 'accept' | 'decline' | 'pressed' | 'backgroundDelivered',
-  pushConfig: PushConfig
-) => {
-  let callFromPush: Call;
-  try {
-    callFromPush = await client.onRingingCall(call_cid);
-  } catch (e) {
-    const logger = getLogger(['processCallFromPush']);
-    logger('error', 'failed to fetch call from push notification', e);
-    return;
-  }
-  // note: when action was pressed or delivered, we dont need to do anything as the only thing is to do is to get the call which adds it to the client
-  try {
-    if (action === 'accept') {
-      if (pushConfig.publishOptions) {
-        callFromPush.updatePublishOptions(pushConfig.publishOptions);
-      }
-      await callFromPush.join();
-    } else if (action === 'decline') {
-      await callFromPush.leave({ reject: true });
-    }
-  } catch (e) {
-    const logger = getLogger(['processCallFromPush']);
-    logger(
-      'error',
-      `failed to process ${action} call from push notification`,
-      e
+  | undefined;
+
+export function isFirebaseStreamVideoMessage(
+  message: FirebaseMessagingTypes.RemoteMessage
+) {
+  return message.data?.sender === 'stream.video';
+}
+
+export function isNotifeeStreamVideoEvent(event: Event) {
+  const { detail } = event;
+  const { notification } = detail;
+  return notification?.data?.sender === 'stream.video';
+}
+
+export function isExpoNotificationStreamVideoEvent(event: ExpoNotification) {
+  if (event.request.trigger.type === 'push') {
+    // iOS
+    const streamPayload = event.request.trigger.payload
+      ?.stream as StreamPushPayload;
+    // Android
+    const remoteMessageData = event.request.trigger.remoteMessage?.data;
+    return (
+      streamPayload?.sender === 'stream.video' ||
+      remoteMessageData?.sender === 'stream.video'
     );
   }
-};
-
-/**
- * This function is used process the call from push notifications due to non ringing calls
- * It does the following steps:
- * 1. Get the call from the client if present or create a new call
- * 2. Fetch the latest state of the call from the server if its not already in ringing state
- * 3. Call all the callbacks to inform the app about the call
- */
-export const processNonIncomingCallFromPush = async (
-  client: StreamVideoClient,
-  call_cid: string,
-  nonRingingNotificationType: NonRingingPushEvent
-) => {
-  let callFromPush: Call;
-  try {
-    const _callFromPush = client.state.calls.find((c) => c.cid === call_cid);
-    if (_callFromPush) {
-      callFromPush = _callFromPush;
-    } else {
-      // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
-      const [callType, callId] = call_cid.split(':');
-      callFromPush = client.call(callType as string, callId as string);
-      await callFromPush.get();
-    }
-  } catch (e) {
-    const logger = getLogger(['processNonIncomingCallFromPush']);
-    logger('error', 'failed to fetch call from push notification', e);
-    return;
-  }
-  onNewCallNotification(callFromPush, nonRingingNotificationType);
-};
-
-/**
- * This function is used to clear all the push related WS subscriptions
- * note: events are subscribed in push for accept/decline through WS
- */
-export const clearPushWSEventSubscriptions = () => {
-  const unsubscriptionCallbacks = RxUtils.getCurrentValue(
-    pushUnsubscriptionCallbacks$
-  );
-  if (unsubscriptionCallbacks) {
-    unsubscriptionCallbacks.forEach((cb) => cb());
-  }
-  pushUnsubscriptionCallbacks$.next(undefined);
-};
-
-/**
- * This ref is used to check if the push WS subscriptions can be added
- * It is used to avoid adding the push WS subscriptions when the client is connected to WS in the foreground
- */
-export const canAddPushWSSubscriptionsRef: CanAddPushWSSubscriptionsRef = {
-  current: true,
-};
+}
+
+export function isPushNotificationiOSStreamVideoEvent(
+  notification: PushNotificationiOSType
+) {
+  const data = notification.getData();
+  const streamPayload = data?.stream as StreamPushPayload;
+  return streamPayload?.sender === 'stream.video';
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.2.15';
+export const version = '1.3.1';

package/dist/commonjs/utils/push/libs/expoTaskManager.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getExpoTaskManagerLib = getExpoTaskManagerLib;
-let expoTaskManagerLib;
-try {
-  expoTaskManagerLib = require('expo-task-manager');
-} catch (_e) {}
-function getExpoTaskManagerLib() {
-  if (!expoTaskManagerLib) {
-    throw Error('expo-task-manager library is not installed. Please see https://docs.expo.dev/versions/latest/sdk/task-manager/ for installation instructions');
-  }
-  return expoTaskManagerLib;
-}
-//# sourceMappingURL=expoTaskManager.js.map

package/dist/commonjs/utils/push/libs/expoTaskManager.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["expoTaskManagerLib","require","_e","getExpoTaskManagerLib","Error"],"sourceRoot":"../../../../../src","sources":["utils/push/libs/expoTaskManager.ts"],"mappings":";;;;;;AAEA,IAAIA,kBAAkD;AAEtD,IAAI;EACFA,kBAAkB,GAAGC,OAAO,CAAC,mBAAmB,CAAC;AACnD,CAAC,CAAC,OAAOC,EAAE,EAAE,CAAC;AAEP,SAASC,qBAAqBA,CAAA,EAAuB;EAC1D,IAAI,CAACH,kBAAkB,EAAE;IACvB,MAAMI,KAAK,CACT,8IACF,CAAC;EACH;EACA,OAAOJ,kBAAkB;AAC3B","ignoreList":[]}