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

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.js

@@ -1,305 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ByteArrayBuilder = void 0;
-const HexaString_1 = require("../../utils/HexaString");
-const AppBuilderError_1 = require("./AppBuilderError");
-const MAX_32_BIT_UINT = 0xffffffff;
-/**
- * ByteArrayBuilder is a utility class to help build APDU payloads.
- * It allows to easily add data to the payload of an APDU command
- * and to encode this data in different formats.
- *
- * @example
- * ```
- * const builder = new ByteArrayBuilder(255)
- *  .add8BitUIntToData(0x05)
- *  .add16BitUIntToData(0x0607)
- *  .addHexaStringToData("0x0809")
- *  .addAsciiStringToData("hello")
- *
- * const payload = builder.build();
- * const builderErrors = builder.getErrors();
- * ```
- */
-class ByteArrayBuilder {
-    maxPayloadSize;
-    data = new Uint8Array();
-    errors = []; // Custom Error
-    constructor(maxPayloadSize = MAX_32_BIT_UINT) {
-        this.maxPayloadSize = maxPayloadSize;
-    }
-    // ==========
-    // Public API
-    // ==========
-    /**
-     * Build a new payload instance with the current state of the builder
-     * @returns {payload} - Returns a new payload instance
-     */
-    build = () => this.data;
-    /**
-     * Try to build a new payload instance with the current state of the builder
-     * if the builder don't contain any error.
-     * @returns {payload | undefined} - Returns a new payload instance or undefined
-     */
-    tryBuild = () => {
-        return this.hasErrors() ? undefined : this.data;
-    };
-    /**
-     * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)
-     * @param value: number | bigint - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add8BitUIntToData = (value) => {
-        return this.addNumberToData(value, 8n, false, false);
-    };
-    /**
-     * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add16BitUIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 16n, false, bigEndian);
-    };
-    /**
-     * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add32BitUIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 32n, false, bigEndian);
-    };
-    /**
-     * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add64BitUIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 64n, false, bigEndian);
-    };
-    /**
-     * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add16BitIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 16n, true, bigEndian);
-    };
-    /**
-     * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add32BitIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 32n, true, bigEndian);
-    };
-    /**
-     * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add64BitIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 64n, true, bigEndian);
-    };
-    /**
-     * Add a Uint8Array to the payload if it has enough remaining space
-     * @param value: Uint8Array - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addBufferToData = (value) => {
-        if (!this.hasEnoughLengthRemaining(value)) {
-            this.errors.push(new AppBuilderError_1.DataOverflowError(value.toString()));
-            return this;
-        }
-        this.data = Uint8Array.from([...this.data, ...value]);
-        return this;
-    };
-    /**
-     * Add a string to the payload if it has enough remaining space
-     * and it can be formatted as a hexadecimal string
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addHexaStringToData = (value) => {
-        const result = (0, HexaString_1.hexaStringToBuffer)(value);
-        if (result === null || result.length === 0) {
-            this.errors.push(new AppBuilderError_1.HexaStringEncodeError(value));
-            return this;
-        }
-        this.addBufferToData(result);
-        return this;
-    };
-    /**
-     * Add an ascii string to the data field if it has enough remaining space
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addAsciiStringToData = (value) => {
-        const bytes = new TextEncoder().encode(value);
-        this.addBufferToData(bytes);
-        return this;
-    };
-    /**
-     * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space
-     * Length-Value encoding is a way to encode data in a binary format with the first byte
-     * being the length of the data and the following bytes being the data itself
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    encodeInLVFromHexa = (value) => {
-        const result = (0, HexaString_1.hexaStringToBuffer)(value);
-        if (result === null || result.length === 0) {
-            this.errors.push(new AppBuilderError_1.HexaStringEncodeError(value));
-            return this;
-        }
-        if (!this.hasEnoughLengthRemaining(result, true)) {
-            this.errors.push(new AppBuilderError_1.DataOverflowError(value));
-            return this;
-        }
-        // values are always being well formatted at this point
-        // therefore no status test is needed
-        this.add8BitUIntToData(result.length);
-        this.addBufferToData(result);
-        return this;
-    };
-    /**
-     * Add a Length-Value encoded buffer to the data field if it has enough remaining space
-     * Length-Value encoding is a way to encode data in a binary format with the first byte
-     * being the length of the data and the following bytes being the data itself
-     * @param value: Uint8Array - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    encodeInLVFromBuffer = (value) => {
-        if (!this.hasEnoughLengthRemaining(value, true)) {
-            this.errors.push(new AppBuilderError_1.DataOverflowError(value.toString()));
-            return this;
-        }
-        this.add8BitUIntToData(value.length);
-        this.addBufferToData(value);
-        return this;
-    };
-    /**
-     * Add a Length-Value encoded ascii string to the data field if it has enough remaining space
-     * Length-Value encoding is a way to encode data in a binary format with the first byte
-     * being the length of the data and the following bytes being the data itself
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    encodeInLVFromAscii = (value) => {
-        if (!this.hasEnoughLengthRemaining(value, true)) {
-            this.errors.push(new AppBuilderError_1.DataOverflowError(value));
-            return this;
-        }
-        this.add8BitUIntToData(value.length);
-        this.addAsciiStringToData(value);
-        return this;
-    };
-    /**
-     * Returns the remaining payload length
-     * @returns {number}
-     */
-    getAvailablePayloadLength = () => {
-        return this.maxPayloadSize - this.data.length;
-    };
-    /**
-     * Returns the current errors
-     * @returns {AppBuilderError[]} - Returns an array of errors
-     */
-    getErrors = () => this.errors;
-    /**
-     * Verifies if the builder contains errors
-     * @returns {boolean} - Returns wether the builder contains errors or not
-     */
-    hasErrors = () => this.errors.length !== 0;
-    // ===========
-    // Private API
-    // ===========
-    /**
-     * Check if there is enough space to add a value to the data field
-     * @param value {string | Uint8Array | number[]} - Value to add to the data
-     * @param hasLv {boolean} - Length-Value encoding flag
-     * @returns {boolean} - Returns true if there is enough space to add the value
-     */
-    hasEnoughLengthRemaining = (value, hasLv = false) => {
-        return (this.data.length + value.length + (hasLv ? 1 : 0) <= this.maxPayloadSize);
-    };
-    /**
-     * Add a number to the payload
-     * @param value: number | bigint - The value to add to the data
-     * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16
-     * @param signed: boolean - Whether the value is signed or unsigned.
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addNumberToData(value, sizeInBits, signed, bigEndian) {
-        // Convert the number to two's complement and check its bounds
-        let converted = this.checkBoundsAndConvert(value, sizeInBits, signed);
-        if (converted === undefined) {
-            return this;
-        }
-        // Compute the buffer
-        const sizeInBytes = Number(sizeInBits) / 8;
-        const buffer = new Uint8Array(sizeInBytes);
-        if (bigEndian) {
-            for (let i = sizeInBytes - 1; i >= 0; i--) {
-                buffer[i] = Number(converted & 0xffn);
-                converted >>= 8n;
-            }
-        }
-        else {
-            for (let i = 0; i < sizeInBytes; i++) {
-                buffer[i] = Number(converted & 0xffn);
-                converted >>= 8n;
-            }
-        }
-        return this.addBufferToData(buffer);
-    }
-    /**
-     * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.
-     * @param value The value to check and convert.
-     * @param sizeInBits The size of the value in bits.
-     * @param signed Whether the value is signed or unsigned.
-     * @returns The converted value, or null if the value is out of bounds.
-     */
-    checkBoundsAndConvert(value, sizeInBits, signed) {
-        // Normalize the value to a bigint
-        if (typeof value === "number") {
-            if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER) {
-                this.errors.push(new AppBuilderError_1.ValueOverflowError(value.toString()));
-                return;
-            }
-            value = BigInt(value);
-        }
-        if (!signed) {
-            // Check if the value is within the bounds of an unsigned integer
-            const limit = 1n << sizeInBits;
-            if (value < 0 || value >= limit) {
-                this.errors.push(new AppBuilderError_1.ValueOverflowError(value.toString(), limit - 1n));
-                return;
-            }
-        }
-        else {
-            // Check if the value is within the bounds of a signed integer
-            const limit = 1n << (sizeInBits - 1n);
-            if (value >= limit || value < -limit) {
-                this.errors.push(new AppBuilderError_1.ValueOverflowError(value.toString(), limit - 1n));
-                return;
-            }
-            // Convert the value to two's complement if it is negative
-            // https://en.wikipedia.org/wiki/Two%27s_complement
-            if (value < 0n) {
-                const mask = (1n << sizeInBits) - 1n;
-                value = -value;
-                value = (~value & mask) + 1n;
-            }
-        }
-        return value;
-    }
-}
-exports.ByteArrayBuilder = ByteArrayBuilder;
-//# sourceMappingURL=ByteArrayBuilder.js.map
+"use strict";var h=Object.defineProperty;var B=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var y=(i,r)=>{for(var t in r)h(i,t,{get:r[t],enumerable:!0})},l=(i,r,t,d)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of f(r))!g.call(i,e)&&e!==t&&h(i,e,{get:()=>r[e],enumerable:!(d=B(r,e))||d.enumerable});return i};var m=i=>l(h({},"__esModule",{value:!0}),i);var D={};y(D,{ByteArrayBuilder:()=>T});module.exports=m(D);var b=require("../../utils/HexaString"),n=require("./AppBuilderError");const A=4294967295;class T{constructor(r=A){this.maxPayloadSize=r}data=new Uint8Array;errors=[];build=()=>this.data;tryBuild=()=>this.hasErrors()?void 0:this.data;add8BitUIntToData=r=>this.addNumberToData(r,8n,!1,!1);add16BitUIntToData=(r,t=!0)=>this.addNumberToData(r,16n,!1,t);add32BitUIntToData=(r,t=!0)=>this.addNumberToData(r,32n,!1,t);add64BitUIntToData=(r,t=!0)=>this.addNumberToData(r,64n,!1,t);add128BitUIntToData=(r,t=!0)=>this.addNumberToData(r,128n,!1,t);add256BitUIntToData=(r,t=!0)=>this.addNumberToData(r,256n,!1,t);add16BitIntToData=(r,t=!0)=>this.addNumberToData(r,16n,!0,t);add32BitIntToData=(r,t=!0)=>this.addNumberToData(r,32n,!0,t);add64BitIntToData=(r,t=!0)=>this.addNumberToData(r,64n,!0,t);add128BitIntToData=(r,t=!0)=>this.addNumberToData(r,128n,!0,t);add256BitIntToData=(r,t=!0)=>this.addNumberToData(r,256n,!0,t);addBufferToData=r=>this.hasEnoughLengthRemaining(r)?(this.data=Uint8Array.from([...this.data,...r]),this):(this.errors.push(new n.DataOverflowError(r.toString())),this);addHexaStringToData=r=>{const t=(0,b.hexaStringToBuffer)(r);return t===null||t.length===0?(this.errors.push(new n.HexaStringEncodeError(r)),this):(this.addBufferToData(t),this)};addAsciiStringToData=r=>{const t=new TextEncoder().encode(r);return this.addBufferToData(t),this};encodeInLVFromHexa=r=>{const t=(0,b.hexaStringToBuffer)(r);return t===null||t.length===0?(this.errors.push(new n.HexaStringEncodeError(r)),this):this.hasEnoughLengthRemaining(t,!0)?(this.add8BitUIntToData(t.length),this.addBufferToData(t),this):(this.errors.push(new n.DataOverflowError(r)),this)};encodeInLVFromBuffer=r=>this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addBufferToData(r),this):(this.errors.push(new n.DataOverflowError(r.toString())),this);encodeInLVFromAscii=r=>this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addAsciiStringToData(r),this):(this.errors.push(new n.DataOverflowError(r)),this);getAvailablePayloadLength=()=>this.maxPayloadSize-this.data.length;getErrors=()=>this.errors;hasErrors=()=>this.errors.length!==0;hasEnoughLengthRemaining=(r,t=!1)=>this.data.length+r.length+(t?1:0)<=this.maxPayloadSize;addNumberToData(r,t,d,e){let a=this.checkBoundsAndConvert(r,t,d);if(a===void 0)return this;const s=Number(t)/8,u=new Uint8Array(s);if(e)for(let o=s-1;o>=0;o--)u[o]=Number(a&0xffn),a>>=8n;else for(let o=0;o<s;o++)u[o]=Number(a&0xffn),a>>=8n;return this.addBufferToData(u)}checkBoundsAndConvert(r,t,d){if(typeof r=="number"){if(!Number.isInteger(r)||r>Number.MAX_SAFE_INTEGER){this.errors.push(new n.ValueOverflowError(r.toString()));return}r=BigInt(r)}if(d){const e=1n<<t-1n;if(r>=e||r<-e){this.errors.push(new n.ValueOverflowError(r.toString(),e-1n));return}if(r<0n){const a=(1n<<t)-1n;r=-r,r=(~r&a)+1n}}else{const e=1n<<t;if(r<0||r>=e){this.errors.push(new n.ValueOverflowError(r.toString(),e-1n));return}}return r}}0&&(module.exports={ByteArrayBuilder});
+//# sourceMappingURL=ByteArrayBuilder.js.map

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"ByteArrayBuilder.js","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayBuilder.ts"],"names":[],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/apdu/utils/ByteArrayBuilder.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport {\n  type AppBuilderError,\n  DataOverflowError,\n  HexaStringEncodeError,\n  ValueOverflowError,\n} from \"./AppBuilderError\";\n\nconst MAX_32_BIT_UINT = 0xffffffff;\n\n/**\n * ByteArrayBuilder is a utility class to help build APDU payloads.\n * It allows to easily add data to the payload of an APDU command\n * and to encode this data in different formats.\n *\n * @example\n * ```\n * const builder = new ByteArrayBuilder(255)\n *  .add8BitUIntToData(0x05)\n *  .add16BitUIntToData(0x0607)\n *  .addHexaStringToData(\"0x0809\")\n *  .addAsciiStringToData(\"hello\")\n *\n * const payload = builder.build();\n * const builderErrors = builder.getErrors();\n * ```\n */\nexport class ByteArrayBuilder {\n  private data: Uint8Array = new Uint8Array();\n  private readonly errors: AppBuilderError[] = []; // Custom Error\n\n  constructor(private maxPayloadSize: number = MAX_32_BIT_UINT) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Build a new payload instance with the current state of the builder\n   * @returns {payload} - Returns a new payload instance\n   */\n  build = (): Uint8Array => this.data;\n\n  /**\n   * Try to build a new payload instance with the current state of the builder\n   * if the builder don't contain any error.\n   * @returns {payload | undefined} - Returns a new payload instance or undefined\n   */\n  tryBuild = (): Uint8Array | undefined => {\n    return this.hasErrors() ? undefined : this.data;\n  };\n\n  /**\n   * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)\n   * @param value: number | bigint - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add8BitUIntToData = (value: number | bigint): ByteArrayBuilder => {\n    return this.addNumberToData(value, 8n, false, false);\n  };\n\n  /**\n   * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, false, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, false, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, false, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, false, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, false, bigEndian);\n  };\n\n  /**\n   * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, true, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, true, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, true, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, true, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, true, bigEndian);\n  };\n\n  /**\n   * Add a Uint8Array to the payload if it has enough remaining space\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addBufferToData = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.data = Uint8Array.from([...this.data, ...value]);\n    return this;\n  };\n\n  /**\n   * Add a string to the payload if it has enough remaining space\n   * and it can be formatted as a hexadecimal string\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addHexaStringToData = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add an ascii string to the data field if it has enough remaining space\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addAsciiStringToData = (value: string): ByteArrayBuilder => {\n    const bytes = new TextEncoder().encode(value);\n    this.addBufferToData(bytes);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromHexa = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n\n    if (!this.hasEnoughLengthRemaining(result, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n    // values are always being well formatted at this point\n    // therefore no status test is needed\n    this.add8BitUIntToData(result.length);\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded buffer to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromBuffer = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addBufferToData(value);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded ascii string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromAscii = (value: string): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addAsciiStringToData(value);\n    return this;\n  };\n\n  /**\n   * Returns the remaining payload length\n   * @returns {number}\n   */\n  getAvailablePayloadLength = (): number => {\n    return this.maxPayloadSize - this.data.length;\n  };\n\n  /**\n   * Returns the current errors\n   * @returns {AppBuilderError[]} - Returns an array of errors\n   */\n  getErrors = (): AppBuilderError[] => this.errors;\n\n  /**\n   * Verifies if the builder contains errors\n   * @returns {boolean} - Returns wether the builder contains errors or not\n   */\n  hasErrors = (): boolean => this.errors.length !== 0;\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check if there is enough space to add a value to the data field\n   * @param value {string | Uint8Array | number[]} - Value to add to the data\n   * @param hasLv {boolean} - Length-Value encoding flag\n   * @returns {boolean} - Returns true if there is enough space to add the value\n   */\n  private hasEnoughLengthRemaining = (\n    value: string | Uint8Array | number[],\n    hasLv: boolean = false,\n  ): boolean => {\n    return (\n      this.data.length + value.length + (hasLv ? 1 : 0) <= this.maxPayloadSize\n    );\n  };\n\n  /**\n   * Add a number to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - Whether the value is signed or unsigned.\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  private addNumberToData(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): ByteArrayBuilder {\n    // Convert the number to two's complement and check its bounds\n    let converted = this.checkBoundsAndConvert(value, sizeInBits, signed);\n    if (converted === undefined) {\n      return this;\n    }\n\n    // Compute the buffer\n    const sizeInBytes = Number(sizeInBits) / 8;\n    const buffer = new Uint8Array(sizeInBytes);\n    if (bigEndian) {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    } else {\n      for (let i = 0; i < sizeInBytes; i++) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    }\n    return this.addBufferToData(buffer);\n  }\n\n  /**\n   * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.\n   * @param value The value to check and convert.\n   * @param sizeInBits The size of the value in bits.\n   * @param signed Whether the value is signed or unsigned.\n   * @returns The converted value, or null if the value is out of bounds.\n   */\n  private checkBoundsAndConvert(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n  ): bigint | undefined {\n    // Normalize the value to a bigint\n    if (typeof value === \"number\") {\n      if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER) {\n        this.errors.push(new ValueOverflowError(value.toString()));\n        return;\n      }\n      value = BigInt(value);\n    }\n\n    if (!signed) {\n      // Check if the value is within the bounds of an unsigned integer\n      const limit = 1n << sizeInBits;\n      if (value < 0 || value >= limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\n      }\n    } else {\n      // Check if the value is within the bounds of a signed integer\n      const limit = 1n << (sizeInBits - 1n);\n      if (value >= limit || value < -limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\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 (value < 0n) {\n        const mask = (1n << sizeInBits) - 1n;\n        value = -value;\n        value = (~value & mask) + 1n;\n      }\n    }\n    return value;\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,sBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,iCAEnCC,EAKO,6BAEP,MAAMC,EAAkB,WAmBjB,MAAMJ,CAAiB,CAI5B,YAAoBK,EAAyBD,EAAiB,CAA1C,oBAAAC,CAA2C,CAHvD,KAAmB,IAAI,WACd,OAA4B,CAAC,EAY9C,MAAQ,IAAkB,KAAK,KAO/B,SAAW,IACF,KAAK,UAAU,EAAI,OAAY,KAAK,KAQ7C,kBAAqBC,GACZ,KAAK,gBAAgBA,EAAO,GAAI,GAAO,EAAK,EASrD,mBAAqB,CACnBA,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,IAAK,GAAOC,CAAS,EAS1D,mBAAqB,CACnBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,IAAK,GAAOC,CAAS,EAS1D,mBAAqB,CACnBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,IAAK,GAAOC,CAAS,EAS1D,oBAAsB,CACpBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,KAAM,GAAOC,CAAS,EAS3D,oBAAsB,CACpBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,KAAM,GAAOC,CAAS,EAS3D,kBAAoB,CAClBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,IAAK,GAAMC,CAAS,EASzD,kBAAoB,CAClBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,IAAK,GAAMC,CAAS,EASzD,kBAAoB,CAClBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,IAAK,GAAMC,CAAS,EASzD,mBAAqB,CACnBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,KAAM,GAAMC,CAAS,EAS1D,mBAAqB,CACnBD,EACAC,EAAqB,KAEd,KAAK,gBAAgBD,EAAO,KAAM,GAAMC,CAAS,EAQ1D,gBAAmBD,GACZ,KAAK,yBAAyBA,CAAK,GAKxC,KAAK,KAAO,WAAW,KAAK,CAAC,GAAG,KAAK,KAAM,GAAGA,CAAK,CAAC,EAC7C,OALL,KAAK,OAAO,KAAK,IAAI,oBAAkBA,EAAM,SAAS,CAAC,CAAC,EACjD,MAaX,oBAAuBA,GAAoC,CACzD,MAAME,KAAS,sBAAmBF,CAAK,EACvC,OAAIE,IAAW,MAAQA,EAAO,SAAW,GACvC,KAAK,OAAO,KAAK,IAAI,wBAAsBF,CAAK,CAAC,EAC1C,OAET,KAAK,gBAAgBE,CAAM,EACpB,KACT,EAOA,qBAAwBF,GAAoC,CAC1D,MAAMG,EAAQ,IAAI,YAAY,EAAE,OAAOH,CAAK,EAC5C,YAAK,gBAAgBG,CAAK,EACnB,IACT,EASA,mBAAsBH,GAAoC,CACxD,MAAME,KAAS,sBAAmBF,CAAK,EACvC,OAAIE,IAAW,MAAQA,EAAO,SAAW,GACvC,KAAK,OAAO,KAAK,IAAI,wBAAsBF,CAAK,CAAC,EAC1C,MAGJ,KAAK,yBAAyBE,EAAQ,EAAI,GAM/C,KAAK,kBAAkBA,EAAO,MAAM,EACpC,KAAK,gBAAgBA,CAAM,EACpB,OAPL,KAAK,OAAO,KAAK,IAAI,oBAAkBF,CAAK,CAAC,EACtC,KAOX,EASA,qBAAwBA,GACjB,KAAK,yBAAyBA,EAAO,EAAI,GAK9C,KAAK,kBAAkBA,EAAM,MAAM,EACnC,KAAK,gBAAgBA,CAAK,EACnB,OANL,KAAK,OAAO,KAAK,IAAI,oBAAkBA,EAAM,SAAS,CAAC,CAAC,EACjD,MAeX,oBAAuBA,GAChB,KAAK,yBAAyBA,EAAO,EAAI,GAK9C,KAAK,kBAAkBA,EAAM,MAAM,EACnC,KAAK,qBAAqBA,CAAK,EACxB,OANL,KAAK,OAAO,KAAK,IAAI,oBAAkBA,CAAK,CAAC,EACtC,MAYX,0BAA4B,IACnB,KAAK,eAAiB,KAAK,KAAK,OAOzC,UAAY,IAAyB,KAAK,OAM1C,UAAY,IAAe,KAAK,OAAO,SAAW,EAY1C,yBAA2B,CACjCA,EACAI,EAAiB,KAGf,KAAK,KAAK,OAASJ,EAAM,QAAUI,EAAQ,EAAI,IAAM,KAAK,eAYtD,gBACNJ,EACAK,EACAC,EACAL,EACkB,CAElB,IAAIM,EAAY,KAAK,sBAAsBP,EAAOK,EAAYC,CAAM,EACpE,GAAIC,IAAc,OAChB,OAAO,KAIT,MAAMC,EAAc,OAAOH,CAAU,EAAI,EACnCI,EAAS,IAAI,WAAWD,CAAW,EACzC,GAAIP,EACF,QAASS,EAAIF,EAAc,EAAGE,GAAK,EAAGA,IACpCD,EAAOC,CAAC,EAAI,OAAOH,EAAY,KAAK,EACpCA,IAAc,OAGhB,SAASG,EAAI,EAAGA,EAAIF,EAAaE,IAC/BD,EAAOC,CAAC,EAAI,OAAOH,EAAY,KAAK,EACpCA,IAAc,GAGlB,OAAO,KAAK,gBAAgBE,CAAM,CACpC,CASQ,sBACNT,EACAK,EACAC,EACoB,CAEpB,GAAI,OAAON,GAAU,SAAU,CAC7B,GAAI,CAAC,OAAO,UAAUA,CAAK,GAAKA,EAAQ,OAAO,iBAAkB,CAC/D,KAAK,OAAO,KAAK,IAAI,qBAAmBA,EAAM,SAAS,CAAC,CAAC,EACzD,MACF,CACAA,EAAQ,OAAOA,CAAK,CACtB,CAEA,GAAKM,EAOE,CAEL,MAAMK,EAAQ,IAAON,EAAa,GAClC,GAAIL,GAASW,GAASX,EAAQ,CAACW,EAAO,CACpC,KAAK,OAAO,KAAK,IAAI,qBAAmBX,EAAM,SAAS,EAAGW,EAAQ,EAAE,CAAC,EACrE,MACF,CAIA,GAAIX,EAAQ,GAAI,CACd,MAAMY,GAAQ,IAAMP,GAAc,GAClCL,EAAQ,CAACA,EACTA,GAAS,CAACA,EAAQY,GAAQ,EAC5B,CACF,KAtBa,CAEX,MAAMD,EAAQ,IAAMN,EACpB,GAAIL,EAAQ,GAAKA,GAASW,EAAO,CAC/B,KAAK,OAAO,KAAK,IAAI,qBAAmBX,EAAM,SAAS,EAAGW,EAAQ,EAAE,CAAC,EACrE,MACF,CACF,CAgBA,OAAOX,CACT,CACF",
+  "names": ["ByteArrayBuilder_exports", "__export", "ByteArrayBuilder", "__toCommonJS", "import_HexaString", "import_AppBuilderError", "MAX_32_BIT_UINT", "maxPayloadSize", "value", "bigEndian", "result", "bytes", "hasLv", "sizeInBits", "signed", "converted", "sizeInBytes", "buffer", "i", "limit", "mask"]
+}

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.test.js

@@ -0,0 +1,2 @@
+"use strict";var c=require("../../utils/HexaString"),a=require("./ApduBuilder"),r=require("./AppBuilderError"),l=require("./ByteArrayBuilder");const x=new Uint8Array([]),g=new Uint8Array([1]),y=new Uint8Array([128,129,130,131,132]),A=new Uint8Array([133,134,135,136]),p=new Uint8Array([3,161,162,163]),E=new Uint8Array([5,109,97,109,97,110]),b=new Uint8Array([2,240,241]),w=new Uint8Array([1,51,2,1,35,69,103,128,129,130,131,132,133,134,135,136,3,161,162,163,5,109,97,109,97,110,2,240,241]),i=new Uint8Array([...Array(255).fill(170)]),s=new Uint8Array([...Array(254).fill(170)]);let f;describe("ByteArrayBuilder",()=>{const d=(e,t,o,n)=>{if(n)switch(o){case 2:f.add16BitIntToData(e,t);break;case 4:f.add32BitIntToData(e,t);break;case 8:f.add64BitIntToData(e,t);break;case 16:f.add128BitIntToData(e,t);break;case 32:f.add256BitIntToData(e,t);break}else switch(o){case 2:f.add16BitUIntToData(e,t);break;case 4:f.add32BitUIntToData(e,t);break;case 8:f.add64BitUIntToData(e,t);break;case 16:f.add128BitUIntToData(e,t);break;case 32:f.add256BitUIntToData(e,t);break}};describe("clean",()=>{beforeEach(()=>{f=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should create an instance",()=>{expect(f).toBeDefined(),expect(f).toBeInstanceOf(l.ByteArrayBuilder)})}),describe("simple",()=>{beforeEach(()=>{f=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should serialize with an empty body",()=>{expect(f.build()).toEqual(x)}),it("should serialize with an single byte body",()=>{f=new l.ByteArrayBuilder(1),f.add8BitUIntToData(1),expect(f.build()).toEqual(g),expect(f.getErrors()).toEqual([])}),it.each([[2,!1,!0,13058,"3302"],[2,!1,!1,0x3302n,"0233"],[2,!0,!0,4200n,"1068"],[2,!0,!0,-4200n,"ef98"],[2,!0,!1,4200,"6810"],[2,!0,!1,-4200,"98ef"],[4,!1,!0,0x01234567n,"01234567"],[4,!1,!1,0x01234567n,"67452301"],[4,!0,!0,123456789,"075bcd15"],[4,!0,!0,-123456789,"f8a432eb"],[4,!0,!1,123456789,"15cd5b07"],[4,!0,!1,-123456789,"eb32a4f8"],[8,!1,!0,14147778004927559n,"0032435442584447"],[8,!1,!1,14147778004927559n,"4744584254433200"],[8,!0,!0,14147778004927559n,"0032435442584447"],[8,!0,!0,-14147778004927559n,"ffcdbcabbda7bbb9"],[8,!0,!1,14147778004927559n,"4744584254433200"],[8,!0,!1,-14147778004927559n,"b9bba7bdabbccdff"],[16,!1,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!1,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!0,!0,-0x00324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[16,!0,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!1,-0x00324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdff"],[32,!1,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!1,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!0,!0,-0x0032435442584447003243544258444700324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[32,!0,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!1,-0x0032435442584447003243544258444700324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff"]])("serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s",(e,t,o,n,u)=>{f=new l.ByteArrayBuilder(e),d(n,o,e,t),expect(f.build()).toEqual((0,c.hexaStringToBuffer)(u)),expect(f.getErrors()).toEqual([]),f=new l.ByteArrayBuilder(e-1),d(n,o,e,t),expect(f.getErrors().length).toEqual(1),expect(f.build()).toEqual(Uint8Array.from([]))}),it.each([[2,!1,!0,0xffffn,"ffff"],[2,!0,!0,0x7fffn,"7fff"],[2,!0,!0,-0x8000n,"8000"],[4,!1,!0,0xffffffffn,"ffffffff"],[4,!0,!0,0x7fffffffn,"7fffffff"],[4,!0,!0,-0x80000000n,"80000000"],[8,!1,!0,0xffffffffffffffffn,"ffffffffffffffff"],[8,!0,!0,0x7fffffffffffffffn,"7fffffffffffffff"],[8,!0,!0,-0x8000000000000000n,"8000000000000000"],[16,!1,!0,0xffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffff"],[16,!0,!0,0x7fffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffff"],[16,!0,!0,-0x80000000000000000000000000000000n,"80000000000000000000000000000000"],[32,!1,!0,0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,-0x8000000000000000000000000000000000000000000000000000000000000000n,"8000000000000000000000000000000000000000000000000000000000000000"]])("serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s",(e,t,o,n,u)=>{f=new l.ByteArrayBuilder(e),d(n,o,e,t),expect(f.build()).toEqual((0,c.hexaStringToBuffer)(u)),expect(f.getErrors()).toEqual([])}),it("Serialize from float to bigint",()=>{f=new l.ByteArrayBuilder(4),f.add32BitIntToData(1234567893e-1,!1),expect(f.getErrors().length).toEqual(1),expect(f.build()).toEqual(Uint8Array.from([]))}),it("should serialize with an 5 byte body from an hexastring",()=>{f.addHexaStringToData("0x8081828384"),expect(f.build()).toEqual(y),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body from an hexastring without '0x'",()=>{f.addHexaStringToData("85868788"),expect(f.build()).toEqual(A),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an hexastring",()=>{f.encodeInLVFromHexa("0xA1A2A3"),expect(f.build()).toEqual(p),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an ascci string",()=>{f.encodeInLVFromAscii("maman"),expect(f.build()).toEqual(E),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const e=new Uint8Array([240,241]);f.encodeInLVFromBuffer(e),expect(f.build()).toEqual(b),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const e=new Uint8Array([240,241]);f.encodeInLVFromBuffer(e),expect(f.build()).toEqual(b),expect(f.getErrors()).toEqual([])}),it("should serialize with an complete body of 0xAA",()=>{const e=new Uint8Array(255).fill(170,0,255);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getErrors()).toEqual([])})}),describe("mixed",()=>{beforeEach(()=>{f=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should serialize with all previous field",()=>{let e=a.APDU_MAX_PAYLOAD;f.add8BitUIntToData(1),e--,expect(f.getAvailablePayloadLength()).toBe(e),f.add16BitUIntToData(13058),e-=2,expect(f.getAvailablePayloadLength()).toBe(e),f.add32BitUIntToData(19088743),e-=4,expect(f.getAvailablePayloadLength()).toBe(e),f.addHexaStringToData("0x8081828384"),e-=5,expect(f.getAvailablePayloadLength()).toBe(e),f.addHexaStringToData("85868788"),e-=4,expect(f.getAvailablePayloadLength()).toBe(e),f.encodeInLVFromHexa("0xA1A2A3"),e-=4,expect(f.getAvailablePayloadLength()).toBe(e),f.encodeInLVFromAscii("maman"),e-=6,expect(f.getAvailablePayloadLength()).toBe(e);const t=new Uint8Array([240,241]);f.encodeInLVFromBuffer(t),e-=3,expect(f.getAvailablePayloadLength()).toBe(e),expect(f.build()).toEqual(w)})}),describe("error",()=>{beforeEach(()=>{f=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it.each([[2,!1,!0,0x10000n],[2,!0,!0,0x8000n],[2,!0,!0,-0x8001n],[4,!1,!0,0x100000000n],[4,!0,!0,0x80000000n],[4,!0,!0,-0x80000001n],[8,!1,!0,0x10000000000000000n],[8,!0,!0,0x8000000000000000n],[8,!0,!0,-0x8000000000000001n]])("serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i",(e,t,o,n)=>{f=new l.ByteArrayBuilder(e),d(n,o,e,t),expect(f.getErrors().length).toEqual(1),expect(f.build()).toEqual(Uint8Array.from([]))}),it("error due to a string not well coded",()=>{f.addHexaStringToData(":08081828384").addHexaStringToData("80818n8384").addHexaStringToData("808182838z"),expect(f.build()).toEqual(x),expect(f.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(f.getErrors()).toEqual([new r.HexaStringEncodeError(":08081828384"),new r.HexaStringEncodeError("80818n8384"),new r.HexaStringEncodeError("808182838z")])}),it("error due direct overflow",()=>{const e=new Uint8Array(256).fill(170,0,256);f.addBufferToData(e),expect(f.build()).toEqual(x),expect(f.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(f.getErrors()).toEqual([new r.DataOverflowError(e.toString())])}),it("error due to subsequent overflow with 1-byte array",()=>{const e=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0);const t=new Uint8Array(1);t.set([255],0),f.addBufferToData(t),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),expect(f.getErrors()).toEqual([new r.DataOverflowError(t.toString())])}),it("error due to subsequent overflow with 1-char ascii",()=>{const e=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0);const t="a";f.addAsciiStringToData(t),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),expect(f.getErrors()).toEqual([new r.DataOverflowError(new TextEncoder().encode(t).toString())])}),it("error due to subsequent overflow with 1-char hexastring",()=>{const e=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),f.addHexaStringToData("0xB4").addHexaStringToData("e1"),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),expect(f.getErrors()).toEqual([new r.DataOverflowError("180"),new r.DataOverflowError("225")])}),it("error due to empty values",()=>{const e="";f.addHexaStringToData(e).encodeInLVFromHexa(e),expect(f.build()).toEqual(x),expect(f.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(f.getErrors()).toEqual([new r.HexaStringEncodeError(e),new r.HexaStringEncodeError(e)])}),it("error due to subsequent overflow with 1-char LV",()=>{const e=new Uint8Array(a.APDU_MAX_PAYLOAD-1).fill(170,0,a.APDU_MAX_PAYLOAD-1);f.addBufferToData(e),expect(f.build()).toEqual(s),expect(f.getAvailablePayloadLength()).toBe(1);const t="n",o="e1",n=new Uint8Array(1);n.set([255],0),f.encodeInLVFromAscii(t).encodeInLVFromHexa(o).encodeInLVFromBuffer(n),expect(f.build()).toEqual(s),expect(f.getAvailablePayloadLength()).toBe(1),expect(f.getErrors()).toEqual([new r.DataOverflowError(t),new r.DataOverflowError(o),new r.DataOverflowError(n.toString())])})})});
+//# sourceMappingURL=ByteArrayBuilder.test.js.map

package/lib/cjs/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": ["import_HexaString", "import_ApduBuilder", "import_AppBuilderError", "import_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"]
+}