livekit-client 0.18.5 → 1.0.1

package/src/room/participant/publishUtils.test.ts

@@ -28,11 +28,11 @@ describe('presetsForResolution', () => {
 
 describe('determineAppropriateEncoding', () => {
   it('uses higher encoding', () => {
-    expect(determineAppropriateEncoding(false, 600, 300)).toEqual(VideoPresets.vga.encoding);
+    expect(determineAppropriateEncoding(false, 600, 300)).toEqual(VideoPresets.h360.encoding);
   });
 
   it('handles portrait', () => {
-    expect(determineAppropriateEncoding(false, 300, 600)).toEqual(VideoPresets.vga.encoding);
+    expect(determineAppropriateEncoding(false, 300, 600)).toEqual(VideoPresets.h360.encoding);
   });
 });
 

package/src/room/track/LocalVideoTrack.ts

@@ -89,7 +89,7 @@ export default class LocalVideoTrack extends LocalTrack {
           bytesSent: v.bytesSent,
           framesSent: v.framesSent,
           timestamp: v.timestamp,
-          rid: v.rid ?? '',
+          rid: v.rid ?? v.id,
           retransmittedPacketsSent: v.retransmittedPacketsSent,
           qualityLimitationReason: v.qualityLimitationReason,
           qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges,

package/src/room/track/RemoteVideoTrack.test.ts

@@ -0,0 +1,149 @@
+import { TrackEvent } from '../events';
+import RemoteVideoTrack, { ElementInfo } from './RemoteVideoTrack';
+import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
+import { Track } from './Track';
+
+jest.useFakeTimers();
+
+describe('RemoteVideoTrack', () => {
+  let track: RemoteVideoTrack;
+
+  beforeEach(() => {
+    track = new RemoteVideoTrack(new MockMediaStreamTrack(), 'sid', undefined, {});
+  });
+  describe('element visibility', () => {
+    let events: boolean[] = [];
+
+    beforeEach(() => {
+      track.on(TrackEvent.VisibilityChanged, (visible) => {
+        events.push(visible);
+      });
+    });
+    afterEach(() => {
+      events = [];
+    });
+
+    it('emits a visibility event upon observing visible element', () => {
+      const elementInfo = new MockElementInfo();
+      elementInfo.visible = true;
+
+      track.observeElementInfo(elementInfo);
+
+      expect(events).toHaveLength(1);
+      expect(events[0]).toBeTruthy();
+    });
+
+    it('emits a visibility event upon element becoming visible', () => {
+      const elementInfo = new MockElementInfo();
+      track.observeElementInfo(elementInfo);
+
+      elementInfo.setVisible(true);
+
+      expect(events).toHaveLength(2);
+      expect(events[1]).toBeTruthy();
+    });
+
+    it('emits a visibility event upon removing only visible element', () => {
+      const elementInfo = new MockElementInfo();
+      elementInfo.visible = true;
+
+      track.observeElementInfo(elementInfo);
+      track.stopObservingElementInfo(elementInfo);
+
+      expect(events).toHaveLength(2);
+      expect(events[1]).toBeFalsy();
+    });
+  });
+
+  describe('element dimensions', () => {
+    let events: Track.Dimensions[] = [];
+
+    beforeEach(() => {
+      track.on(TrackEvent.VideoDimensionsChanged, (dimensions) => {
+        events.push(dimensions);
+      });
+    });
+
+    afterEach(() => {
+      events = [];
+    });
+
+    it('emits a dimensions event upon observing element', () => {
+      const elementInfo = new MockElementInfo();
+      elementInfo.setDimensions(100, 100);
+
+      track.observeElementInfo(elementInfo);
+      jest.runAllTimers();
+
+      expect(events).toHaveLength(1);
+      expect(events[0].width).toBe(100);
+      expect(events[0].height).toBe(100);
+    });
+
+    it('emits a dimensions event upon element resize', () => {
+      const elementInfo = new MockElementInfo();
+      elementInfo.setDimensions(100, 100);
+
+      track.observeElementInfo(elementInfo);
+      jest.runAllTimers();
+
+      elementInfo.setDimensions(200, 200);
+      jest.runAllTimers();
+
+      expect(events).toHaveLength(2);
+      expect(events[1].width).toBe(200);
+      expect(events[1].height).toBe(200);
+    });
+  });
+});
+
+class MockElementInfo implements ElementInfo {
+  element: object = {};
+
+  private _width = 0;
+
+  private _height = 0;
+
+  setDimensions(width: number, height: number) {
+    let shouldEmit = false;
+    if (this._width !== width) {
+      this._width = width;
+      shouldEmit = true;
+    }
+    if (this._height !== height) {
+      this._height = height;
+      shouldEmit = true;
+    }
+
+    if (shouldEmit) {
+      this.handleResize?.();
+    }
+  }
+
+  width(): number {
+    return this._width;
+  }
+
+  height(): number {
+    return this._height;
+  }
+
+  visible = false;
+
+  setVisible = (visible: boolean) => {
+    if (this.visible !== visible) {
+      this.visible = visible;
+      this.handleVisibilityChanged?.();
+    }
+  };
+
+  visibilityChangedAt = 0;
+
+  handleResize?: () => void;
+
+  handleVisibilityChanged?: () => void;
+
+  observe(): void {}
+
+  stopObserving(): void {}
+}

package/src/room/track/RemoteVideoTrack.ts

@@ -1,15 +1,11 @@
 import { debounce } from 'ts-debounce';
 import { TrackEvent } from '../events';
 import { computeBitrate, monitorFrequency, VideoReceiverStats } from '../stats';
-import {
-  getIntersectionObserver,
-  getResizeObserver,
-  isMobile,
-  ObservableMediaElement,
-} from '../utils';
+import { getIntersectionObserver, getResizeObserver, ObservableMediaElement } from '../utils';
 import RemoteTrack from './RemoteTrack';
 import { attachToElement, detachTrack, Track } from './Track';
 import { AdaptiveStreamSettings } from './types';
+import log from '../../logger';
 
 const REACTION_DELAY = 100;
 
@@ -27,6 +23,8 @@ export default class RemoteVideoTrack extends RemoteTrack {
 
   private lastDimensions?: Track.Dimensions;
 
+  private hasUsedAttach: boolean = false;
+
   constructor(
     mediaTrack: MediaStreamTrack,
     sid: string,
@@ -45,9 +43,9 @@ export default class RemoteVideoTrack extends RemoteTrack {
   }
 
   get mediaStreamTrack() {
-    if (this.isAdaptiveStream && this.attachedElements.length === 0) {
-      throw Error(
-        'When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, direct usage of mediaStreamTrack is unsupported in this case',
+    if (this.isAdaptiveStream && !this.hasUsedAttach) {
+      log.warn(
+        'When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start',
       );
     }
     return this._mediaStreamTrack;
@@ -82,23 +80,51 @@ export default class RemoteVideoTrack extends RemoteTrack {
       this.adaptiveStreamSettings &&
       this.elementInfos.find((info) => info.element === element) === undefined
     ) {
-      this.elementInfos.push({
-        element,
-        visible: true, // default visible
-      });
-
-      (element as ObservableMediaElement).handleResize = this.debouncedHandleResize;
-      (element as ObservableMediaElement).handleVisibilityChanged = this.handleVisibilityChanged;
-
-      getIntersectionObserver().observe(element);
-      getResizeObserver().observe(element);
+      const elementInfo = new HTMLElementInfo(element);
+      this.observeElementInfo(elementInfo);
+    }
+    this.hasUsedAttach = true;
+    return element;
+  }
 
+  /**
+   * Observe an ElementInfo for changes when adaptive streaming.
+   * @param elementInfo
+   * @internal
+   */
+  observeElementInfo(elementInfo: ElementInfo) {
+    if (
+      this.adaptiveStreamSettings &&
+      this.elementInfos.find((info) => info === elementInfo) === undefined
+    ) {
+      elementInfo.handleResize = () => {
+        this.debouncedHandleResize();
+      };
+      elementInfo.handleVisibilityChanged = () => {
+        this.updateVisibility();
+      };
+      this.elementInfos.push(elementInfo);
+      elementInfo.observe();
       // trigger the first resize update cycle
       // if the tab is backgrounded, the initial resize event does not fire until
       // the tab comes into focus for the first time.
       this.debouncedHandleResize();
+      this.updateVisibility();
     }
-    return element;
+  }
+
+  /**
+   * Stop observing an ElementInfo for changes.
+   * @param elementInfo
+   * @internal
+   */
+  stopObservingElementInfo(elementInfo: ElementInfo) {
+    const stopElementInfos = this.elementInfos.filter((info) => info === elementInfo);
+    for (const info of stopElementInfos) {
+      info.stopObserving();
+    }
+    this.elementInfos = this.elementInfos.filter((info) => info !== elementInfo);
+    this.updateVisibility();
   }
 
   detach(): HTMLMediaElement[];
@@ -166,26 +192,16 @@ export default class RemoteVideoTrack extends RemoteTrack {
   }
 
   private stopObservingElement(element: HTMLMediaElement) {
-    getIntersectionObserver()?.unobserve(element);
-    getResizeObserver()?.unobserve(element);
+    const stopElementInfos = this.elementInfos.filter((info) => info.element === element);
+    for (const info of stopElementInfos) {
+      info.stopObserving();
+    }
     this.elementInfos = this.elementInfos.filter((info) => info.element !== element);
   }
 
-  private handleVisibilityChanged = (entry: IntersectionObserverEntry) => {
-    const { target, isIntersecting } = entry;
-    const elementInfo = this.elementInfos.find((info) => info.element === target);
-    if (elementInfo) {
-      elementInfo.visible = isIntersecting;
-      elementInfo.visibilityChangedAt = Date.now();
-    }
-    this.updateVisibility();
-  };
-
   protected async handleAppVisibilityChanged() {
     await super.handleAppVisibilityChanged();
     if (!this.isAdaptiveStream) return;
-    // on desktop don't pause when tab is backgrounded
-    if (!isMobile()) return;
     this.updateVisibility();
   }
 
@@ -198,7 +214,12 @@ export default class RemoteVideoTrack extends RemoteTrack {
       (prev, info) => Math.max(prev, info.visibilityChangedAt || 0),
       0,
     );
-    const isVisible = this.elementInfos.some((info) => info.visible) && !this.isInBackground;
+
+    const backgroundPause =
+      this.adaptiveStreamSettings?.pauseVideoInBackground ?? true // default to true
+        ? this.isInBackground
+        : false;
+    const isVisible = this.elementInfos.some((info) => info.visible) && !backgroundPause;
 
     if (this.lastVisible === isVisible) {
       return;
@@ -222,8 +243,8 @@ export default class RemoteVideoTrack extends RemoteTrack {
     for (const info of this.elementInfos) {
       const pixelDensity = this.adaptiveStreamSettings?.pixelDensity ?? 1;
       const pixelDensityValue = pixelDensity === 'screen' ? window.devicePixelRatio : pixelDensity;
-      const currentElementWidth = info.element.clientWidth * pixelDensityValue;
-      const currentElementHeight = info.element.clientHeight * pixelDensityValue;
+      const currentElementWidth = info.width() * pixelDensityValue;
+      const currentElementHeight = info.height() * pixelDensityValue;
       if (currentElementWidth + currentElementHeight > maxWidth + maxHeight) {
         maxWidth = currentElementWidth;
         maxHeight = currentElementHeight;
@@ -238,12 +259,70 @@ export default class RemoteVideoTrack extends RemoteTrack {
       width: maxWidth,
       height: maxHeight,
     };
+
     this.emit(TrackEvent.VideoDimensionsChanged, this.lastDimensions, this);
   }
 }
 
-interface ElementInfo {
+export interface ElementInfo {
+  element: object;
+  width(): number;
+  height(): number;
+  visible: boolean;
+  visibilityChangedAt: number | undefined;
+
+  handleResize?: () => void;
+  handleVisibilityChanged?: () => void;
+  observe(): void;
+  stopObserving(): void;
+}
+
+class HTMLElementInfo implements ElementInfo {
   element: HTMLMediaElement;
+
   visible: boolean;
-  visibilityChangedAt?: number;
+
+  visibilityChangedAt: number | undefined;
+
+  handleResize?: () => void;
+
+  handleVisibilityChanged?: () => void;
+
+  constructor(element: HTMLMediaElement, visible: boolean = false) {
+    this.element = element;
+    this.visible = visible;
+    this.visibilityChangedAt = 0;
+  }
+
+  width(): number {
+    return this.element.clientWidth;
+  }
+
+  height(): number {
+    return this.element.clientWidth;
+  }
+
+  observe() {
+    (this.element as ObservableMediaElement).handleResize = () => {
+      this.handleResize?.();
+    };
+    (this.element as ObservableMediaElement).handleVisibilityChanged = this.onVisibilityChanged;
+
+    getIntersectionObserver().observe(this.element);
+    getResizeObserver().observe(this.element);
+  }
+
+  private onVisibilityChanged = (entry: IntersectionObserverEntry) => {
+    const { target, isIntersecting } = entry;
+    if (target === this.element) {
+      this.visible = isIntersecting;
+      this.visibilityChangedAt = Date.now();
+      this.handleVisibilityChanged?.();
+    }
+  };
+
+  stopObserving() {
+    getIntersectionObserver()?.unobserve(this.element);
+    getResizeObserver()?.unobserve(this.element);
+  }
 }

package/src/room/track/Track.ts

@@ -5,6 +5,8 @@ import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc';
 import { TrackEvent } from '../events';
 import { isFireFox, isSafari, isWeb } from '../utils';
 
+const BACKGROUND_REACTION_DELAY = 5000;
+
 // keep old audio elements when detached, we would re-use them since on iOS
 // Safari tracks which audio elements have been "blessed" by the user.
 const recycledElements: Array<HTMLAudioElement> = [];
@@ -32,6 +34,8 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
 
   protected isInBackground: boolean;
 
+  private backgroundTimeout: ReturnType<typeof setTimeout> | undefined;
+
   protected _currentBitrate: number = 0;
 
   protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind) {
@@ -179,8 +183,20 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
     }
   }
 
-  appVisibilityChangedListener = () => {
-    this.handleAppVisibilityChanged();
+  protected appVisibilityChangedListener = () => {
+    if (this.backgroundTimeout) {
+      clearTimeout(this.backgroundTimeout);
+    }
+    // delay app visibility update if it goes to hidden
+    // update immediately if it comes back to focus
+    if (document.visibilityState === 'hidden') {
+      this.backgroundTimeout = setTimeout(
+        () => this.handleAppVisibilityChanged(),
+        BACKGROUND_REACTION_DELAY,
+      );
+    } else {
+      this.handleAppVisibilityChanged();
+    }
   };
 
   protected async handleAppVisibilityChanged() {

package/src/room/track/create.ts

@@ -89,7 +89,7 @@ export async function createLocalScreenTracks(
     options = {};
   }
   if (options.resolution === undefined) {
-    options.resolution = VideoPresets.fhd.resolution;
+    options.resolution = VideoPresets.h1080.resolution;
   }
 
   let videoConstraints: MediaTrackConstraints | boolean = true;

package/src/room/track/options.ts

@@ -232,20 +232,10 @@ export const VideoPresets = {
   h216: new VideoPreset(384, 216, 180_000, 15),
   h360: new VideoPreset(640, 360, 300_000, 20),
   h540: new VideoPreset(960, 540, 600_000, 25),
-  h720: new VideoPreset(1280, 720, 2_000_000, 30),
+  h720: new VideoPreset(1280, 720, 1_700_000, 30),
   h1080: new VideoPreset(1920, 1080, 3_000_000, 30),
   h1440: new VideoPreset(2560, 1440, 5_000_000, 30),
   h2160: new VideoPreset(3840, 2160, 8_000_000, 30),
-  /** @deprecated */
-  qvga: new VideoPreset(320, 180, 120_000, 10),
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 300_000, 20),
-  /** @deprecated */
-  qhd: new VideoPreset(960, 540, 600_000, 25),
-  /** @deprecated */
-  hd: new VideoPreset(1280, 720, 2_000_000, 30),
-  /** @deprecated */
-  fhd: new VideoPreset(1920, 1080, 3_000_000, 30),
 } as const;
 
 /**
@@ -261,16 +251,6 @@ export const VideoPresets43 = {
   h720: new VideoPreset(960, 720, 1_500_000, 30),
   h1080: new VideoPreset(1440, 1080, 2_500_000, 30),
   h1440: new VideoPreset(1920, 1440, 3_500_000, 30),
-  /** @deprecated */
-  qvga: new VideoPreset(240, 180, 90_000, 10),
-  /** @deprecated */
-  vga: new VideoPreset(480, 360, 225_000, 20),
-  /** @deprecated */
-  qhd: new VideoPreset(720, 540, 450_000, 25),
-  /** @deprecated */
-  hd: new VideoPreset(960, 720, 1_500_000, 30),
-  /** @deprecated */
-  fhd: new VideoPreset(1440, 1080, 2_800_000, 30),
 } as const;
 
 export const ScreenSharePresets = {
@@ -279,14 +259,4 @@ export const ScreenSharePresets = {
   h720fps15: new VideoPreset(1280, 720, 1_000_000, 15),
   h1080fps15: new VideoPreset(1920, 1080, 1_500_000, 15),
   h1080fps30: new VideoPreset(1920, 1080, 3_000_000, 30),
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 200_000, 3),
-  /** @deprecated */
-  hd_8: new VideoPreset(1280, 720, 400_000, 5),
-  /** @deprecated */
-  hd_15: new VideoPreset(1280, 720, 1_000_000, 15),
-  /** @deprecated */
-  fhd_15: new VideoPreset(1920, 1080, 1_500_000, 15),
-  /** @deprecated */
-  fhd_30: new VideoPreset(1920, 1080, 3_000_000, 30),
 } as const;

package/src/room/track/types.ts

@@ -17,4 +17,9 @@ export type AdaptiveStreamSettings = {
    * streaming on high definition screens.
    */
   pixelDensity?: number | 'screen';
+  /**
+   * If true, video gets paused when switching to another tab.
+   * Defaults to true.
+   */
+  pauseVideoInBackground?: boolean;
 };

package/src/room/track/utils.test.ts

@@ -8,7 +8,7 @@ describe('mergeDefaultOptions', () => {
   };
   const videoDefaults: VideoCaptureOptions = {
     deviceId: 'video123',
-    resolution: VideoPresets.fhd.resolution,
+    resolution: VideoPresets.h1080.resolution,
   };
 
   it('does not enable undefined options', () => {
@@ -88,7 +88,7 @@ describe('constraintsForOptions', () => {
   it('converts video options correctly', () => {
     const constraints = constraintsForOptions({
       video: {
-        resolution: VideoPresets.hd.resolution,
+        resolution: VideoPresets.h720.resolution,
         facingMode: 'user',
         deviceId: 'video123',
       },
@@ -102,9 +102,9 @@ describe('constraintsForOptions', () => {
       'facingMode',
       'deviceId',
     ]);
-    expect(videoOpts.width).toEqual(VideoPresets.hd.resolution.width);
-    expect(videoOpts.height).toEqual(VideoPresets.hd.resolution.height);
-    expect(videoOpts.frameRate).toEqual(VideoPresets.hd.resolution.frameRate);
-    expect(videoOpts.aspectRatio).toEqual(VideoPresets.hd.resolution.aspectRatio);
+    expect(videoOpts.width).toEqual(VideoPresets.h720.resolution.width);
+    expect(videoOpts.height).toEqual(VideoPresets.h720.resolution.height);
+    expect(videoOpts.frameRate).toEqual(VideoPresets.h720.resolution.frameRate);
+    expect(videoOpts.aspectRatio).toEqual(VideoPresets.h720.resolution.aspectRatio);
   });
 });

package/src/test/MockMediaStreamTrack.ts

@@ -0,0 +1,83 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export default class MockMediaStreamTrack implements MediaStreamTrack {
+  contentHint: string = '';
+
+  enabled: boolean = true;
+
+  id: string = 'id';
+
+  kind: string = 'video';
+
+  label: string = 'label';
+
+  muted: boolean = false;
+
+  onended: ((this: MediaStreamTrack, ev: Event) => any) | null = null;
+
+  onmute: ((this: MediaStreamTrack, ev: Event) => any) | null = null;
+
+  onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null = null;
+
+  readyState: MediaStreamTrackState = 'live';
+
+  isolated: boolean = false;
+
+  onisolationchange: ((this: MediaStreamTrack, ev: Event) => any) | null = null;
+
+  // @ts-ignore
+  applyConstraints(constraints?: MediaTrackConstraints): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  clone(): MediaStreamTrack {
+    throw new Error('Method not implemented.');
+  }
+
+  getCapabilities(): MediaTrackCapabilities {
+    throw new Error('Method not implemented.');
+  }
+
+  getConstraints(): MediaTrackConstraints {
+    throw new Error('Method not implemented.');
+  }
+
+  getSettings(): MediaTrackSettings {
+    throw new Error('Method not implemented.');
+  }
+
+  stop(): void {
+    throw new Error('Method not implemented.');
+  }
+
+  addEventListener<K extends keyof MediaStreamTrackEventMap>(
+    type: K,
+    listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions,
+  ): void;
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions,
+  ): void;
+  addEventListener(type: any, listener: any, options?: any): void {
+    throw new Error('Method not implemented.');
+  }
+
+  removeEventListener<K extends keyof MediaStreamTrackEventMap>(
+    type: K,
+    listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any,
+    options?: boolean | EventListenerOptions,
+  ): void;
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions,
+  ): void;
+  removeEventListener(type: any, listener: any, options?: any): void {
+    throw new Error('Method not implemented.');
+  }
+
+  dispatchEvent(event: Event): boolean {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.18.5';
+export const version = '1.0.1';
 export const protocolVersion = 7;

package/dist/connect.d.ts

@@ -1,24 +0,0 @@
-import { ConnectOptions } from './options';
-import Room from './room/Room';
-export { version } from './version';
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
- */
-export declare function connect(url: string, token: string, options?: ConnectOptions): Promise<Room>;
-//# sourceMappingURL=connect.d.ts.map

package/dist/connect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C,OAAO,IAAI,MAAM,aAAa,CAAC;AAE/B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAsEjG"}