@netkitty/codec 1.0.0

package/dist/helper/IPToBuffer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert IPv4 string to Buffer
+ * @param ipv4
+ * @constructor
+ */
+export declare function IPv4ToBuffer(ipv4: string): Buffer;
+/**
+ * Convert IPv6 string to Buffer
+ * @param ipv6
+ * @constructor
+ */
+export declare function IPv6ToBuffer(ipv6: string): Buffer;

package/dist/helper/IPToBuffer.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPv4ToBuffer = IPv4ToBuffer;
+exports.IPv6ToBuffer = IPv6ToBuffer;
+const ip_address_1 = require("ip-address");
+const NumberToBuffer_1 = require("./NumberToBuffer");
+/**
+ * Convert IPv4 string to Buffer
+ * @param ipv4
+ * @constructor
+ */
+function IPv4ToBuffer(ipv4) {
+    const numArr = ipv4.split('.').map((value) => parseInt(value)).map((value) => value ? value : 0);
+    return (0, NumberToBuffer_1.UInt32ToBuffer)(parseInt(Buffer.from(numArr).toString('hex'), 16));
+}
+/**
+ * Convert IPv6 string to Buffer
+ * @param ipv6
+ * @constructor
+ */
+function IPv6ToBuffer(ipv6) {
+    try {
+        const bytes = new ip_address_1.Address6(ipv6).toByteArray();
+        const buffer = Buffer.alloc(16, 0);
+        //ip-address toByteArray() returns the shortest byte array, so compressed
+        //addresses (::1, ::ffff:...) yield fewer than 16 bytes. Right-align them so
+        //the low-order octets land at the end of the 16-byte field.
+        Buffer.from(bytes).copy(buffer, 16 - bytes.length);
+        return buffer;
+    }
+    catch (e) {
+        return Buffer.alloc(16, 0);
+    }
+}

package/dist/helper/NumberToBERBuffer.d.ts

@@ -0,0 +1,18 @@
+/** Encode a signed 8-bit integer as a minimal-length BER INTEGER content buffer. */
+export declare const Int8ToBERBuffer: (value: number) => Buffer;
+/** Encode a signed 16-bit integer as a minimal-length BER INTEGER content buffer. */
+export declare const Int16ToBERBuffer: (value: number) => Buffer;
+/** Encode a signed 32-bit integer as a minimal-length BER INTEGER content buffer. */
+export declare const Int32ToBERBuffer: (value: number) => Buffer;
+/** Encode a signed 64-bit bigint as a minimal-length BER INTEGER content buffer. */
+export declare const Int64ToBERBuffer: (value: bigint) => Buffer;
+/** Encode an unsigned 8-bit integer as a BER INTEGER content buffer (00-padded to stay positive). */
+export declare const UInt8ToBERBuffer: (value: number) => Buffer;
+/** Encode an unsigned 16-bit integer as a BER INTEGER content buffer (00-padded to stay positive). */
+export declare const UInt16ToBERBuffer: (value: number) => Buffer;
+/** Encode an unsigned 32-bit integer as a BER INTEGER content buffer (00-padded to stay positive). */
+export declare const UInt32ToBERBuffer: (value: number) => Buffer;
+/** Encode an unsigned 64-bit bigint as a BER INTEGER content buffer (00-padded to stay positive). */
+export declare const UInt64ToBERBuffer: (value: bigint) => Buffer;
+/** Encode a 32-bit float as an IEC 61850 FLOATING-POINT content buffer (leading 08 exponent-width byte + IEEE-754 bytes). */
+export declare const Float32ToBERBuffer: (value: number) => Buffer;

package/dist/helper/NumberToBERBuffer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float32ToBERBuffer = exports.UInt64ToBERBuffer = exports.UInt32ToBERBuffer = exports.UInt16ToBERBuffer = exports.UInt8ToBERBuffer = exports.Int64ToBERBuffer = exports.Int32ToBERBuffer = exports.Int16ToBERBuffer = exports.Int8ToBERBuffer = void 0;
+const NumberToBERHex_1 = require("./NumberToBERHex");
+/** Encode a signed 8-bit integer as a minimal-length BER INTEGER content buffer. */
+const Int8ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.Int8ToBERHex)(value), 'hex');
+exports.Int8ToBERBuffer = Int8ToBERBuffer;
+/** Encode a signed 16-bit integer as a minimal-length BER INTEGER content buffer. */
+const Int16ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.Int16ToBERHex)(value), 'hex');
+exports.Int16ToBERBuffer = Int16ToBERBuffer;
+/** Encode a signed 32-bit integer as a minimal-length BER INTEGER content buffer. */
+const Int32ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.Int32ToBERHex)(value), 'hex');
+exports.Int32ToBERBuffer = Int32ToBERBuffer;
+/** Encode a signed 64-bit bigint as a minimal-length BER INTEGER content buffer. */
+const Int64ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.Int64ToBERHex)(value), 'hex');
+exports.Int64ToBERBuffer = Int64ToBERBuffer;
+/** Encode an unsigned 8-bit integer as a BER INTEGER content buffer (00-padded to stay positive). */
+const UInt8ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.UInt8ToBERHex)(value), 'hex');
+exports.UInt8ToBERBuffer = UInt8ToBERBuffer;
+/** Encode an unsigned 16-bit integer as a BER INTEGER content buffer (00-padded to stay positive). */
+const UInt16ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.UInt16ToBERHex)(value), 'hex');
+exports.UInt16ToBERBuffer = UInt16ToBERBuffer;
+/** Encode an unsigned 32-bit integer as a BER INTEGER content buffer (00-padded to stay positive). */
+const UInt32ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.UInt32ToBERHex)(value), 'hex');
+exports.UInt32ToBERBuffer = UInt32ToBERBuffer;
+/** Encode an unsigned 64-bit bigint as a BER INTEGER content buffer (00-padded to stay positive). */
+const UInt64ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.UInt64ToBERHex)(value), 'hex');
+exports.UInt64ToBERBuffer = UInt64ToBERBuffer;
+/** Encode a 32-bit float as an IEC 61850 FLOATING-POINT content buffer (leading 08 exponent-width byte + IEEE-754 bytes). */
+const Float32ToBERBuffer = (value) => Buffer.from((0, NumberToBERHex_1.Float32ToBERHex)(value), 'hex');
+exports.Float32ToBERBuffer = Float32ToBERBuffer;

package/dist/helper/NumberToBERHex.d.ts

@@ -0,0 +1,18 @@
+/** Encode a signed 8-bit integer as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+export declare const Int8ToBERHex: (value: number) => string;
+/** Encode a signed 16-bit integer as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+export declare const Int16ToBERHex: (value: number) => string;
+/** Encode a signed 32-bit integer as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+export declare const Int32ToBERHex: (value: number) => string;
+/** Encode a signed 64-bit bigint as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+export declare const Int64ToBERHex: (value: bigint) => string;
+/** Encode an unsigned 8-bit integer as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+export declare const UInt8ToBERHex: (value: number) => string;
+/** Encode an unsigned 16-bit integer as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+export declare const UInt16ToBERHex: (value: number) => string;
+/** Encode an unsigned 32-bit integer as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+export declare const UInt32ToBERHex: (value: number) => string;
+/** Encode an unsigned 64-bit bigint as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+export declare const UInt64ToBERHex: (value: bigint) => string;
+/** Encode a 32-bit float as an IEC 61850 FLOATING-POINT content hex string (a leading 08 exponent-width byte followed by the big-endian IEEE-754 bytes). */
+export declare const Float32ToBERHex: (value: number) => string;

package/dist/helper/NumberToBERHex.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float32ToBERHex = exports.UInt64ToBERHex = exports.UInt32ToBERHex = exports.UInt16ToBERHex = exports.UInt8ToBERHex = exports.Int64ToBERHex = exports.Int32ToBERHex = exports.Int16ToBERHex = exports.Int8ToBERHex = void 0;
+const NumberToHex_1 = require("./NumberToHex");
+function toBERHex(rawHex) {
+    const hex = rawHex.padStart(rawHex.length + rawHex.length % 2, '0');
+    return Buffer.from(hex, 'hex')[0].toString(2).padStart(8, '0').startsWith('1') ? `00${hex}` : hex;
+}
+function toSignedBERHex(value) {
+    const v = BigInt(value);
+    if (v >= 0n) {
+        let hex = v.toString(16);
+        if (hex.length % 2)
+            hex = `0${hex}`;
+        if (parseInt(hex.slice(0, 2), 16) >= 0x80)
+            hex = `00${hex}`;
+        return hex;
+    }
+    let bytes = 1;
+    while (v < -(1n << (BigInt(bytes) * 8n - 1n)))
+        bytes++;
+    const mask = (1n << (BigInt(bytes) * 8n)) - 1n;
+    return (v & mask).toString(16).padStart(bytes * 2, '0');
+}
+/** Encode a signed 8-bit integer as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+const Int8ToBERHex = (value) => toSignedBERHex(value);
+exports.Int8ToBERHex = Int8ToBERHex;
+/** Encode a signed 16-bit integer as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+const Int16ToBERHex = (value) => toSignedBERHex(value);
+exports.Int16ToBERHex = Int16ToBERHex;
+/** Encode a signed 32-bit integer as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+const Int32ToBERHex = (value) => toSignedBERHex(value);
+exports.Int32ToBERHex = Int32ToBERHex;
+/** Encode a signed 64-bit bigint as a minimal-length BER INTEGER content hex string (two's complement, leading sign byte as needed). */
+const Int64ToBERHex = (value) => toSignedBERHex(value);
+exports.Int64ToBERHex = Int64ToBERHex;
+/** Encode an unsigned 8-bit integer as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+const UInt8ToBERHex = (value) => toBERHex(value.toString(16));
+exports.UInt8ToBERHex = UInt8ToBERHex;
+/** Encode an unsigned 16-bit integer as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+const UInt16ToBERHex = (value) => toBERHex(value.toString(16));
+exports.UInt16ToBERHex = UInt16ToBERHex;
+/** Encode an unsigned 32-bit integer as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+const UInt32ToBERHex = (value) => toBERHex(value.toString(16));
+exports.UInt32ToBERHex = UInt32ToBERHex;
+/** Encode an unsigned 64-bit bigint as a BER INTEGER content hex string (prepends a 00 byte when the high bit is set to keep it positive). */
+const UInt64ToBERHex = (value) => toBERHex(BigInt(value).toString(16));
+exports.UInt64ToBERHex = UInt64ToBERHex;
+//Float32 precision is always 8, therefore add '08' prefix for Float32ToHex result
+/** Encode a 32-bit float as an IEC 61850 FLOATING-POINT content hex string (a leading 08 exponent-width byte followed by the big-endian IEEE-754 bytes). */
+const Float32ToBERHex = (value) => `08${(0, NumberToHex_1.Float32ToHex)(value)}`;
+exports.Float32ToBERHex = Float32ToBERHex;

package/dist/helper/NumberToBuffer.d.ts

@@ -0,0 +1,18 @@
+/** Write a signed 8-bit integer to a 1-byte buffer (value masked to the field width). */
+export declare const Int8ToBuffer: (value: number) => Buffer;
+/** Write a signed 16-bit integer to a big-endian 2-byte buffer (value masked to the field width). */
+export declare const Int16ToBuffer: (value: number) => Buffer;
+/** Write a signed 32-bit integer to a big-endian 4-byte buffer (value masked to the field width). */
+export declare const Int32ToBuffer: (value: number) => Buffer;
+/** Write a signed 64-bit bigint to a big-endian 8-byte buffer. */
+export declare const Int64ToBuffer: (value: bigint) => Buffer;
+/** Write an unsigned 8-bit integer to a 1-byte buffer (value masked to the field width). */
+export declare const UInt8ToBuffer: (value: number) => Buffer;
+/** Write an unsigned 16-bit integer to a big-endian 2-byte buffer (value masked to the field width). */
+export declare const UInt16ToBuffer: (value: number) => Buffer;
+/** Write an unsigned 32-bit integer to a big-endian 4-byte buffer (value masked to the field width). */
+export declare const UInt32ToBuffer: (value: number) => Buffer;
+/** Write an unsigned 64-bit bigint to a big-endian 8-byte buffer. */
+export declare const UInt64ToBuffer: (value: bigint) => Buffer;
+/** Write an IEEE-754 32-bit float to a big-endian 4-byte buffer. */
+export declare const Float32ToBuffer: (value: number) => Buffer;

package/dist/helper/NumberToBuffer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float32ToBuffer = exports.UInt64ToBuffer = exports.UInt32ToBuffer = exports.UInt16ToBuffer = exports.UInt8ToBuffer = exports.Int64ToBuffer = exports.Int32ToBuffer = exports.Int16ToBuffer = exports.Int8ToBuffer = void 0;
+const NumberToHex_1 = require("./NumberToHex");
+//8/16/32-bit writes use native Buffer accessors instead of number→hex-string→Buffer. Int and UInt
+//emit identical bytes (the field's low bytes, big-endian), so both go through the unsigned writer
+//after masking to the field width — matching the old hex path, whose TypedArray view also wrote the
+//value's low bytes. In-range values (the only ones encode produces, after Ajv coercion + field clamp)
+//are byte-for-byte identical, which the round-trip fixtures enforce. Out-of-range values wrap to the
+//field width here (a cleaner, well-defined result than the old odd-length-hex nibble truncation).
+//64-bit and float keep their existing implementations.
+/** Write a signed 8-bit integer to a 1-byte buffer (value masked to the field width). */
+const Int8ToBuffer = (value) => { const buffer = Buffer.allocUnsafe(1); buffer.writeUInt8(value & 0xff, 0); return buffer; };
+exports.Int8ToBuffer = Int8ToBuffer;
+/** Write a signed 16-bit integer to a big-endian 2-byte buffer (value masked to the field width). */
+const Int16ToBuffer = (value) => { const buffer = Buffer.allocUnsafe(2); buffer.writeUInt16BE(value & 0xffff, 0); return buffer; };
+exports.Int16ToBuffer = Int16ToBuffer;
+/** Write a signed 32-bit integer to a big-endian 4-byte buffer (value masked to the field width). */
+const Int32ToBuffer = (value) => { const buffer = Buffer.allocUnsafe(4); buffer.writeUInt32BE(value >>> 0, 0); return buffer; };
+exports.Int32ToBuffer = Int32ToBuffer;
+/** Write a signed 64-bit bigint to a big-endian 8-byte buffer. */
+const Int64ToBuffer = (value) => Buffer.from((0, NumberToHex_1.Int64ToHex)(value), 'hex');
+exports.Int64ToBuffer = Int64ToBuffer;
+/** Write an unsigned 8-bit integer to a 1-byte buffer (value masked to the field width). */
+const UInt8ToBuffer = (value) => { const buffer = Buffer.allocUnsafe(1); buffer.writeUInt8(value & 0xff, 0); return buffer; };
+exports.UInt8ToBuffer = UInt8ToBuffer;
+/** Write an unsigned 16-bit integer to a big-endian 2-byte buffer (value masked to the field width). */
+const UInt16ToBuffer = (value) => { const buffer = Buffer.allocUnsafe(2); buffer.writeUInt16BE(value & 0xffff, 0); return buffer; };
+exports.UInt16ToBuffer = UInt16ToBuffer;
+/** Write an unsigned 32-bit integer to a big-endian 4-byte buffer (value masked to the field width). */
+const UInt32ToBuffer = (value) => { const buffer = Buffer.allocUnsafe(4); buffer.writeUInt32BE(value >>> 0, 0); return buffer; };
+exports.UInt32ToBuffer = UInt32ToBuffer;
+/** Write an unsigned 64-bit bigint to a big-endian 8-byte buffer. */
+const UInt64ToBuffer = (value) => Buffer.from((0, NumberToHex_1.UInt64ToHex)(value), 'hex');
+exports.UInt64ToBuffer = UInt64ToBuffer;
+/** Write an IEEE-754 32-bit float to a big-endian 4-byte buffer. */
+const Float32ToBuffer = (value) => Buffer.from((0, NumberToHex_1.Float32ToHex)(value), 'hex');
+exports.Float32ToBuffer = Float32ToBuffer;

package/dist/helper/NumberToHex.d.ts

@@ -0,0 +1,18 @@
+/** Convert a signed 8-bit integer to a 2-char two's-complement hex string. */
+export declare const Int8ToHex: (value: number) => string;
+/** Convert a signed 16-bit integer to a 4-char big-endian two's-complement hex string. */
+export declare const Int16ToHex: (value: number) => string;
+/** Convert a signed 32-bit integer to an 8-char big-endian two's-complement hex string. */
+export declare const Int32ToHex: (value: number) => string;
+/** Convert a signed 64-bit bigint to a 16-char big-endian hex string. */
+export declare const Int64ToHex: (value: bigint) => string;
+/** Convert an unsigned 8-bit integer to a 2-char hex string. */
+export declare const UInt8ToHex: (value: number) => string;
+/** Convert an unsigned 16-bit integer to a 4-char big-endian hex string. */
+export declare const UInt16ToHex: (value: number) => string;
+/** Convert an unsigned 32-bit integer to an 8-char big-endian hex string. */
+export declare const UInt32ToHex: (value: number) => string;
+/** Convert an unsigned 64-bit bigint to a 16-char big-endian hex string. */
+export declare const UInt64ToHex: (value: bigint) => string;
+/** Convert an IEEE-754 32-bit float to an 8-char big-endian hex string. */
+export declare const Float32ToHex: (value: number) => string;

package/dist/helper/NumberToHex.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float32ToHex = exports.UInt64ToHex = exports.UInt32ToHex = exports.UInt16ToHex = exports.UInt8ToHex = exports.Int64ToHex = exports.Int32ToHex = exports.Int16ToHex = exports.Int8ToHex = void 0;
+/** Convert a signed 8-bit integer to a 2-char two's-complement hex string. */
+const Int8ToHex = (value) => new Uint8Array(Int8Array.from([value]).buffer)[0].toString(16).padStart(2, '0');
+exports.Int8ToHex = Int8ToHex;
+/** Convert a signed 16-bit integer to a 4-char big-endian two's-complement hex string. */
+const Int16ToHex = (value) => new Uint16Array(Int16Array.from([value]).buffer)[0].toString(16).padStart(4, '0');
+exports.Int16ToHex = Int16ToHex;
+/** Convert a signed 32-bit integer to an 8-char big-endian two's-complement hex string. */
+const Int32ToHex = (value) => new Uint32Array(Int32Array.from([value]).buffer)[0].toString(16).padStart(8, '0');
+exports.Int32ToHex = Int32ToHex;
+/** Convert a signed 64-bit bigint to a 16-char big-endian hex string. */
+const Int64ToHex = (value) => BigInt(value).toString(16).padStart(16, '0');
+exports.Int64ToHex = Int64ToHex;
+/** Convert an unsigned 8-bit integer to a 2-char hex string. */
+const UInt8ToHex = (value) => value.toString(16).padStart(2, '0');
+exports.UInt8ToHex = UInt8ToHex;
+/** Convert an unsigned 16-bit integer to a 4-char big-endian hex string. */
+const UInt16ToHex = (value) => value.toString(16).padStart(4, '0');
+exports.UInt16ToHex = UInt16ToHex;
+/** Convert an unsigned 32-bit integer to an 8-char big-endian hex string. */
+const UInt32ToHex = (value) => value.toString(16).padStart(8, '0');
+exports.UInt32ToHex = UInt32ToHex;
+/** Convert an unsigned 64-bit bigint to a 16-char big-endian hex string. */
+const UInt64ToHex = (value) => BigInt(value).toString(16).padStart(16, '0');
+exports.UInt64ToHex = UInt64ToHex;
+/** Convert an IEEE-754 32-bit float to an 8-char big-endian hex string. */
+const Float32ToHex = (value) => {
+    const buffer = new ArrayBuffer(4);
+    const dataView = new DataView(buffer);
+    dataView.setFloat32(0, value, false);
+    return dataView.getUint32(0, false).toString(16).padStart(8, '0');
+};
+exports.Float32ToHex = Float32ToHex;

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Base header abstract class
+ */
+export { BaseHeader } from './abstracts/BaseHeader';
+/**
+ * Network packet codec
+ */
+export { Codec } from './Codec';
+/**
+ * Flexible Object for codec data instance
+ */
+export { FlexibleObject } from './lib/FlexibleObject';
+/**
+ * Types
+ */
+export { type CodecEncodeResult } from './types/CodecEncodeResult';
+export { type CodecEncodeInput } from './types/CodecEncodeInput';
+export { type CodecDecodeResult } from './types/CodecDecodeResult';
+export { type CodecSchema } from './types/CodecSchema';
+export { type HeaderTreeNode } from './types/HeaderTreeNode';
+export { type CodecModuleConstructor } from './types/CodecModuleConstructor';
+export { type CodecModule } from './types/CodecModule';
+export { type CodecErrorInfo } from './types/CodecErrorInfo';
+export { type NextLayer, type ConsistencyIssue } from './types/LayerGraph';
+export { type DissectionField, type DissectionLayer } from './types/Dissection';
+/**
+ * Schemas
+ */
+export { type ProtocolFieldJSONSchema } from './schema/ProtocolFieldJSONSchema';
+export { type ProtocolFieldJSONSchemaDefinition } from './schema/ProtocolFieldJSONSchemaDefinition';
+export { type ProtocolJSONSchema } from './schema/ProtocolJSONSchema';
+/**
+ * Enums
+ */
+export { StringContentEncodingEnum } from './lib/StringContentEncodingEnum';
+/**
+ * Protocol header classes (Ethernet, IPv4/6, TCP/UDP, ARP, TLS, GOOSE, SV, IEC104, ...)
+ */
+export * from './PacketHeaders';
+/**
+ * Helper conversion functions
+ */
+export { BufferToHex } from './helper/BufferToHex';
+export { HexToBuffer } from './helper/HexToBuffer';
+export { BufferToIPv4, BufferToIPv6 } from './helper/BufferToIP';
+export { IPv4ToBuffer, IPv6ToBuffer } from './helper/IPToBuffer';
+export { BufferToFloat32, BufferToInt16, BufferToInt32, BufferToInt64, BufferToInt8, BufferToUInt16, BufferToUInt32, BufferToUInt64, BufferToUInt8 } from './helper/BufferToNumber';
+export { HexToFloat32, HexToInt16, HexToInt32, HexToInt64, HexToInt8, HexToUInt16, HexToUInt32, HexToUInt64, HexToUInt8 } from './helper/HexToNumber';
+export { Int16ToBERBuffer, Int32ToBERBuffer, Int64ToBERBuffer, Int8ToBERBuffer, UInt16ToBERBuffer, UInt32ToBERBuffer, UInt64ToBERBuffer, UInt8ToBERBuffer } from './helper/NumberToBERBuffer';
+export { Int16ToBERHex, Int32ToBERHex, Int64ToBERHex, Int8ToBERHex, UInt16ToBERHex, UInt32ToBERHex, UInt64ToBERHex, UInt8ToBERHex } from './helper/NumberToBERHex';
+export { Float32ToBuffer, Int16ToBuffer, Int32ToBuffer, Int64ToBuffer, Int8ToBuffer, UInt16ToBuffer, UInt32ToBuffer, UInt64ToBuffer, UInt8ToBuffer } from './helper/NumberToBuffer';
+export { Float32ToHex, Int16ToHex, Int32ToHex, Int64ToHex, Int8ToHex, UInt16ToHex, UInt32ToHex, UInt64ToHex, UInt8ToHex } from './helper/NumberToHex';

package/dist/index.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UInt16ToBuffer = exports.Int8ToBuffer = exports.Int64ToBuffer = exports.Int32ToBuffer = exports.Int16ToBuffer = exports.Float32ToBuffer = exports.UInt8ToBERHex = exports.UInt64ToBERHex = exports.UInt32ToBERHex = exports.UInt16ToBERHex = exports.Int8ToBERHex = exports.Int64ToBERHex = exports.Int32ToBERHex = exports.Int16ToBERHex = exports.UInt8ToBERBuffer = exports.UInt64ToBERBuffer = exports.UInt32ToBERBuffer = exports.UInt16ToBERBuffer = exports.Int8ToBERBuffer = exports.Int64ToBERBuffer = exports.Int32ToBERBuffer = exports.Int16ToBERBuffer = exports.HexToUInt8 = exports.HexToUInt64 = exports.HexToUInt32 = exports.HexToUInt16 = exports.HexToInt8 = exports.HexToInt64 = exports.HexToInt32 = exports.HexToInt16 = exports.HexToFloat32 = exports.BufferToUInt8 = exports.BufferToUInt64 = exports.BufferToUInt32 = exports.BufferToUInt16 = exports.BufferToInt8 = exports.BufferToInt64 = exports.BufferToInt32 = exports.BufferToInt16 = exports.BufferToFloat32 = exports.IPv6ToBuffer = exports.IPv4ToBuffer = exports.BufferToIPv6 = exports.BufferToIPv4 = exports.HexToBuffer = exports.BufferToHex = exports.StringContentEncodingEnum = exports.FlexibleObject = exports.Codec = exports.BaseHeader = void 0;
+exports.UInt8ToHex = exports.UInt64ToHex = exports.UInt32ToHex = exports.UInt16ToHex = exports.Int8ToHex = exports.Int64ToHex = exports.Int32ToHex = exports.Int16ToHex = exports.Float32ToHex = exports.UInt8ToBuffer = exports.UInt64ToBuffer = exports.UInt32ToBuffer = void 0;
+/**
+ * Base header abstract class
+ */
+var BaseHeader_1 = require("./abstracts/BaseHeader");
+Object.defineProperty(exports, "BaseHeader", { enumerable: true, get: function () { return BaseHeader_1.BaseHeader; } });
+/**
+ * Network packet codec
+ */
+var Codec_1 = require("./Codec");
+Object.defineProperty(exports, "Codec", { enumerable: true, get: function () { return Codec_1.Codec; } });
+/**
+ * Flexible Object for codec data instance
+ */
+var FlexibleObject_1 = require("./lib/FlexibleObject");
+Object.defineProperty(exports, "FlexibleObject", { enumerable: true, get: function () { return FlexibleObject_1.FlexibleObject; } });
+/**
+ * Enums
+ */
+var StringContentEncodingEnum_1 = require("./lib/StringContentEncodingEnum");
+Object.defineProperty(exports, "StringContentEncodingEnum", { enumerable: true, get: function () { return StringContentEncodingEnum_1.StringContentEncodingEnum; } });
+/**
+ * Protocol header classes (Ethernet, IPv4/6, TCP/UDP, ARP, TLS, GOOSE, SV, IEC104, ...)
+ */
+__exportStar(require("./PacketHeaders"), exports);
+/**
+ * Helper conversion functions
+ */
+var BufferToHex_1 = require("./helper/BufferToHex");
+Object.defineProperty(exports, "BufferToHex", { enumerable: true, get: function () { return BufferToHex_1.BufferToHex; } });
+var HexToBuffer_1 = require("./helper/HexToBuffer");
+Object.defineProperty(exports, "HexToBuffer", { enumerable: true, get: function () { return HexToBuffer_1.HexToBuffer; } });
+var BufferToIP_1 = require("./helper/BufferToIP");
+Object.defineProperty(exports, "BufferToIPv4", { enumerable: true, get: function () { return BufferToIP_1.BufferToIPv4; } });
+Object.defineProperty(exports, "BufferToIPv6", { enumerable: true, get: function () { return BufferToIP_1.BufferToIPv6; } });
+var IPToBuffer_1 = require("./helper/IPToBuffer");
+Object.defineProperty(exports, "IPv4ToBuffer", { enumerable: true, get: function () { return IPToBuffer_1.IPv4ToBuffer; } });
+Object.defineProperty(exports, "IPv6ToBuffer", { enumerable: true, get: function () { return IPToBuffer_1.IPv6ToBuffer; } });
+var BufferToNumber_1 = require("./helper/BufferToNumber");
+Object.defineProperty(exports, "BufferToFloat32", { enumerable: true, get: function () { return BufferToNumber_1.BufferToFloat32; } });
+Object.defineProperty(exports, "BufferToInt16", { enumerable: true, get: function () { return BufferToNumber_1.BufferToInt16; } });
+Object.defineProperty(exports, "BufferToInt32", { enumerable: true, get: function () { return BufferToNumber_1.BufferToInt32; } });
+Object.defineProperty(exports, "BufferToInt64", { enumerable: true, get: function () { return BufferToNumber_1.BufferToInt64; } });
+Object.defineProperty(exports, "BufferToInt8", { enumerable: true, get: function () { return BufferToNumber_1.BufferToInt8; } });
+Object.defineProperty(exports, "BufferToUInt16", { enumerable: true, get: function () { return BufferToNumber_1.BufferToUInt16; } });
+Object.defineProperty(exports, "BufferToUInt32", { enumerable: true, get: function () { return BufferToNumber_1.BufferToUInt32; } });
+Object.defineProperty(exports, "BufferToUInt64", { enumerable: true, get: function () { return BufferToNumber_1.BufferToUInt64; } });
+Object.defineProperty(exports, "BufferToUInt8", { enumerable: true, get: function () { return BufferToNumber_1.BufferToUInt8; } });
+var HexToNumber_1 = require("./helper/HexToNumber");
+Object.defineProperty(exports, "HexToFloat32", { enumerable: true, get: function () { return HexToNumber_1.HexToFloat32; } });
+Object.defineProperty(exports, "HexToInt16", { enumerable: true, get: function () { return HexToNumber_1.HexToInt16; } });
+Object.defineProperty(exports, "HexToInt32", { enumerable: true, get: function () { return HexToNumber_1.HexToInt32; } });
+Object.defineProperty(exports, "HexToInt64", { enumerable: true, get: function () { return HexToNumber_1.HexToInt64; } });
+Object.defineProperty(exports, "HexToInt8", { enumerable: true, get: function () { return HexToNumber_1.HexToInt8; } });
+Object.defineProperty(exports, "HexToUInt16", { enumerable: true, get: function () { return HexToNumber_1.HexToUInt16; } });
+Object.defineProperty(exports, "HexToUInt32", { enumerable: true, get: function () { return HexToNumber_1.HexToUInt32; } });
+Object.defineProperty(exports, "HexToUInt64", { enumerable: true, get: function () { return HexToNumber_1.HexToUInt64; } });
+Object.defineProperty(exports, "HexToUInt8", { enumerable: true, get: function () { return HexToNumber_1.HexToUInt8; } });
+var NumberToBERBuffer_1 = require("./helper/NumberToBERBuffer");
+Object.defineProperty(exports, "Int16ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.Int16ToBERBuffer; } });
+Object.defineProperty(exports, "Int32ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.Int32ToBERBuffer; } });
+Object.defineProperty(exports, "Int64ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.Int64ToBERBuffer; } });
+Object.defineProperty(exports, "Int8ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.Int8ToBERBuffer; } });
+Object.defineProperty(exports, "UInt16ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.UInt16ToBERBuffer; } });
+Object.defineProperty(exports, "UInt32ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.UInt32ToBERBuffer; } });
+Object.defineProperty(exports, "UInt64ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.UInt64ToBERBuffer; } });
+Object.defineProperty(exports, "UInt8ToBERBuffer", { enumerable: true, get: function () { return NumberToBERBuffer_1.UInt8ToBERBuffer; } });
+var NumberToBERHex_1 = require("./helper/NumberToBERHex");
+Object.defineProperty(exports, "Int16ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.Int16ToBERHex; } });
+Object.defineProperty(exports, "Int32ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.Int32ToBERHex; } });
+Object.defineProperty(exports, "Int64ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.Int64ToBERHex; } });
+Object.defineProperty(exports, "Int8ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.Int8ToBERHex; } });
+Object.defineProperty(exports, "UInt16ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.UInt16ToBERHex; } });
+Object.defineProperty(exports, "UInt32ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.UInt32ToBERHex; } });
+Object.defineProperty(exports, "UInt64ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.UInt64ToBERHex; } });
+Object.defineProperty(exports, "UInt8ToBERHex", { enumerable: true, get: function () { return NumberToBERHex_1.UInt8ToBERHex; } });
+var NumberToBuffer_1 = require("./helper/NumberToBuffer");
+Object.defineProperty(exports, "Float32ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.Float32ToBuffer; } });
+Object.defineProperty(exports, "Int16ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.Int16ToBuffer; } });
+Object.defineProperty(exports, "Int32ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.Int32ToBuffer; } });
+Object.defineProperty(exports, "Int64ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.Int64ToBuffer; } });
+Object.defineProperty(exports, "Int8ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.Int8ToBuffer; } });
+Object.defineProperty(exports, "UInt16ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.UInt16ToBuffer; } });
+Object.defineProperty(exports, "UInt32ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.UInt32ToBuffer; } });
+Object.defineProperty(exports, "UInt64ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.UInt64ToBuffer; } });
+Object.defineProperty(exports, "UInt8ToBuffer", { enumerable: true, get: function () { return NumberToBuffer_1.UInt8ToBuffer; } });
+var NumberToHex_1 = require("./helper/NumberToHex");
+Object.defineProperty(exports, "Float32ToHex", { enumerable: true, get: function () { return NumberToHex_1.Float32ToHex; } });
+Object.defineProperty(exports, "Int16ToHex", { enumerable: true, get: function () { return NumberToHex_1.Int16ToHex; } });
+Object.defineProperty(exports, "Int32ToHex", { enumerable: true, get: function () { return NumberToHex_1.Int32ToHex; } });
+Object.defineProperty(exports, "Int64ToHex", { enumerable: true, get: function () { return NumberToHex_1.Int64ToHex; } });
+Object.defineProperty(exports, "Int8ToHex", { enumerable: true, get: function () { return NumberToHex_1.Int8ToHex; } });
+Object.defineProperty(exports, "UInt16ToHex", { enumerable: true, get: function () { return NumberToHex_1.UInt16ToHex; } });
+Object.defineProperty(exports, "UInt32ToHex", { enumerable: true, get: function () { return NumberToHex_1.UInt32ToHex; } });
+Object.defineProperty(exports, "UInt64ToHex", { enumerable: true, get: function () { return NumberToHex_1.UInt64ToHex; } });
+Object.defineProperty(exports, "UInt8ToHex", { enumerable: true, get: function () { return NumberToHex_1.UInt8ToHex; } });

package/dist/lib/FlexibleObject.d.ts

@@ -0,0 +1,27 @@
+export declare class FlexibleObject {
+    #private;
+    constructor(data?: object, parent?: FlexibleObject, key?: string);
+    /**
+     * Set object node value
+     * @param value
+     */
+    setValue(value: any): void;
+    /**
+     * Get object node value
+     * @param defaultValue
+     * @param onUndefinedCallback
+     * @param getPathIndex
+     */
+    getValue<T = any>(defaultValue?: T, onUndefinedCallback?: (nodePath: string) => void, getPathIndex?: number): T;
+    /**
+     * Is current object's value undefined
+     */
+    isUndefined(): boolean;
+    /**
+     * Get current object path
+     * The index parameter indicates array item if this object is an array
+     * @param index
+     */
+    getPath(index?: number): string;
+    [p: string]: FlexibleObject;
+}

package/dist/lib/FlexibleObject.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexibleObject = void 0;
+class FlexibleObject {
+    #parent;
+    //This node's key within its parent (root = ''). The dotted path is reconstructed lazily by walking
+    //parents in getPath(), instead of storing a per-node paths array. The `[...paths, key]` copy on
+    //every child node was a major allocation on the encode input-tree deep-clone (setValue) and the
+    //decode field tree; getPath is only called on the cold error-recording path.
+    #key;
+    #data;
+    #undefined = true;
+    #markFlexibleObjectDefined() {
+        if (!this.#undefined)
+            return;
+        this.#undefined = false;
+        if (this.#parent)
+            this.#parent.#markFlexibleObjectDefined();
+    }
+    constructor(data, parent, key) {
+        this.#parent = parent;
+        this.#data = {};
+        this.#key = key !== undefined ? key : '';
+        if (data !== undefined)
+            this.setValue(data);
+        return new Proxy(this, {
+            get: (target, p) => {
+                if (this[p])
+                    return (...args) => this[p](...args);
+                if (target.#data[p] === undefined)
+                    target.#data[p] = new FlexibleObject(target.#data[p], this, p);
+                return target.#data[p];
+            },
+            set: (target, p, newValue) => {
+                return false;
+            }
+        });
+    }
+    /**
+     * Set object node value
+     * @param value
+     */
+    // @ts-ignore
+    setValue(value) {
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            Object.keys(value).forEach((key) => {
+                this.#data[key] = new FlexibleObject(this.#data[key], this, key);
+                this.#data[key].setValue(value[key]);
+            });
+        }
+        else {
+            this.#data = value;
+        }
+        this.#markFlexibleObjectDefined();
+    }
+    /**
+     * Get object node value
+     * @param defaultValue
+     * @param onUndefinedCallback
+     * @param getPathIndex
+     */
+    // @ts-ignore
+    getValue(defaultValue, onUndefinedCallback, getPathIndex) {
+        if (this.#undefined) {
+            if (onUndefinedCallback)
+                onUndefinedCallback(this.getPath(getPathIndex));
+            if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            return undefined;
+        }
+        if (typeof this.#data === 'object' && !Array.isArray(this.#data)) {
+            const dumpObject = {};
+            Object.keys(this.#data).forEach((key) => {
+                const dumpResult = this.#data[key].getValue();
+                if (dumpResult === undefined)
+                    return;
+                dumpObject[key] = dumpResult;
+            });
+            return dumpObject;
+        }
+        else {
+            return this.#undefined ? undefined : this.#data;
+        }
+    }
+    /**
+     * Is current object's value undefined
+     */
+    // @ts-ignore
+    isUndefined() {
+        return this.#undefined;
+    }
+    /**
+     * Get current object path
+     * The index parameter indicates array item if this object is an array
+     * @param index
+     */
+    // @ts-ignore
+    getPath(index) {
+        //Walk parents to rebuild the dotted path (cold path: only error recording calls this).
+        const parts = [];
+        let node = this;
+        while (node !== undefined && node.#parent !== undefined) {
+            parts.unshift(node.#key);
+            node = node.#parent;
+        }
+        const objPath = parts.join('.');
+        if (index === undefined)
+            return objPath;
+        return `${objPath}[${index}]`;
+    }
+}
+exports.FlexibleObject = FlexibleObject;

package/dist/lib/GetBERIntegerLengthFromBuffer.d.ts

@@ -0,0 +1,6 @@
+/**
+ *  Get BER encoded integer real length from buffer
+ * @param buffer
+ * @constructor
+ */
+export declare function GetBERIntegerLengthFromBuffer(buffer: Buffer): number;

package/dist/lib/GetBERIntegerLengthFromBuffer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetBERIntegerLengthFromBuffer = GetBERIntegerLengthFromBuffer;
+/**
+ *  Get BER encoded integer real length from buffer
+ * @param buffer
+ * @constructor
+ */
+function GetBERIntegerLengthFromBuffer(buffer) {
+    if (buffer[0] === 0) {
+        return buffer.length - 1;
+    }
+    else {
+        return buffer.length;
+    }
+}

package/dist/lib/ProcessPacketPostHandlers.d.ts

@@ -0,0 +1,13 @@
+import { PostHandlerItem } from '../types/PostHandlerItem';
+/**
+ * Process packet post encode handlers
+ * @param handlerItemsArray
+ * @constructor
+ */
+export declare function ProcessPacketEncodePostHandlers(handlerItemsArray: PostHandlerItem[][]): PostHandlerItem[];
+/**
+ * Process packet post decode handlers
+ * @param handlerItemsArray
+ * @constructor
+ */
+export declare function ProcessPacketDecodePostHandlers(handlerItemsArray: PostHandlerItem[][]): PostHandlerItem[];