@netkitty/codec 1.0.0

package/dist/headers/IAX2.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAX2 = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * IAX2 — Inter-Asterisk eXchange version 2 (RFC 5456), the Asterisk VoIP signalling + media trunking
+ * protocol, UDP port 4569. Every IAX2 datagram carries exactly one frame whose first bit (the F bit,
+ * the MSB of octet 0) selects the frame format:
+ *
+ *  - Full frame (F = 1) — a 12-byte header: F(1) + Source Call Number(15) | R(1, retransmit) +
+ *    Destination Call Number(15) | Timestamp(32) | OSeqno(8) | ISeqno(8) | Frame Type(8) | C(1) +
+ *    Subclass(7), followed by the frame data (the Information Elements of a NEW/AUTHREQ/… command, or a
+ *    media payload). Full frames are reliably delivered and carry the call-control state.
+ *  - Mini frame (F = 0) — a 4-byte header: F(1) + Source Call Number(15) | Timestamp(16), followed by
+ *    the media payload. Mini frames carry audio with a truncated 16-bit timestamp to save bandwidth.
+ *
+ * Byte-perfect strategy (minimal slice): the format is chosen by peeking the MSB of octet 0; the fixed
+ * header is bit-unpacked field by field and the frame data is kept verbatim as `data` hex. IAX2 has no
+ * in-frame length field — one frame occupies the whole UDP payload — so `data` runs to the transport
+ * payload end (udp.length − 8, clamped to the captured bytes so Ethernet padding is not consumed). Every
+ * wire field is a plain clamped integer (no Ajv enum), so a crafted / non-conformant value decoded off
+ * the wire re-encodes without being rejected — decode never fails and encode is a faithful executor. A
+ * well-formed frame round-trips byte-for-byte.
+ */
+class IAX2 extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'iax2';
+        this.name = 'Inter-Asterisk eXchange v2';
+        this.nickname = 'IAX2';
+        //IAX2 rides UDP port 4569. No content magic (the F bit alone is not distinctive), so this stays a
+        //pure port-bucket protocol: matchKeys only, no heuristicFallback.
+        this.matchKeys = ['udpport:4569'];
+        //A leaf header — the frame data (IAX2 Information Elements or the media payload) requires
+        //Frame-Type- and Subclass-dependent parsing layered on top of this faithful base.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (IAX2.#schemaCache ??= IAX2.#buildSchema());
+    }
+    /**
+     * Header-relative end offset of the transport payload available to this frame, so a decode never
+     * reads past the real UDP payload and trailing Ethernet padding is left to the codec. Over UDP the
+     * bound is (udp.length − 8); clamped to what was actually captured.
+     */
+    #payloadEnd() {
+        let end = this.packet.length - this.startPos;
+        const prev = this.prevCodecModule;
+        if (prev && prev.id === 'udp') {
+            const udpLength = prev.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < end)
+                end = udpLength - 8;
+        }
+        return end < 0 ? 0 : end;
+    }
+    /** True when the frame currently being decoded/encoded is a Full frame (F bit set). */
+    #isFull() {
+        return this.instance.fullFrame.getValue() === true;
+    }
+    /**
+     * An unsigned integer bit-field present ONLY in Full frames (R bit, Destination Call Number, the C
+     * bit, the Subclass). Decode/encode no-op on a Mini frame so those keys never appear, keeping the
+     * Mini decode result minimal and its re-encode byte-exact.
+     */
+    static #fullBits(name, offset, length, bitOffset, bitLength, label) {
+        const maximum = 2 ** bitLength - 1;
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: maximum,
+            decode: function () {
+                if (!this.#isFull())
+                    return;
+                this.instance[name].setValue(this.readBits(offset, length, bitOffset, bitLength));
+            },
+            encode: function () {
+                if (!this.#isFull())
+                    return;
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > maximum) {
+                    this.recordError(node.getPath(), `Maximum value is ${maximum}`);
+                    value = maximum;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBits(offset, length, bitOffset, bitLength, value);
+            }
+        };
+    }
+    /**
+     * An unsigned big-endian integer byte-field present ONLY in Full frames (OSeqno, ISeqno, Frame
+     * Type). Decode/encode no-op on a Mini frame.
+     */
+    static #fullUInt(name, offset, byteLength, label) {
+        const maximum = byteLength === 1 ? 255 : 65535;
+        const read = byteLength === 1 ? BufferToNumber_1.BufferToUInt8 : BufferToNumber_1.BufferToUInt16;
+        const write = byteLength === 1 ? NumberToBuffer_1.UInt8ToBuffer : NumberToBuffer_1.UInt16ToBuffer;
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: maximum,
+            decode: function () {
+                if (!this.#isFull())
+                    return;
+                this.instance[name].setValue(read(this.readBytes(offset, byteLength)));
+            },
+            encode: function () {
+                if (!this.#isFull())
+                    return;
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > maximum) {
+                    this.recordError(node.getPath(), `Maximum value is ${maximum}`);
+                    value = maximum;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBytes(offset, write(value));
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'IAX2 src=${sourceCall} ts=${timestamp}',
+            properties: {
+                //F bit (MSB of octet 0): true => Full frame (12-byte header), false => Mini frame (4-byte
+                //header). Decoded first so every following field can branch on the frame format.
+                fullFrame: {
+                    type: 'boolean',
+                    label: 'Full Frame',
+                    decode: function () {
+                        this.instance.fullFrame.setValue(this.readBits(0, 1, 0, 1) === 1);
+                    },
+                    encode: function () {
+                        const value = this.instance.fullFrame.getValue() === true;
+                        this.instance.fullFrame.setValue(value);
+                        this.writeBits(0, 1, 0, 1, value ? 1 : 0);
+                    }
+                },
+                //Source Call Number: the low 15 bits of the first 2 octets. Present in BOTH formats.
+                sourceCall: {
+                    type: 'integer',
+                    label: 'Source Call Number',
+                    minimum: 0,
+                    maximum: 32767,
+                    decode: function () {
+                        this.instance.sourceCall.setValue(this.readBits(0, 2, 1, 15));
+                    },
+                    encode: function () {
+                        const node = this.instance.sourceCall;
+                        let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > 32767) {
+                            this.recordError(node.getPath(), 'Maximum value is 32767');
+                            value = 32767;
+                        }
+                        if (value < 0) {
+                            this.recordError(node.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        node.setValue(value);
+                        this.writeBits(0, 2, 1, 15, value);
+                    }
+                },
+                //Retransmit (R) bit — MSB of octet 2. Full frames only.
+                retransmit: this.#fullBits('retransmit', 2, 1, 0, 1, 'Retransmit'),
+                //Destination Call Number: the low 15 bits of octets 2..3. Full frames only.
+                destCall: this.#fullBits('destCall', 2, 2, 1, 15, 'Destination Call Number'),
+                //Timestamp: 32-bit (Full, octets 4..7) or 16-bit truncated (Mini, octets 2..3). A single
+                //field whose width/offset follow the frame format; the Ajv maximum stays at the 32-bit
+                //ceiling so a decoded Full timestamp is never rejected on re-encode.
+                timestamp: {
+                    type: 'integer',
+                    label: 'Timestamp',
+                    minimum: 0,
+                    maximum: 4294967295,
+                    decode: function () {
+                        if (this.#isFull()) {
+                            this.instance.timestamp.setValue((0, BufferToNumber_1.BufferToUInt32)(this.readBytes(4, 4)));
+                        }
+                        else {
+                            this.instance.timestamp.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                        }
+                    },
+                    encode: function () {
+                        const full = this.#isFull();
+                        const maximum = full ? 4294967295 : 65535;
+                        const node = this.instance.timestamp;
+                        let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > maximum) {
+                            this.recordError(node.getPath(), `Maximum value is ${maximum}`);
+                            value = maximum;
+                        }
+                        if (value < 0) {
+                            this.recordError(node.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        node.setValue(value);
+                        if (full)
+                            this.writeBytes(4, (0, NumberToBuffer_1.UInt32ToBuffer)(value));
+                        else
+                            this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //Outbound stream sequence number (octet 8). Full frames only.
+                oSeqno: this.#fullUInt('oSeqno', 8, 1, 'Outbound Sequence Number'),
+                //Inbound stream sequence number (octet 9). Full frames only.
+                iSeqno: this.#fullUInt('iSeqno', 9, 1, 'Inbound Sequence Number'),
+                //Frame Type (octet 10): 1 DTMF, 2 Voice, 4 Control, 6 IAX, 7 Text, … Full frames only.
+                //Kept as a plain clamped byte (no Ajv enum) so any crafted value round-trips.
+                frameType: this.#fullUInt('frameType', 10, 1, 'Frame Type'),
+                //C bit — MSB of octet 11. When set, the Subclass is interpreted as 2^Subclass. Preserved
+                //verbatim so the frame round-trips regardless of interpretation. Full frames only.
+                subclassC: this.#fullBits('subclassC', 11, 1, 0, 1, 'Subclass Is Power Of Two (C)'),
+                //Subclass: low 7 bits of octet 11 — the command within the Frame Type (e.g. NEW=1 within
+                //Frame Type 6 IAX). Full frames only.
+                subclass: this.#fullBits('subclass', 11, 1, 1, 7, 'Subclass'),
+                //The frame data after the fixed header (Full: from octet 12; Mini: from octet 4), kept
+                //verbatim. IAX2 has no in-frame length field, so it runs to the transport payload end
+                //(udp.length − 8, clamped to the captured bytes), leaving trailing padding to the codec.
+                data: {
+                    type: 'string',
+                    label: 'Data',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const headerLength = this.#isFull() ? 12 : 4;
+                        const end = this.#payloadEnd();
+                        this.instance.data.setValue(end > headerLength ? (0, BufferToHex_1.BufferToHex)(this.readBytes(headerLength, end - headerLength)) : '');
+                    },
+                    encode: function () {
+                        const headerLength = this.#isFull() ? 12 : 4;
+                        const data = this.instance.data.getValue('');
+                        if (data)
+                            this.writeBytes(headerLength, (0, HexToBuffer_1.HexToBuffer)(data));
+                        else
+                            this.readBytes(headerLength, 0);
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //Selected via the udpport:4569 bucket. Require the transport payload to hold the full fixed
+        //header for the frame format the F bit announces — 4 bytes for a Mini frame, 12 for a Full
+        //frame — so a short datagram on 4569 falls through to raw and the always-re-emitted Full header
+        //never breaks the byte round-trip. The payload bound is the UDP payload (udp.length − 8), not
+        //the captured frame, so Ethernet padding is not mistaken for header bytes.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        const end = this.#payloadEnd();
+        if (end < 4)
+            return false;
+        const full = ((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1, true)) & 0x80) !== 0;
+        if (full && end < 12)
+            return false;
+        return true;
+    }
+}
+exports.IAX2 = IAX2;

package/dist/headers/ICMP.d.ts

@@ -0,0 +1,15 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+export declare class ICMP extends BaseHeader {
+    /**
+     * Calculate ICMPv4 checksum
+     * @protected
+     */
+    protected calculateIcmpChecksum(): number;
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    name: string;
+    nickname: string;
+    match(): boolean;
+}

package/dist/headers/ICMP.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICMP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+const BufferToHex_1 = require("../helper/BufferToHex");
+class ICMP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'integer',
+                    label: 'Type',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.type.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        const type = this.instance.type.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.type.setValue(type);
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt8ToBuffer)(type));
+                    }
+                },
+                code: {
+                    type: 'integer',
+                    label: 'Code',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.code.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1)));
+                    },
+                    encode: () => {
+                        const code = this.instance.code.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.code.setValue(code);
+                        this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(code));
+                    }
+                },
+                checksum: {
+                    type: 'integer',
+                    label: 'Checksum',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.checksum.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: () => {
+                        let checksum = this.instance.checksum.getValue(0);
+                        this.instance.checksum.setValue(checksum);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                        if (!checksum) {
+                            checksum = this.calculateIcmpChecksum();
+                            this.instance.checksum.setValue(checksum);
+                            this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                        }
+                    }
+                },
+                ident: {
+                    type: 'number',
+                    label: 'Identifier (BE)',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.ident.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(4, 2)));
+                    },
+                    encode: () => {
+                        const ident = this.instance.ident.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.ident.setValue(ident);
+                        this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(ident));
+                    }
+                },
+                seq: {
+                    type: 'number',
+                    label: 'Sequence Number (BE)',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.seq.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(6, 2)));
+                    },
+                    encode: () => {
+                        const seq = this.instance.seq.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.seq.setValue(seq);
+                        this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(seq));
+                    }
+                },
+                message: {
+                    type: 'string',
+                    label: 'Message Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: () => {
+                        const messageDataLength = this.packet.length - this.startPos - 8;
+                        this.instance.message.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(8, messageDataLength)));
+                    },
+                    encode: () => {
+                        const messageHex = this.instance.message.getValue('');
+                        this.instance.message.setValue(messageHex);
+                        this.writeBytes(8, Buffer.from(messageHex, 'hex'));
+                    }
+                }
+            }
+        };
+        this.id = 'icmp';
+        this.matchKeys = ['ipproto:1'];
+        this.name = 'Internet Control Message Protocol';
+        this.nickname = 'ICMP';
+    }
+    /**
+     * Calculate ICMPv4 checksum
+     * @protected
+     */
+    calculateIcmpChecksum() {
+        const icmpHeader = Buffer.concat([
+            (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.type.getValue(0)),
+            (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.code.getValue(0)),
+            (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.checksum.getValue(0)),
+            (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.ident.getValue(0)),
+            (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.seq.getValue(0)),
+            Buffer.from(this.instance.message.getValue(''), 'hex')
+        ]);
+        const paddedBuffer = icmpHeader.length % 2 === 1 ?
+            Buffer.concat([
+                icmpHeader,
+                (0, NumberToBuffer_1.UInt8ToBuffer)(0)
+            ]) : icmpHeader;
+        // 4. 计算 checksum
+        let checksum = 0;
+        for (let i = 0; i < paddedBuffer.length; i += 2) {
+            const word = (paddedBuffer[i] << 8) | (paddedBuffer[i + 1] || 0);
+            checksum += word;
+            // 处理溢出
+            if (checksum > 0xFFFF) {
+                checksum = (checksum & 0xFFFF) + 1;
+            }
+        }
+        // 取反得到最终 checksum
+        return (~checksum) & 0xFFFF;
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        return this.prevCodecModule.instance.protocol.getValue() === 0x01;
+    }
+}
+exports.ICMP = ICMP;

package/dist/headers/ICMPv6.d.ts

@@ -0,0 +1,15 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+export declare class ICMPv6 extends BaseHeader {
+    /**
+     * Calculate ICMPv6 checksum
+     * @protected
+     */
+    protected calculateIcmpv6Checksum(): number;
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    name: string;
+    nickname: string;
+    match(): boolean;
+}

package/dist/headers/ICMPv6.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICMPv6 = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const IPToBuffer_1 = require("../helper/IPToBuffer");
+class ICMPv6 extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'integer',
+                    label: 'Type',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.type.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        const type = this.instance.type.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.type.setValue(type);
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt8ToBuffer)(type));
+                    }
+                },
+                code: {
+                    type: 'integer',
+                    label: 'Code',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.code.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1)));
+                    },
+                    encode: () => {
+                        const code = this.instance.code.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        this.instance.code.setValue(code);
+                        this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(code));
+                    }
+                },
+                checksum: {
+                    type: 'integer',
+                    label: 'Checksum',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.checksum.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: () => {
+                        let checksum = this.instance.checksum.getValue(0);
+                        this.instance.checksum.setValue(checksum);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                        if (!checksum) {
+                            checksum = this.calculateIcmpv6Checksum();
+                            this.instance.checksum.setValue(checksum);
+                            this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(checksum));
+                        }
+                    }
+                },
+                message: {
+                    type: 'string',
+                    label: 'Message Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: () => {
+                        const messageDataLength = this.packet.length - this.startPos - 4;
+                        this.instance.message.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(4, messageDataLength)));
+                    },
+                    encode: () => {
+                        const messageHex = this.instance.message.getValue('');
+                        this.instance.message.setValue(messageHex);
+                        this.writeBytes(4, Buffer.from(messageHex, 'hex'));
+                    }
+                }
+            }
+        };
+        this.id = 'icmpv6';
+        this.matchKeys = ['ipproto:58'];
+        this.name = 'Internet Control Message Protocol v6';
+        this.nickname = 'ICMPv6';
+    }
+    /**
+     * Calculate ICMPv6 checksum
+     * @protected
+     */
+    calculateIcmpv6Checksum() {
+        const ipv6Header = this.prevCodecModules.find((prevCodecModule) => prevCodecModule.id === 'ipv6');
+        if (!ipv6Header)
+            return 0;
+        const messageBody = Buffer.from(this.instance.message.getValue(''), 'hex');
+        const sip = ipv6Header.instance.sip.getValue('0000:0000:0000:0000:0000:0000:0000:0000');
+        const dip = ipv6Header.instance.dip.getValue('0000:0000:0000:0000:0000:0000:0000:0000');
+        const pseudoHeader = Buffer.concat([
+            (0, IPToBuffer_1.IPv6ToBuffer)(sip),
+            (0, IPToBuffer_1.IPv6ToBuffer)(dip),
+            (0, NumberToBuffer_1.UInt32ToBuffer)(messageBody.length + 4),
+            (0, NumberToBuffer_1.UInt8ToBuffer)(0x00),
+            (0, NumberToBuffer_1.UInt8ToBuffer)(0x00),
+            (0, NumberToBuffer_1.UInt8ToBuffer)(0x00),
+            (0, NumberToBuffer_1.UInt8ToBuffer)(0x3a)
+        ]);
+        const icmpHeader = Buffer.concat([
+            (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.type.getValue(0)),
+            (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.code.getValue(0)),
+            (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.checksum.getValue(0))
+        ]);
+        const buffer = Buffer.concat([
+            pseudoHeader,
+            icmpHeader,
+            messageBody
+        ]);
+        const paddedBuffer = buffer.length % 2 === 1 ? Buffer.concat([buffer, (0, NumberToBuffer_1.UInt8ToBuffer)(0)]) : buffer;
+        let checksum = 0;
+        for (let i = 0; i < paddedBuffer.length; i += 2) {
+            checksum += (paddedBuffer[i] << 8) | (paddedBuffer[i + 1] || 0);
+            if (checksum > 0xFFFF)
+                checksum = (checksum & 0xFFFF) + 1;
+        }
+        return (~checksum) & 0xFFFF;
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        return this.prevCodecModule.instance.nxt.getValue() === 0x3a;
+    }
+}
+exports.ICMPv6 = ICMPv6;

package/dist/headers/IEC104_I_Frame.d.ts

@@ -0,0 +1,23 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+export declare class IEC104_I_Frame extends BaseHeader {
+    /**
+     * True when decode preserved an unparsed ASDU (unknown/unsupported type id) and no
+     * structured IOA content is present. Encode then re-emits the raw ASDU bytes verbatim;
+     * supplying structured IOA turns this false and encode rebuilds from fields.
+     */
+    protected asduRawFallbackActive(): boolean;
+    /**
+     * Write an information object's 3-octet address. SQ=0 frames carry a per-object address; SQ=1
+     * frames carry a single base address (before the first element) with the rest implied by
+     * incrementing, so only object 1 writes it.
+     */
+    protected writeIOAAddress(offset: number, buffer: Buffer, i: number): void;
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    name: string;
+    nickname: string;
+    match(): boolean;
+}