@netkitty/codec 1.0.0

package/dist/errors/CodecSchemaValidateError.d.ts

@@ -0,0 +1,4 @@
+export declare class CodecSchemaValidateError extends Error implements NodeJS.ErrnoException {
+    errno: number;
+    code: string;
+}

package/dist/errors/CodecSchemaValidateError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodecSchemaValidateError = void 0;
+class CodecSchemaValidateError extends Error {
+    constructor() {
+        super(...arguments);
+        this.errno = 2001;
+        this.code = 'E_CODEC_SCHEMA_VALIDATE';
+    }
+}
+exports.CodecSchemaValidateError = CodecSchemaValidateError;

package/dist/headers/ADSAMS.d.ts

@@ -0,0 +1,33 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Beckhoff ADS/AMS (Automation Device Specification / Automation Message Specification, TwinCAT), TCP
+ * port 48898 (0xBF02). An ADS/AMS packet begins with a 6-byte AMS/TCP header — a 2-byte Reserved field
+ * (0 for an AMS command) and a 4-byte Length (the count of the bytes that follow the AMS/TCP header, i.e.
+ * the 32-byte AMS header plus its data) — followed by the 32-byte AMS header: the target AmsNetId (6) and
+ * target AmsPort (2), the source AmsNetId (6) and source AmsPort (2), the Command Id (2), State Flags (2),
+ * Data Length (4), Error Code (4) and Invoke Id (4), then `Data Length` bytes of command-specific data.
+ *
+ * ⚠️ Every multi-byte field is LITTLE-ENDIAN (ADS/AMS on-wire byte order). There is no little-endian
+ * helper in this codebase, so the uint16 / uint32 fields are read and written byte-by-byte in their
+ * closures. The 6-byte AmsNetId fields (`a.b.c.d.e.f`) are kept verbatim as hex.
+ *
+ * The command-specific data is command- and direction-dependent (a Read request carries index group /
+ * index offset / length; a Read response carries a result + data; only the paired transaction reveals
+ * which), which is cross-packet state, so this single-packet codec keeps it verbatim as `data` hex
+ * (byte-perfect) and does not sub-decode it. The AMS/TCP Length is auto-computed from the AMS header +
+ * data on encode when not supplied, else honored verbatim (a crafted packet may lie); the data is bounded
+ * by Data Length so a pipelined / trailing packet is left to the codec's recursion / RawData. A
+ * well-formed packet round-trips byte-for-byte.
+ */
+export declare class ADSAMS extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/ADSAMS.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADSAMS = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * Beckhoff ADS/AMS (Automation Device Specification / Automation Message Specification, TwinCAT), TCP
+ * port 48898 (0xBF02). An ADS/AMS packet begins with a 6-byte AMS/TCP header — a 2-byte Reserved field
+ * (0 for an AMS command) and a 4-byte Length (the count of the bytes that follow the AMS/TCP header, i.e.
+ * the 32-byte AMS header plus its data) — followed by the 32-byte AMS header: the target AmsNetId (6) and
+ * target AmsPort (2), the source AmsNetId (6) and source AmsPort (2), the Command Id (2), State Flags (2),
+ * Data Length (4), Error Code (4) and Invoke Id (4), then `Data Length` bytes of command-specific data.
+ *
+ * ⚠️ Every multi-byte field is LITTLE-ENDIAN (ADS/AMS on-wire byte order). There is no little-endian
+ * helper in this codebase, so the uint16 / uint32 fields are read and written byte-by-byte in their
+ * closures. The 6-byte AmsNetId fields (`a.b.c.d.e.f`) are kept verbatim as hex.
+ *
+ * The command-specific data is command- and direction-dependent (a Read request carries index group /
+ * index offset / length; a Read response carries a result + data; only the paired transaction reveals
+ * which), which is cross-packet state, so this single-packet codec keeps it verbatim as `data` hex
+ * (byte-perfect) and does not sub-decode it. The AMS/TCP Length is auto-computed from the AMS header +
+ * data on encode when not supplied, else honored verbatim (a crafted packet may lie); the data is bounded
+ * by Data Length so a pipelined / trailing packet is left to the codec's recursion / RawData. A
+ * well-formed packet round-trips byte-for-byte.
+ */
+class ADSAMS extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'adsams';
+        this.name = 'Beckhoff ADS/AMS';
+        this.nickname = 'ADS/AMS';
+        this.matchKeys = ['tcpport:48898'];
+        //A leaf header — the command data requires command- and direction-dependent, cross-packet parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (ADSAMS.#schemaCache ??= ADSAMS.#buildSchema());
+    }
+    /** A little-endian unsigned 16-bit field of 2 octets at `offset`. */
+    static #fieldUInt16LE(name, offset, label) {
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: 65535,
+            decode: function () {
+                const b = this.readBytes(offset, 2);
+                this.instance[name].setValue(b[0] | (b[1] << 8));
+            },
+            encode: function () {
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > 65535) {
+                    this.recordError(node.getPath(), 'Maximum value is 65535');
+                    value = 65535;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBytes(offset, Buffer.from([value & 0xff, (value >> 8) & 0xff]));
+            }
+        };
+    }
+    /** A little-endian unsigned 32-bit field of 4 octets at `offset`. */
+    static #fieldUInt32LE(name, offset, label) {
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: 4294967295,
+            decode: function () {
+                const b = this.readBytes(offset, 4);
+                this.instance[name].setValue((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0);
+            },
+            encode: function () {
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > 4294967295) {
+                    this.recordError(node.getPath(), 'Maximum value is 4294967295');
+                    value = 4294967295;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBytes(offset, Buffer.from([value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >>> 24) & 0xff]));
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'ADS/AMS cmd=${commandId} invoke=${invokeId}',
+            properties: {
+                //===== AMS/TCP header (6 bytes) =====
+                //Reserved: 0 for an AMS command; kept verbatim so any non-zero reserved still round-trips.
+                reserved: this.fieldHex('reserved', 0, 2, 'Reserved'),
+                length: {
+                    type: 'integer',
+                    label: 'AMS/TCP Length',
+                    minimum: 0,
+                    maximum: 4294967295,
+                    decode: function () {
+                        const b = this.readBytes(2, 4);
+                        this.instance.length.setValue((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0);
+                    },
+                    encode: function () {
+                        //Length counts the AMS header (32) + the command data that follow the 6-byte
+                        //AMS/TCP header. Honored when supplied (a crafted packet may lie); else derived.
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 32 + (0, HexToBuffer_1.HexToBuffer)(this.instance.data.getValue('')).length;
+                        if (value > 4294967295) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 4294967295');
+                            value = 4294967295;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.length.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.length.setValue(value);
+                        this.writeBytes(2, Buffer.from([value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >>> 24) & 0xff]));
+                    }
+                },
+                //===== AMS header (32 bytes) =====
+                //6-byte AmsNetId values kept verbatim as hex (on-wire order, e.g. c0a800010101).
+                targetNetId: this.fieldHex('targetNetId', 6, 6, 'Target AmsNetId'),
+                targetPort: this.#fieldUInt16LE('targetPort', 12, 'Target AmsPort'),
+                sourceNetId: this.fieldHex('sourceNetId', 14, 6, 'Source AmsNetId'),
+                sourcePort: this.#fieldUInt16LE('sourcePort', 20, 'Source AmsPort'),
+                //Command Id: 1 ReadDeviceInfo, 2 Read, 3 Write, 4 ReadState, ... (kept as a raw uint, no
+                //enum constraint, so any on-wire command id decodes and re-encodes).
+                commandId: this.#fieldUInt16LE('commandId', 22, 'Command Id'),
+                //State Flags: bit0 response(1)/request(0), bit2 ADS command (0x0004); kept verbatim.
+                stateFlags: this.#fieldUInt16LE('stateFlags', 24, 'State Flags'),
+                dataLength: {
+                    type: 'integer',
+                    label: 'Data Length',
+                    minimum: 0,
+                    maximum: 4294967295,
+                    decode: function () {
+                        const b = this.readBytes(26, 4);
+                        this.instance.dataLength.setValue((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0);
+                    },
+                    encode: function () {
+                        //Data Length counts the command data that follow the 38-byte header. Honored when
+                        //supplied (a crafted packet may lie); else derived from the data.
+                        const provided = this.instance.dataLength.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : (0, HexToBuffer_1.HexToBuffer)(this.instance.data.getValue('')).length;
+                        if (value > 4294967295) {
+                            this.recordError(this.instance.dataLength.getPath(), 'Maximum value is 4294967295');
+                            value = 4294967295;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.dataLength.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.dataLength.setValue(value);
+                        this.writeBytes(26, Buffer.from([value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >>> 24) & 0xff]));
+                    }
+                },
+                //Error Code honored verbatim (never recomputed).
+                errorCode: this.#fieldUInt32LE('errorCode', 30, 'Error Code'),
+                invokeId: this.#fieldUInt32LE('invokeId', 34, 'Invoke Id'),
+                //The command-specific data after the 38-byte AMS/TCP+AMS header, kept verbatim. Bounded by
+                //Data Length (data ends at offset 38 + dataLength) and the captured bytes, so trailing /
+                //pipelined data is left to the codec's recursion / RawData.
+                data: {
+                    type: 'string',
+                    label: 'Data',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        const dataLength = this.instance.dataLength.getValue(0);
+                        let end = 38 + dataLength;
+                        if (end > remaining)
+                            end = remaining;
+                        this.instance.data.setValue(end > 38 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(38, end - 38)) : '');
+                    },
+                    encode: function () {
+                        const data = this.instance.data.getValue('');
+                        if (data)
+                            this.writeBytes(38, (0, HexToBuffer_1.HexToBuffer)(data));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //ADS/AMS rides on TCP port 48898. The AMS/TCP + AMS headers carry no strong content magic, so
+        //the well-known port is the signature: require the full 6-byte AMS/TCP header + 32-byte AMS
+        //header (38 bytes) to be present so the fixed AMS-header fields are never re-emitted from a
+        //truncated slice.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'tcp')
+            return false;
+        return this.packet.length - this.startPos >= 38;
+    }
+}
+exports.ADSAMS = ADSAMS;

package/dist/headers/AH.d.ts

@@ -0,0 +1,28 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * AH — IP Authentication Header (RFC 4302), carried directly over IP as protocol 51. Like the IPv6
+ * extension headers it is a next-header-chained shim, not a leaf: a fixed 12-byte prefix — Next Header
+ * (the IP-protocol number of what it protects), Payload Len (the whole AH's length in 4-octet words
+ * minus 2), a 2-byte Reserved, a 32-bit Security Parameters Index and a 32-bit Sequence Number —
+ * followed by a variable Integrity Check Value whose length is (PayloadLen+2)*4 - 12 octets (12 for
+ * the ubiquitous HMAC-SHA1-96). The protected upper-layer payload follows and is left to the codec's
+ * recursion: AH's Next Header drives the same `ipproto` demux dimension IPv4/IPv6 use, so a transport-
+ * mode AH over UDP recurses into UDP, while an unrecognised next-header falls through to RawData.
+ *
+ * The ICV is honored verbatim, not recomputed (AH is a faithful executor — it cannot rederive an HMAC
+ * without the SA key), and Payload Len is honored-else-derived: a supplied value is kept, an absent one
+ * is computed from the ICV length. A well-formed AH message round-trips byte-for-byte.
+ */
+export declare class AH extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly isProtocol: boolean;
+    readonly matchKeys: string[];
+    readonly demuxProducers: DemuxProducer[];
+    match(): boolean;
+}

package/dist/headers/AH.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AH = 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");
+/**
+ * AH — IP Authentication Header (RFC 4302), carried directly over IP as protocol 51. Like the IPv6
+ * extension headers it is a next-header-chained shim, not a leaf: a fixed 12-byte prefix — Next Header
+ * (the IP-protocol number of what it protects), Payload Len (the whole AH's length in 4-octet words
+ * minus 2), a 2-byte Reserved, a 32-bit Security Parameters Index and a 32-bit Sequence Number —
+ * followed by a variable Integrity Check Value whose length is (PayloadLen+2)*4 - 12 octets (12 for
+ * the ubiquitous HMAC-SHA1-96). The protected upper-layer payload follows and is left to the codec's
+ * recursion: AH's Next Header drives the same `ipproto` demux dimension IPv4/IPv6 use, so a transport-
+ * mode AH over UDP recurses into UDP, while an unrecognised next-header falls through to RawData.
+ *
+ * The ICV is honored verbatim, not recomputed (AH is a faithful executor — it cannot rederive an HMAC
+ * without the SA key), and Payload Len is honored-else-derived: a supplied value is kept, an absent one
+ * is computed from the ICV length. A well-formed AH message round-trips byte-for-byte.
+ */
+class AH extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        //Byte length of the ICV written during encode; consumed by the Payload Len derive handler.
+        this.#icvByteLength = 0;
+        this.id = 'ah';
+        this.name = 'IP Authentication Header';
+        this.nickname = 'AH';
+        this.isProtocol = false;
+        this.matchKeys = ['ipproto:51'];
+        //Extension-header style: it consumes ipproto:51 and produces the next-header key for the protected
+        //payload after it (mirrors the IPv6 Hop-by-Hop header).
+        this.demuxProducers = [{ field: 'nxt', namespace: 'ipproto', kind: 'uint' }];
+    }
+    static #schemaCache;
+    //Byte length of the ICV written during encode; consumed by the Payload Len derive handler.
+    #icvByteLength;
+    get SCHEMA() {
+        return (AH.#schemaCache ??= AH.#buildSchema());
+    }
+    /**
+     * The length available to AH's own header (fixed prefix + ICV), bounded by the enclosing IP
+     * datagram — so a lying Payload Len near the end of the IP payload does not read into a trailing
+     * FCS. The protected inner payload is left to the codec's recursion.
+     */
+    #available() {
+        let available = this.packet.length - this.startPos;
+        const prev = this.prevCodecModule;
+        if (prev && prev.id === 'ipv4') {
+            const ipPayload = prev.instance.length.getValue(0) - prev.length;
+            if (ipPayload >= 0 && ipPayload < available)
+                available = ipPayload;
+        }
+        else if (prev && prev.id === 'ipv6') {
+            const ipPayload = prev.instance.plen.getValue(0);
+            if (ipPayload >= 0 && ipPayload < available)
+                available = ipPayload;
+        }
+        return available < 0 ? 0 : available;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'AH spi=${spi} seq=${sequenceNumber}',
+            properties: {
+                //Next Header is an IP-protocol number (the type of the protected payload); stored as
+                //`nxt` — the field name IPv6 extension headers use — so the `ipproto` demux routes the
+                //inner layer and TCP/UDP's `nxt`-aware match() accepts AH as a parent.
+                nxt: this.fieldUInt('nxt', 0, 1, 'Next Header'),
+                //AH total length in 4-octet words minus 2. Honored-else-derived: a supplied value is
+                //kept verbatim, an absent (0) one is recomputed from the encoded ICV length.
+                payloadLen: {
+                    type: 'integer',
+                    label: 'Payload Length',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: function () {
+                        this.instance.payloadLen.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(1, 1)));
+                    },
+                    encode: function () {
+                        const payloadLen = this.instance.payloadLen.getValue(0);
+                        this.instance.payloadLen.setValue(payloadLen);
+                        this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(payloadLen));
+                        if (!payloadLen) {
+                            this.addPostSelfEncodeHandler(() => {
+                                //Fixed prefix is 12 octets (3 words); total = 12 + ICV octets, and
+                                //Payload Len = totalWords - 2 = (12 + icvBytes)/4 - 2 = icvBytes/4 + 1.
+                                const derived = Math.max(0, Math.ceil((12 + this.#icvByteLength) / 4) - 2);
+                                this.instance.payloadLen.setValue(derived);
+                                this.writeBytes(1, (0, NumberToBuffer_1.UInt8ToBuffer)(derived));
+                            });
+                        }
+                    }
+                },
+                reserved: this.fieldHex('reserved', 2, 2, 'Reserved'),
+                spi: this.fieldUInt('spi', 4, 4, 'Security Parameters Index'),
+                sequenceNumber: this.fieldUInt('sequenceNumber', 8, 4, 'Sequence Number'),
+                //Integrity Check Value: variable length driven by Payload Len, bounded by the IP payload
+                //so a lying length cannot read past the datagram. Honored verbatim — an HMAC cannot be
+                //rederived without the SA key.
+                icv: {
+                    type: 'string',
+                    label: 'Integrity Check Value',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const payloadLen = this.instance.payloadLen.getValue(0);
+                        const available = this.#available();
+                        let icvLength = (payloadLen + 2) * 4 - 12;
+                        if (icvLength < 0)
+                            icvLength = 0;
+                        if (12 + icvLength > available)
+                            icvLength = Math.max(0, available - 12);
+                        this.instance.icv.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(12, icvLength)));
+                    },
+                    encode: function () {
+                        const icvBuffer = (0, HexToBuffer_1.HexToBuffer)(this.instance.icv.getValue(''));
+                        this.#icvByteLength = icvBuffer.length;
+                        this.writeBytes(12, icvBuffer);
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //AH sits directly above IPv4 (protocol field) or IPv6 (next-header field) with protocol 51, and
+        //needs at least its 12-byte fixed prefix within the IP payload.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.instance.protocol.getValue() !== 0x33 && this.prevCodecModule.instance.nxt.getValue() !== 0x33)
+            return false;
+        return this.#available() >= 12;
+    }
+}
+exports.AH = AH;

package/dist/headers/AMQP.d.ts

@@ -0,0 +1,31 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * AMQP 0-9-1 — the Advanced Message Queuing Protocol as spoken by RabbitMQ and friends, carried over TCP
+ * port 5672. A connection opens with an 8-byte protocol header — the literal "AMQP" followed by four
+ * version octets (0 0 9 1 for 0-9-1) — sent once at connection start to negotiate the version. Everything
+ * after that is a stream of frames: a 1-byte type (1=METHOD, 2=HEADER, 3=BODY, 8=HEARTBEAT), a 2-byte
+ * channel, a 4-byte payload length, `length` payload octets, and a single 0xCE frame-end octet.
+ *
+ * This codec handles BOTH forms in one header (they are distinguished on the wire by the leading "AMQP"
+ * literal). The protocol-header handshake decodes to {isProtocolHeader:true, protocol:'AMQP', + the four
+ * version octets}; a frame decodes to type/channel/length/payload/frameEnd. The frame payload carries a
+ * class/method id and its arguments (METHOD), a content-header (HEADER), or opaque bytes (BODY) — decoding
+ * those is cross-frame, class-dependent state, so this minimal slice keeps the payload verbatim as hex
+ * (byte-perfect). The payload is bounded by the length field (the frame ends at offset 7+length, with the
+ * frame-end octet there), so a pipelined second frame or trailing bytes are left to the codec's recursion
+ * / RawData. Length is honored when supplied on encode (a crafted frame may lie), else derived from the
+ * payload bytes. A well-formed handshake or frame round-trips byte-for-byte.
+ */
+export declare class AMQP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}