@reversense/dxc-struct 1.0.7

package/README.md

@@ -0,0 +1,169 @@
+# dxc-struct
+
+Node.js equivalent of Python's Struct library for parsing and writing binary data.
+
+## Installation
+
+```bash
+npm i @dexcalibur/dxc-struct
+```
+
+## Description
+
+`dxc-struct` provides a TypeScript/JavaScript implementation for converting between binary data and JavaScript values, similar to Python's `struct` module. It supports encoding and decoding various data types including integers, floats, strings, and byte arrays with configurable endianness.
+
+## Features
+
+- **Binary data parsing** and encoding
+- **Multiple data types**: integers (signed/unsigned), floats, doubles, strings, byte arrays
+- **Endianness control**: Big-endian and little-endian support
+- **Format strings**: Python-like format strings for structured data
+- **TypeScript support**: Fully typed for type safety
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { Struct } from '@dexcalibur/dxc-struct';
+
+// Pack data into binary format
+const data = Struct.pack('<IHB', [0x12345678, 0xABCD, 0xFF]);
+
+// Unpack binary data
+const values = Struct.unpack('<IHB', data);
+console.log(values); // [305419896, 43981, 255]
+```
+
+### Format Strings
+
+Format strings define the data structure with the following syntax:
+
+#### Endianness
+- `<` - Little-endian (default for native)
+- No prefix - Big-endian
+
+#### Data Types
+
+| Format | Type | Size (bytes) | Description |
+|--------|------|--------------|-------------|
+| `c` | char | 1 | Single character |
+| `b` | signed byte | 1 | Signed integer (-128 to 127) |
+| `B` | unsigned byte | 1 | Unsigned integer (0 to 255) |
+| `h` | short | 2 | Signed integer (-32768 to 32767) |
+| `H` | unsigned short | 2 | Unsigned integer (0 to 65535) |
+| `i` / `l` | int/long | 4 | Signed integer (-2³¹ to 2³¹-1) |
+| `I` / `L` | unsigned int/long | 4 | Unsigned integer (0 to 2³²-1) |
+| `q` | long long | 8 | Signed 64-bit integer (BigInt) |
+| `Q` | unsigned long long | 8 | Unsigned 64-bit integer (BigInt) |
+| `f` | float | 4 | IEEE 754 single-precision |
+| `d` | double | 8 | IEEE 754 double-precision |
+| `s` | string | variable | Fixed-length string |
+| `S` | string | variable | Null-terminated string |
+| `A` | byte array | variable | Byte array |
+| `x` | padding | 1 | Padding byte |
+
+#### Count Prefix
+Add a number before the format character to specify count: `4I` = four integers
+
+#### Named Fields
+Add field names in parentheses: `I(id)H(value)` returns an object with named fields
+
+### Examples
+
+#### Unpacking with Named Fields
+
+```typescript
+const buffer = Buffer.from([0x78, 0x56, 0x34, 0x12, 0xCD, 0xAB]);
+const result = Struct.unpack('<I(id)H(value)', buffer);
+console.log(result); // { id: 305419896, value: 43981 }
+```
+
+#### Packing Multiple Values
+
+```typescript
+const buffer = Struct.pack('<3H', [0x1234, 0x5678, 0x9ABC]);
+```
+
+#### Working with Strings
+
+```typescript
+// Fixed-length string
+const data = Struct.pack('<5s', ['hello']);
+
+// Null-terminated string
+const nullTerm = Struct.pack('<S', ['hello']);
+```
+
+#### 64-bit Integers (BigInt)
+
+```typescript
+const data = Struct.pack('<Q', [BigInt('0xFFFFFFFFFFFFFFFF')]);
+const values = Struct.unpack('<Q', data);
+console.log(values[0]); // 18446744073709551615n
+```
+
+## API Reference
+
+### `Struct.pack(format, values)`
+Packs values into a new Buffer according to the format string.
+
+**Parameters:**
+- `format` (string): Format string defining data layout
+- `values` (any[]): Array of values to pack
+
+**Returns:** Buffer containing packed binary data
+
+### `Struct.packTo(format, buffer, offset, values)`
+Packs values into an existing Buffer at a specific offset.
+
+**Parameters:**
+- `format` (string): Format string defining data layout
+- `buffer` (Buffer | any[]): Target buffer
+- `offset` (number): Starting offset in buffer
+- `values` (any[]): Array of values to pack
+
+**Returns:** Modified buffer
+
+### `Struct.unpack(format, data, offset?)`
+Unpacks binary data according to the format string.
+
+**Parameters:**
+- `format` (string): Format string defining data layout
+- `data` (Buffer | any[] | string): Binary data to unpack
+- `offset` (number, optional): Starting offset (default: 0)
+
+**Returns:** Array of unpacked values or object with named fields
+
+### `Struct.calcLength(format, values)`
+Calculates the byte length required for packing the given values.
+
+**Parameters:**
+- `format` (string): Format string
+- `values` (any): Values to be packed
+
+**Returns:** Number of bytes required
+
+## Development
+
+### Build
+
+```bash
+npm run build
+```
+
+### Test
+
+```bash
+npm test
+```
+
+## License
+
+AGPL-3.0-only
+
+Copyright (C) 2026 Reversense SAS
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+See [LICENSE](LICENSE) for more details.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { Struct } from "./src/Struct.js";
+export { Struct };

package/dist/index.js

@@ -0,0 +1,24 @@
+import { StructEncoder } from "./src/StructEncoder.js";
+import { StructDecoder } from "./src/StructDecoder.js";
+import { Struct } from "./src/Struct.js";
+[
+    { token: 'A', en: StructEncoder.byteArray, de: StructDecoder.byteArray, opts: { size: 1 } },
+    { token: 'c', en: StructEncoder.chr, de: StructDecoder.chr, opts: { size: 1 } },
+    { token: 'b', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1 } },
+    { token: 'B', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1 } },
+    { token: 'h', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1 } },
+    { token: 'H', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1 } },
+    { token: 's', en: StructEncoder.str, de: StructDecoder.str, opts: { size: 1 } },
+    { token: 'S', en: StructEncoder.str, de: StructDecoder.nullTerminatedStr, opts: { size: 1 } },
+    { token: 'f', en: StructEncoder.ieee754_fp, de: StructDecoder.ieee754_fp, opts: { size: 4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77) } },
+    { token: 'd', en: StructEncoder.ieee754_fp, de: StructDecoder.ieee754_fp, opts: { size: 8, mLen: 52, rt: 0 } },
+    { token: 'i', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1 } },
+    { token: 'I', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1 } },
+    { token: 'l', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1 } },
+    { token: 'L', en: StructEncoder.int, de: StructDecoder.int, opts: { size: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1 } },
+    { token: 'q', en: StructEncoder.bigintEncoder, de: StructDecoder.bigintDecoder, opts: { size: 8, bSigned: true, min: -Math.pow(2, 63), max: Math.pow(2, 63) - 1 } },
+    { token: 'Q', en: StructEncoder.bigintEncoder, de: StructDecoder.bigintDecoder, opts: { size: 8, bSigned: false, min: 0, max: Math.pow(2, 64) - 1 } },
+].map((vOp) => {
+    Struct.OP[vOp.token] = vOp;
+});
+export { Struct };

package/dist/src/Struct.d.ts

@@ -0,0 +1,49 @@
+import { Endianness } from "./common.js";
+export type Token = string;
+export interface TransformerOpts {
+    size: number;
+    mLen?: number;
+    min?: number;
+    max?: number;
+    rt?: number;
+    bSigned?: boolean;
+}
+export interface Operation {
+    token: Token;
+    en: ((...args: any) => any);
+    de: ((...args: any) => any);
+    opts: TransformerOpts;
+}
+export declare class Struct {
+    static NATIVE_ENDIANNESS: Endianness;
+    static PADDING_TOK: string;
+    static BE_FLAG: string;
+    static OP: Record<Token, Operation>;
+    static FORMAT: string;
+    static _lenLut: {
+        A: number;
+        x: number;
+        c: number;
+        b: number;
+        B: number;
+        h: number;
+        H: number;
+        s: number;
+        S: number;
+        f: number;
+        d: number;
+        i: number;
+        I: number;
+        l: number;
+        L: number;
+        q: number;
+        Q: number;
+    };
+    static _UnpackSeries(pEndian: Endianness, pOpe: Operation, pElCount: number, pElSize: number, pArr: any[] | Buffer | string, pOffset: number): any[];
+    static _PackSeries(pEndian: Endianness, pOp: Operation, pElCount: number, pElSize: number, pDestArr: any[] | Buffer, pOffset: number, pSourceArr: any[] | Buffer, i: any): void;
+    static _zip(keys: any, values: any): any;
+    static unpack(pFmt: string, pArr: any[] | Buffer | string, pOffset?: number): any;
+    static packTo(pFmt: string, pArr: any[] | Buffer, pStartAt: number, pSource: any[]): any[] | Buffer<ArrayBufferLike>;
+    static pack(pFmt: string, pBinaryData: any[]): any;
+    static calcLength(pFmt: string, pValues: any): number;
+}

package/dist/src/Struct.js

@@ -0,0 +1,140 @@
+import { RuntimeException } from "./error/RuntimeException.js";
+import { Endianness } from "./common.js";
+const NOT_NULL_TERM_STRING = 'S';
+export class Struct {
+    static _UnpackSeries(pEndian, pOpe, pElCount, pElSize, pArr, pOffset) {
+        let res = [];
+        for (let i = 0; i < pElCount; i++) {
+            res.push(pOpe.de.apply(null, [pEndian, pOpe, pArr, pOffset + i * pElSize]));
+        }
+        return res;
+    }
+    static _PackSeries(pEndian, pOp, pElCount, pElSize, pDestArr, pOffset, pSourceArr, i) {
+        for (let o = 0; o < pElCount; o++) {
+            pOp.en.apply(null, [pEndian, pOp, pDestArr, pOffset + o * pElSize, pSourceArr[i + o]]);
+        }
+    }
+    ;
+    static _zip(keys, values) {
+        let result = {};
+        for (var i = 0; i < keys.length; i++) {
+            result[keys[i]] = values[i];
+        }
+        return result;
+    }
+    static unpack(pFmt, pArr, pOffset = 0) {
+        let endian = (pFmt.charAt(0) != '<') ? Endianness.BIG_ENDIAN : Struct.NATIVE_ENDIANNESS;
+        const re = new RegExp(Struct.FORMAT, 'g');
+        let m;
+        let elCount;
+        let elSz = 0;
+        let rk = [];
+        let rv = [];
+        while (m = re.exec(pFmt)) {
+            elCount = ((m[1] == undefined) || (m[1] == '')) ? 1 : parseInt(m[1]);
+            if (m[2] === NOT_NULL_TERM_STRING) {
+                elCount = 0;
+                while (pArr[pOffset + elCount] !== 0) {
+                    elCount++;
+                }
+                elCount++;
+            }
+            elSz = Struct.OP[m[2]].opts.size;
+            if ((pOffset + elCount * elSz) > pArr.length) {
+                throw RuntimeException.READ_OOB();
+            }
+            if ('SAs'.indexOf(m[2]) != -1) {
+                rv.push(Struct.OP[m[2]].de(pArr, pOffset, elCount));
+            }
+            else {
+                rv.push(Struct._UnpackSeries(endian, Struct.OP[m[2]], elCount, elSz, pArr, pOffset));
+            }
+            rk.push(m[4]);
+            pOffset += elCount * elSz;
+        }
+        rv = Array.prototype.concat.apply([], rv);
+        if (rk.indexOf(undefined) !== -1) {
+            return rv;
+        }
+        else {
+            return Struct._zip(rk, rv);
+        }
+    }
+    ;
+    static packTo(pFmt, pArr, pStartAt, pSource) {
+        let bigEndian = (pFmt.charAt(0) != '<') ? Endianness.BIG_ENDIAN : Struct.NATIVE_ENDIANNESS;
+        const re = new RegExp(Struct.FORMAT, 'g');
+        let offset = pStartAt;
+        let m;
+        let sz, dataLen = 0, i = 0, j = 0;
+        let opType;
+        while (m = re.exec(pFmt)) {
+            opType = m[2];
+            dataLen = ((m[1] == undefined) || (m[1] == '')) ? 1 : parseInt(m[1]);
+            if (opType === NOT_NULL_TERM_STRING) {
+                dataLen = pSource[i].length + 1;
+            }
+            sz = Struct.OP[m[2]].opts.size;
+            if ((offset + dataLen * sz) > pArr.length) {
+                throw RuntimeException.WRITE_OOB();
+            }
+            switch (opType) {
+                case 'A':
+                case 's':
+                case 'S':
+                    if ((i + 1) > pSource.length) {
+                        throw RuntimeException.READ_OOB();
+                    }
+                    Struct.OP[opType].en(pArr, offset, dataLen, pSource[i]);
+                    i += 1;
+                    break;
+                case Struct.PADDING_TOK:
+                    for (j = 0; j < dataLen; j++) {
+                        pArr[offset + j] = 0;
+                    }
+                    break;
+                default:
+                    if ((i + dataLen) > pSource.length) {
+                        throw RuntimeException.READ_OOB();
+                    }
+                    Struct._PackSeries(bigEndian, Struct.OP[opType], dataLen, sz, pArr, offset, pSource, i);
+                    i += dataLen;
+                    break;
+            }
+            offset += dataLen * sz;
+        }
+        return pArr;
+    }
+    ;
+    static pack(pFmt, pBinaryData) {
+        return Struct.packTo(pFmt, new Buffer(this.calcLength(pFmt, pBinaryData)), 0, pBinaryData);
+    }
+    static calcLength(pFmt, pValues) {
+        const re = new RegExp(Struct.FORMAT, 'g');
+        let m, n, sum = 0, i = 0;
+        while (m = re.exec(pFmt)) {
+            if ((m[1] == undefined) || (m[1] == '')) {
+                n = Struct.OP[m[2]].opts.size;
+            }
+            else {
+                n = parseInt(m[1]) * Struct.OP[m[2]].opts.size;
+            }
+            if (m[2] === NOT_NULL_TERM_STRING) {
+                n = pValues[i].length + 1;
+            }
+            sum += n;
+            if (m[2] !== Struct.PADDING_TOK) {
+                i++;
+            }
+        }
+        return sum;
+    }
+    ;
+}
+Struct.NATIVE_ENDIANNESS = Endianness.LITTLE_ENDIAN;
+Struct.PADDING_TOK = 'x';
+Struct.BE_FLAG = '<';
+Struct.OP = {};
+Struct.FORMAT = '(\\d+)?([AxcbBhHsSfdiIlLqQ])(\\(([a-zA-Z0-9]+)\\))?';
+Struct._lenLut = { 'A': 1, 'x': 1, 'c': 1, 'b': 1, 'B': 1, 'h': 2, 'H': 2, 's': 1,
+    'S': 1, 'f': 4, 'd': 8, 'i': 4, 'I': 4, 'l': 4, 'L': 4, 'q': 8, 'Q': 8 };

package/dist/src/StructDecoder.d.ts

@@ -0,0 +1,11 @@
+import { Endianness } from "./common.js";
+import { Operation } from "./Struct.js";
+export declare class StructDecoder {
+    static byteArray(pArr: any[], pOffset: number, pLength: number): any[];
+    static chr(pArr: number[], pOffset: number): string;
+    static int(pEndianness: Endianness, pOp: Operation, pArr: any, pOffset: number): number;
+    static bigintDecoder(pEndianness: Endianness, pOp: Operation, pArr: any, pOffset: number): bigint;
+    static str(pArr: number[], pOffset: number, pLen: number): string;
+    static nullTerminatedStr(pArr: number[], pOffset: number, pLen: number): string;
+    static ieee754_fp(pEndianness: Endianness, pOp: Operation, pArr: any[], pOffset: number): number;
+}

package/dist/src/StructDecoder.js

@@ -0,0 +1,90 @@
+import { Endianness } from "./common.js";
+export class StructDecoder {
+    static byteArray(pArr, pOffset, pLength) {
+        return [pArr.slice(pOffset, pOffset + pLength)];
+    }
+    static chr(pArr, pOffset) {
+        return String.fromCharCode(pArr[pOffset]);
+    }
+    static int(pEndianness, pOp, pArr, pOffset) {
+        let lsb, nsb;
+        if (pEndianness == Endianness.BIG_ENDIAN) {
+            lsb = pOp.opts.size - 1;
+            nsb = -1;
+        }
+        else {
+            lsb = 0;
+            nsb = 1;
+        }
+        let stop = lsb + nsb * pOp.opts.size, rv, i, f;
+        for (rv = 0, i = lsb, f = 1; i != stop; rv += (pArr[pOffset + i] * f), i += nsb, f *= 256)
+            ;
+        if (pOp.opts.bSigned && (rv & Math.pow(2, pOp.opts.size * 8 - 1))) {
+            rv -= Math.pow(2, pOp.opts.size * 8);
+        }
+        return rv;
+    }
+    ;
+    static bigintDecoder(pEndianness, pOp, pArr, pOffset) {
+        let lsb, nsb;
+        if (pEndianness == Endianness.BIG_ENDIAN) {
+            lsb = pOp.opts.size - 1;
+            nsb = -1;
+        }
+        else {
+            lsb = 0;
+            nsb = 1;
+        }
+        let stop = lsb + nsb * pOp.opts.size;
+        let i;
+        let rv = BigInt(0);
+        let f = BigInt(1);
+        for (i = lsb; i != stop; i += nsb) {
+            rv += BigInt(pArr[pOffset + i]) * f;
+            f *= BigInt(256);
+        }
+        if (pOp.opts.bSigned && (rv >> BigInt(pOp.opts.size * 8 - 1)) == BigInt(1)) {
+            rv -= BigInt(1) << BigInt(pOp.opts.size * 8);
+        }
+        return rv;
+    }
+    ;
+    static str(pArr, pOffset, pLen) {
+        let s = new Array(pLen);
+        for (let i = 0; i < pLen; s[i] = String.fromCharCode(pArr[pOffset + i]), i++)
+            ;
+        return s.join('');
+    }
+    ;
+    static nullTerminatedStr(pArr, pOffset, pLen) {
+        let str = StructDecoder.str(pArr, pOffset, pLen);
+        return str.substring(0, str.length - 1);
+    }
+    ;
+    static ieee754_fp(pEndianness, pOp, pArr, pOffset) {
+        let s, e, m, i, d, nBits, mLen, eLen, eBias, eMax;
+        mLen = pOp.opts.mLen, eLen = pOp.opts.size * 8 - pOp.opts.mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1;
+        i = (pEndianness == Endianness.BIG_ENDIAN) ? 0 : (pOp.opts.size - 1);
+        d = (pEndianness == Endianness.BIG_ENDIAN) ? 1 : -1;
+        s = pArr[pOffset + i];
+        i += d;
+        nBits = -7;
+        for (e = s & ((1 << (-nBits)) - 1), s >>= (-nBits), nBits += eLen; nBits > 0; e = e * 256 + pArr[pOffset + i], i += d, nBits -= 8)
+            ;
+        for (m = e & ((1 << (-nBits)) - 1), e >>= (-nBits), nBits += mLen; nBits > 0; m = m * 256 + pArr[pOffset + i], i += d, nBits -= 8)
+            ;
+        switch (e) {
+            case 0:
+                e = 1 - eBias;
+                break;
+            case eMax:
+                return m ? NaN : ((s ? -1 : 1) * Infinity);
+            default:
+                m = m + Math.pow(2, mLen);
+                e = e - eBias;
+                break;
+        }
+        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    }
+    ;
+}

package/dist/src/StructEncoder.d.ts

@@ -0,0 +1,10 @@
+import { Endianness } from "./common.js";
+import { Operation } from "./Struct.js";
+export declare class StructEncoder {
+    static byteArray(pDestArr: number[], pOffset: number, pLen: number, pSourceArr: number[]): void;
+    static chr(pDestArr: number[], pOffset: number, pChar: string): void;
+    static str(pDestArr: number[], pOffset: number, pLen: number, pSourceStr: string): void;
+    static int(pEndianness: Endianness, pOp: Operation, pArr: any[], pOffset: number, v: number): void;
+    static bigintEncoder(pEndianness: Endianness, pOp: Operation, pArr: any[], pOffset: number, v: bigint): void;
+    static ieee754_fp(pEndianness: Endianness, pOp: Operation, pDestArr: any[], pOffset: number, pValue: number): void;
+}

package/dist/src/StructEncoder.js

@@ -0,0 +1,92 @@
+import { Endianness } from "./common.js";
+export class StructEncoder {
+    static byteArray(pDestArr, pOffset, pLen, pSourceArr) {
+        for (let i = 0; i < pLen; pDestArr[pOffset + i] = pSourceArr[i] ? pSourceArr[i] : 0, i++)
+            ;
+    }
+    static chr(pDestArr, pOffset, pChar) {
+        pDestArr[pOffset] = pChar.charCodeAt(0);
+    }
+    ;
+    static str(pDestArr, pOffset, pLen, pSourceStr) {
+        for (let t, i = 0; i < pLen; pDestArr[pOffset + i] = (t = pSourceStr.charCodeAt(i)) ? t : 0, i++)
+            ;
+    }
+    ;
+    static int(pEndianness, pOp, pArr, pOffset, v) {
+        let lsb, nsb;
+        if (pEndianness == Endianness.BIG_ENDIAN) {
+            lsb = pOp.opts.size - 1;
+            nsb = -1;
+        }
+        else {
+            lsb = 0;
+            nsb = 1;
+        }
+        let stop = lsb + nsb * pOp.opts.size, i;
+        v = (v < pOp.opts.min) ? pOp.opts.min : (v > pOp.opts.max) ? pOp.opts.max : v;
+        for (i = lsb; i != stop; pArr[pOffset + i] = v & 0xff, i += nsb, v >>= 8)
+            ;
+    }
+    ;
+    static bigintEncoder(pEndianness, pOp, pArr, pOffset, v) {
+        let lsb, nsb;
+        if (pEndianness == Endianness.BIG_ENDIAN) {
+            lsb = pOp.opts.size - 1;
+            nsb = -1;
+        }
+        else {
+            lsb = 0;
+            nsb = 1;
+        }
+        let stop = lsb + nsb * pOp.opts.size, i;
+        v = BigInt((v < pOp.opts.min) ? pOp.opts.min : (v > pOp.opts.max) ? pOp.opts.max : v);
+        for (i = lsb; i != stop; pArr[pOffset + i] = v & BigInt(0xff), i += nsb, v >>= BigInt(8))
+            ;
+    }
+    static ieee754_fp(pEndianness, pOp, pDestArr, pOffset, pValue) {
+        let s, e, m, i, d, c, mLen, eLen, eBias, eMax, abs;
+        mLen = pOp.opts.mLen, eLen = pOp.opts.size * 8 - pOp.opts.mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1;
+        s = pValue < 0 ? 1 : 0;
+        abs = Math.abs(pValue);
+        if (isNaN(abs) || (abs == Infinity)) {
+            m = isNaN(abs) ? 1 : 0;
+            e = eMax;
+        }
+        else {
+            e = Math.floor(Math.log(abs) / Math.LN2);
+            if (abs * (c = Math.pow(2, -e)) < 1) {
+                e--;
+                c *= 2;
+            }
+            if (e + eBias >= 1) {
+                abs += pOp.opts.rt / c;
+            }
+            else {
+                abs += pOp.opts.rt * Math.pow(2, 1 - eBias);
+            }
+            if (abs * c >= 2) {
+                e++;
+                c /= 2;
+            }
+            if (e + eBias >= eMax) {
+                m = 0;
+                e = eMax;
+            }
+            else if (e + eBias >= 1) {
+                m = (abs * c - 1) * Math.pow(2, mLen);
+                e = e + eBias;
+            }
+            else {
+                m = abs * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+                e = 0;
+            }
+        }
+        for (i = (pEndianness == Endianness.BIG_ENDIAN) ? (pOp.opts.size - 1) : 0, d = (pEndianness == Endianness.BIG_ENDIAN) ? -1 : 1; mLen >= 8; pDestArr[pOffset + i] = m & 0xff, i += d, m /= 256, mLen -= 8)
+            ;
+        for (e = (e << mLen) | m, eLen += mLen; eLen > 0; pDestArr[pOffset + i] = e & 0xff, i += d, e /= 256, eLen -= 8)
+            ;
+        pDestArr[pOffset + i - d] |= s * 128;
+    }
+    ;
+}

package/dist/src/common.d.ts

@@ -0,0 +1,4 @@
+export declare enum Endianness {
+    LITTLE_ENDIAN = 0,
+    BIG_ENDIAN = 1
+}

package/dist/src/common.js

@@ -0,0 +1,5 @@
+export var Endianness;
+(function (Endianness) {
+    Endianness[Endianness["LITTLE_ENDIAN"] = 0] = "LITTLE_ENDIAN";
+    Endianness[Endianness["BIG_ENDIAN"] = 1] = "BIG_ENDIAN";
+})(Endianness || (Endianness = {}));

package/dist/src/error/MonitoredError.d.ts

@@ -0,0 +1,14 @@
+export declare class MonitoredError extends Error {
+    static ERR_CODE_BASE: number;
+    static NEW_HOOK: ((pErr: MonitoredError | null) => void);
+    cmp: string;
+    code: number;
+    extra: any;
+    constructor(pCmp: string, pMsg: string, pCode?: number, pExtra?: any);
+    getCode(): number;
+    getMessage(): string;
+    getExtra(): any;
+    toString(): string;
+    protected _triggerNewHook(): void;
+    toObject(pIncludeExtra?: boolean): any;
+}

package/dist/src/error/MonitoredError.js

@@ -0,0 +1,33 @@
+export class MonitoredError extends Error {
+    constructor(pCmp, pMsg, pCode = -1, pExtra = null) {
+        super(pMsg);
+        this.cmp = pCmp;
+        this.code = pCode;
+        this.extra = pExtra;
+    }
+    getCode() {
+        return this.code;
+    }
+    getMessage() {
+        return `[${this.cmp}][#${this.code}] ${this.message} `;
+    }
+    getExtra() {
+        return this.extra;
+    }
+    toString() {
+        return `[${this.cmp}] [#${this.code != null ? this.code : "<null>"} ${this.message}`;
+    }
+    _triggerNewHook() {
+        MonitoredError.NEW_HOOK.apply(null, [this]);
+    }
+    toObject(pIncludeExtra = false) {
+        return {
+            cmp: this.cmp,
+            code: this.code,
+            msg: this.message,
+            extra: pIncludeExtra ? this.extra : null
+        };
+    }
+}
+MonitoredError.ERR_CODE_BASE = 1000;
+MonitoredError.NEW_HOOK = (() => { });

package/dist/src/error/RuntimeException.d.ts

@@ -0,0 +1,7 @@
+import { MonitoredError } from "./MonitoredError.js";
+export declare class RuntimeException extends MonitoredError {
+    static WRITE_OOB: () => RuntimeException;
+    static READ_OOB: () => RuntimeException;
+    static UNKNOWN_FORMAT: (pToken: string) => RuntimeException;
+    constructor(pMsg: string, pCode?: number, pExtra?: any);
+}

package/dist/src/error/RuntimeException.js

@@ -0,0 +1,15 @@
+import { MonitoredError } from "./MonitoredError.js";
+export class RuntimeException extends MonitoredError {
+    constructor(pMsg, pCode = null, pExtra = null) {
+        super('DXC-STRUCT', pMsg, pCode, pExtra);
+    }
+}
+RuntimeException.WRITE_OOB = () => {
+    return new RuntimeException("Write Out-of-Bound", MonitoredError.ERR_CODE_BASE + 1);
+};
+RuntimeException.READ_OOB = () => {
+    return new RuntimeException("Read Out-of-Bound", MonitoredError.ERR_CODE_BASE + 2);
+};
+RuntimeException.UNKNOWN_FORMAT = (pToken) => {
+    return new RuntimeException("Format is invalid. Following token is not recognized [token=" + pToken + "]", MonitoredError.ERR_CODE_BASE + 3);
+};