@onekeyfe/hd-transport-web-device 1.1.34-alpha.2 → 1.1.34-alpha.3

package/__tests__/electron-ble-transport.test.ts

@@ -0,0 +1,342 @@
+import transport, { PROTOCOL_V2_CHANNEL_BLE_UART, bytesToHex } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ElectronBleTransport from '../src/electron-ble-transport';
+
+const { ProtocolV1, ProtocolV2, parseConfigure } = transport;
+
+const protocolV1Schema = {
+  nested: {
+    Initialize: {
+      fields: {},
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 1,
+        MessageType_Success: 2,
+      },
+    },
+  },
+};
+
+const protocolV2Schema = {
+  nested: {
+    ProtocolInfoRequest: {
+      fields: {},
+    },
+    ProtocolInfo: {
+      fields: {
+        version: {
+          type: 'uint32',
+          id: 1,
+        },
+        supported_messages: {
+          rule: 'repeated',
+          type: 'uint32',
+          id: 2,
+          options: {
+            packed: false,
+          },
+        },
+        protobuf_definition: {
+          type: 'string',
+          id: 3,
+        },
+      },
+    },
+    Ping: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_ProtocolInfoRequest: 60200,
+        MessageType_ProtocolInfo: 60201,
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+const schemas = {
+  protocolV1: parseConfigure(protocolV1Schema),
+  protocolV2: parseConfigure(protocolV2Schema),
+};
+
+jest.setTimeout(10_000);
+
+const createLogger = () => ({
+  debug: jest.fn(),
+  error: jest.fn(),
+});
+
+const createNobleBle = (device = { id: 'flaky-pro2-id', name: 'Unknown BLE Device' }) => ({
+  enumerate: jest.fn(() => Promise.resolve([device])),
+  getDevice: jest.fn(() => Promise.resolve(device)),
+  connect: jest.fn(() => Promise.resolve()),
+  disconnect: jest.fn(() => Promise.resolve()),
+  subscribe: jest.fn(() => Promise.resolve()),
+  unsubscribe: jest.fn(() => Promise.resolve()),
+  write: jest.fn(() => Promise.resolve()),
+  onNotification: jest.fn(() => jest.fn()),
+  onDeviceDisconnected: jest.fn(() => jest.fn()),
+  checkAvailability: jest.fn(() =>
+    Promise.resolve({
+      available: true,
+      state: 'poweredOn',
+      unsupported: false,
+      initialized: true,
+    })
+  ),
+});
+
+const configureTransport = (nobleBle: ReturnType<typeof createNobleBle>) => {
+  (global as any).window = {
+    desktopApi: {
+      nobleBle,
+    },
+  };
+
+  const transport = new ElectronBleTransport();
+  transport.init(createLogger());
+  transport.configure(protocolV1Schema);
+  transport.configureProtocolV2(protocolV2Schema);
+  return transport;
+};
+
+describe('ElectronBleTransport protocol detection', () => {
+  afterEach(() => {
+    delete (global as any).window;
+    jest.clearAllMocks();
+  });
+
+  test('detects Protocol V2 after Protocol V1 probe timeout', async () => {
+    const device = { id: 'unknown-pro2-id', name: 'Unknown BLE Device' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    let writeCount = 0;
+    nobleBle.write.mockImplementation(() => {
+      writeCount += 1;
+      if (writeCount === 2) {
+        setTimeout(() => notificationHandler?.(device.id, bytesToHex(probeResponse)), 0);
+      }
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+          protocolType: 'V2',
+        })
+      );
+      expect(transport.getProtocolType(device.id)).toBe('V2');
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('detects Protocol V1 when device responds to Initialize', async () => {
+    const device = { id: 'classic-id', name: 'OneKey Classic' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+
+    // Build a V1 Success notification (no 64-byte padding, matching real BLE behaviour).
+    // Format: ?## (3f2323) + typeId BE (0002) + length BE (00000004) + protobuf payload (0a026f6b)
+    const v1ResponseHex = '3f23230002000000040a026f6b';
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      // Respond to first write (V1 Initialize probe) with V1 Success
+      setTimeout(() => notificationHandler?.(device.id, v1ResponseHex), 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+        })
+      );
+      expect(transport.getProtocolType(device.id)).toBe('V1');
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('throws when both protocol probes fail', async () => {
+    const device = { id: 'dead-device-id', name: 'Unknown Device' };
+    const nobleBle = createNobleBle(device);
+
+    // Never respond to writes — both probes will timeout
+    nobleBle.onNotification.mockImplementation(() => jest.fn());
+
+    const transport = configureTransport(nobleBle);
+
+    await expect(transport.acquire({ uuid: device.id })).rejects.toThrow(
+      /Unable to detect BLE protocol/
+    );
+    expect(transport.getProtocolType(device.id)).toBeUndefined();
+  });
+
+  test('probes Protocol V2 instead of trusting the Pro2 name hint', async () => {
+    const device = { id: 'named-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(probeResponse)), 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await expect(transport.acquire({ uuid: device.id })).resolves.toEqual(
+        expect.objectContaining({
+          uuid: device.id,
+          protocolType: 'V2',
+        })
+      );
+      expect(nobleBle.write).toHaveBeenCalledTimes(1);
+      expect(transport.getProtocolType(device.id)).toBe('V2');
+      await expect(transport.call(device.id, 'Ping', { message: 'after-probe' })).resolves.toEqual({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
+      const sentSeqs = nobleBle.write.mock.calls.map(([, hex]) =>
+        Number.parseInt(hex.slice(12, 14), 16)
+      );
+      expect(sentSeqs).toEqual([1, 2]);
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('rejects the active Protocol V2 reader when pairing is rejected', async () => {
+    const device = { id: 'pairing-rejected-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    let pairingRejected = false;
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(
+        () =>
+          notificationHandler?.(
+            device.id,
+            pairingRejected ? 'PAIRING_REJECTED' : bytesToHex(probeResponse)
+          ),
+        0
+      );
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await transport.acquire({ uuid: device.id });
+      pairingRejected = true;
+
+      await expect(
+        transport.call(device.id, 'Ping', { message: 'pairing' }, { timeoutMs: 50 })
+      ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleDeviceBondedCanceled });
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+
+  test('rebuilds the active link when Core acquires the same device again', async () => {
+    const device = { id: 'repeated-acquire-pro2-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    let notificationHandler: ((deviceId: string, data: string) => void) | undefined;
+    const response = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+
+    nobleBle.onNotification.mockImplementation(handler => {
+      notificationHandler = handler;
+      return jest.fn();
+    });
+    nobleBle.write.mockImplementation(() => {
+      setTimeout(() => notificationHandler?.(device.id, bytesToHex(response)), 0);
+      return Promise.resolve();
+    });
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await transport.acquire({ uuid: device.id });
+      await transport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      await expect(
+        transport.call(device.id, 'Ping', { message: 'after-reacquire' })
+      ).resolves.toEqual({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
+
+      const sentSeqs = nobleBle.write.mock.calls.map(([, hex]) =>
+        Number.parseInt(hex.slice(12, 14), 16)
+      );
+      expect(sentSeqs).toEqual([1, 2]);
+    } finally {
+      await transport.release(device.id);
+    }
+  });
+});

package/__tests__/webusb-protocol-v2-timeout.test.ts

@@ -0,0 +1,65 @@
+import transport, { ProtocolV2FrameAssembler } from '@onekeyfe/hd-transport';
+
+import WebUsbTransport from '../src/webusb';
+
+const schema = {
+  nested: {
+    Ping: { fields: { message: { type: 'string', id: 1 } } },
+    Success: { fields: { message: { type: 'string', id: 1 } } },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+describe('WebUsbTransport Protocol V2 timeout recovery', () => {
+  test('invalidates and resets the cached connection before another call can start', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.protocolV2Assemblers.set(path, new ProtocolV2FrameAssembler());
+    webusb.transferOutOnce = jest.fn().mockResolvedValue(undefined);
+    webusb.receiveProtocolV2Frame = jest.fn(() => new Promise(() => {}));
+    webusb.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      webusb.protocolV2Sessions.delete(path);
+      webusb.protocolV2ReadTimeouts.delete(path);
+      webusb.protocolV2Assemblers.get(path)?.reset();
+    });
+
+    await expect(
+      webusb.callProtocolV2(path, 'Ping', { message: 'timeout' }, { timeoutMs: 10 })
+    ).rejects.toThrow('timeout');
+
+    expect(webusb.resetConnectionAfterProbe).toHaveBeenCalledWith(path);
+    expect(webusb.protocolV2Sessions.has(path)).toBe(false);
+  });
+
+  test('resets a stalled write while retaining the device sequence cursor', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.protocolV2WriteTimeoutMs = 10;
+    webusb.protocolV2Assemblers.set(path, new ProtocolV2FrameAssembler());
+    webusb.transferOutOnce = jest.fn(() => new Promise(() => {}));
+    webusb.receiveProtocolV2Frame = jest.fn();
+    webusb.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      webusb.protocolV2Sessions.delete(path);
+      webusb.protocolV2ReadTimeouts.delete(path);
+      webusb.protocolV2Assemblers.get(path)?.reset();
+    });
+
+    await expect(
+      webusb.callProtocolV2(path, 'Ping', { message: 'timeout' }, { timeoutMs: 10 })
+    ).rejects.toThrow('Protocol V2 write timeout after 10ms for Ping');
+
+    expect(webusb.resetConnectionAfterProbe).toHaveBeenCalledWith(path);
+    expect(webusb.protocolV2Sequences.has(path)).toBe(true);
+    expect(webusb.protocolV2Sessions.has(path)).toBe(false);
+    expect(webusb.receiveProtocolV2Frame).not.toHaveBeenCalled();
+  });
+});

package/dist/electron-ble-transport.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import transport from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type EventEmitter from 'events';
 import type { DesktopAPI } from '@onekeyfe/hd-transport-electron';
+import type { OneKeyDeviceInfo, ProtocolType, TransportCallOptions } from '@onekeyfe/hd-transport';
+import type EventEmitter from 'events';
 declare global {
     interface Window {
         desktopApi?: DesktopAPI;
@@ -11,35 +11,71 @@ declare global {
 export type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
+    expectedProtocol?: ProtocolType;
 };
 export default class ElectronBleTransport {
-    _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+    private _messages;
+    private _messagesV2;
     name: string;
     configured: boolean;
-    runPromise: Deferred<any> | null;
+    runPromise: Deferred<Uint8Array | string> | null;
     Log?: any;
     emitter?: EventEmitter;
     private connectedDevices;
-    private dataBuffers;
+    private deviceProtocol;
+    private deviceProtocolHints;
+    private v1Buffers;
+    private v2Assemblers;
+    private v2FrameQueues;
+    private v2FramePromises;
+    private protocolV2Links;
     private notificationCleanups;
     private disconnectCleanups;
+    private notificationTokens;
+    private nextNotificationToken;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;
     configure(signedData: any): void;
-    listen(): void;
-    enumerate(): Promise<{
-        id: string;
-        name: string;
-    }[]>;
+    configureProtocolV2(signedData: any): void;
+    listen(): Promise<OneKeyDeviceInfo[]>;
+    enumerate(): Promise<OneKeyDeviceInfo[]>;
     acquire(input: BleAcquireInput): Promise<{
         uuid: string;
+        commType: import("@onekeyfe/hd-transport").OneKeyDeviceCommType;
         path: string;
+        session?: string | null | undefined;
+        debugSession?: string | null | undefined;
+        debug: boolean;
+        id: string;
+        name: string | null;
+        protocolType?: ProtocolType | undefined;
     }>;
     release(id: string): Promise<void>;
-    disconnect(id: string): Promise<void>;
-    private handleNotificationData;
-    call(uuid: string, name: string, data: Record<string, unknown>): Promise<import("@onekeyfe/hd-transport").MessageFromOneKey>;
-    private processNotificationPacket;
+    private createProtocolMismatchError;
+    private createProtocolDetectionError;
+    private clearProbeProtocol;
+    private detectProtocol;
+    private createNotificationSubscription;
+    private resetProbeStateAfterProtocolProbe;
+    private probeProtocolV1;
+    private probeProtocolV2;
+    private writeWithChunking;
+    private writeOnce;
+    private handleNotification;
+    private handleProtocolV2Notification;
+    private getProtocolV2FrameQueue;
+    private resolveProtocolV2Frame;
+    private rejectAllProtocolV2Frames;
+    private resetProtocolV2Frames;
+    private rejectProtocolV2Frames;
+    private readProtocolV2Frame;
+    private handleProtocolV1Notification;
+    call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<import("@onekeyfe/hd-transport").MessageFromOneKey>;
+    private callProtocolV1;
+    private callProtocolV2;
+    private createProtocolV2Adapter;
+    private processProtocolV1Notification;
+    getProtocolType(path: string): ProtocolType | undefined;
 }
 //# sourceMappingURL=electron-ble-transport.d.ts.map

package/dist/electron-ble-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":";AAAA,OAAO,SAAkD,MAAM,wBAAwB,CAAC;AASxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAKlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,UAAU,CAAC,EAAE,UAAU,CAAC;KACzB;CACF;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AASF,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,IAAI,SAA0B;IAE9B,UAAU,UAAS;IAEnB,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAExC,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,gBAAgB,CAA0B;IAGlD,OAAO,CAAC,WAAW,CAAsE;IAGzF,OAAO,CAAC,oBAAoB,CAAsC;IAGlE,OAAO,CAAC,kBAAkB,CAAsC;IAGhE,OAAO,CAAC,oBAAoB;IAmC5B,OAAO,CAAC,kBAAkB;IAmB1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAexC,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,MAAM;IAEA,SAAS,IAAI,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAcpD,OAAO,CAAC,KAAK,EAAE,eAAe;;;;IA4F9B,OAAO,CAAC,EAAE,EAAE,MAAM;IAoBlB,UAAU,CAAC,EAAE,EAAE,MAAM;IAsB3B,OAAO,CAAC,sBAAsB;IA2BxB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA2EpE,OAAO,CAAC,yBAAyB;CAyDlC"}
+{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":";AAoBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnG,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAIvC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,UAAU,CAAC,EAAE,UAAU,CAAC;KACzB;CACF;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC;AAoCF,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,OAAO,CAAC,SAAS,CAA0D;IAE3E,OAAO,CAAC,WAAW,CAA0D;IAE7E,IAAI,SAA0B;IAE9B,UAAU,UAAS;IAEnB,UAAU,EAAE,QAAQ,CAAC,UAAU,GAAG,MAAM,CAAC,GAAG,IAAI,CAAQ;IAExD,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAEnE,OAAO,CAAC,SAAS,CAAsE;IAEvF,OAAO,CAAC,YAAY,CAAoD;IAExE,OAAO,CAAC,aAAa,CAAwC;IAE7D,OAAO,CAAC,eAAe,CAAgD;IAEvE,OAAO,CAAC,eAAe,CAmBpB;IAEH,OAAO,CAAC,oBAAoB,CAAsC;IAElE,OAAO,CAAC,kBAAkB,CAAsC;IAEhE,OAAO,CAAC,kBAAkB,CAAkC;IAE5D,OAAO,CAAC,qBAAqB,CAAK;IAElC,OAAO,CAAC,oBAAoB;IA+B5B,OAAO,CAAC,kBAAkB;IA0B1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAcxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAKzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAO7B,MAAM;IAIN,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAqBxC,OAAO,CAAC,KAAK,EAAE,eAAe;;;;;;;;;;;IA0F9B,OAAO,CAAC,EAAE,EAAE,MAAM;IAgBxB,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;IA8C5B,OAAO,CAAC,8BAA8B;YAgBxB,iCAAiC;YAqCjC,eAAe;YAgBf,eAAe;YAuBf,iBAAiB;YAsBjB,SAAS;IASvB,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,4BAA4B;IAkBpC,OAAO,CAAC,uBAAuB;IAS/B,OAAO,CAAC,sBAAsB;IAU9B,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,sBAAsB;YAShB,mBAAmB;IAiBjC,OAAO,CAAC,4BAA4B;IAgB9B,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YA2BlB,cAAc;YAuEd,cAAc;IAiC5B,OAAO,CAAC,uBAAuB;IA0C/B,OAAO,CAAC,6BAA6B;IAsCrC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}