@onekeyfe/hd-transport 1.2.0-alpha.20 → 1.2.0-alpha.22

package/__tests__/messages.test.js

@@ -101,17 +101,44 @@ describe('messages', () => {
     expect(v2Messages.nested.MessageType.values).toMatchObject({
       MessageType_DeviceStatusGet: 60602,
       MessageType_DeviceStatus: 60603,
-      MessageType_DeviceSessionGet: 60606,
       MessageType_DeviceSession: 60607,
       MessageType_DeviceSessionAskPin: 60608,
+      MessageType_DeviceSessionOpen: 60609,
     });
     expect(v2Messages.nested.DeviceStatusGet).toEqual({ fields: {} });
-    expect(v2Messages.nested.DeviceSessionGet.fields.session_id).toMatchObject({
+    expect(v2Messages.nested.ProtocolInfoRequest.fields.eventless_wallet_session).toMatchObject({
+      id: 1,
+      type: 'bool',
+      options: { default: false },
+    });
+    expect(v2Messages.nested).not.toHaveProperty('DeviceSessionGet');
+    expect(v2Messages.nested.DeviceSessionResume.fields.session_id).toMatchObject({
+      rule: 'required',
       id: 1,
       type: 'bytes',
     });
-    expect(v2Messages.nested).not.toHaveProperty('DeviceSessionOpen');
-    expect(v2Messages.nested).not.toHaveProperty('DeviceSessionResume');
+    expect(v2Messages.nested.DeviceSessionOpen.fields).toMatchObject({
+      resume: { id: 1, type: 'DeviceSessionResume' },
+      select: { id: 2, type: 'DeviceSessionSelect' },
+    });
+    expect(v2Messages.nested.DeviceSessionSelect.fields).toMatchObject({
+      host_passphrase: { id: 1, type: 'DeviceSessionHostPassphrase' },
+      passphrase_on_device: { id: 2, type: 'DeviceSessionPassphraseOnDevice' },
+      attach_pin_on_device: { id: 3, type: 'DeviceSessionAttachPinOnDevice' },
+    });
+    expect(v2Messages.nested.DeviceSessionHostPassphrase.fields.passphrase).toMatchObject({
+      rule: 'required',
+      id: 1,
+      type: 'string',
+    });
+    expect(v2Messages.nested.DeviceSessionErrorCode.values).toEqual({
+      DeviceSessionError_None: 0,
+      DeviceSessionError_UserCancelled: 1,
+      DeviceSessionError_InvalidSession: 2,
+      DeviceSessionError_AttachPinUnavailable: 3,
+      DeviceSessionError_PassphraseDisabled: 4,
+      DeviceSessionError_Busy: 5,
+    });
     expect(v2Messages.nested).not.toHaveProperty('DeviceWalletSelect');
     expect(v2Messages.nested).not.toHaveProperty('DeviceWalletType');
     expect(v2Messages.nested).not.toHaveProperty('DeviceHiddenWalletSelect');
@@ -126,9 +153,7 @@ describe('messages', () => {
     expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
       'MessageType_DeviceSessionPinResult'
     );
-    expect(v2Messages.nested.MessageType.values).not.toHaveProperty(
-      'MessageType_DeviceSessionOpen'
-    );
+    expect(v2Messages.nested.MessageType.values).not.toHaveProperty('MessageType_DeviceSessionGet');
   });
 
   test('Protocol V2 onboarding status matches the current firmware-pro2 schema', () => {

package/__tests__/protocol-v2-link-manager.test.js

@@ -55,7 +55,12 @@ const rewriteSeq = (frame, seq) => {
 const createAdapterFactory = sentSeqs => {
   const adapters = [];
   let generation = 0;
-  const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+  const success = ProtocolV2.encodeFrame(
+    schemas,
+    'Success',
+    { message: 'ok' },
+    { router: 1, packetSrc: 0, seq: 1 }
+  );
 
   return {
     adapters,
@@ -108,12 +113,15 @@ describe('ProtocolV2LinkManager', () => {
 
     await manager.call('device-a', createAdapter, 'Ping', { message: '1' }, { timeoutMs: 123 });
 
-    expect(adapters[0].prepareCall).toHaveBeenCalledWith({
-      messageName: 'Ping',
-      timeoutMs: 123,
-      highVolume: false,
-      generation: 1,
-    });
+    expect(adapters[0].prepareCall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        messageName: 'Ping',
+        timeoutMs: 123,
+        highVolume: false,
+        generation: 1,
+        signal: expect.any(AbortSignal),
+      })
+    );
   });
 
   test('invalidates a link-fatal call before the next call creates a new link', async () => {
@@ -158,31 +166,6 @@ describe('ProtocolV2LinkManager', () => {
     expect(sentSeqs).toEqual([1, 2]);
   });
 
-  test('times out a stalled write and resets the link before releasing the call queue', async () => {
-    const adapter = {
-      router: 1,
-      generation: 1,
-      prepareCall: jest.fn(),
-      writeFrame: jest.fn(() => new Promise(() => {})),
-      readFrame: jest.fn(),
-      reset: jest.fn(() => Promise.resolve()),
-      writeTimeoutMs: 10,
-    };
-    const manager = new ProtocolV2LinkManager({
-      getSchemas: () => schemas,
-      classifyError: error =>
-        String(error).includes('write timeout') ? 'link-fatal' : 'recoverable',
-    });
-
-    await expect(
-      manager.call('device-a', () => adapter, 'Ping', { message: 'pending' })
-    ).rejects.toThrow('Protocol V2 write timeout after 10ms for Ping');
-
-    expect(adapter.reset).toHaveBeenCalledWith(expect.stringContaining('write timeout'));
-    expect(adapter.readFrame).not.toHaveBeenCalled();
-    expect(manager.callQueues.size).toBe(0);
-  });
-
   test('invalidates every active link while retaining per-device cursors', async () => {
     const sentSeqs = [];
     const { adapters, createAdapter } = createAdapterFactory(sentSeqs);
@@ -225,7 +208,12 @@ describe('ProtocolV2LinkManager', () => {
     const deviceABlocked = new Promise(resolve => {
       releaseDeviceA = resolve;
     });
-    const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
     const createAdapter = key => {
       let requestSeq = 0;
       return {
@@ -323,7 +311,12 @@ describe('ProtocolV2LinkManager', () => {
     const writeBlocked = new Promise(resolve => {
       releaseWrite = resolve;
     });
-    const success = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const success = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: 1, packetSrc: 0, seq: 1 }
+    );
     const adapter = {
       router: 1,
       generation: 1,

package/__tests__/protocol-v2.test.js

@@ -2,13 +2,17 @@ const { ProtocolV2 } = require('../src/protocols');
 const { parseConfigure } = require('../src/serialization/protobuf/messages');
 const {
   ProtocolV2FrameAssembler,
+  ProtocolV2LinkError,
   ProtocolV2SequenceCursor,
   ProtocolV2Session,
   hexToBytes,
   probeProtocolV2,
 } = require('../src/protocols/v2/session');
 const protocolV2 = require('../src/protocols/v2');
-const { PROTOCOL_V2_FRAME_MAX_BYTES } = require('../src/constants');
+const {
+  PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
+  PROTOCOL_V2_FRAME_MAX_BYTES,
+} = require('../src/constants');
 
 const protocolV1Messages = parseConfigure({
   nested: {
@@ -162,6 +166,18 @@ const protocolV2Messages = parseConfigure({
         },
       },
     },
+    DeviceSession: {
+      fields: {
+        session_id: {
+          type: 'bytes',
+          id: 1,
+        },
+        btc_test_address: {
+          type: 'string',
+          id: 2,
+        },
+      },
+    },
     FileWrite: {
       fields: {},
     },
@@ -195,6 +211,7 @@ const protocolV2Messages = parseConfigure({
         MessageType_FileWrite: 60805,
         MessageType_DeviceFirmwareUpdateRequest: 61000,
         MessageType_DeviceFirmwareUpdateStatus: 61002,
+        MessageType_DeviceSession: 60607,
         MessageType_PartialNested: 62000,
       },
     },
@@ -208,6 +225,7 @@ const schemas = {
 
 const rewriteSeq = (frame, seq) => {
   const copy = new Uint8Array(frame);
+  copy[4] = 1;
   copy[6] = seq;
   copy[copy.length - 1] = protocolV2.crc8(copy, copy.length - 1);
   return copy;
@@ -259,6 +277,34 @@ describe('Protocol V2 framing and session', () => {
     expect(decoded.message).toEqual({ message: 'ok' });
   });
 
+  test('round-trips a DeviceSession response with a 32-byte session id', () => {
+    const sessionId = '01'.repeat(32);
+    const frame = ProtocolV2.encodeFrame(schemas, 'DeviceSession', {
+      session_id: sessionId,
+      btc_test_address: 'tb1qwallet',
+    });
+
+    const decoded = ProtocolV2.decodeFrame(schemas, frame);
+
+    expect(decoded.type).toBe('DeviceSession');
+    expect(decoded.message).toEqual({
+      session_id: sessionId,
+      btc_test_address: 'tb1qwallet',
+    });
+  });
+
+  test('reports malformed DeviceSession protobuf as a schema-compatible transport error', () => {
+    const malformedPayload = new Uint8Array(32);
+    malformedPayload[0] = 0x0a;
+    malformedPayload[1] = 101;
+    const frame = protocolV2.encodeProtobufFrame(60607, malformedPayload);
+
+    expect(() => ProtocolV2.decodeFrame(schemas, frame)).toThrow(
+      'Protocol V2 protobuf decode failed for "DeviceSession" (60607, 32-byte payload); ' +
+        'the payload is malformed or incompatible with the active SDK schema.'
+    );
+  });
+
   test('decodes missing optional nested messages as null', () => {
     const frame = ProtocolV2.encodeFrame(schemas, 'PartialNested', {
       label: 'only label',
@@ -388,7 +434,7 @@ describe('Protocol V2 framing and session', () => {
       logger,
       logPrefix: 'ProtocolV2 Test',
       writeFrame: () => Promise.resolve(),
-      readFrame: () => Promise.resolve(response),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
     });
 
     await expect(session.call('Ping', { message: 'hello' })).rejects.toThrow();
@@ -410,7 +456,10 @@ describe('Protocol V2 framing and session', () => {
     const response = ProtocolV2.encodeFrame(schemas, 'Success', {
       message: 'ok',
     });
-    const readFrame = jest.fn().mockResolvedValueOnce(ack).mockResolvedValueOnce(response);
+    const readFrame = jest
+      .fn()
+      .mockResolvedValueOnce(ack)
+      .mockResolvedValueOnce(rewriteSeq(response, 1));
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
@@ -427,56 +476,93 @@ describe('Protocol V2 framing and session', () => {
     expect(readFrame).toHaveBeenCalledTimes(2);
   });
 
-  test('session ignores an ACK whose sequence does not match the request', async () => {
-    const mismatchedAck = new Uint8Array(8);
-    mismatchedAck[0] = 0x5a;
-    mismatchedAck[1] = 8;
-    mismatchedAck[4] = 1;
-    mismatchedAck[5] = 1;
-    mismatchedAck[6] = 2;
-    mismatchedAck[3] = protocolV2.crc8(mismatchedAck, 3);
-    mismatchedAck[7] = protocolV2.crc8(mismatchedAck, 7);
-    const readFrame = jest
-      .fn()
-      .mockResolvedValueOnce(mismatchedAck)
-      .mockImplementation(() => new Promise(() => {}));
+  test('session accepts a terminal response before an ACK', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'ok',
+    });
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
+    });
+
+    await expect(
+      session.call('Ping', { message: 'hello' }, { expectedTypes: ['Success'] })
+    ).resolves.toEqual({
+      type: 'Success',
+      message: {
+        message: 'ok',
+      },
+    });
+  });
+
+  test('session uses the unified response timeout before the first ACK', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'ok',
+    });
+    const readFrame = jest.fn(() => Promise.resolve(rewriteSeq(response, 1)));
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
-      deliveryTimeoutMs: 10,
       writeFrame: () => Promise.resolve(),
       readFrame,
     });
 
-    await expect(session.call('Ping', { message: 'hello' })).rejects.toThrow(
-      'Protocol V2 delivery timeout after 10ms for Ping'
-    );
-    expect(readFrame).toHaveBeenCalledTimes(2);
+    await expect(
+      session.call(
+        'Ping',
+        { message: 'hello' },
+        {
+          timeoutMs: 12_345,
+          expectedTypes: ['Success'],
+        }
+      )
+    ).resolves.toEqual({
+      type: 'Success',
+      message: {
+        message: 'ok',
+      },
+    });
+    expect(readFrame).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 12_345 }));
   });
 
-  test('session keeps waiting for a response after a matching delivery ACK', async () => {
+  test('session rejects an ACK that belongs to another request sequence', async () => {
     const ack = new Uint8Array(8);
     ack[0] = 0x5a;
     ack[1] = 8;
     ack[4] = 1;
     ack[5] = 1;
-    ack[6] = 1;
+    ack[6] = 2;
     ack[3] = protocolV2.crc8(ack, 3);
     ack[7] = protocolV2.crc8(ack, 7);
-    const readFrame = jest
-      .fn()
-      .mockResolvedValueOnce(ack)
-      .mockImplementation(() => new Promise(() => {}));
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
-      deliveryTimeoutMs: 10,
       writeFrame: () => Promise.resolve(),
-      readFrame,
+      readFrame: () => Promise.resolve(ack),
     });
 
-    await expect(session.call('Ping', { message: 'hello' }, { timeoutMs: 25 })).rejects.toThrow(
-      'Protocol V2 response timeout after 25ms for Ping'
+    await expect(session.call('Ping', { message: 'hello' })).rejects.toEqual(
+      expect.objectContaining({
+        name: 'ProtocolV2LinkError',
+        code: 'ack-sequence',
+        message: 'Protocol V2 ACK sequence mismatch: expected 1, got 2',
+      })
+    );
+  });
+
+  test('session rejects a response from another routing channel', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'wrong route' });
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame: () => Promise.resolve(response),
+    });
+
+    await expect(session.call('Ping', { message: 'hello' })).rejects.toBeInstanceOf(
+      ProtocolV2LinkError
     );
   });
 
@@ -490,7 +576,7 @@ describe('Protocol V2 framing and session', () => {
       router: 1,
       maxFrameBytes: 2048,
       writeFrame,
-      readFrame: () => Promise.resolve(response),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
     });
 
     await expect(session.call('Ping', { message: 'x'.repeat(2048) })).rejects.toThrow(
@@ -499,28 +585,40 @@ describe('Protocol V2 framing and session', () => {
     expect(writeFrame).not.toHaveBeenCalled();
   });
 
-  test('session starts response timeout after the frame is written', async () => {
-    const response = ProtocolV2.encodeFrame(schemas, 'Success', {
-      message: 'ok',
-    });
+  test('session watchdog covers a write that never settles', async () => {
+    const readFrame = jest.fn();
+    let writeSignal;
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
-      writeFrame: () =>
-        new Promise(resolve => {
-          setTimeout(resolve, 30);
-        }),
-      readFrame: () => Promise.resolve(response),
+      writeFrame: (_frame, context) => {
+        writeSignal = context.signal;
+        return new Promise(() => {});
+      },
+      readFrame,
     });
 
     await expect(
       session.call('Ping', { message: 'hello' }, { timeoutMs: 10, expectedTypes: ['Success'] })
-    ).resolves.toEqual({
-      type: 'Success',
-      message: {
-        message: 'ok',
-      },
+    ).rejects.toThrow('Protocol V2 response timeout after 10ms for Ping');
+    expect(writeSignal.aborted).toBe(true);
+    expect(readFrame).not.toHaveBeenCalled();
+  });
+
+  test('session watchdog covers prepareCall before writing', async () => {
+    const writeFrame = jest.fn();
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      prepareCall: () => new Promise(() => {}),
+      writeFrame,
+      readFrame: jest.fn(),
     });
+
+    await expect(session.call('Ping', { message: 'hello' }, { timeoutMs: 10 })).rejects.toThrow(
+      'Protocol V2 response timeout after 10ms for Ping'
+    );
+    expect(writeFrame).not.toHaveBeenCalled();
   });
 
   test('session logs a device-owned response seq without rejecting the frame', async () => {
@@ -550,6 +648,41 @@ describe('Protocol V2 framing and session', () => {
     expect(logger.debug).not.toHaveBeenCalled();
   });
 
+  test('session accepts gaps in the firmware-global response sequence', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const readFrame = jest
+      .fn()
+      .mockResolvedValueOnce(rewriteSeq(response, 1))
+      .mockResolvedValueOnce(rewriteSeq(response, 4));
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame,
+    });
+
+    await session.call('Ping', { message: 'first' });
+    await expect(session.call('Ping', { message: 'second' })).resolves.toMatchObject({
+      type: 'Success',
+    });
+  });
+
+  test('session rejects a duplicate device response sequence', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    const readFrame = jest.fn(() => Promise.resolve(rewriteSeq(response, 7)));
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame,
+    });
+
+    await session.call('Ping', { message: 'first' });
+    await expect(session.call('Ping', { message: 'second' })).rejects.toThrow(
+      'Protocol V2 duplicate response sequence: 7'
+    );
+  });
+
   test('session does not log transmit or receive payload details', async () => {
     const response = ProtocolV2.encodeFrame(schemas, 'Success', {
       message: 'accepted',
@@ -561,7 +694,7 @@ describe('Protocol V2 framing and session', () => {
       schemas,
       router: 1,
       writeFrame: () => Promise.resolve(),
-      readFrame: () => Promise.resolve(response),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
       logger,
       logPrefix: 'ProtocolV2 Test',
     });
@@ -587,7 +720,7 @@ describe('Protocol V2 framing and session', () => {
       schemas,
       router: 1,
       writeFrame: () => Promise.resolve(),
-      readFrame: () => Promise.resolve(response),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
       logger,
     });
 
@@ -612,7 +745,10 @@ describe('Protocol V2 framing and session', () => {
     const logger = {
       debug: jest.fn(),
     };
-    const readFrame = jest.fn().mockResolvedValueOnce(stale).mockResolvedValueOnce(response);
+    const readFrame = jest
+      .fn()
+      .mockResolvedValueOnce(rewriteSeq(stale, 1))
+      .mockResolvedValueOnce(rewriteSeq(response, 2));
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
@@ -649,7 +785,9 @@ describe('Protocol V2 framing and session', () => {
       const [writtenFrame] = written;
       const { seq } = protocolV2.decodeFrame(writtenFrame);
       return Promise.resolve(
-        readFrame.mock.calls.length === 1 ? rewriteSeq(progress, seq) : rewriteSeq(success, seq)
+        readFrame.mock.calls.length === 1
+          ? rewriteSeq(progress, seq)
+          : rewriteSeq(success, protocolV2.nextProtoSeq(seq))
       );
     });
     const session = new ProtocolV2Session({
@@ -826,7 +964,7 @@ describe('Protocol V2 framing and session', () => {
         }
         return Promise.resolve();
       },
-      readFrame: () => Promise.resolve(response),
+      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
     });
 
     await expect(session.call('Ping', { message: '1' })).rejects.toThrow('transport write failed');
@@ -895,6 +1033,7 @@ describe('Protocol V2 framing and session', () => {
     const writeContexts = [];
     const readContexts = [];
     const response = ProtocolV2.encodeFrame(schemas, 'Success', { message: 'ok' });
+    let responseSeq = 0;
     const session = new ProtocolV2Session({
       schemas,
       router: 1,
@@ -905,18 +1044,65 @@ describe('Protocol V2 framing and session', () => {
       },
       readFrame: context => {
         readContexts.push(context);
-        return Promise.resolve(response);
+        responseSeq = protocolV2.nextProtoSeq(responseSeq);
+        return Promise.resolve(rewriteSeq(response, responseSeq));
       },
     });
 
     await session.call('Ping', { message: 'ping' }, { timeoutMs: 123 });
     await session.call('FileWrite', {}, { timeoutMs: 456 });
+    await session.call('Ping', { message: 'default-timeout' });
 
-    expect(writeContexts).toEqual([
-      { messageName: 'Ping', timeoutMs: 123, highVolume: false, generation: 7 },
-      { messageName: 'FileWrite', timeoutMs: 456, highVolume: true, generation: 7 },
+    const normalizeContext = ({ signal, ...context }) => ({
+      ...context,
+      signalAborted: signal.aborted,
+    });
+    expect(writeContexts.map(normalizeContext)).toEqual([
+      {
+        messageName: 'Ping',
+        timeoutMs: 123,
+        highVolume: false,
+        generation: 7,
+        signalAborted: false,
+      },
+      {
+        messageName: 'FileWrite',
+        timeoutMs: 456,
+        highVolume: true,
+        generation: 7,
+        signalAborted: false,
+      },
+      {
+        messageName: 'Ping',
+        timeoutMs: PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
+        highVolume: false,
+        generation: 7,
+        signalAborted: false,
+      },
+    ]);
+    expect(readContexts.map(normalizeContext)).toEqual([
+      {
+        messageName: 'Ping',
+        timeoutMs: 123,
+        highVolume: false,
+        generation: 7,
+        signalAborted: false,
+      },
+      {
+        messageName: 'FileWrite',
+        timeoutMs: 456,
+        highVolume: true,
+        generation: 7,
+        signalAborted: false,
+      },
+      {
+        messageName: 'Ping',
+        timeoutMs: PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS,
+        highVolume: false,
+        generation: 7,
+        signalAborted: false,
+      },
     ]);
-    expect(readContexts).toEqual(writeContexts);
   });
 
   test('assembler throws and resets on frames with an impossible length field', () => {

package/dist/constants.d.ts

@@ -14,4 +14,5 @@ export declare const PROTOCOL_V2_CHANNEL_USB = 0;
 export declare const PROTOCOL_V2_CHANNEL_BLE_UART = 1;
 export declare const PROTOCOL_V2_CHANNEL_SOCKET = 2;
 export declare const PROTOCOL_V2_PACKET_SRC_COMMAND = 0;
+export declare const PROTOCOL_V2_DEFAULT_RESPONSE_TIMEOUT_MS: number;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,KAAO,CAAC;AAG1C,eAAO,MAAM,uBAAuB,KAAO,CAAC;AAG5C,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAGjD,eAAO,MAAM,2BAA2B,QAAqC,CAAC;AAG9E,eAAO,MAAM,+BAA+B,QAAQ,CAAC;AAGrD,eAAO,MAAM,gCAAgC,QAA0C,CAAC;AAKxF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAGhD,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAGpD,eAAO,MAAM,oCAAoC,MAAM,CAAC;AAGxD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAGpD,eAAO,MAAM,2BAA2B,OAAqC,CAAC;AAM9E,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAG5C,eAAO,MAAM,8BAA8B,IAAI,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,KAAO,CAAC;AAG1C,eAAO,MAAM,uBAAuB,KAAO,CAAC;AAG5C,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAGjD,eAAO,MAAM,2BAA2B,QAAqC,CAAC;AAG9E,eAAO,MAAM,+BAA+B,QAAQ,CAAC;AAGrD,eAAO,MAAM,gCAAgC,QAA0C,CAAC;AAKxF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAGhD,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAGpD,eAAO,MAAM,oCAAoC,MAAM,CAAC;AAGxD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAGpD,eAAO,MAAM,2BAA2B,OAAqC,CAAC;AAM9E,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAG5C,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAQhD,eAAO,MAAM,uCAAuC,QAAgB,CAAC"}