@ledgerhq/device-management-kit 0.0.0-signer-eth-20250122093657 → 0.0.0-test-recursive-stack-20251002122259

package/lib/esm/src/api/apdu/utils/ByteArrayBuilder.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayBuilder.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\nimport { DataOverflowError, HexaStringEncodeError } from \"./AppBuilderError\";\nimport { ByteArrayBuilder } from \"./ByteArrayBuilder\";\n\nconst COMMAND_NO_BODY = new Uint8Array([]);\n\nconst COMMAND_BODY_SINGLE = new Uint8Array([0x01]);\n\nconst COMMAND_BODY_HEXA1 = new Uint8Array([0x80, 0x81, 0x82, 0x83, 0x84]);\n\nconst COMMAND_BODY_HEXA2 = new Uint8Array([0x85, 0x86, 0x87, 0x88]);\n\nconst COMMAND_BODY_LV_HEXA = new Uint8Array([0x03, 0xa1, 0xa2, 0xa3]);\n\nconst COMMAND_BODY_LV_ASCII = new Uint8Array([\n  0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n]);\n\nconst COMMAND_BODY_LV_ARRAY = new Uint8Array([0x02, 0xf0, 0xf1]);\n\nconst COMMAND_BODY_COMBINED = new Uint8Array([\n  0x01, 0x33, 0x02, 0x01, 0x23, 0x45, 0x67, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,\n  0x86, 0x87, 0x88, 0x03, 0xa1, 0xa2, 0xa3, 0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n  0x02, 0xf0, 0xf1,\n]);\n\nconst COMMAND_BODY_MAX = new Uint8Array([...Array<number>(255).fill(0xaa)]);\n\nconst COMMAND_BODY_NEARLY = new Uint8Array([...Array<number>(254).fill(0xaa)]);\n\nlet builder: ByteArrayBuilder;\n\ndescribe(\"ByteArrayBuilder\", () => {\n  const builderAddNumber = (\n    num: number | bigint,\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ) => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitIntToData(num, bigEndian);\n          break;\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitUIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitUIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitUIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitUIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitUIntToData(num, bigEndian);\n          break;\n      }\n    }\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should create an instance\", () => {\n      expect(builder).toBeDefined();\n      expect(builder).toBeInstanceOf(ByteArrayBuilder);\n    });\n  });\n\n  describe(\"simple\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with an empty body\", () => {\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n    });\n\n    it(\"should serialize with an single byte body\", () => {\n      builder = new ByteArrayBuilder(1);\n      builder.add8BitUIntToData(0x01);\n      expect(builder.build()).toEqual(COMMAND_BODY_SINGLE);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it.each([\n      [2, false, true, 0x3302, \"3302\"],\n      [2, false, false, 0x3302n, \"0233\"],\n      [2, true, true, 4200n, \"1068\"],\n      [2, true, true, -4200n, \"ef98\"],\n      [2, true, false, 4200, \"6810\"],\n      [2, true, false, -4200, \"98ef\"],\n      [4, false, true, 0x01234567n, \"01234567\"],\n      [4, false, false, 0x01234567n, \"67452301\"],\n      [4, true, true, 123456789, \"075bcd15\"],\n      [4, true, true, -123456789, \"f8a432eb\"],\n      [4, true, false, 123456789, \"15cd5b07\"],\n      [4, true, false, -123456789, \"eb32a4f8\"],\n      [8, false, true, 14147778004927559n, \"0032435442584447\"],\n      [8, false, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, true, 14147778004927559n, \"0032435442584447\"],\n      [8, true, true, -14147778004927559n, \"ffcdbcabbda7bbb9\"],\n      [8, true, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, false, -14147778004927559n, \"b9bba7bdabbccdff\"],\n      [\n        16,\n        false,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        false,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x00324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        16,\n        true,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        false,\n        -0x00324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        false,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        32,\n        true,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        false,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n    ])(\n      \"serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n\n        // Retry with a buffer too small\n        builder = new ByteArrayBuilder(sizeInBits - 1);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it.each([\n      [2, false, true, 0xffffn, \"ffff\"],\n      [2, true, true, 0x7fffn, \"7fff\"],\n      [2, true, true, -0x8000n, \"8000\"],\n      [4, false, true, 0xffffffffn, \"ffffffff\"],\n      [4, true, true, 0x7fffffffn, \"7fffffff\"],\n      [4, true, true, -0x80000000n, \"80000000\"],\n      [8, false, true, 0xffffffffffffffffn, \"ffffffffffffffff\"],\n      [8, true, true, 0x7fffffffffffffffn, \"7fffffffffffffff\"],\n      [8, true, true, -0x8000000000000000n, \"8000000000000000\"],\n      [\n        16,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x80000000000000000000000000000000n,\n        \"80000000000000000000000000000000\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n      ],\n    ])(\n      \"serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n      },\n    );\n\n    it(\"Serialize from float to bigint\", () => {\n      builder = new ByteArrayBuilder(4);\n      builder.add32BitIntToData(123456789.3, false);\n      expect(builder.getErrors().length).toEqual(1);\n      expect(builder.build()).toEqual(Uint8Array.from([]));\n    });\n\n    it(\"should serialize with an 5 byte body from an hexastring\", () => {\n      builder.addHexaStringToData(\"0x8081828384\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA1);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body from an hexastring without '0x'\", () => {\n      builder.addHexaStringToData(\"85868788\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA2);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an hexastring\", () => {\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_HEXA);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an ascci string\", () => {\n      builder.encodeInLVFromAscii(\"maman\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ASCII);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an complete body of 0xAA\", () => {\n      const myarray = new Uint8Array(255).fill(0xaa, 0, 255);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getErrors()).toEqual([]);\n    });\n  });\n\n  describe(\"mixed\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with all previous field\", () => {\n      let available = APDU_MAX_PAYLOAD;\n      builder.add8BitUIntToData(0x01);\n      available--;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add16BitUIntToData(0x3302);\n      available -= 2;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add32BitUIntToData(0x01234567);\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"0x8081828384\");\n      available -= 5;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"85868788\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromAscii(\"maman\");\n      available -= 6;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      available -= 3;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_COMBINED);\n    });\n  });\n\n  describe(\"error\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it.each([\n      [2, false, true, 0x10000n],\n      [2, true, true, 0x8000n],\n      [2, true, true, -0x8001n],\n      [4, false, true, 0x100000000n],\n      [4, true, true, 0x80000000n],\n      [4, true, true, -0x80000001n],\n      [8, false, true, 0x10000000000000000n],\n      [8, true, true, 0x8000000000000000n],\n      [8, true, true, -0x8000000000000001n],\n    ])(\n      \"serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i\",\n      (sizeInBits, signed, bigEndian, input) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it(\"error due to a string not well coded\", () => {\n      builder\n        .addHexaStringToData(\":08081828384\")\n        .addHexaStringToData(\"80818n8384\")\n        .addHexaStringToData(\"808182838z\");\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(\":08081828384\"),\n        new HexaStringEncodeError(\"80818n8384\"),\n        new HexaStringEncodeError(\"808182838z\"),\n      ]);\n    });\n\n    it(\"error due direct overflow\", () => {\n      const myarray = new Uint8Array(256).fill(0xaa, 0, 256);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(myarray.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-byte array\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder.addBufferToData(mybuffer);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char ascii\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mystring = \"a\";\n\n      builder.addAsciiStringToData(mystring);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(new TextEncoder().encode(mystring).toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char hexastring\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const firstString = \"0xB4\";\n      const secondString = \"e1\";\n\n      builder\n        .addHexaStringToData(firstString)\n        .addHexaStringToData(secondString);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError((0xb4).toString()),\n        new DataOverflowError((0xe1).toString()),\n      ]);\n    });\n\n    it(\"error due to empty values\", () => {\n      const mystring = \"\";\n\n      builder.addHexaStringToData(mystring).encodeInLVFromHexa(mystring);\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(mystring),\n        new HexaStringEncodeError(mystring),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char LV\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD - 1).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD - 1,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n\n      const firstString = \"n\";\n      const secondString = \"e1\";\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder\n        .encodeInLVFromAscii(firstString)\n        .encodeInLVFromHexa(secondString)\n        .encodeInLVFromBuffer(mybuffer);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(firstString),\n        new DataOverflowError(secondString),\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\nimport { DataOverflowError, HexaStringEncodeError } from \"./AppBuilderError\";\nimport { ByteArrayBuilder } from \"./ByteArrayBuilder\";\n\nconst COMMAND_NO_BODY = new Uint8Array([]);\n\nconst COMMAND_BODY_SINGLE = new Uint8Array([0x01]);\n\nconst COMMAND_BODY_HEXA1 = new Uint8Array([0x80, 0x81, 0x82, 0x83, 0x84]);\n\nconst COMMAND_BODY_HEXA2 = new Uint8Array([0x85, 0x86, 0x87, 0x88]);\n\nconst COMMAND_BODY_LV_HEXA = new Uint8Array([0x03, 0xa1, 0xa2, 0xa3]);\n\nconst COMMAND_BODY_LV_ASCII = new Uint8Array([\n  0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n]);\n\nconst COMMAND_BODY_LV_ARRAY = new Uint8Array([0x02, 0xf0, 0xf1]);\n\nconst COMMAND_BODY_COMBINED = new Uint8Array([\n  0x01, 0x33, 0x02, 0x01, 0x23, 0x45, 0x67, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,\n  0x86, 0x87, 0x88, 0x03, 0xa1, 0xa2, 0xa3, 0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n  0x02, 0xf0, 0xf1,\n]);\n\nconst COMMAND_BODY_MAX = new Uint8Array([...Array<number>(255).fill(0xaa)]);\n\nconst COMMAND_BODY_NEARLY = new Uint8Array([...Array<number>(254).fill(0xaa)]);\n\nlet builder: ByteArrayBuilder;\n\ndescribe(\"ByteArrayBuilder\", () => {\n  const builderAddNumber = (\n    num: number | bigint,\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ) => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitIntToData(num, bigEndian);\n          break;\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitUIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitUIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitUIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitUIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitUIntToData(num, bigEndian);\n          break;\n      }\n    }\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should create an instance\", () => {\n      expect(builder).toBeDefined();\n      expect(builder).toBeInstanceOf(ByteArrayBuilder);\n    });\n  });\n\n  describe(\"simple\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with an empty body\", () => {\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n    });\n\n    it(\"should serialize with an single byte body\", () => {\n      builder = new ByteArrayBuilder(1);\n      builder.add8BitUIntToData(0x01);\n      expect(builder.build()).toEqual(COMMAND_BODY_SINGLE);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it.each([\n      [2, false, true, 0x3302, \"3302\"],\n      [2, false, false, 0x3302n, \"0233\"],\n      [2, true, true, 4200n, \"1068\"],\n      [2, true, true, -4200n, \"ef98\"],\n      [2, true, false, 4200, \"6810\"],\n      [2, true, false, -4200, \"98ef\"],\n      [4, false, true, 0x01234567n, \"01234567\"],\n      [4, false, false, 0x01234567n, \"67452301\"],\n      [4, true, true, 123456789, \"075bcd15\"],\n      [4, true, true, -123456789, \"f8a432eb\"],\n      [4, true, false, 123456789, \"15cd5b07\"],\n      [4, true, false, -123456789, \"eb32a4f8\"],\n      [8, false, true, 14147778004927559n, \"0032435442584447\"],\n      [8, false, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, true, 14147778004927559n, \"0032435442584447\"],\n      [8, true, true, -14147778004927559n, \"ffcdbcabbda7bbb9\"],\n      [8, true, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, false, -14147778004927559n, \"b9bba7bdabbccdff\"],\n      [\n        16,\n        false,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        false,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x00324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        16,\n        true,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        false,\n        -0x00324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        false,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        32,\n        true,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        false,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n    ])(\n      \"serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n\n        // Retry with a buffer too small\n        builder = new ByteArrayBuilder(sizeInBits - 1);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it.each([\n      [2, false, true, 0xffffn, \"ffff\"],\n      [2, true, true, 0x7fffn, \"7fff\"],\n      [2, true, true, -0x8000n, \"8000\"],\n      [4, false, true, 0xffffffffn, \"ffffffff\"],\n      [4, true, true, 0x7fffffffn, \"7fffffff\"],\n      [4, true, true, -0x80000000n, \"80000000\"],\n      [8, false, true, 0xffffffffffffffffn, \"ffffffffffffffff\"],\n      [8, true, true, 0x7fffffffffffffffn, \"7fffffffffffffff\"],\n      [8, true, true, -0x8000000000000000n, \"8000000000000000\"],\n      [\n        16,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x80000000000000000000000000000000n,\n        \"80000000000000000000000000000000\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n      ],\n    ])(\n      \"serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n      },\n    );\n\n    it(\"Serialize from float to bigint\", () => {\n      builder = new ByteArrayBuilder(4);\n      builder.add32BitIntToData(123456789.3, false);\n      expect(builder.getErrors().length).toEqual(1);\n      expect(builder.build()).toEqual(Uint8Array.from([]));\n    });\n\n    it(\"should serialize with an 5 byte body from an hexastring\", () => {\n      builder.addHexaStringToData(\"0x8081828384\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA1);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body from an hexastring without '0x'\", () => {\n      builder.addHexaStringToData(\"85868788\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA2);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an hexastring\", () => {\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_HEXA);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an ascci string\", () => {\n      builder.encodeInLVFromAscii(\"maman\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ASCII);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an ascii string\", () => {\n      builder.encodeInTLVFromAscii(0x05, \"coucou\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x06, 0x63, 0x6f, 0x75, 0x63, 0x6f, 0x75]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an hexastring\", () => {\n      builder.encodeInTLVFromHexa(0x05, \"0xA1A2A3\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x03, 0xa1, 0xa2, 0xa3]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from a buffer\", () => {\n      builder.encodeInTLVFromBuffer(\n        0x06,\n        Uint8Array.from([0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint8\", () => {\n      builder.encodeInTLVFromUInt8(0x06, 0x56);\n      expect(builder.build()).toEqual(Uint8Array.from([0x06, 0x01, 0x56]));\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint16\", () => {\n      builder.encodeInTLVFromUInt16(0x06, 0x3456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x02, 0x34, 0x56]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint32\", () => {\n      builder.encodeInTLVFromUInt32(0x06, 0x90123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0x90, 0x12, 0x34, 0x56]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint64\", () => {\n      builder.encodeInTLVFromUInt64(0x06, 0x567890123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([\n          0x06, 0x08, 0x00, 0x00, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,\n        ]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an complete body of 0xAA\", () => {\n      const myarray = new Uint8Array(255).fill(0xaa, 0, 255);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getErrors()).toEqual([]);\n    });\n  });\n\n  describe(\"mixed\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with all previous field\", () => {\n      let available = APDU_MAX_PAYLOAD;\n      builder.add8BitUIntToData(0x01);\n      available--;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add16BitUIntToData(0x3302);\n      available -= 2;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add32BitUIntToData(0x01234567);\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"0x8081828384\");\n      available -= 5;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"85868788\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromAscii(\"maman\");\n      available -= 6;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      available -= 3;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_COMBINED);\n    });\n  });\n\n  describe(\"error\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it.each([\n      [2, false, true, 0x10000n],\n      [2, true, true, 0x8000n],\n      [2, true, true, -0x8001n],\n      [4, false, true, 0x100000000n],\n      [4, true, true, 0x80000000n],\n      [4, true, true, -0x80000001n],\n      [8, false, true, 0x10000000000000000n],\n      [8, true, true, 0x8000000000000000n],\n      [8, true, true, -0x8000000000000001n],\n    ])(\n      \"serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i\",\n      (sizeInBits, signed, bigEndian, input) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it(\"error due to a string not well coded\", () => {\n      builder\n        .addHexaStringToData(\":08081828384\")\n        .addHexaStringToData(\"80818n8384\")\n        .addHexaStringToData(\"808182838z\");\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(\":08081828384\"),\n        new HexaStringEncodeError(\"80818n8384\"),\n        new HexaStringEncodeError(\"808182838z\"),\n      ]);\n    });\n\n    it(\"error due direct overflow\", () => {\n      const myarray = new Uint8Array(256).fill(0xaa, 0, 256);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(myarray.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-byte array\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder.addBufferToData(mybuffer);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char ascii\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mystring = \"a\";\n\n      builder.addAsciiStringToData(mystring);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(new TextEncoder().encode(mystring).toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char hexastring\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const firstString = \"0xB4\";\n      const secondString = \"e1\";\n\n      builder\n        .addHexaStringToData(firstString)\n        .addHexaStringToData(secondString);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError((0xb4).toString()),\n        new DataOverflowError((0xe1).toString()),\n      ]);\n    });\n\n    it(\"error due to empty values\", () => {\n      const mystring = \"\";\n\n      builder.addHexaStringToData(mystring).encodeInLVFromHexa(mystring);\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(mystring),\n        new HexaStringEncodeError(mystring),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char LV\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD - 1).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD - 1,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n\n      const firstString = \"n\";\n      const secondString = \"e1\";\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder\n        .encodeInLVFromAscii(firstString)\n        .encodeInLVFromHexa(secondString)\n        .encodeInLVFromBuffer(mybuffer);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(firstString),\n        new DataOverflowError(secondString),\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["hexaStringToBuffer", "APDU_MAX_PAYLOAD", "DataOverflowError", "HexaStringEncodeError", "ByteArrayBuilder", "COMMAND_NO_BODY", "COMMAND_BODY_SINGLE", "COMMAND_BODY_HEXA1", "COMMAND_BODY_HEXA2", "COMMAND_BODY_LV_HEXA", "COMMAND_BODY_LV_ASCII", "COMMAND_BODY_LV_ARRAY", "COMMAND_BODY_COMBINED", "COMMAND_BODY_MAX", "COMMAND_BODY_NEARLY", "builder", "builderAddNumber", "num", "bigEndian", "sizeInBits", "signed", "input", "output", "myarray", "available", "mybuffer", "mystring", "firstString", "secondString"]
 }

package/lib/esm/src/api/apdu/utils/ByteArrayParser.js

@@ -1,2 +1,2 @@
-import{bufferToHexaString as d}from"../../utils/HexaString";class s{constructor(e){this.buffer=e}index=0;testMinimalLength(e){return e<=this.buffer.length-this.index}extract8BitUInt(){if(!this.outOfRange(1))return this.buffer[this.index++]}extract16BitUInt(e=!0){const t=this.extractNumber(16n,!1,e);return t===void 0?void 0:Number(t)}extract16BitInt(e=!0){const t=this.extractNumber(16n,!0,e);return t===void 0?void 0:Number(t)}extract32BitUInt(e=!0){const t=this.extractNumber(32n,!1,e);return t===void 0?void 0:Number(t)}extract32BitInt(e=!0){const t=this.extractNumber(32n,!0,e);return t===void 0?void 0:Number(t)}extract64BitUInt(e=!0){return this.extractNumber(64n,!1,e)}extract64BitInt(e=!0){return this.extractNumber(64n,!0,e)}extract128BitUInt(e=!0){return this.extractNumber(128n,!1,e)}extract128BitInt(e=!0){return this.extractNumber(128n,!0,e)}extract256BitUInt(e=!0){return this.extractNumber(256n,!1,e)}extract256BitInt(e=!0){return this.extractNumber(256n,!0,e)}extractFieldByLength(e){if(this.outOfRange(e))return;if(e===0)return new Uint8Array;const t=this.buffer.slice(this.index,this.index+e);return this.index+=e,t}extractFieldLVEncoded(){const e=this.extract8BitUInt();if(e===void 0)return;if(e===0)return new Uint8Array;const t=this.extractFieldByLength(e);return t===void 0&&this.index--,t}extractFieldTLVEncoded(){if(this.outOfRange(2))return;const e=this.extract8BitUInt(),t=this.extractFieldLVEncoded();if(e===void 0||t===void 0){this.index--;return}return{tag:e,value:t}}encodeToHexaString(e,t=!1){if(e===void 0||e.length===0)return"";const r=d(e);return t?r:r.slice(2)}encodeToString(e){let t="",r=0;if(!e)return t;for(;r<=e.length;){const i=e[r];i&&(t+=String.fromCharCode(i)),r++}return t}getCurrentIndex(){return this.index}resetIndex(){this.index=0}getUnparsedRemainingLength(){return this.buffer.length-this.index}outOfRange(e){return this.index+e>this.buffer.length}extractNumber(e,t,r){const i=Number(e)/8;if(this.outOfRange(i))return;let u=0n;if(r)for(let n=0;n<i;n++)u=u<<8n|BigInt(this.buffer[n+this.index]);else for(let n=i-1;n>=0;n--)u=u<<8n|BigInt(this.buffer[n+this.index]);if(t){const n=1n<<e-1n;u&n&&(u-=n<<1n)}return this.index+=i,u}}export{s as ByteArrayParser};
+import{bufferToHexaString as d}from"../../utils/HexaString";class s{constructor(e){this.buffer=e}index=0;testMinimalLength(e){return e<=this.buffer.length-this.index}extract8BitUInt(){if(!this.outOfRange(1))return this.buffer[this.index++]}extract16BitUInt(e=!0){const t=this.extractNumber(16n,!1,e);return t===void 0?void 0:Number(t)}extract16BitInt(e=!0){const t=this.extractNumber(16n,!0,e);return t===void 0?void 0:Number(t)}extract32BitUInt(e=!0){const t=this.extractNumber(32n,!1,e);return t===void 0?void 0:Number(t)}extract32BitInt(e=!0){const t=this.extractNumber(32n,!0,e);return t===void 0?void 0:Number(t)}extract64BitUInt(e=!0){return this.extractNumber(64n,!1,e)}extract64BitInt(e=!0){return this.extractNumber(64n,!0,e)}extract128BitUInt(e=!0){return this.extractNumber(128n,!1,e)}extract128BitInt(e=!0){return this.extractNumber(128n,!0,e)}extract256BitUInt(e=!0){return this.extractNumber(256n,!1,e)}extract256BitInt(e=!0){return this.extractNumber(256n,!0,e)}extractFieldByLength(e){if(this.outOfRange(e))return;if(e===0)return new Uint8Array;const t=this.buffer.slice(this.index,this.index+e);return this.index+=e,t}extractFieldLVEncoded(){const e=this.extract8BitUInt();if(e===void 0)return;if(e===0)return new Uint8Array;const t=this.extractFieldByLength(e);return t===void 0&&this.index--,t}extractFieldTLVEncoded(){if(this.outOfRange(2))return;const e=this.index,t=this.extract8BitUInt(),n=this.extractFieldLVEncoded();if(t===void 0||n===void 0){this.index--;return}const i=this.index;return{tag:t,value:n,tlv:this.buffer.slice(e,i)}}encodeToHexaString(e,t=!1){if(e===void 0||e.length===0)return"";const n=d(e);return t?n:n.slice(2)}encodeToString(e){let t="",n=0;if(!e)return t;for(;n<=e.length;){const i=e[n];i&&(t+=String.fromCharCode(i)),n++}return t}getCurrentIndex(){return this.index}resetIndex(){this.index=0}getUnparsedRemainingLength(){return this.buffer.length-this.index}outOfRange(e){return this.index+e>this.buffer.length}extractNumber(e,t,n){const i=Number(e)/8;if(this.outOfRange(i))return;let u=0n;if(n)for(let r=0;r<i;r++)u=u<<8n|BigInt(this.buffer[r+this.index]);else for(let r=i-1;r>=0;r--)u=u<<8n|BigInt(this.buffer[r+this.index]);if(t){const r=1n<<e-1n;u&r&&(u-=r<<1n)}return this.index+=i,u}}export{s as ByteArrayParser};
 //# sourceMappingURL=ByteArrayParser.js.map

package/lib/esm/src/api/apdu/utils/ByteArrayParser.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayParser.ts"],
-  "sourcesContent": ["import { bufferToHexaString, type HexaString } from \"@api/utils/HexaString\";\n\nexport type TaggedField = {\n  readonly tag: number;\n  readonly value: Uint8Array;\n};\n\n/**\n * ByteArrayParser is a utility class to help parse a byte array.\n *\n * It provides methods to extract fields of different types from the buffer.\n *\n * @example\n * ```\n * const parser = new ByteArrayParser(buffer);\n * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));\n * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n * ```\n */\nexport class ByteArrayParser {\n  private index: number = 0;\n\n  constructor(private readonly buffer: Uint8Array) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Test if the length is greater than the response length\n   * @param length: number\n   * @returns {boolean} - Returns false if the length is greater than the response length\n   */\n  testMinimalLength(length: number): boolean {\n    return length <= this.buffer.length - this.index;\n  }\n\n  /**\n   * Extract a single byte from the response\n   * @returns {number | undefined} - Returns the byte extracted from the response\n   */\n  extract8BitUInt(): number | undefined {\n    if (this.outOfRange(1)) return;\n    return this.buffer[this.index++];\n  }\n\n  /**\n   * Extract a 16-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response\n   */\n  extract16BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 16-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit signed integer extracted from the response\n   */\n  extract16BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response\n   */\n  extract32BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit signed integer extracted from the response\n   */\n  extract32BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 64-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit unsigned integer extracted from the response\n   */\n  extract64BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 64-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit signed integer extracted from the response\n   */\n  extract64BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit unsigned integer extracted from the response\n   */\n  extract128BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit signed integer extracted from the response\n   */\n  extract128BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit unsigned integer extracted from the response\n   */\n  extract256BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit signed integer extracted from the response\n   */\n  extract256BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, true, bigEndian);\n  }\n\n  /**\n   * Extract a field of a specified length from the response\n   * @param length: number - The length of the field to extract\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldByLength(length: number): Uint8Array | undefined {\n    if (this.outOfRange(length)) return;\n    if (length === 0) return new Uint8Array();\n    const field = this.buffer.slice(this.index, this.index + length);\n    this.index += length;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is length-value encoded\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldLVEncoded(): Uint8Array | undefined {\n    // extract Length field\n    const length = this.extract8BitUInt();\n    if (length === undefined) return;\n    else if (length === 0) return new Uint8Array();\n    const field = this.extractFieldByLength(length);\n    // if the field is inconsistent then roll back to the initial point\n    if (field === undefined) this.index--;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is tag-length-value encoded\n   * @returns {TaggedField | undefined} - Returns the field extracted from the response\n   */\n  extractFieldTLVEncoded(): TaggedField | undefined {\n    if (this.outOfRange(2)) return;\n\n    const tag = this.extract8BitUInt();\n    const value = this.extractFieldLVEncoded();\n\n    if (tag === undefined || value === undefined) {\n      this.index--;\n      return;\n    }\n    return { tag, value };\n  }\n\n  /**\n   * Encode a value to a hexadecimal string\n   * @param value {Uint8Array} - The value to encode\n   * @param prefix {boolean} - Whether to add a prefix to the encoded value\n   * @returns {string} - The encoded value as a hexadecimal string\n   */\n  encodeToHexaString(value?: Uint8Array, prefix?: false): string;\n  encodeToHexaString(value?: Uint8Array, prefix?: true): HexaString;\n  encodeToHexaString(\n    value?: Uint8Array,\n    prefix: boolean = false,\n  ): HexaString | string {\n    if (value === undefined || value.length === 0) return \"\";\n    const result = bufferToHexaString(value);\n    return prefix ? result : result.slice(2);\n  }\n\n  /**\n   * Encode a value to an ASCII string\n   * @param value {Uint8Array} - The value to encode\n   * @returns {string} - The encoded value as an ASCII string\n   */\n  encodeToString(value?: Uint8Array): string {\n    let result = \"\";\n    let index = 0;\n\n    if (!value) return result;\n\n    while (index <= value.length) {\n      const item = value[index];\n      if (item) result += String.fromCharCode(item);\n      index++;\n    }\n\n    return result;\n  }\n\n  /**\n   * Get the current index of the parser\n   * @returns {number} - The current index of the parser\n   */\n  getCurrentIndex(): number {\n    return this.index;\n  }\n\n  /**\n   * Reset the index of the parser to 0\n   */\n  resetIndex() {\n    this.index = 0;\n  }\n\n  /**\n   * Get the remaining length of the response\n   * @returns {number} - The remaining length of the response\n   */\n  getUnparsedRemainingLength(): number {\n    return this.buffer.length - this.index;\n  }\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check whether the expected length is out of range\n   * @param length: number\n   * @returns {boolean} - Returns true if the expected length is out of range\n   */\n  private outOfRange(length: number): boolean {\n    return this.index + length > this.buffer.length;\n  }\n\n  /**\n   * Extract a number from the buffer\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - True is the number can be signed and converted to two's compliment\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {bigint | undefined} - Returns the number extracted from the buffer\n   */\n  private extractNumber(\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): bigint | undefined {\n    // Check the range\n    const sizeInBytes: number = Number(sizeInBits) / 8;\n    if (this.outOfRange(sizeInBytes)) return;\n\n    // Compute the number\n    let value: bigint = 0n;\n    if (bigEndian) {\n      for (let i = 0; i < sizeInBytes; i++) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    } else {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    }\n\n    // Convert the value to two's complement if it is negative\n    // https://en.wikipedia.org/wiki/Two%27s_complement\n    if (signed) {\n      const limit = 1n << (sizeInBits - 1n);\n      if (value & limit) {\n        value -= limit << 1n;\n      }\n    }\n\n    this.index += sizeInBytes;\n    return value;\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["bufferToHexaString", "ByteArrayParser", "buffer", "length", "bigEndian", "value", "field", "tag", "prefix", "result", "index", "item", "sizeInBits", "signed", "sizeInBytes", "i", "limit"]
+  "sourcesContent": ["import { bufferToHexaString, type HexaString } from \"@api/utils/HexaString\";\n\nexport type TaggedField = {\n  readonly tag: number;\n  readonly value: Uint8Array;\n  readonly tlv: Uint8Array;\n};\n\n/**\n * ByteArrayParser is a utility class to help parse a byte array.\n *\n * It provides methods to extract fields of different types from the buffer.\n *\n * @example\n * ```\n * const parser = new ByteArrayParser(buffer);\n * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));\n * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n * ```\n */\nexport class ByteArrayParser {\n  private index: number = 0;\n\n  constructor(private readonly buffer: Uint8Array) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Test if the length is greater than the response length\n   * @param length: number\n   * @returns {boolean} - Returns false if the length is greater than the response length\n   */\n  testMinimalLength(length: number): boolean {\n    return length <= this.buffer.length - this.index;\n  }\n\n  /**\n   * Extract a single byte from the response\n   * @returns {number | undefined} - Returns the byte extracted from the response\n   */\n  extract8BitUInt(): number | undefined {\n    if (this.outOfRange(1)) return;\n    return this.buffer[this.index++];\n  }\n\n  /**\n   * Extract a 16-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response\n   */\n  extract16BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 16-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit signed integer extracted from the response\n   */\n  extract16BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response\n   */\n  extract32BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit signed integer extracted from the response\n   */\n  extract32BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 64-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit unsigned integer extracted from the response\n   */\n  extract64BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 64-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit signed integer extracted from the response\n   */\n  extract64BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit unsigned integer extracted from the response\n   */\n  extract128BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit signed integer extracted from the response\n   */\n  extract128BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit unsigned integer extracted from the response\n   */\n  extract256BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit signed integer extracted from the response\n   */\n  extract256BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, true, bigEndian);\n  }\n\n  /**\n   * Extract a field of a specified length from the response\n   * @param length: number - The length of the field to extract\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldByLength(length: number): Uint8Array | undefined {\n    if (this.outOfRange(length)) return;\n    if (length === 0) return new Uint8Array();\n    const field = this.buffer.slice(this.index, this.index + length);\n    this.index += length;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is length-value encoded\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldLVEncoded(): Uint8Array | undefined {\n    // extract Length field\n    const length = this.extract8BitUInt();\n    if (length === undefined) return;\n    else if (length === 0) return new Uint8Array();\n    const field = this.extractFieldByLength(length);\n    // if the field is inconsistent then roll back to the initial point\n    if (field === undefined) this.index--;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is tag-length-value encoded\n   * @returns {TaggedField | undefined} - Returns the field extracted from the response\n   */\n  extractFieldTLVEncoded(): TaggedField | undefined {\n    if (this.outOfRange(2)) return;\n\n    const startIndex = this.index;\n    const tag = this.extract8BitUInt();\n    const value = this.extractFieldLVEncoded();\n\n    if (tag === undefined || value === undefined) {\n      this.index--;\n      return;\n    }\n    const endIndex = this.index;\n    return { tag, value, tlv: this.buffer.slice(startIndex, endIndex) };\n  }\n\n  /**\n   * Encode a value to a hexadecimal string\n   * @param value {Uint8Array} - The value to encode\n   * @param prefix {boolean} - Whether to add a prefix to the encoded value\n   * @returns {string} - The encoded value as a hexadecimal string\n   */\n  encodeToHexaString(value?: Uint8Array, prefix?: false): string;\n  encodeToHexaString(value?: Uint8Array, prefix?: true): HexaString;\n  encodeToHexaString(\n    value?: Uint8Array,\n    prefix: boolean = false,\n  ): HexaString | string {\n    if (value === undefined || value.length === 0) return \"\";\n    const result = bufferToHexaString(value);\n    return prefix ? result : result.slice(2);\n  }\n\n  /**\n   * Encode a value to an ASCII string\n   * @param value {Uint8Array} - The value to encode\n   * @returns {string} - The encoded value as an ASCII string\n   */\n  encodeToString(value?: Uint8Array): string {\n    let result = \"\";\n    let index = 0;\n\n    if (!value) return result;\n\n    while (index <= value.length) {\n      const item = value[index];\n      if (item) result += String.fromCharCode(item);\n      index++;\n    }\n\n    return result;\n  }\n\n  /**\n   * Get the current index of the parser\n   * @returns {number} - The current index of the parser\n   */\n  getCurrentIndex(): number {\n    return this.index;\n  }\n\n  /**\n   * Reset the index of the parser to 0\n   */\n  resetIndex() {\n    this.index = 0;\n  }\n\n  /**\n   * Get the remaining length of the response\n   * @returns {number} - The remaining length of the response\n   */\n  getUnparsedRemainingLength(): number {\n    return this.buffer.length - this.index;\n  }\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check whether the expected length is out of range\n   * @param length: number\n   * @returns {boolean} - Returns true if the expected length is out of range\n   */\n  private outOfRange(length: number): boolean {\n    return this.index + length > this.buffer.length;\n  }\n\n  /**\n   * Extract a number from the buffer\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - True is the number can be signed and converted to two's compliment\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {bigint | undefined} - Returns the number extracted from the buffer\n   */\n  private extractNumber(\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): bigint | undefined {\n    // Check the range\n    const sizeInBytes: number = Number(sizeInBits) / 8;\n    if (this.outOfRange(sizeInBytes)) return;\n\n    // Compute the number\n    let value: bigint = 0n;\n    if (bigEndian) {\n      for (let i = 0; i < sizeInBytes; i++) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    } else {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    }\n\n    // Convert the value to two's complement if it is negative\n    // https://en.wikipedia.org/wiki/Two%27s_complement\n    if (signed) {\n      const limit = 1n << (sizeInBits - 1n);\n      if (value & limit) {\n        value -= limit << 1n;\n      }\n    }\n\n    this.index += sizeInBytes;\n    return value;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["bufferToHexaString", "ByteArrayParser", "buffer", "length", "bigEndian", "value", "field", "startIndex", "tag", "endIndex", "prefix", "result", "index", "item", "sizeInBits", "signed", "sizeInBytes", "i", "limit"]
 }

package/lib/esm/src/api/apdu/utils/ByteArrayParser.test.js

@@ -1,2 +1,2 @@
-import{hexaStringToBuffer as s}from"../../utils/HexaString";import{ByteArrayParser as c}from"./ByteArrayParser";const p=new Uint8Array([1]),u=new Uint8Array([0]),l=new Uint8Array([1,1]),b=new Uint8Array([171,0]),d=new Uint8Array([1,2,3,...Array(253).fill(170)]),L="33000004",R="0xe6000000",E=3858759680,i="2.2.3",m="2.30",C="1.16",S=0,A=1,T=0,U=new Uint8Array([51,0,0,4,5,50,46,50,46,51,4,230,0,0,0,4,50,46,51,48,4,49,46,49,54,1,0,1,1,1,0]),I=new Uint8Array([66,79,76,79,83]),h="BOLOS",g=new Uint8Array([1,5,66,79,76,79,83,5,50,46,50,46,51]);let e,x=p;describe("ByteArrayParser",()=>{const B=(t,f,n)=>{if(n)switch(f){case 2:return e.extract16BitInt(t);case 4:return e.extract32BitInt(t);case 8:return e.extract64BitInt(t);case 16:return e.extract128BitInt(t);case 32:return e.extract256BitInt(t)}else switch(f){case 2:return e.extract16BitUInt(t);case 4:return e.extract32BitUInt(t);case 8:return e.extract64BitUInt(t);case 16:return e.extract128BitUInt(t);case 32:return e.extract256BitUInt(t)}};describe("clean",()=>{beforeEach(()=>{jest.resetAllMocks()}),it("should create an instance",()=>{e=new c(x),expect(e).toBeDefined(),expect(e).toBeInstanceOf(c)}),it("Extract a single byte",()=>{e=new c(x),expect(e.extract8BitUInt()).toBe(1),expect(e.getCurrentIndex()).toBe(1),expect(e.getUnparsedRemainingLength()).toBe(0)}),it("Extract one byte",()=>{x=d,e=new c(x);let t=0,f=d.length;for(expect(f).toBe(256),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--,expect(e.extract8BitUInt()).toBe(1),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--,expect(e.extract8BitUInt()).toBe(2),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--,expect(e.extract8BitUInt()).toBe(3),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--;f!=0;)expect(e.extract8BitUInt()).toBe(170),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--}),it.each([[2,!1,!0,"ffff",65535],[2,!0,!0,"7fff",32767],[2,!0,!0,"8000",-32768],[4,!1,!0,"ffffffff",4294967295],[4,!0,!0,"7fffffff",2147483647],[4,!0,!0,"80000000",-2147483648],[8,!1,!0,"ffffffffffffffff",0xffffffffffffffffn],[8,!0,!0,"7fffffffffffffff",0x7fffffffffffffffn],[8,!0,!0,"8000000000000000",-0x8000000000000000n],[16,!1,!0,"ffffffffffffffffffffffffffffffff",0xffffffffffffffffffffffffffffffffn],[16,!0,!0,"7fffffffffffffffffffffffffffffff",0x7fffffffffffffffffffffffffffffffn],[16,!0,!0,"80000000000000000000000000000000",-0x80000000000000000000000000000000n],[32,!1,!0,"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn],[32,!0,!0,"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn],[32,!0,!0,"8000000000000000000000000000000000000000000000000000000000000000",-0x8000000000000000000000000000000000000000000000000000000000000000n]])("Extract a number to the limit: size %i, signed %s, bigEndian %s, buffer %s, expected %i",(t,f,n,r,a)=>{e=new c(s(r));const o=B(n,t,f);expect(o).toStrictEqual(a)}),it.each([[2,!1,!0,"3302",13058],[2,!1,!1,"0233",13058],[2,!0,!0,"1068",4200],[2,!0,!0,"ef98",-4200],[2,!0,!1,"6810",4200],[2,!0,!1,"98ef",-4200],[4,!1,!0,"01234567",19088743],[4,!1,!1,"67452301",19088743],[4,!0,!0,"075bcd15",123456789],[4,!0,!0,"f8a432eb",-123456789],[4,!0,!1,"15cd5b07",123456789],[4,!0,!1,"eb32a4f8",-123456789],[8,!1,!0,"0032435442584447",14147778004927559n],[8,!1,!1,"4744584254433200",14147778004927559n],[8,!0,!0,"0032435442584447",14147778004927559n],[8,!0,!0,"ffcdbcabbda7bbb9",-14147778004927559n],[8,!0,!1,"4744584254433200",14147778004927559n],[8,!0,!1,"b9bba7bdabbccdff",-14147778004927559n],[16,!1,!0,"00324354425844470032435442584447",0x00324354425844470032435442584447n],[16,!1,!1,"47445842544332004744584254433200",0x00324354425844470032435442584447n],[16,!0,!0,"00324354425844470032435442584447",0x00324354425844470032435442584447n],[16,!0,!0,"ffcdbcabbda7bbb8ffcdbcabbda7bbb9",-0x00324354425844470032435442584447n],[16,!0,!1,"47445842544332004744584254433200",0x00324354425844470032435442584447n],[16,!0,!1,"b9bba7bdabbccdffb8bba7bdabbccdff",-0x00324354425844470032435442584447n],[32,!1,!0,"0032435442584447003243544258444700324354425844470032435442584447",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!1,!1,"4744584254433200474458425443320047445842544332004744584254433200",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!0,"0032435442584447003243544258444700324354425844470032435442584447",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!0,"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9",-0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!1,"4744584254433200474458425443320047445842544332004744584254433200",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!1,"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff",-0x0032435442584447003243544258444700324354425844470032435442584447n]])("Extract the following number: size %i, signed %s, bigEndian %s, buffer %s, expected %i",(t,f,n,r,a)=>{e=new c(s(r));const o=B(n,t,f);expect(o).toStrictEqual(a)}),it("Extract 16-bit & 32-bit number",()=>{x=d,e=new c(x);let t=0,f=d.length;expect(f).toBe(256),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBe(258),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBe(938),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),e.resetIndex(),t=0,f=d.length,expect(e.extract32BitUInt()).toBe(16909226),t+=4,f-=4,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract32BitUInt()).toBe(2863311530),t+=4,f-=4,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)}),it("Parse a GetAppVersion response",()=>{x=g,e=new c(x);let t=0,f=g.length;expect(f).toBe(13),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);const n=e.extract8BitUInt();t++,f--,expect(n).toBe(1),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let r=e.extractFieldLVEncoded();expect(r).toStrictEqual(I),expect(e.encodeToString(r)).toBe(h),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),r=e.extractFieldLVEncoded(),expect(e.encodeToString(r)).toBe(i),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),e.resetIndex(),t=0,f=g.length,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);const a=e.extractFieldTLVEncoded();expect(a?.tag).toBe(1),expect(a?.value).toStrictEqual(I),expect(e.encodeToString(a?.value)).toBe(h),t+=7,f-=7,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),r=e.extractFieldLVEncoded(),expect(e.encodeToString(r)).toBe(i),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)}),it("Parse a GetVersion response",()=>{x=U,e=new c(x);let t=0,f=U.length;expect(f).toBe(31),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.testMinimalLength(25)).toBe(!0);let n=e.extractFieldByLength(4);expect(e.encodeToHexaString(n)).toBe(L),t+=4,f-=4,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(e.encodeToString(n)).toBe(i),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded();const r=e.encodeToHexaString(n,!0);expect(r).toBe(R),expect(parseInt(r,16)).toBe(E),t+=5,f-=5,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(e.encodeToString(n)).toBe(m),t+=5,f-=5,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(e.encodeToString(n)).toBe(C),t+=5,f-=5,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n?.at(0)).toBe(S),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n?.at(0)).toBe(A),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n?.at(0)).toBe(T),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)})}),describe("errors",()=>{it("no response",()=>{x=new Uint8Array,e=new c(x);const t=0,f=0;expect(e.testMinimalLength(1)).toBe(!1),expect(e.extract8BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract32BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let n=e.extractFieldByLength(2);expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);const r=e.extractFieldTLVEncoded();expect(r).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)}),it("length error",()=>{x=p,e=new c(x);const t=0,f=p.length;expect(f).toBe(1),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract32BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let n=e.extractFieldByLength(2);expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let r=e.extractFieldTLVEncoded();expect(r).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),x=l,e=new c(x),r=e.extractFieldTLVEncoded(),expect(r).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(l.length)}),it("Test zero length",()=>{x=u,e=new c(x);const t=new Uint8Array,f=0;let n=u.length;expect(n).toBe(1),expect(e.getCurrentIndex()).toBe(f),expect(e.getUnparsedRemainingLength()).toBe(n);const r=e.extract8BitUInt();expect(r).toBe(0),expect(e.getCurrentIndex()).toBe(1),expect(e.getUnparsedRemainingLength()).toBe(0),e.resetIndex();let a=e.extractFieldByLength(0);expect(a).toStrictEqual(t),expect(e.encodeToString(a)).toBe(""),expect(e.getCurrentIndex()).toBe(f),expect(e.getUnparsedRemainingLength()).toBe(n),a=e.extractFieldLVEncoded(),expect(e.getCurrentIndex()).toBe(1),expect(e.getUnparsedRemainingLength()).toBe(0),expect(a).toStrictEqual(t),expect(e.encodeToString(a)).toBe(""),x=b,e=new c(x),n=b.length,expect(n).toBe(2),expect(e.getCurrentIndex()).toBe(f),expect(e.getUnparsedRemainingLength()).toBe(n);const o=e.extractFieldTLVEncoded();expect(o?.tag).toBe(171),expect(o?.value).toStrictEqual(t),expect(e.encodeToString(o?.value)).toBe(""),expect(e.getCurrentIndex()).toBe(2),expect(e.getUnparsedRemainingLength()).toBe(0),expect(e.encodeToHexaString()).toBe(""),expect(e.encodeToString()).toBe("")})})});
+import{hexaStringToBuffer as s}from"../../utils/HexaString";import{ByteArrayParser as c}from"./ByteArrayParser";const p=new Uint8Array([1]),u=new Uint8Array([0]),l=new Uint8Array([1,1]),b=new Uint8Array([171,0]),d=new Uint8Array([1,2,3,...Array(253).fill(170)]),L="33000004",R="0xe6000000",E=3858759680,i="2.2.3",m="2.30",C="1.16",S=0,A=1,T=0,U=new Uint8Array([51,0,0,4,5,50,46,50,46,51,4,230,0,0,0,4,50,46,51,48,4,49,46,49,54,1,0,1,1,1,0]),I=new Uint8Array([66,79,76,79,83]),h="BOLOS",g=new Uint8Array([1,5,66,79,76,79,83,5,50,46,50,46,51]);let e,x=p;describe("ByteArrayParser",()=>{const B=(t,f,n)=>{if(n)switch(f){case 2:return e.extract16BitInt(t);case 4:return e.extract32BitInt(t);case 8:return e.extract64BitInt(t);case 16:return e.extract128BitInt(t);case 32:return e.extract256BitInt(t)}else switch(f){case 2:return e.extract16BitUInt(t);case 4:return e.extract32BitUInt(t);case 8:return e.extract64BitUInt(t);case 16:return e.extract128BitUInt(t);case 32:return e.extract256BitUInt(t)}};describe("clean",()=>{beforeEach(()=>{vi.resetAllMocks()}),it("should create an instance",()=>{e=new c(x),expect(e).toBeDefined(),expect(e).toBeInstanceOf(c)}),it("Extract a single byte",()=>{e=new c(x),expect(e.extract8BitUInt()).toBe(1),expect(e.getCurrentIndex()).toBe(1),expect(e.getUnparsedRemainingLength()).toBe(0)}),it("Extract one byte",()=>{x=d,e=new c(x);let t=0,f=d.length;for(expect(f).toBe(256),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--,expect(e.extract8BitUInt()).toBe(1),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--,expect(e.extract8BitUInt()).toBe(2),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--,expect(e.extract8BitUInt()).toBe(3),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--;f!=0;)expect(e.extract8BitUInt()).toBe(170),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),t++,f--}),it.each([[2,!1,!0,"ffff",65535],[2,!0,!0,"7fff",32767],[2,!0,!0,"8000",-32768],[4,!1,!0,"ffffffff",4294967295],[4,!0,!0,"7fffffff",2147483647],[4,!0,!0,"80000000",-2147483648],[8,!1,!0,"ffffffffffffffff",0xffffffffffffffffn],[8,!0,!0,"7fffffffffffffff",0x7fffffffffffffffn],[8,!0,!0,"8000000000000000",-0x8000000000000000n],[16,!1,!0,"ffffffffffffffffffffffffffffffff",0xffffffffffffffffffffffffffffffffn],[16,!0,!0,"7fffffffffffffffffffffffffffffff",0x7fffffffffffffffffffffffffffffffn],[16,!0,!0,"80000000000000000000000000000000",-0x80000000000000000000000000000000n],[32,!1,!0,"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn],[32,!0,!0,"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn],[32,!0,!0,"8000000000000000000000000000000000000000000000000000000000000000",-0x8000000000000000000000000000000000000000000000000000000000000000n]])("Extract a number to the limit: size %i, signed %s, bigEndian %s, buffer %s, expected %i",(t,f,n,r,a)=>{e=new c(s(r));const o=B(n,t,f);expect(o).toStrictEqual(a)}),it.each([[2,!1,!0,"3302",13058],[2,!1,!1,"0233",13058],[2,!0,!0,"1068",4200],[2,!0,!0,"ef98",-4200],[2,!0,!1,"6810",4200],[2,!0,!1,"98ef",-4200],[4,!1,!0,"01234567",19088743],[4,!1,!1,"67452301",19088743],[4,!0,!0,"075bcd15",123456789],[4,!0,!0,"f8a432eb",-123456789],[4,!0,!1,"15cd5b07",123456789],[4,!0,!1,"eb32a4f8",-123456789],[8,!1,!0,"0032435442584447",14147778004927559n],[8,!1,!1,"4744584254433200",14147778004927559n],[8,!0,!0,"0032435442584447",14147778004927559n],[8,!0,!0,"ffcdbcabbda7bbb9",-14147778004927559n],[8,!0,!1,"4744584254433200",14147778004927559n],[8,!0,!1,"b9bba7bdabbccdff",-14147778004927559n],[16,!1,!0,"00324354425844470032435442584447",0x00324354425844470032435442584447n],[16,!1,!1,"47445842544332004744584254433200",0x00324354425844470032435442584447n],[16,!0,!0,"00324354425844470032435442584447",0x00324354425844470032435442584447n],[16,!0,!0,"ffcdbcabbda7bbb8ffcdbcabbda7bbb9",-0x00324354425844470032435442584447n],[16,!0,!1,"47445842544332004744584254433200",0x00324354425844470032435442584447n],[16,!0,!1,"b9bba7bdabbccdffb8bba7bdabbccdff",-0x00324354425844470032435442584447n],[32,!1,!0,"0032435442584447003243544258444700324354425844470032435442584447",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!1,!1,"4744584254433200474458425443320047445842544332004744584254433200",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!0,"0032435442584447003243544258444700324354425844470032435442584447",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!0,"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9",-0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!1,"4744584254433200474458425443320047445842544332004744584254433200",0x0032435442584447003243544258444700324354425844470032435442584447n],[32,!0,!1,"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff",-0x0032435442584447003243544258444700324354425844470032435442584447n]])("Extract the following number: size %i, signed %s, bigEndian %s, buffer %s, expected %i",(t,f,n,r,a)=>{e=new c(s(r));const o=B(n,t,f);expect(o).toStrictEqual(a)}),it("Extract 16-bit & 32-bit number",()=>{x=d,e=new c(x);let t=0,f=d.length;expect(f).toBe(256),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBe(258),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBe(938),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),e.resetIndex(),t=0,f=d.length,expect(e.extract32BitUInt()).toBe(16909226),t+=4,f-=4,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract32BitUInt()).toBe(2863311530),t+=4,f-=4,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)}),it("Parse a GetAppVersion response",()=>{x=g,e=new c(x);let t=0,f=g.length;expect(f).toBe(13),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);const n=e.extract8BitUInt();t++,f--,expect(n).toBe(1),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let r=e.extractFieldLVEncoded();expect(r).toStrictEqual(I),expect(e.encodeToString(r)).toBe(h),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),r=e.extractFieldLVEncoded(),expect(e.encodeToString(r)).toBe(i),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),e.resetIndex(),t=0,f=g.length,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);const a=e.extractFieldTLVEncoded();expect(a?.tag).toBe(1),expect(a?.value).toStrictEqual(I),expect(e.encodeToString(a?.value)).toBe(h),t+=7,f-=7,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),r=e.extractFieldLVEncoded(),expect(e.encodeToString(r)).toBe(i),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)}),it("Parse a GetVersion response",()=>{x=U,e=new c(x);let t=0,f=U.length;expect(f).toBe(31),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.testMinimalLength(25)).toBe(!0);let n=e.extractFieldByLength(4);expect(e.encodeToHexaString(n)).toBe(L),t+=4,f-=4,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(e.encodeToString(n)).toBe(i),t+=6,f-=6,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded();const r=e.encodeToHexaString(n,!0);expect(r).toBe(R),expect(parseInt(r,16)).toBe(E),t+=5,f-=5,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(e.encodeToString(n)).toBe(m),t+=5,f-=5,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(e.encodeToString(n)).toBe(C),t+=5,f-=5,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n?.at(0)).toBe(S),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n?.at(0)).toBe(A),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n?.at(0)).toBe(T),t+=2,f-=2,expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)})}),describe("errors",()=>{it("no response",()=>{x=new Uint8Array,e=new c(x);const t=0,f=0;expect(e.testMinimalLength(1)).toBe(!1),expect(e.extract8BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract32BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let n=e.extractFieldByLength(2);expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);const r=e.extractFieldTLVEncoded();expect(r).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f)}),it("length error",()=>{x=p,e=new c(x);const t=0,f=p.length;expect(f).toBe(1),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract16BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),expect(e.extract32BitUInt()).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let n=e.extractFieldByLength(2);expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),n=e.extractFieldLVEncoded(),expect(n).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f);let r=e.extractFieldTLVEncoded();expect(r).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(f),x=l,e=new c(x),r=e.extractFieldTLVEncoded(),expect(r).toBeUndefined(),expect(e.getCurrentIndex()).toBe(t),expect(e.getUnparsedRemainingLength()).toBe(l.length)}),it("Test zero length",()=>{x=u,e=new c(x);const t=new Uint8Array,f=0;let n=u.length;expect(n).toBe(1),expect(e.getCurrentIndex()).toBe(f),expect(e.getUnparsedRemainingLength()).toBe(n);const r=e.extract8BitUInt();expect(r).toBe(0),expect(e.getCurrentIndex()).toBe(1),expect(e.getUnparsedRemainingLength()).toBe(0),e.resetIndex();let a=e.extractFieldByLength(0);expect(a).toStrictEqual(t),expect(e.encodeToString(a)).toBe(""),expect(e.getCurrentIndex()).toBe(f),expect(e.getUnparsedRemainingLength()).toBe(n),a=e.extractFieldLVEncoded(),expect(e.getCurrentIndex()).toBe(1),expect(e.getUnparsedRemainingLength()).toBe(0),expect(a).toStrictEqual(t),expect(e.encodeToString(a)).toBe(""),x=b,e=new c(x),n=b.length,expect(n).toBe(2),expect(e.getCurrentIndex()).toBe(f),expect(e.getUnparsedRemainingLength()).toBe(n);const o=e.extractFieldTLVEncoded();expect(o?.tag).toBe(171),expect(o?.value).toStrictEqual(t),expect(e.encodeToString(o?.value)).toBe(""),expect(e.getCurrentIndex()).toBe(2),expect(e.getUnparsedRemainingLength()).toBe(0),expect(e.encodeToHexaString()).toBe(""),expect(e.encodeToString()).toBe("")})})});
 //# sourceMappingURL=ByteArrayParser.test.js.map

package/lib/esm/src/api/apdu/utils/ByteArrayParser.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayParser.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { ByteArrayParser } from \"./ByteArrayParser\";\n\nconst RESPONSE_ONE_BYTE = new Uint8Array([0x01]);\nconst RESPONSE_LV_ZERO = new Uint8Array([0x00]);\nconst RESPONSE_TWO_BYTES = new Uint8Array([0x01, 0x01]);\nconst RESPONSE_TLV_ZERO = new Uint8Array([0xab, 0x00]);\nconst RESPONSE_ALL_BYTES = new Uint8Array([\n  0x01,\n  0x02,\n  0x03,\n  ...Array<number>(253).fill(0xaa),\n]);\n\n/*\nType : 33 00 00 04 -> nanoX\nVersion SE (LV): 2.2.3\nFlag: E600000000\n  PIN OK\n  Factory init Ok\n  Onboarding done\nVersion MCU(LV): 2.30\nVersion BootLoader(LV): 1.16\nHW rev: 0\nLanguage(LV): Fra & Eng\nRecover state (LV): 1\n*/\nconst DEVICE_TYPE = \"33000004\";\nconst DEVICE_FLAGS = \"0xe6000000\";\nconst NUMERIC_FLAGS = 0xe6000000;\nconst VERSION_FW_SE = \"2.2.3\";\nconst VERSION_FW_MCU = \"2.30\";\nconst VERSION_FW_BL = \"1.16\";\nconst HARDWARE_REV = 0;\nconst LANGUAGE_PACK = 1;\nconst RECOVER_STATE = 0;\nconst RESPONSE_GET_VERSION = new Uint8Array([\n  0x33, 0x00, 0x00, 0x04, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x32, 0x2e, 0x33, 0x30, 0x04, 0x31, 0x2e, 0x31, 0x36, 0x01,\n  0x00, 0x01, 0x01, 0x01, 0x00,\n]);\n\n/*\nFormat version: 1\nName: BOLOS\nVersion: 2.2.3\n*/\nconst DASHBOARD_HEX = new Uint8Array([0x42, 0x4f, 0x4c, 0x4f, 0x53]);\nconst DASHBOARD_NAME = \"BOLOS\";\nconst RESPONSE_GET_APP_VERSION = new Uint8Array([\n  0x01, 0x05, 0x42, 0x4f, 0x4c, 0x4f, 0x53, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33,\n]);\n\nlet parser: ByteArrayParser;\nlet response = RESPONSE_ONE_BYTE;\n\ndescribe(\"ByteArrayParser\", () => {\n  const parserExtractNumber = (\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ): bigint | number | undefined => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitInt(bigEndian);\n        case 4:\n          return parser.extract32BitInt(bigEndian);\n        case 8:\n          return parser.extract64BitInt(bigEndian);\n        case 16:\n          return parser.extract128BitInt(bigEndian);\n        case 32:\n          return parser.extract256BitInt(bigEndian);\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitUInt(bigEndian);\n        case 4:\n          return parser.extract32BitUInt(bigEndian);\n        case 8:\n          return parser.extract64BitUInt(bigEndian);\n        case 16:\n          return parser.extract128BitUInt(bigEndian);\n        case 32:\n          return parser.extract256BitUInt(bigEndian);\n      }\n    }\n    return undefined;\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      jest.resetAllMocks();\n    });\n\n    it(\"should create an instance\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser).toBeDefined();\n      expect(parser).toBeInstanceOf(ByteArrayParser);\n    });\n\n    it(\"Extract a single byte\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n    });\n\n    it(\"Extract one byte\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x02);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x03);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      while (length != 0) {\n        expect(parser.extract8BitUInt()).toBe(0xaa);\n        expect(parser.getCurrentIndex()).toBe(index);\n        expect(parser.getUnparsedRemainingLength()).toBe(length);\n        index++;\n        length--;\n      }\n    });\n\n    it.each([\n      [2, false, true, \"ffff\", 0xffff],\n      [2, true, true, \"7fff\", 0x7fff],\n      [2, true, true, \"8000\", -0x8000],\n      [4, false, true, \"ffffffff\", 0xffffffff],\n      [4, true, true, \"7fffffff\", 0x7fffffff],\n      [4, true, true, \"80000000\", -0x80000000],\n      [8, false, true, \"ffffffffffffffff\", 0xffffffffffffffffn],\n      [8, true, true, \"7fffffffffffffff\", 0x7fffffffffffffffn],\n      [8, true, true, \"8000000000000000\", -0x8000000000000000n],\n      [\n        16,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"80000000000000000000000000000000\",\n        -0x80000000000000000000000000000000n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n      ],\n    ])(\n      \"Extract a number to the limit: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it.each([\n      [2, false, true, \"3302\", 0x3302],\n      [2, false, false, \"0233\", 0x3302],\n      [2, true, true, \"1068\", 4200],\n      [2, true, true, \"ef98\", -4200],\n      [2, true, false, \"6810\", 4200],\n      [2, true, false, \"98ef\", -4200],\n      [4, false, true, \"01234567\", 0x01234567],\n      [4, false, false, \"67452301\", 0x01234567],\n      [4, true, true, \"075bcd15\", 123456789],\n      [4, true, true, \"f8a432eb\", -123456789],\n      [4, true, false, \"15cd5b07\", 123456789],\n      [4, true, false, \"eb32a4f8\", -123456789],\n      [8, false, true, \"0032435442584447\", 14147778004927559n],\n      [8, false, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, true, \"0032435442584447\", 14147778004927559n],\n      [8, true, true, \"ffcdbcabbda7bbb9\", -14147778004927559n],\n      [8, true, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, false, \"b9bba7bdabbccdff\", -14147778004927559n],\n      [\n        16,\n        false,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        false,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n    ])(\n      \"Extract the following number: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it(\"Extract 16-bit & 32-bit number\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x0102);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x03aa);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_ALL_BYTES.length;\n\n      expect(parser.extract32BitUInt()).toBe(0x010203aa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBe(0xaaaaaaaa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetAppVersion response\", () => {\n      response = RESPONSE_GET_APP_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_APP_VERSION.length;\n\n      // Parse the response considering the first field to be the format field\n      expect(length).toBe(13);\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      index++;\n      length--;\n      expect(value).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldLVEncoded();\n      expect(array).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(array)).toBe(DASHBOARD_NAME);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      // Reparse the response considering the first field to be the TLV formatted\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_GET_APP_VERSION.length;\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0x01);\n      expect(field?.value).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(field?.value)).toBe(DASHBOARD_NAME);\n      index += 7;\n      length -= 7;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetVersion response\", () => {\n      response = RESPONSE_GET_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_VERSION.length;\n\n      expect(length).toBe(31);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      expect(parser.testMinimalLength(25)).toBe(true);\n\n      let array = parser.extractFieldByLength(4);\n      expect(parser.encodeToHexaString(array)).toBe(DEVICE_TYPE);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      const flags = parser.encodeToHexaString(array, true);\n      expect(flags).toBe(DEVICE_FLAGS);\n      expect(parseInt(flags, 16)).toBe(NUMERIC_FLAGS);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_MCU);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_BL);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(HARDWARE_REV);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(LANGUAGE_PACK);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(RECOVER_STATE);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n  });\n\n  describe(\"errors\", () => {\n    it(\"no response\", () => {\n      response = new Uint8Array();\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = 0;\n\n      expect(parser.testMinimalLength(1)).toBe(false);\n\n      expect(parser.extract8BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"length error\", () => {\n      response = RESPONSE_ONE_BYTE;\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = RESPONSE_ONE_BYTE.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      response = RESPONSE_TWO_BYTES;\n      parser = new ByteArrayParser(response);\n\n      field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(\n        RESPONSE_TWO_BYTES.length,\n      );\n    });\n\n    it(\"Test zero length\", () => {\n      response = RESPONSE_LV_ZERO;\n      parser = new ByteArrayParser(response);\n      const zero = new Uint8Array();\n\n      const index = 0;\n      let length = RESPONSE_LV_ZERO.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      expect(value).toBe(0);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      parser.resetIndex();\n\n      let array = parser.extractFieldByLength(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n\n      response = RESPONSE_TLV_ZERO;\n      parser = new ByteArrayParser(response);\n      length = RESPONSE_TLV_ZERO.length;\n\n      expect(length).toBe(2);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0xab);\n      expect(field?.value).toStrictEqual(zero);\n      expect(parser.encodeToString(field?.value)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(2);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      expect(parser.encodeToHexaString()).toBe(\"\");\n      expect(parser.encodeToString()).toBe(\"\");\n    });\n  });\n});\n"],
-  "mappings": "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EACvC,CAAC,EAAG,GAAO,GAAO,WAAY,QAAU,EACxC,CAAC,EAAG,GAAM,GAAM,WAAY,SAAS,EACrC,CAAC,EAAG,GAAM,GAAM,WAAY,UAAU,EACtC,CAAC,EAAG,GAAM,GAAO,WAAY,SAAS,EACtC,CAAC,EAAG,GAAM,GAAO,WAAY,UAAU,EACvC,CAAC,EAAG,GAAO,GAAM,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAO,GAAO,mBAAoB,kBAAkB,EACxD,CAAC,EAAG,GAAM,GAAM,mBAAoB,kBAAkB,EACtD,CAAC,EAAG,GAAM,GAAM,mBAAoB,CAAC,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAO,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAO,mBAAoB,CAAC,kBAAkB,EACxD,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,CAAC,mCACH,EACA,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,CAAC,mCACH,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,CAAC,mEACH,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,CAAC,mEACH,CACF,CAAC,EACC,yFACA,CAACL,EAAYC,EAAQF,EAAWK,EAAOC,IAAW,CAChDT,EAAS,IAAInB,EAAgBD,EAAmB4B,CAAK,CAAE,EACvD,MAAME,EAASR,EAAoBC,EAAWC,EAAYC,CAAM,EAChE,OAAOK,CAAM,EAAE,cAAcD,CAAM,CACrC,CACF,EAEA,GAAG,iCAAkC,IAAM,CACzCR,EAAWf,EACXc,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,IAAIK,EAAQ,EACRC,EAASrB,EAAmB,OAEhC,OAAOqB,CAAM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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { ByteArrayParser } from \"./ByteArrayParser\";\n\nconst RESPONSE_ONE_BYTE = new Uint8Array([0x01]);\nconst RESPONSE_LV_ZERO = new Uint8Array([0x00]);\nconst RESPONSE_TWO_BYTES = new Uint8Array([0x01, 0x01]);\nconst RESPONSE_TLV_ZERO = new Uint8Array([0xab, 0x00]);\nconst RESPONSE_ALL_BYTES = new Uint8Array([\n  0x01,\n  0x02,\n  0x03,\n  ...Array<number>(253).fill(0xaa),\n]);\n\n/*\nType : 33 00 00 04 -> nanoX\nVersion SE (LV): 2.2.3\nFlag: E600000000\n  PIN OK\n  Factory init Ok\n  Onboarding done\nVersion MCU(LV): 2.30\nVersion BootLoader(LV): 1.16\nHW rev: 0\nLanguage(LV): Fra & Eng\nRecover state (LV): 1\n*/\nconst DEVICE_TYPE = \"33000004\";\nconst DEVICE_FLAGS = \"0xe6000000\";\nconst NUMERIC_FLAGS = 0xe6000000;\nconst VERSION_FW_SE = \"2.2.3\";\nconst VERSION_FW_MCU = \"2.30\";\nconst VERSION_FW_BL = \"1.16\";\nconst HARDWARE_REV = 0;\nconst LANGUAGE_PACK = 1;\nconst RECOVER_STATE = 0;\nconst RESPONSE_GET_VERSION = new Uint8Array([\n  0x33, 0x00, 0x00, 0x04, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x32, 0x2e, 0x33, 0x30, 0x04, 0x31, 0x2e, 0x31, 0x36, 0x01,\n  0x00, 0x01, 0x01, 0x01, 0x00,\n]);\n\n/*\nFormat version: 1\nName: BOLOS\nVersion: 2.2.3\n*/\nconst DASHBOARD_HEX = new Uint8Array([0x42, 0x4f, 0x4c, 0x4f, 0x53]);\nconst DASHBOARD_NAME = \"BOLOS\";\nconst RESPONSE_GET_APP_VERSION = new Uint8Array([\n  0x01, 0x05, 0x42, 0x4f, 0x4c, 0x4f, 0x53, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33,\n]);\n\nlet parser: ByteArrayParser;\nlet response = RESPONSE_ONE_BYTE;\n\ndescribe(\"ByteArrayParser\", () => {\n  const parserExtractNumber = (\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ): bigint | number | undefined => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitInt(bigEndian);\n        case 4:\n          return parser.extract32BitInt(bigEndian);\n        case 8:\n          return parser.extract64BitInt(bigEndian);\n        case 16:\n          return parser.extract128BitInt(bigEndian);\n        case 32:\n          return parser.extract256BitInt(bigEndian);\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitUInt(bigEndian);\n        case 4:\n          return parser.extract32BitUInt(bigEndian);\n        case 8:\n          return parser.extract64BitUInt(bigEndian);\n        case 16:\n          return parser.extract128BitUInt(bigEndian);\n        case 32:\n          return parser.extract256BitUInt(bigEndian);\n      }\n    }\n    return undefined;\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      vi.resetAllMocks();\n    });\n\n    it(\"should create an instance\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser).toBeDefined();\n      expect(parser).toBeInstanceOf(ByteArrayParser);\n    });\n\n    it(\"Extract a single byte\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n    });\n\n    it(\"Extract one byte\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x02);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x03);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      while (length != 0) {\n        expect(parser.extract8BitUInt()).toBe(0xaa);\n        expect(parser.getCurrentIndex()).toBe(index);\n        expect(parser.getUnparsedRemainingLength()).toBe(length);\n        index++;\n        length--;\n      }\n    });\n\n    it.each([\n      [2, false, true, \"ffff\", 0xffff],\n      [2, true, true, \"7fff\", 0x7fff],\n      [2, true, true, \"8000\", -0x8000],\n      [4, false, true, \"ffffffff\", 0xffffffff],\n      [4, true, true, \"7fffffff\", 0x7fffffff],\n      [4, true, true, \"80000000\", -0x80000000],\n      [8, false, true, \"ffffffffffffffff\", 0xffffffffffffffffn],\n      [8, true, true, \"7fffffffffffffff\", 0x7fffffffffffffffn],\n      [8, true, true, \"8000000000000000\", -0x8000000000000000n],\n      [\n        16,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"80000000000000000000000000000000\",\n        -0x80000000000000000000000000000000n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n      ],\n    ])(\n      \"Extract a number to the limit: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it.each([\n      [2, false, true, \"3302\", 0x3302],\n      [2, false, false, \"0233\", 0x3302],\n      [2, true, true, \"1068\", 4200],\n      [2, true, true, \"ef98\", -4200],\n      [2, true, false, \"6810\", 4200],\n      [2, true, false, \"98ef\", -4200],\n      [4, false, true, \"01234567\", 0x01234567],\n      [4, false, false, \"67452301\", 0x01234567],\n      [4, true, true, \"075bcd15\", 123456789],\n      [4, true, true, \"f8a432eb\", -123456789],\n      [4, true, false, \"15cd5b07\", 123456789],\n      [4, true, false, \"eb32a4f8\", -123456789],\n      [8, false, true, \"0032435442584447\", 14147778004927559n],\n      [8, false, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, true, \"0032435442584447\", 14147778004927559n],\n      [8, true, true, \"ffcdbcabbda7bbb9\", -14147778004927559n],\n      [8, true, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, false, \"b9bba7bdabbccdff\", -14147778004927559n],\n      [\n        16,\n        false,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        false,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n    ])(\n      \"Extract the following number: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it(\"Extract 16-bit & 32-bit number\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x0102);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x03aa);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_ALL_BYTES.length;\n\n      expect(parser.extract32BitUInt()).toBe(0x010203aa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBe(0xaaaaaaaa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetAppVersion response\", () => {\n      response = RESPONSE_GET_APP_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_APP_VERSION.length;\n\n      // Parse the response considering the first field to be the format field\n      expect(length).toBe(13);\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      index++;\n      length--;\n      expect(value).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldLVEncoded();\n      expect(array).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(array)).toBe(DASHBOARD_NAME);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      // Reparse the response considering the first field to be the TLV formatted\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_GET_APP_VERSION.length;\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0x01);\n      expect(field?.value).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(field?.value)).toBe(DASHBOARD_NAME);\n      index += 7;\n      length -= 7;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetVersion response\", () => {\n      response = RESPONSE_GET_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_VERSION.length;\n\n      expect(length).toBe(31);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      expect(parser.testMinimalLength(25)).toBe(true);\n\n      let array = parser.extractFieldByLength(4);\n      expect(parser.encodeToHexaString(array)).toBe(DEVICE_TYPE);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      const flags = parser.encodeToHexaString(array, true);\n      expect(flags).toBe(DEVICE_FLAGS);\n      expect(parseInt(flags, 16)).toBe(NUMERIC_FLAGS);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_MCU);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_BL);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(HARDWARE_REV);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(LANGUAGE_PACK);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(RECOVER_STATE);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n  });\n\n  describe(\"errors\", () => {\n    it(\"no response\", () => {\n      response = new Uint8Array();\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = 0;\n\n      expect(parser.testMinimalLength(1)).toBe(false);\n\n      expect(parser.extract8BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"length error\", () => {\n      response = RESPONSE_ONE_BYTE;\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = RESPONSE_ONE_BYTE.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      response = RESPONSE_TWO_BYTES;\n      parser = new ByteArrayParser(response);\n\n      field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(\n        RESPONSE_TWO_BYTES.length,\n      );\n    });\n\n    it(\"Test zero length\", () => {\n      response = RESPONSE_LV_ZERO;\n      parser = new ByteArrayParser(response);\n      const zero = new Uint8Array();\n\n      const index = 0;\n      let length = RESPONSE_LV_ZERO.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      expect(value).toBe(0);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      parser.resetIndex();\n\n      let array = parser.extractFieldByLength(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n\n      response = RESPONSE_TLV_ZERO;\n      parser = new ByteArrayParser(response);\n      length = RESPONSE_TLV_ZERO.length;\n\n      expect(length).toBe(2);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0xab);\n      expect(field?.value).toStrictEqual(zero);\n      expect(parser.encodeToString(field?.value)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(2);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      expect(parser.encodeToHexaString()).toBe(\"\");\n      expect(parser.encodeToString()).toBe(\"\");\n    });\n  });\n});\n"],
+  "mappings": "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EACvC,CAAC,EAAG,GAAO,GAAO,WAAY,QAAU,EACxC,CAAC,EAAG,GAAM,GAAM,WAAY,SAAS,EACrC,CAAC,EAAG,GAAM,GAAM,WAAY,UAAU,EACtC,CAAC,EAAG,GAAM,GAAO,WAAY,SAAS,EACtC,CAAC,EAAG,GAAM,GAAO,WAAY,UAAU,EACvC,CAAC,EAAG,GAAO,GAAM,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAO,GAAO,mBAAoB,kBAAkB,EACxD,CAAC,EAAG,GAAM,GAAM,mBAAoB,kBAAkB,EACtD,CAAC,EAAG,GAAM,GAAM,mBAAoB,CAAC,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAO,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAO,mBAAoB,CAAC,kBAAkB,EACxD,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,CAAC,mCACH,EACA,CACE,GACA,GACA,GACA,mCACA,mCACF,EACA,CACE,GACA,GACA,GACA,mCACA,CAAC,mCACH,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,CAAC,mEACH,EACA,CACE,GACA,GACA,GACA,mEACA,mEACF,EACA,CACE,GACA,GACA,GACA,mEACA,CAAC,mEACH,CACF,CAAC,EACC,yFACA,CAACL,EAAYC,EAAQF,EAAWK,EAAOC,IAAW,CAChDT,EAAS,IAAInB,EAAgBD,EAAmB4B,CAAK,CAAE,EACvD,MAAME,EAASR,EAAoBC,EAAWC,EAAYC,CAAM,EAChE,OAAOK,CAAM,EAAE,cAAcD,CAAM,CACrC,CACF,EAEA,GAAG,iCAAkC,IAAM,CACzCR,EAAWf,EACXc,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,IAAIK,EAAQ,EACRC,EAASrB,EAAmB,OAEhC,OAAOqB,CAAM,EAAE,KAAK,GAAG,EACvB,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,KAAK,GAAM,EAC7CM,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,KAAK,GAAM,EAC7CM,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDP,EAAO,WAAW,EAClBM,EAAQ,EACRC,EAASrB,EAAmB,OAE5B,OAAOc,EAAO,iBAAiB,CAAC,EAAE,KAAK,QAAU,EACjDM,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,KAAK,UAAU,EACjDM,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,CACzD,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzCN,EAAWF,EACXC,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,IAAIK,EAAQ,EACRC,EAASR,EAAyB,OAGtC,OAAOQ,CAAM,EAAE,KAAK,EAAE,EAEtB,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,MAAMI,EAAQX,EAAO,gBAAgB,EACrCM,IACAC,IACA,OAAOI,CAAK,EAAE,KAAK,CAAC,EACpB,OAAOX,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,IAAIK,EAAQZ,EAAO,sBAAsB,EACzC,OAAOY,CAAK,EAAE,cAAcf,CAAa,EACzC,OAAOG,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAKd,CAAc,EACxDQ,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOA,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAKtB,CAAa,EACvDgB,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAGvDP,EAAO,WAAW,EAClBM,EAAQ,EACRC,EAASR,EAAyB,OAElC,OAAOC,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,MAAMM,EAAQb,EAAO,uBAAuB,EAC5C,OAAOa,GAAO,GAAG,EAAE,KAAK,CAAI,EAC5B,OAAOA,GAAO,KAAK,EAAE,cAAchB,CAAa,EAChD,OAAOG,EAAO,eAAea,GAAO,KAAK,CAAC,EAAE,KAAKf,CAAc,EAC/DQ,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOA,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAKtB,CAAa,EACvDgB,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,CACzD,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtCN,EAAWL,EACXI,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,IAAIK,EAAQ,EACRC,EAASX,EAAqB,OAElC,OAAOW,CAAM,EAAE,KAAK,EAAE,EACtB,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EACvD,OAAOP,EAAO,kBAAkB,EAAE,CAAC,EAAE,KAAK,EAAI,EAE9C,IAAIY,EAAQZ,EAAO,qBAAqB,CAAC,EACzC,OAAOA,EAAO,mBAAmBY,CAAK,CAAC,EAAE,KAAKzB,CAAW,EACzDmB,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOA,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAKtB,CAAa,EACvDgB,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,MAAMc,EAAQd,EAAO,mBAAmBY,EAAO,EAAI,EACnD,OAAOE,CAAK,EAAE,KAAK1B,CAAY,EAC/B,OAAO,SAAS0B,EAAO,EAAE,CAAC,EAAE,KAAKzB,CAAa,EAC9CiB,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOA,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAKrB,CAAc,EACxDe,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOA,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAKpB,CAAa,EACvDc,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOY,GAAO,GAAG,CAAC,CAAC,EAAE,KAAKnB,CAAY,EACtCa,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOY,GAAO,GAAG,CAAC,CAAC,EAAE,KAAKlB,CAAa,EACvCY,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOY,GAAO,GAAG,CAAC,CAAC,EAAE,KAAKjB,CAAa,EACvCW,GAAS,EACTC,GAAU,EACV,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,CACzD,CAAC,CACH,CAAC,EAED,SAAS,SAAU,IAAM,CACvB,GAAG,cAAe,IAAM,CACtBN,EAAW,IAAI,WACfD,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,MAAMK,EAAQ,EACRC,EAAS,EAEf,OAAOP,EAAO,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAK,EAE9C,OAAOA,EAAO,gBAAgB,CAAC,EAAE,cAAc,EAC/C,OAAOA,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,cAAc,EAChD,OAAOA,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,cAAc,EAChD,OAAOA,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,IAAIK,EAAQZ,EAAO,qBAAqB,CAAC,EACzC,OAAOY,CAAK,EAAE,cAAc,EAC5B,OAAOZ,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOY,CAAK,EAAE,cAAc,EAC5B,OAAOZ,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,MAAMM,EAAQb,EAAO,uBAAuB,EAC5C,OAAOa,CAAK,EAAE,cAAc,EAC5B,OAAOb,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,CACzD,CAAC,EAED,GAAG,eAAgB,IAAM,CACvBN,EAAWnB,EACXkB,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,MAAMK,EAAQ,EACRC,EAASzB,EAAkB,OAEjC,OAAOyB,CAAM,EAAE,KAAK,CAAC,EACrB,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,cAAc,EAChD,OAAOA,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,OAAOP,EAAO,iBAAiB,CAAC,EAAE,cAAc,EAChD,OAAOA,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,IAAIK,EAAQZ,EAAO,qBAAqB,CAAC,EACzC,OAAOY,CAAK,EAAE,cAAc,EAC5B,OAAOZ,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOY,CAAK,EAAE,cAAc,EAC5B,OAAOZ,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,IAAIM,EAAQb,EAAO,uBAAuB,EAC1C,OAAOa,CAAK,EAAE,cAAc,EAC5B,OAAOb,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDN,EAAWjB,EACXgB,EAAS,IAAInB,EAAgBoB,CAAQ,EAErCY,EAAQb,EAAO,uBAAuB,EACtC,OAAOa,CAAK,EAAE,cAAc,EAC5B,OAAOb,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAC1ChB,EAAmB,MACrB,CACF,CAAC,EAED,GAAG,mBAAoB,IAAM,CAC3BiB,EAAWlB,EACXiB,EAAS,IAAInB,EAAgBoB,CAAQ,EACrC,MAAMc,EAAO,IAAI,WAEXT,EAAQ,EACd,IAAIC,EAASxB,EAAiB,OAE9B,OAAOwB,CAAM,EAAE,KAAK,CAAC,EACrB,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,MAAMI,EAAQX,EAAO,gBAAgB,EACrC,OAAOW,CAAK,EAAE,KAAK,CAAC,EACpB,OAAOX,EAAO,gBAAgB,CAAC,EAAE,KAAK,CAAC,EACvC,OAAOA,EAAO,2BAA2B,CAAC,EAAE,KAAK,CAAC,EAElDA,EAAO,WAAW,EAElB,IAAIY,EAAQZ,EAAO,qBAAqB,CAAC,EACzC,OAAOY,CAAK,EAAE,cAAcG,CAAI,EAChC,OAAOf,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAK,EAAE,EAC5C,OAAOZ,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvDK,EAAQZ,EAAO,sBAAsB,EACrC,OAAOA,EAAO,gBAAgB,CAAC,EAAE,KAAK,CAAC,EACvC,OAAOA,EAAO,2BAA2B,CAAC,EAAE,KAAK,CAAC,EAClD,OAAOY,CAAK,EAAE,cAAcG,CAAI,EAChC,OAAOf,EAAO,eAAeY,CAAK,CAAC,EAAE,KAAK,EAAE,EAE5CX,EAAWhB,EACXe,EAAS,IAAInB,EAAgBoB,CAAQ,EACrCM,EAAStB,EAAkB,OAE3B,OAAOsB,CAAM,EAAE,KAAK,CAAC,EACrB,OAAOP,EAAO,gBAAgB,CAAC,EAAE,KAAKM,CAAK,EAC3C,OAAON,EAAO,2BAA2B,CAAC,EAAE,KAAKO,CAAM,EAEvD,MAAMM,EAAQb,EAAO,uBAAuB,EAC5C,OAAOa,GAAO,GAAG,EAAE,KAAK,GAAI,EAC5B,OAAOA,GAAO,KAAK,EAAE,cAAcE,CAAI,EACvC,OAAOf,EAAO,eAAea,GAAO,KAAK,CAAC,EAAE,KAAK,EAAE,EACnD,OAAOb,EAAO,gBAAgB,CAAC,EAAE,KAAK,CAAC,EACvC,OAAOA,EAAO,2BAA2B,CAAC,EAAE,KAAK,CAAC,EAElD,OAAOA,EAAO,mBAAmB,CAAC,EAAE,KAAK,EAAE,EAC3C,OAAOA,EAAO,eAAe,CAAC,EAAE,KAAK,EAAE,CACzC,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["hexaStringToBuffer", "ByteArrayParser", "RESPONSE_ONE_BYTE", "RESPONSE_LV_ZERO", "RESPONSE_TWO_BYTES", "RESPONSE_TLV_ZERO", "RESPONSE_ALL_BYTES", "DEVICE_TYPE", "DEVICE_FLAGS", "NUMERIC_FLAGS", "VERSION_FW_SE", "VERSION_FW_MCU", "VERSION_FW_BL", "HARDWARE_REV", "LANGUAGE_PACK", "RECOVER_STATE", "RESPONSE_GET_VERSION", "DASHBOARD_HEX", "DASHBOARD_NAME", "RESPONSE_GET_APP_VERSION", "parser", "response", "parserExtractNumber", "bigEndian", "sizeInBits", "signed", "index", "length", "input", "output", "result", "value", "array", "field", "flags", "zero"]
 }

package/lib/esm/src/api/command/di/commandModule.js

@@ -1,2 +1,2 @@
-import{ContainerModule as a}from"inversify";import{SendCommandUseCase as d}from"../../command/use-case/SendCommandUseCase";import{StubUseCase as t}from"../../../../src/di.stub";import{commandTypes as o}from"./commandTypes";const b=({stub:n=!1}={})=>new a((e,s,r,m,i,C,u)=>{e(o.SendCommandUseCase).to(d),n&&m(o.SendCommandUseCase).to(t)});export{b as commandModuleFactory};
+import{ContainerModule as n}from"inversify";import{SendCommandUseCase as d}from"../../command/use-case/SendCommandUseCase";import{StubUseCase as r}from"../../../../src/di.stub";import{commandTypes as o}from"./commandTypes";const i=({stub:e=!1}={})=>new n(({bind:m,rebindSync:a})=>{m(o.SendCommandUseCase).to(d),e&&a(o.SendCommandUseCase).to(r)});export{i as commandModuleFactory};
 //# sourceMappingURL=commandModule.js.map

package/lib/esm/src/api/command/di/commandModule.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/di/commandModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandTypes } from \"./commandTypes\";\n\ntype CommandModuleArgs = Partial<{\n  readonly stub: boolean;\n}>;\n\nexport const commandModuleFactory = ({\n  stub = false,\n}: CommandModuleArgs = {}) =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(commandTypes.SendCommandUseCase).to(SendCommandUseCase);\n      if (stub) {\n        rebind(commandTypes.SendCommandUseCase).to(StubUseCase);\n      }\n    },\n  );\n"],
-  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,sBAAAC,MAA0B,2CACnC,OAAS,eAAAC,MAAmB,oBAE5B,OAAS,gBAAAC,MAAoB,iBAMtB,MAAMC,EAAuB,CAAC,CACnC,KAAAC,EAAO,EACT,EAAuB,CAAC,IACtB,IAAIL,EACF,CACEM,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAKH,EAAa,kBAAkB,EAAE,GAAGF,CAAkB,EACvDI,GACFI,EAAON,EAAa,kBAAkB,EAAE,GAAGD,CAAW,CAE1D,CACF",
-  "names": ["ContainerModule", "SendCommandUseCase", "StubUseCase", "commandTypes", "commandModuleFactory", "stub", "bind", "_unbind", "_isBound", "rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandTypes } from \"./commandTypes\";\n\ntype CommandModuleArgs = Partial<{\n  readonly stub: boolean;\n}>;\n\nexport const commandModuleFactory = ({\n  stub = false,\n}: CommandModuleArgs = {}) =>\n  new ContainerModule(({ bind, rebindSync }) => {\n    bind(commandTypes.SendCommandUseCase).to(SendCommandUseCase);\n    if (stub) {\n      rebindSync(commandTypes.SendCommandUseCase).to(StubUseCase);\n    }\n  });\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,sBAAAC,MAA0B,2CACnC,OAAS,eAAAC,MAAmB,oBAE5B,OAAS,gBAAAC,MAAoB,iBAMtB,MAAMC,EAAuB,CAAC,CACnC,KAAAC,EAAO,EACT,EAAuB,CAAC,IACtB,IAAIL,EAAgB,CAAC,CAAE,KAAAM,EAAM,WAAAC,CAAW,IAAM,CAC5CD,EAAKH,EAAa,kBAAkB,EAAE,GAAGF,CAAkB,EACvDI,GACFE,EAAWJ,EAAa,kBAAkB,EAAE,GAAGD,CAAW,CAE9D,CAAC",
+  "names": ["ContainerModule", "SendCommandUseCase", "StubUseCase", "commandTypes", "commandModuleFactory", "stub", "bind", "rebindSync"]
 }

package/lib/esm/src/api/command/di/commandModule.test.js

@@ -1,2 +1,2 @@
-import{Container as n}from"inversify";import{SendCommandUseCase as r}from"../../command/use-case/SendCommandUseCase";import{deviceSessionModuleFactory as a}from"../../../internal/device-session/di/deviceSessionModule";import{loggerModuleFactory as s}from"../../../internal/logger-publisher/di/loggerModule";import{StubUseCase as c}from"../../../../src/di.stub";import{commandModuleFactory as d}from"./commandModule";import{commandTypes as m}from"./commandTypes";describe("commandModuleFactory",()=>{describe("Default",()=>{let e,o;beforeEach(()=>{o=d(),e=new n,e.load(o,a(),s())}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return non-stubbed sendCommand usecase",()=>{const t=e.get(m.SendCommandUseCase);expect(t).toBeInstanceOf(r)})}),describe("Stubbed",()=>{let e,o;beforeEach(()=>{o=d({stub:!0}),e=new n,e.load(o)}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return stubbed sendCommand usecase",()=>{const t=e.get(m.SendCommandUseCase);expect(t).toBeInstanceOf(c)})})});
+import{Container as n}from"inversify";import{SendCommandUseCase as r}from"../../command/use-case/SendCommandUseCase";import{deviceSessionModuleFactory as a}from"../../../internal/device-session/di/deviceSessionModule";import{loggerModuleFactory as s}from"../../../internal/logger-publisher/di/loggerModule";import{StubUseCase as c}from"../../../../src/di.stub";import{commandModuleFactory as d}from"./commandModule";import{commandTypes as m}from"./commandTypes";describe("commandModuleFactory",()=>{describe("Default",()=>{let e,o;beforeEach(()=>{o=d(),e=new n,e.loadSync(o,a(),s())}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return non-stubbed sendCommand usecase",()=>{const t=e.get(m.SendCommandUseCase);expect(t).toBeInstanceOf(r)})}),describe("Stubbed",()=>{let e,o;beforeEach(()=>{o=d({stub:!0}),e=new n,e.loadSync(o)}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return stubbed sendCommand usecase",()=>{const t=e.get(m.SendCommandUseCase);expect(t).toBeInstanceOf(c)})})});
 //# sourceMappingURL=commandModule.test.js.map

package/lib/esm/src/api/command/di/commandModule.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/di/commandModule.test.ts"],
-  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { deviceSessionModuleFactory } from \"@internal/device-session/di/deviceSessionModule\";\nimport { loggerModuleFactory } from \"@internal/logger-publisher/di/loggerModule\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandModuleFactory } from \"./commandModule\";\nimport { commandTypes } from \"./commandTypes\";\n\ndescribe(\"commandModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory();\n      container = new Container();\n      container.load(mod, deviceSessionModuleFactory(), loggerModuleFactory());\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return non-stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get<SendCommandUseCase>(\n        commandTypes.SendCommandUseCase,\n      );\n      expect(sendCommandUseCase).toBeInstanceOf(SendCommandUseCase);\n    });\n  });\n\n  describe(\"Stubbed\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory({ stub: true });\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get(commandTypes.SendCommandUseCase);\n      expect(sendCommandUseCase).toBeInstanceOf(StubUseCase);\n    });\n  });\n});\n"],
-  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,sBAAAC,MAA0B,2CACnC,OAAS,8BAAAC,MAAkC,kDAC3C,OAAS,uBAAAC,MAA2B,6CACpC,OAAS,eAAAC,MAAmB,oBAE5B,OAAS,wBAAAC,MAA4B,kBACrC,OAAS,gBAAAC,MAAoB,iBAE7B,SAAS,uBAAwB,IAAM,CACrC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMH,EAAqB,EAC3BE,EAAY,IAAIP,EAChBO,EAAU,KAAKC,EAAKN,EAA2B,EAAGC,EAAoB,CAAC,CACzE,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOK,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,gDAAiD,IAAM,CACxD,MAAMC,EAAqBF,EAAU,IACnCD,EAAa,kBACf,EACA,OAAOG,CAAkB,EAAE,eAAeR,CAAkB,CAC9D,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,IAAIM,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMH,EAAqB,CAAE,KAAM,EAAK,CAAC,EACzCE,EAAY,IAAIP,EAChBO,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMC,EAAqBF,EAAU,IAAID,EAAa,kBAAkB,EACxE,OAAOG,CAAkB,EAAE,eAAeL,CAAW,CACvD,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { deviceSessionModuleFactory } from \"@internal/device-session/di/deviceSessionModule\";\nimport { loggerModuleFactory } from \"@internal/logger-publisher/di/loggerModule\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandModuleFactory } from \"./commandModule\";\nimport { commandTypes } from \"./commandTypes\";\n\ndescribe(\"commandModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory();\n      container = new Container();\n      container.loadSync(\n        mod,\n        deviceSessionModuleFactory(),\n        loggerModuleFactory(),\n      );\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return non-stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get<SendCommandUseCase>(\n        commandTypes.SendCommandUseCase,\n      );\n      expect(sendCommandUseCase).toBeInstanceOf(SendCommandUseCase);\n    });\n  });\n\n  describe(\"Stubbed\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory({ stub: true });\n      container = new Container();\n      container.loadSync(mod);\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get(commandTypes.SendCommandUseCase);\n      expect(sendCommandUseCase).toBeInstanceOf(StubUseCase);\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,sBAAAC,MAA0B,2CACnC,OAAS,8BAAAC,MAAkC,kDAC3C,OAAS,uBAAAC,MAA2B,6CACpC,OAAS,eAAAC,MAAmB,oBAE5B,OAAS,wBAAAC,MAA4B,kBACrC,OAAS,gBAAAC,MAAoB,iBAE7B,SAAS,uBAAwB,IAAM,CACrC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMH,EAAqB,EAC3BE,EAAY,IAAIP,EAChBO,EAAU,SACRC,EACAN,EAA2B,EAC3BC,EAAoB,CACtB,CACF,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOK,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,gDAAiD,IAAM,CACxD,MAAMC,EAAqBF,EAAU,IACnCD,EAAa,kBACf,EACA,OAAOG,CAAkB,EAAE,eAAeR,CAAkB,CAC9D,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,IAAIM,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMH,EAAqB,CAAE,KAAM,EAAK,CAAC,EACzCE,EAAY,IAAIP,EAChBO,EAAU,SAASC,CAAG,CACxB,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMC,EAAqBF,EAAU,IAAID,EAAa,kBAAkB,EACxE,OAAOG,CAAkB,EAAE,eAAeL,CAAW,CACvD,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["Container", "SendCommandUseCase", "deviceSessionModuleFactory", "loggerModuleFactory", "StubUseCase", "commandModuleFactory", "commandTypes", "container", "mod", "sendCommandUseCase"]
 }

package/lib/esm/src/api/command/os/GetCustomImageSizeCommand.js

@@ -0,0 +1,2 @@
+import{ApduBuilder as n}from"../../apdu/utils/ApduBuilder";import{ApduParser as d}from"../../apdu/utils/ApduParser";import{InvalidStatusWordError as i}from"../../command/Errors";import{CommandResultFactory as o}from"../../command/model/CommandResult";import{isCommandErrorCode as p}from"../../command/utils/CommandErrors";import{CommandUtils as u}from"../../command/utils/CommandUtils";import{GlobalCommandErrorHandler as C}from"../../command/utils/GlobalCommandError";import{DeviceExchangeError as g}from"../../Error";const s={"662e":{message:"Invalid state, no background image loaded."},"662f":{message:"Invalid state, device is in recovery mode."}};class l extends g{constructor({message:e,errorCode:r}){super({message:e,errorCode:r,tag:"GetCustomImageSizeCommandError"})}}class x{getApdu(){const e={cla:224,ins:100,p1:0,p2:0};return new n(e).build()}parseResponse(e){const r=new d(e);if(!u.isSuccessResponse(e)){const t=r.encodeToHexaString(e.statusCode);return p(t,s)?o({error:new l({...s[t],errorCode:t})}):o({error:C.handle(e)})}const m=r.extract32BitUInt();return m===void 0?o({error:new i("Didn't receive any size")}):o({data:m})}}export{x as GetCustomImageSizeCommand,l as GetCustomImageSizeCommandError};
+//# sourceMappingURL=GetCustomImageSizeCommand.js.map

package/lib/esm/src/api/command/os/GetCustomImageSizeCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/GetCustomImageSizeCommand.ts"],
+  "sourcesContent": ["import { type Apdu } from \"@api/apdu/model/Apdu\";\nimport { ApduBuilder, type ApduBuilderArgs } from \"@api/apdu/utils/ApduBuilder\";\nimport { ApduParser } from \"@api/apdu/utils/ApduParser\";\nimport { type Command } from \"@api/command/Command\";\nimport { InvalidStatusWordError } from \"@api/command/Errors\";\nimport {\n  type CommandResult,\n  CommandResultFactory,\n} from \"@api/command/model/CommandResult\";\nimport {\n  type CommandErrors,\n  isCommandErrorCode,\n} from \"@api/command/utils/CommandErrors\";\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { GlobalCommandErrorHandler } from \"@api/command/utils/GlobalCommandError\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { type CommandErrorArgs, DeviceExchangeError } from \"@api/Error\";\n\nexport type GetCustomImageSizeResponse = number;\n\nexport type GetCustomImageSizeErrorCodes = \"662e\" | \"662f\";\n\nconst IMAGE_SIZE_ERRORS: CommandErrors<GetCustomImageSizeErrorCodes> = {\n  \"662e\": { message: \"Invalid state, no background image loaded.\" },\n  \"662f\": { message: \"Invalid state, device is in recovery mode.\" },\n};\n\nexport type GetCustomImageSizeCommandResult = CommandResult<\n  GetCustomImageSizeResponse,\n  GetCustomImageSizeErrorCodes\n>;\n\nexport class GetCustomImageSizeCommandError extends DeviceExchangeError<GetCustomImageSizeErrorCodes> {\n  constructor({\n    message,\n    errorCode,\n  }: CommandErrorArgs<GetCustomImageSizeErrorCodes>) {\n    super({ message, errorCode, tag: \"GetCustomImageSizeCommandError\" });\n  }\n}\n\nexport class GetCustomImageSizeCommand\n  implements\n    Command<GetCustomImageSizeResponse, void, GetCustomImageSizeErrorCodes>\n{\n  getApdu(): Apdu {\n    const apduArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x64,\n      p1: 0x00,\n      p2: 0x00,\n    };\n    return new ApduBuilder(apduArgs).build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): GetCustomImageSizeCommandResult {\n    const parser = new ApduParser(apduResponse);\n\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, IMAGE_SIZE_ERRORS)) {\n        return CommandResultFactory({\n          error: new GetCustomImageSizeCommandError({\n            ...IMAGE_SIZE_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    const size = parser.extract32BitUInt();\n    if (size === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Didn't receive any size\"),\n      });\n    }\n\n    return CommandResultFactory({\n      data: size,\n    });\n  }\n}\n"],
+  "mappings": "AACA,OAAS,eAAAA,MAAyC,8BAClD,OAAS,cAAAC,MAAkB,6BAE3B,OAAS,0BAAAC,MAA8B,sBACvC,OAEE,wBAAAC,MACK,mCACP,OAEE,sBAAAC,MACK,mCACP,OAAS,gBAAAC,MAAoB,kCAC7B,OAAS,6BAAAC,MAAiC,wCAE1C,OAAgC,uBAAAC,MAA2B,aAM3D,MAAMC,EAAiE,CACrE,OAAQ,CAAE,QAAS,4CAA6C,EAChE,OAAQ,CAAE,QAAS,4CAA6C,CAClE,EAOO,MAAMC,UAAuCF,CAAkD,CACpG,YAAY,CACV,QAAAG,EACA,UAAAC,CACF,EAAmD,CACjD,MAAM,CAAE,QAAAD,EAAS,UAAAC,EAAW,IAAK,gCAAiC,CAAC,CACrE,CACF,CAEO,MAAMC,CAGb,CACE,SAAgB,CACd,MAAMC,EAA4B,CAChC,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EACA,OAAO,IAAIb,EAAYa,CAAQ,EAAE,MAAM,CACzC,CAEA,cAAcC,EAA6D,CACzE,MAAMC,EAAS,IAAId,EAAWa,CAAY,EAE1C,GAAI,CAACT,EAAa,kBAAkBS,CAAY,EAAG,CACjD,MAAMH,EAAYI,EAAO,mBAAmBD,EAAa,UAAU,EACnE,OAAIV,EAAmBO,EAAWH,CAAiB,EAC1CL,EAAqB,CAC1B,MAAO,IAAIM,EAA+B,CACxC,GAAGD,EAAkBG,CAAS,EAC9B,UAAAA,CACF,CAAC,CACH,CAAC,EAEIR,EAAqB,CAC1B,MAAOG,EAA0B,OAAOQ,CAAY,CACtD,CAAC,CACH,CAEA,MAAME,EAAOD,EAAO,iBAAiB,EACrC,OAAIC,IAAS,OACJb,EAAqB,CAC1B,MAAO,IAAID,EAAuB,yBAAyB,CAC7D,CAAC,EAGIC,EAAqB,CAC1B,KAAMa,CACR,CAAC,CACH,CACF",
+  "names": ["ApduBuilder", "ApduParser", "InvalidStatusWordError", "CommandResultFactory", "isCommandErrorCode", "CommandUtils", "GlobalCommandErrorHandler", "DeviceExchangeError", "IMAGE_SIZE_ERRORS", "GetCustomImageSizeCommandError", "message", "errorCode", "GetCustomImageSizeCommand", "apduArgs", "apduResponse", "parser", "size"]
+}

package/lib/esm/src/api/command/os/GetCustomImageSizeCommand.test.js

@@ -0,0 +1,2 @@
+import{InvalidStatusWordError as n}from"../../command/Errors";import{CommandResultFactory as r}from"../../command/model/CommandResult";import{isSuccessCommandResult as a}from"../../command/model/CommandResult";import{GetCustomImageSizeCommand as i}from"../../command/os/GetCustomImageSizeCommand";import{ApduResponse as o}from"../../device-session/ApduResponse";const u=new Uint8Array([224,100,0,0,0]);describe("GetCustomImageSizeCommand",()=>{let t;beforeEach(()=>{t=new i}),it("should return the correct APDU",()=>{const e=t.getApdu();expect(e.getRawApdu()).toStrictEqual(u)}),it("should parse result successfully",()=>{const e=new o({statusCode:new Uint8Array([144,0]),data:new Uint8Array([0,0,137,233])}),s=t.parseResponse(e);expect(s).toStrictEqual(r({data:35305}))}),it("should fail on invalid size",()=>{const e=new o({statusCode:new Uint8Array([144,0]),data:new Uint8Array([233])}),s=t.parseResponse(e);expect(s).toStrictEqual(r({error:new n("Didn't receive any size")}))}),it("should fail on device error",()=>{const e=new o({statusCode:new Uint8Array([102,46]),data:new Uint8Array([])}),s=t.parseResponse(e);expect(a(s)).toBeFalsy()})});
+//# sourceMappingURL=GetCustomImageSizeCommand.test.js.map

package/lib/esm/src/api/command/os/GetCustomImageSizeCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/GetCustomImageSizeCommand.test.ts"],
+  "sourcesContent": ["import { InvalidStatusWordError } from \"@api/command/Errors\";\nimport { CommandResultFactory } from \"@api/command/model/CommandResult\";\nimport { isSuccessCommandResult } from \"@api/command/model/CommandResult\";\nimport { GetCustomImageSizeCommand } from \"@api/command/os/GetCustomImageSizeCommand\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nconst IMAGE_SIZE_APDU = new Uint8Array([0xe0, 0x64, 0x00, 0x00, 0x00]);\n\ndescribe(\"GetCustomImageSizeCommand\", () => {\n  let command: GetCustomImageSizeCommand;\n\n  beforeEach(() => {\n    command = new GetCustomImageSizeCommand();\n  });\n\n  it(\"should return the correct APDU\", () => {\n    const apdu = command.getApdu();\n    expect(apdu.getRawApdu()).toStrictEqual(IMAGE_SIZE_APDU);\n  });\n\n  it(\"should parse result successfully\", () => {\n    const response: ApduResponse = new ApduResponse({\n      statusCode: new Uint8Array([0x90, 0x00]),\n      data: new Uint8Array([0x00, 0x00, 0x89, 0xe9]),\n    });\n    const result = command.parseResponse(response);\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        data: 35305,\n      }),\n    );\n  });\n\n  it(\"should fail on invalid size\", () => {\n    const response: ApduResponse = new ApduResponse({\n      statusCode: new Uint8Array([0x90, 0x00]),\n      data: new Uint8Array([0xe9]),\n    });\n    const result = command.parseResponse(response);\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"Didn't receive any size\"),\n      }),\n    );\n  });\n\n  it(\"should fail on device error\", () => {\n    const response: ApduResponse = new ApduResponse({\n      statusCode: new Uint8Array([0x66, 0x2e]),\n      data: new Uint8Array([]),\n    });\n    const result = command.parseResponse(response);\n    expect(isSuccessCommandResult(result)).toBeFalsy();\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,0BAAAA,MAA8B,sBACvC,OAAS,wBAAAC,MAA4B,mCACrC,OAAS,0BAAAC,MAA8B,mCACvC,OAAS,6BAAAC,MAAiC,4CAC1C,OAAS,gBAAAC,MAAoB,mCAE7B,MAAMC,EAAkB,IAAI,WAAW,CAAC,IAAM,IAAM,EAAM,EAAM,CAAI,CAAC,EAErE,SAAS,4BAA6B,IAAM,CAC1C,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAU,IAAIH,CAChB,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzC,MAAMI,EAAOD,EAAQ,QAAQ,EAC7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cAAcF,CAAe,CACzD,CAAC,EAED,GAAG,mCAAoC,IAAM,CAC3C,MAAMG,EAAyB,IAAIJ,EAAa,CAC9C,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,EAAM,EAAM,IAAM,GAAI,CAAC,CAC/C,CAAC,EACKK,EAASH,EAAQ,cAAcE,CAAQ,EAC7C,OAAOC,CAAM,EAAE,cACbR,EAAqB,CACnB,KAAM,KACR,CAAC,CACH,CACF,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,MAAMO,EAAyB,IAAIJ,EAAa,CAC9C,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,GAAI,CAAC,CAC7B,CAAC,EACKK,EAASH,EAAQ,cAAcE,CAAQ,EAC7C,OAAOC,CAAM,EAAE,cACbR,EAAqB,CACnB,MAAO,IAAID,EAAuB,yBAAyB,CAC7D,CAAC,CACH,CACF,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,MAAMQ,EAAyB,IAAIJ,EAAa,CAC9C,WAAY,IAAI,WAAW,CAAC,IAAM,EAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EACKK,EAASH,EAAQ,cAAcE,CAAQ,EAC7C,OAAON,EAAuBO,CAAM,CAAC,EAAE,UAAU,CACnD,CAAC,CACH,CAAC",
+  "names": ["InvalidStatusWordError", "CommandResultFactory", "isSuccessCommandResult", "GetCustomImageSizeCommand", "ApduResponse", "IMAGE_SIZE_APDU", "command", "apdu", "response", "result"]
+}