@onekeyfe/hd-transport-usb 1.2.0-alpha.7 → 1.2.0-alpha.71

package/__tests__/protocol-v2-link.test.ts

@@ -0,0 +1,439 @@
+import transportPackage, { PROTOCOL_V2_CHANNEL_USB, ProtocolV2 } from '@onekeyfe/hd-transport';
+
+import NodeUsbTransport from '../src';
+
+let mockUsbDevices: any[] = [];
+
+jest.mock('usb', () => ({
+  getDeviceList: jest.fn(() => mockUsbDevices),
+}));
+
+const { parseConfigure } = transportPackage;
+
+const protocolV1Schema = {
+  nested: {
+    Initialize: { fields: {} },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 1,
+        MessageType_Success: 2,
+      },
+    },
+  },
+};
+
+const protocolV2Schema = {
+  nested: {
+    Ping: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+const schemas = {
+  protocolV1: parseConfigure(protocolV1Schema),
+  protocolV2: parseConfigure(protocolV2Schema),
+};
+
+type PendingRead = {
+  started: Promise<void>;
+  fail: (error?: Error) => void;
+};
+
+const createHarness = () => {
+  const path = '6136';
+  const responseQueue: Buffer[] = [];
+  const sentSeqs: number[] = [];
+  let cancelledTransferCount = 0;
+  let writeError: Error | undefined;
+  let holdNextRead:
+    | {
+        markStarted: () => void;
+        started: Promise<void>;
+        callback?: (error?: Error, data?: Buffer) => void;
+      }
+    | undefined;
+
+  const performInTransfer = (callback: (error?: Error, data?: Buffer) => void) => {
+    if (epIn.timeout === 50) {
+      callback(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
+      return;
+    }
+    if (holdNextRead) {
+      const pending = holdNextRead;
+      holdNextRead = undefined;
+      pending.callback = callback;
+      pending.markStarted();
+      return;
+    }
+    const response = responseQueue.shift();
+    if (!response) {
+      callback(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
+      return;
+    }
+    callback(undefined, response);
+  };
+
+  const epIn = {
+    direction: 'in',
+    address: 0x81,
+    timeout: 30_000,
+    transfer: jest.fn((_length: number, callback: (error?: Error, data?: Buffer) => void) => {
+      performInTransfer(callback);
+    }),
+    makeTransfer: jest.fn(
+      (
+        _timeout: number,
+        callback: (error: Error | undefined, data: Buffer, actualLength: number) => void
+      ) => {
+        let settled = false;
+        const finish = (error?: Error, data = Buffer.alloc(0)) => {
+          if (settled) return;
+          settled = true;
+          callback(error, data, data.length);
+        };
+        return {
+          submit: jest.fn((buffer: Buffer) => {
+            performInTransfer((error, data) => {
+              if (error) {
+                finish(error);
+                return;
+              }
+              data?.copy(buffer);
+              finish(undefined, buffer.subarray(0, data?.length ?? 0));
+            });
+          }),
+          cancel: jest.fn(() => {
+            cancelledTransferCount += 1;
+            finish(new Error('LIBUSB_TRANSFER_CANCELLED'));
+          }),
+        };
+      }
+    ),
+  };
+
+  const performOutTransfer = (data: Buffer, callback: (error?: Error) => void) => {
+    const seq = data[6];
+    sentSeqs.push(seq);
+    if (writeError) {
+      const error = writeError;
+      writeError = undefined;
+      callback(error);
+      return;
+    }
+    responseQueue.push(
+      Buffer.from(
+        ProtocolV2.encodeFrame(
+          schemas,
+          'Success',
+          { message: 'ok' },
+          { router: PROTOCOL_V2_CHANNEL_USB, seq }
+        )
+      )
+    );
+    callback();
+  };
+
+  const epOut = {
+    direction: 'out',
+    address: 0x01,
+    timeout: 30_000,
+    transfer: jest.fn((data: Buffer, callback: (error?: Error) => void) => {
+      performOutTransfer(data, callback);
+    }),
+    makeTransfer: jest.fn(
+      (
+        _timeout: number,
+        callback: (error: Error | undefined, data: Buffer, actualLength: number) => void
+      ) => {
+        let settled = false;
+        const finish = (error: Error | undefined, data: Buffer) => {
+          if (settled) return;
+          settled = true;
+          callback(error, data, data.length);
+        };
+        return {
+          submit: jest.fn((data: Buffer) => {
+            performOutTransfer(data, error => finish(error, data));
+          }),
+          cancel: jest.fn(() => {
+            cancelledTransferCount += 1;
+            finish(new Error('LIBUSB_TRANSFER_CANCELLED'), Buffer.alloc(0));
+          }),
+        };
+      }
+    ),
+  };
+
+  const iface = {
+    descriptor: { bInterfaceClass: 0xff, bInterfaceNumber: 0 },
+    endpoints: [epIn, epOut],
+    claim: jest.fn(),
+    release: jest.fn((closeEndpointsOrCallback: boolean | (() => void), callback?: () => void) => {
+      if (typeof closeEndpointsOrCallback === 'function') closeEndpointsOrCallback();
+      else callback?.();
+    }),
+    isKernelDriverActive: jest.fn(() => false),
+    detachKernelDriver: jest.fn(),
+  };
+
+  const device = {
+    busNumber: 1,
+    deviceAddress: 2,
+    timeout: 30_000,
+    deviceDescriptor: {
+      idVendor: 0x1209,
+      idProduct: 0x4f4a,
+      iSerialNumber: 1,
+    },
+    interfaces: [iface],
+    open: jest.fn(),
+    close: jest.fn(),
+    getStringDescriptor: jest.fn(
+      (_index: number, callback: (error?: Error, value?: string) => void) =>
+        callback(undefined, path)
+    ),
+  };
+
+  mockUsbDevices = [device];
+  const transport = new NodeUsbTransport();
+  transport.init({ debug: jest.fn(), error: jest.fn() });
+  transport.configure(protocolV1Schema);
+  transport.configureProtocolV2(protocolV2Schema);
+
+  return {
+    transport,
+    path,
+    device,
+    iface,
+    epIn,
+    epOut,
+    sentSeqs,
+    getCancelledTransferCount: () => cancelledTransferCount,
+    async acquire() {
+      await transport.enumerate();
+      await transport.acquire({ path, expectedProtocol: 'V2' });
+    },
+    failNextWrite(error: Error) {
+      writeError = error;
+    },
+    holdRead(): PendingRead {
+      let markStarted: () => void = () => undefined;
+      const started = new Promise<void>(resolve => {
+        markStarted = resolve;
+      });
+      const pending = { markStarted, started, callback: undefined };
+      holdNextRead = pending;
+      return {
+        started,
+        fail(error = new Error('read released after test')) {
+          pending.callback?.(error);
+        },
+      };
+    },
+  };
+};
+
+describe('NodeUsbTransport Protocol V2 link lifecycle', () => {
+  test('falls back to Protocol V2 when a cached V1 hint is stale', async () => {
+    const transport = new NodeUsbTransport() as any;
+    const events: string[] = [];
+    transport.probeProtocolV1 = jest.fn().mockImplementation(() => {
+      events.push('probe-v1');
+      return Promise.resolve(false);
+    });
+    transport.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      events.push('reset');
+      return Promise.resolve();
+    });
+    transport.probeProtocolV2 = jest.fn().mockImplementation(() => {
+      events.push('probe-v2');
+      return Promise.resolve(true);
+    });
+
+    await expect(transport.detectProtocol('pro-usb', undefined, 'V1')).resolves.toBe('V2');
+
+    expect(events).toEqual(['probe-v1', 'reset', 'probe-v2']);
+    expect(transport.getProtocolType('pro-usb')).toBe('V2');
+  });
+
+  test('keeps active links when the Protocol V2 schema is configured repeatedly', () => {
+    const transport = new NodeUsbTransport() as any;
+    transport.invalidateAllProtocolV2UsbLinks = jest.fn().mockResolvedValue(undefined);
+    const schemaSource = JSON.stringify(protocolV2Schema);
+
+    transport.configureProtocolV2(schemaSource);
+    transport.configureProtocolV2(schemaSource);
+
+    expect(transport.invalidateAllProtocolV2UsbLinks).not.toHaveBeenCalled();
+  });
+
+  test('does not retry a native transfer cancelled by probe cleanup', () => {
+    const { transport } = createHarness();
+
+    expect((transport as any).isRetryableError(new Error('LIBUSB_TRANSFER_CANCELLED'))).toBe(false);
+  });
+
+  test('cancels pending native transfers before closing a timed-out protocol probe', async () => {
+    const harness = createHarness();
+    const { transport, path } = harness;
+    await harness.acquire();
+    const cancelActiveTransfers = jest.spyOn(transport as any, 'cancelActiveTransfers');
+    const closeOpenDevice = jest.spyOn(transport as any, 'closeOpenDevice');
+
+    await (transport as any).resetConnectionAfterProbe(path);
+
+    expect(cancelActiveTransfers).toHaveBeenCalledWith(path);
+    expect(closeOpenDevice).toHaveBeenCalledWith(path);
+    expect(cancelActiveTransfers.mock.invocationCallOrder[0]).toBeLessThan(
+      closeOpenDevice.mock.invocationCallOrder[0]
+    );
+  });
+
+  test('releases the USB interface when protocol detection rejects acquire', async () => {
+    const harness = createHarness();
+    const { transport, path, device, iface } = harness;
+    await transport.enumerate();
+    device.close.mockClear();
+    iface.release.mockClear();
+    jest
+      .spyOn(transport as any, 'detectProtocol')
+      .mockRejectedValueOnce(new Error('terminal protocol probe failure'));
+
+    await expect(transport.acquire({ path })).rejects.toMatchObject({
+      errorCode: expect.any(Number),
+    });
+
+    expect(iface.release).toHaveBeenCalledTimes(1);
+    expect(device.close).toHaveBeenCalledTimes(1);
+    expect((transport as any).openDevices.has(path)).toBe(false);
+  });
+
+  test('stop releases an acquired USB interface even before a Protocol V2 call', async () => {
+    const harness = createHarness();
+    const { transport, path, device, iface } = harness;
+    await transport.enumerate();
+    await transport.acquire({ path, expectedProtocol: 'V2' });
+    device.close.mockClear();
+    iface.release.mockClear();
+
+    await transport.stop();
+
+    expect(iface.release).toHaveBeenCalledTimes(1);
+    expect(device.close).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(path)).toBeUndefined();
+  });
+
+  test('actively probes explicit Protocol V2 during bootloader reconnect', async () => {
+    const harness = createHarness();
+    const { transport, path, epOut } = harness;
+
+    await transport.enumerate();
+    await transport.acquire({ path, expectedProtocol: 'V2' });
+
+    expect(epOut.makeTransfer).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(path)).toBe('V2');
+    await transport.release(path);
+  });
+
+  test('keeps seq across calls and actively probed reacquire', async () => {
+    const harness = createHarness();
+    const { transport, path, sentSeqs } = harness;
+
+    await harness.acquire();
+    await transport.call(path, 'Ping', { message: 'first' });
+    await transport.release(path);
+    await harness.acquire();
+    await transport.call(path, 'Ping', { message: 'second' });
+
+    expect(sentSeqs).toEqual([1, 2, 3, 4]);
+    await transport.release(path);
+  });
+
+  test('does not resend a Protocol V2 frame after transferOut fails', async () => {
+    const harness = createHarness();
+    const { transport, path, epOut } = harness;
+    await harness.acquire();
+    epOut.makeTransfer.mockClear();
+    harness.failNextWrite(new Error('LIBUSB_ERROR_IO'));
+
+    await expect(transport.call(path, 'Ping', { message: 'write-failure' })).rejects.toThrow(
+      'LIBUSB_ERROR_IO'
+    );
+
+    expect(epOut.makeTransfer).toHaveBeenCalledTimes(1);
+  });
+
+  test('rejects a pending read when release invalidates the link', async () => {
+    const harness = createHarness();
+    const { transport, path } = harness;
+    await harness.acquire();
+    const pendingRead = harness.holdRead();
+
+    const call = transport.call(path, 'Ping', { message: 'pending' }, { timeoutMs: 5000 });
+    const outcome = call.then(
+      () => 'resolved',
+      error => error.message
+    );
+    await pendingRead.started;
+    await transport.release(path);
+    const settled = await Promise.race([
+      outcome,
+      new Promise<string>(resolve => {
+        setTimeout(() => resolve('still pending'), 50);
+      }),
+    ]);
+    pendingRead.fail();
+
+    expect(settled).not.toBe('still pending');
+  });
+
+  test('stop cancels an in-flight native USB transfer before releasing the interface', async () => {
+    const harness = createHarness();
+    const { transport, path } = harness;
+    await harness.acquire();
+    const pendingRead = harness.holdRead();
+
+    const call = transport.call(path, 'Ping', { message: 'pending' }, { timeoutMs: 5000 });
+    await pendingRead.started;
+    await transport.stop();
+
+    await expect(call).rejects.toThrow();
+    expect(harness.getCancelledTransferCount()).toBe(1);
+  });
+
+  test('keeps the cursor after a response timeout rebuilds the USB connection', async () => {
+    const harness = createHarness();
+    const { transport, path, sentSeqs } = harness;
+    await harness.acquire();
+    const pendingRead = harness.holdRead();
+
+    await expect(
+      transport.call(path, 'Ping', { message: 'timeout' }, { timeoutMs: 20 })
+    ).rejects.toThrow('20ms');
+    pendingRead.fail();
+    await harness.acquire();
+    await transport.call(path, 'Ping', { message: 'after-timeout' });
+
+    expect(sentSeqs).toEqual([1, 2, 3, 4]);
+    await transport.release(path);
+  });
+});

package/dist/index.d.ts

@@ -1,51 +1,120 @@
 import * as transport from '@onekeyfe/hd-transport';
-import transport__default, { OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolType } from '@onekeyfe/hd-transport';
+import transport__default, { ProtocolV2UsbTransportBase, OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolV2Schemas, ProtocolV2CallContext, ProtocolType } from '@onekeyfe/hd-transport';
 import EventEmitter from 'events';
 
-declare class NodeUsbTransport {
+/**
+ * Node.js USB Transport — complete transport implementation using libusb.
+ *
+ * Unlike the old UsbPlugin (which was a LowlevelTransportSharedPlugin piped
+ * through LowlevelTransport), this class is a standalone transport that handles
+ * both protocol encoding/decoding and USB I/O directly.
+ *
+ * Modeled after WebUsbTransport.
+ */
+declare class NodeUsbTransport extends ProtocolV2UsbTransportBase<string> {
     messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    /** Protobuf schema for Protocol V2 transports. */
     messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    private protocolV2SchemaSource;
     name: string;
     version: string;
     configured: boolean;
     isOutdated: boolean;
     Log?: any;
     emitter?: EventEmitter;
+    /** serial → bus id, built during enumerate */
     private serialToBusId;
+    /** path → opened device state */
     private openDevices;
+    /** Per-path protocol type detected by active wire-level probe. */
     private deviceProtocol;
-    private protocolV2Assemblers;
-    private protocolV2Sessions;
-    private protocolV2ReadTimeouts;
+    /** per-path reconnect lock to prevent concurrent reconnects */
     private reconnectLocks;
+    /**
+     * Retain the low-level Transfer so release()/stop() can cancel native pending reads.
+     * Endpoint.transfer() hides it and may keep the CLI alive after output completes.
+     */
+    private activeTransfers;
+    /** set to true when cancel() is called; checked by retry loops */
     private cancelled;
+    constructor();
+    /**
+     * Initialize transport.
+     * Signature matches the Transport.init interface (logger, emitter).
+     */
     init(logger: any, emitter?: EventEmitter): Promise<string>;
     configure(signedData: any): Promise<void>;
     configureProtocolV2(signedData: any): void;
     listen(): void;
-    stop(): void;
+    stop(): Promise<void>;
+    /**
+     * Low-level post (send only, no response). Not used by NodeUsbTransport
+     * since call() handles the full send+receive cycle, but required by the Transport interface.
+     */
     post(path: string, name: string, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Low-level read (receive only). Not used by NodeUsbTransport
+     * since call() handles the full send+receive cycle, but required by the Transport interface.
+     */
     read(path: string): Promise<{
         message: {
             [key: string]: any;
         };
         type: string;
     }>;
+    /**
+     * Enumerate connected OneKey USB devices.
+     * Opens each device briefly to read its serial number (used as `path`),
+     * then closes it. acquire() re-opens from a fresh getDeviceList().
+     */
     enumerate(): Promise<OneKeyDeviceInfo[]>;
+    /**
+     * Acquire device — open USB device, claim interface, return path (string).
+     */
     acquire(input: AcquireInput): Promise<string>;
+    /**
+     * Release device — release interface and close.
+     */
     release(path: string, _onclose?: boolean): Promise<void>;
+    private cancelActiveTransfers;
+    private createTrackedTransfer;
+    private transferInOnce;
+    private transferOutOnce;
     private closeOpenDevice;
+    /**
+     * Call device method — encode protobuf, send packets, receive response.
+     * This is the core method that replaces LowlevelTransport's call + UsbPlugin's send/receive.
+     */
     call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
     private callProtocolV1;
     cancel(): void;
+    /**
+     * Get the current open device for a path, re-resolving from the map
+     * so callers always use a fresh reference after reconnect.
+     */
     private getOpenDevice;
     private getErrorMessage;
     private isRetryableError;
     private isUsbTransferTimeout;
     private getDeviceInterface;
+    /**
+     * Reconnect device before retrying a failed transfer (aligned with WebUsbTransport).
+     * Uses per-path lock to prevent concurrent reconnects to the same device.
+     */
     private reconnectForRetry;
+    /**
+     * Send all encoded chunks to the device with retry.
+     * If a chunk fails and triggers reconnect, the entire sequence restarts
+     * from chunk 0 because the device resets protocol state on reconnect.
+     */
     private sendAllChunksWithRetry;
+    /**
+     * USB IN transfer with retry and reconnect (aligned with WebUsbTransport).
+     */
     private transferInWithRetry;
+    /**
+     * Open a USB device by path (serial number), claim interface, cache endpoints.
+     */
     private openDevice;
     private drainStaleInput;
     private createProtocolMismatchError;
@@ -55,9 +124,18 @@ declare class NodeUsbTransport {
     private withProtocolReadTimeout;
     private probeProtocolV1;
     private probeProtocolV2;
-    private writeProtocolV2Frame;
-    private receiveProtocolV2Frame;
+    protected getProtocolV2UsbSchemas(): ProtocolV2Schemas;
+    protected getProtocolV2UsbLogger(): any;
+    protected writeProtocolV2UsbPacket(path: string, frame: Uint8Array, _context: ProtocolV2CallContext): Promise<void>;
+    protected readProtocolV2UsbPacket(path: string, _context: ProtocolV2CallContext): Promise<Uint8Array>;
+    protected resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void>;
+    protected onProtocolV2UsbLinkInvalidated(path: string, reason: string): void;
+    protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error;
     private callProtocolV2;
+    /**
+     * Receive a complete protobuf response from the device.
+     * Reads 64-byte packets, strips 0x3F marker, reassembles into hex string.
+     */
     private receiveData;
     getProtocolType(path: string): ProtocolType | undefined;
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,SAWN,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAgKhC,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGlE,UAAU,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEpE,IAAI,SAAsB;IAE1B,OAAO,SAAM;IAEb,UAAU,UAAS;IAEnB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,WAAW,CAAiC;IAGpD,OAAO,CAAC,cAAc,CAAwC;IAG9D,OAAO,CAAC,oBAAoB,CAAoD;IAGhF,OAAO,CAAC,kBAAkB,CAA6C;IAGvE,OAAO,CAAC,sBAAsB,CAA8C;IAG5E,OAAO,CAAC,cAAc,CAA0C;IAGhE,OAAO,CAAC,SAAS,CAAS;IAM1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAMxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAOzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAOnC,MAAM;IAIN,IAAI;IAQE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9E,IAAI,CAAC,IAAI,EAAE,MAAM;;;;;;IAiBjB,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA8BxC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB7C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;YAMhD,eAAe;IA6BvB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YAwClB,cAAc;IA0B5B,MAAM;IAWN,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,oBAAoB;IAK5B,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,iBAAiB;YAmDX,sBAAsB;YAyCtB,mBAAmB;YA2CnB,UAAU;YA+DV,eAAe;IAiB7B,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;YAOtB,cAAc;YA4Cd,yBAAyB;YAezB,uBAAuB;YA0CvB,eAAe;YAcf,eAAe;YAcf,oBAAoB;YA+BpB,sBAAsB;YAwCtB,cAAc;YAgDd,WAAW;IA6CzB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}