@ledgerhq/device-management-kit 0.0.0-develop-20241011001048 → 0.0.0-develop-20241219141541

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

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

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

@@ -1 +1,7 @@
-{"version":3,"file":"ByteArrayParser.js","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayParser.ts"],"names":[],"mappings":"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"}
+{
+  "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"]
+}

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

@@ -0,0 +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("")})})});
+//# sourceMappingURL=ByteArrayParser.test.js.map

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

@@ -0,0 +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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",
+  "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/Command.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=Command.js.map
+//# sourceMappingURL=Command.js.map

package/lib/esm/src/api/command/Command.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"Command.js","sourceRoot":"","sources":["../../../../../src/api/command/Command.ts"],"names":[],"mappings":""}
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/esm/src/api/command/Errors.js

@@ -1,36 +1,2 @@
-export class InvalidStatusWordError {
-    _tag = "InvalidStatusWordError";
-    originalError;
-    constructor(message) {
-        this.originalError = new Error(message ?? "Invalid status word.");
-    }
-}
-export class InvalidBatteryStatusTypeError {
-    _tag = "InvalidBatteryStatusTypeError";
-    originalError;
-    constructor(message) {
-        this.originalError = new Error(message ?? "Invalid battery status type.");
-    }
-}
-export class InvalidBatteryDataError {
-    _tag = "InvalidBatteryDataError";
-    originalError;
-    constructor(message) {
-        this.originalError = new Error(message ?? "Invalid battery data.");
-    }
-}
-export class InvalidBatteryFlagsError {
-    _tag = "InvalidBatteryFlagsError";
-    originalError;
-    constructor(message) {
-        this.originalError = new Error(message ?? "Invalid battery flags.");
-    }
-}
-export class InvalidResponseFormatError {
-    _tag = "InvalidResponseFormatError";
-    originalError;
-    constructor(message) {
-        this.originalError = new Error(message ?? "Invalid response format.");
-    }
-}
-//# sourceMappingURL=Errors.js.map
+class t{_tag="InvalidStatusWordError";originalError;constructor(r){this.originalError=new Error(r??"Invalid status word.")}}class a{_tag="InvalidBatteryStatusTypeError";originalError;constructor(r){this.originalError=new Error(r??"Invalid battery status type.")}}class n{_tag="InvalidBatteryDataError";originalError;constructor(r){this.originalError=new Error(r??"Invalid battery data.")}}class i{_tag="InvalidBatteryFlagsError";originalError;constructor(r){this.originalError=new Error(r??"Invalid battery flags.")}}class e{_tag="InvalidResponseFormatError";originalError;constructor(r){this.originalError=new Error(r??"Invalid response format.")}}export{n as InvalidBatteryDataError,i as InvalidBatteryFlagsError,a as InvalidBatteryStatusTypeError,e as InvalidResponseFormatError,t as InvalidStatusWordError};
+//# sourceMappingURL=Errors.js.map

package/lib/esm/src/api/command/Errors.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"Errors.js","sourceRoot":"","sources":["../../../../../src/api/command/Errors.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,sBAAsB;IACxB,IAAI,GAAG,wBAAwB,CAAC;IAChC,aAAa,CAAS;IAE/B,YAAY,OAAgB;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,IAAI,sBAAsB,CAAC,CAAC;IACpE,CAAC;CACF;AAED,MAAM,OAAO,6BAA6B;IAC/B,IAAI,GAAG,+BAA+B,CAAC;IACvC,aAAa,CAAQ;IAE9B,YAAY,OAAgB;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,IAAI,8BAA8B,CAAC,CAAC;IAC5E,CAAC;CACF;AAED,MAAM,OAAO,uBAAuB;IACzB,IAAI,GAAG,yBAAyB,CAAC;IACjC,aAAa,CAAQ;IAE9B,YAAY,OAAgB;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,IAAI,uBAAuB,CAAC,CAAC;IACrE,CAAC;CACF;AAED,MAAM,OAAO,wBAAwB;IAC1B,IAAI,GAAG,0BAA0B,CAAC;IAClC,aAAa,CAAQ;IAE9B,YAAY,OAAgB;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,IAAI,wBAAwB,CAAC,CAAC;IACtE,CAAC;CACF;AAED,MAAM,OAAO,0BAA0B;IAC5B,IAAI,GAAG,4BAA4B,CAAC;IACpC,aAAa,CAAQ;IAE9B,YAAY,OAAgB;QAC1B,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,IAAI,0BAA0B,CAAC,CAAC;IACxE,CAAC;CACF"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/command/Errors.ts"],
+  "sourcesContent": ["import { type DmkError } from \"@api/Error\";\n\nexport class InvalidStatusWordError implements DmkError {\n  readonly _tag = \"InvalidStatusWordError\";\n  readonly originalError?: Error;\n\n  constructor(message?: string) {\n    this.originalError = new Error(message ?? \"Invalid status word.\");\n  }\n}\n\nexport class InvalidBatteryStatusTypeError implements DmkError {\n  readonly _tag = \"InvalidBatteryStatusTypeError\";\n  readonly originalError: Error;\n\n  constructor(message?: string) {\n    this.originalError = new Error(message ?? \"Invalid battery status type.\");\n  }\n}\n\nexport class InvalidBatteryDataError implements DmkError {\n  readonly _tag = \"InvalidBatteryDataError\";\n  readonly originalError: Error;\n\n  constructor(message?: string) {\n    this.originalError = new Error(message ?? \"Invalid battery data.\");\n  }\n}\n\nexport class InvalidBatteryFlagsError implements DmkError {\n  readonly _tag = \"InvalidBatteryFlagsError\";\n  readonly originalError: Error;\n\n  constructor(message?: string) {\n    this.originalError = new Error(message ?? \"Invalid battery flags.\");\n  }\n}\n\nexport class InvalidResponseFormatError implements DmkError {\n  readonly _tag = \"InvalidResponseFormatError\";\n  readonly originalError: Error;\n\n  constructor(message?: string) {\n    this.originalError = new Error(message ?? \"Invalid response format.\");\n  }\n}\n"],
+  "mappings": "AAEO,MAAMA,CAA2C,CAC7C,KAAO,yBACP,cAET,YAAYC,EAAkB,CAC5B,KAAK,cAAgB,IAAI,MAAMA,GAAW,sBAAsB,CAClE,CACF,CAEO,MAAMC,CAAkD,CACpD,KAAO,gCACP,cAET,YAAYD,EAAkB,CAC5B,KAAK,cAAgB,IAAI,MAAMA,GAAW,8BAA8B,CAC1E,CACF,CAEO,MAAME,CAA4C,CAC9C,KAAO,0BACP,cAET,YAAYF,EAAkB,CAC5B,KAAK,cAAgB,IAAI,MAAMA,GAAW,uBAAuB,CACnE,CACF,CAEO,MAAMG,CAA6C,CAC/C,KAAO,2BACP,cAET,YAAYH,EAAkB,CAC5B,KAAK,cAAgB,IAAI,MAAMA,GAAW,wBAAwB,CACpE,CACF,CAEO,MAAMI,CAA+C,CACjD,KAAO,6BACP,cAET,YAAYJ,EAAkB,CAC5B,KAAK,cAAgB,IAAI,MAAMA,GAAW,0BAA0B,CACtE,CACF",
+  "names": ["InvalidStatusWordError", "message", "InvalidBatteryStatusTypeError", "InvalidBatteryDataError", "InvalidBatteryFlagsError", "InvalidResponseFormatError"]
+}

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

@@ -1,11 +1,2 @@
-import { ContainerModule } from "inversify";
-import { SendCommandUseCase } from "../../command/use-case/SendCommandUseCase";
-import { StubUseCase } from "../../../../src/di.stub";
-import { commandTypes } from "./commandTypes";
-export const commandModuleFactory = ({ stub = false, } = {}) => new ContainerModule((bind, _unbind, _isBound, rebind, _unbindAsync, _onActivation, _onDeactivation) => {
-    bind(commandTypes.SendCommandUseCase).to(SendCommandUseCase);
-    if (stub) {
-        rebind(commandTypes.SendCommandUseCase).to(StubUseCase);
-    }
-});
-//# sourceMappingURL=commandModule.js.map
+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};
+//# sourceMappingURL=commandModule.js.map

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

@@ -1 +1,7 @@
-{"version":3,"file":"commandModule.js","sourceRoot":"","sources":["../../../../../../src/api/command/di/commandModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAM9C,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,EACnC,IAAI,GAAG,KAAK,MACS,EAAE,EAAE,EAAE,CAC3B,IAAI,eAAe,CACjB,CACE,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,MAAM,EACN,YAAY,EACZ,aAAa,EACb,eAAe,EACf,EAAE;IACF,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC;IAC7D,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC,CACF,CAAC"}
+{
+  "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"]
+}

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

@@ -0,0 +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)})})});
+//# sourceMappingURL=commandModule.test.js.map

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

@@ -0,0 +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",
+  "names": ["Container", "SendCommandUseCase", "deviceSessionModuleFactory", "loggerModuleFactory", "StubUseCase", "commandModuleFactory", "commandTypes", "container", "mod", "sendCommandUseCase"]
+}

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

@@ -1,4 +1,2 @@
-export const commandTypes = {
-    SendCommandUseCase: Symbol.for("SendCommandUseCase"),
-};
-//# sourceMappingURL=commandTypes.js.map
+const e={SendCommandUseCase:Symbol.for("SendCommandUseCase")};export{e as commandTypes};
+//# sourceMappingURL=commandTypes.js.map

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

@@ -1 +1,7 @@
-{"version":3,"file":"commandTypes.js","sourceRoot":"","sources":["../../../../../../src/api/command/di/commandTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,kBAAkB,EAAE,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC;CACrD,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/di/commandTypes.ts"],
+  "sourcesContent": ["export const commandTypes = {\n  SendCommandUseCase: Symbol.for(\"SendCommandUseCase\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAe,CAC1B,mBAAoB,OAAO,IAAI,oBAAoB,CACrD",
+  "names": ["commandTypes"]
+}