@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/turn/protocol.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StunServerProtocol = void 0;
+const const_js_1 = require("./stun/const.js");
+const message_js_1 = require("./stun/message.js");
+class StunServerProtocol {
+    constructor(options = {}) {
+        this.software = options.software;
+        this.fingerprint = options.fingerprint ?? 'if-present';
+        this.authenticateRequest = options.authenticateRequest;
+    }
+    handleDatagram(input) {
+        if (!(0, const_js_1.isStunMessage)(input.data)) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'non-stun'
+                }
+            ];
+        }
+        const request = (0, message_js_1.parseMessage)(input.data);
+        if (!request) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'malformed'
+                }
+            ];
+        }
+        if (request.messageClass === const_js_1.classes.INDICATION) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'binding-indication'
+                }
+            ];
+        }
+        if (request.messageClass !== const_js_1.classes.REQUEST) {
+            return [
+                {
+                    type: 'ignore',
+                    reason: 'non-request'
+                }
+            ];
+        }
+        const context = {
+            ...input,
+            message: request
+        };
+        const unknownAttributes = [
+            ...new Set(request.unknownAttributeTypes.filter(const_js_1.isComprehensionRequiredAttribute))
+        ].sort((left, right) => left - right);
+        if (unknownAttributes.length > 0) {
+            return [
+                this.sendAction(this.errorResponse(context, 420, 'Unknown Attribute', [
+                    ['UNKNOWN-ATTRIBUTES', unknownAttributes]
+                ]), input.remoteAddress)
+            ];
+        }
+        if (request.messageMethod !== const_js_1.methods.BINDING) {
+            return [
+                this.sendAction(this.errorResponse(context, 400, 'Bad Request'), input.remoteAddress)
+            ];
+        }
+        const authResult = this.authenticateRequest?.(context);
+        if (authResult?.ok === false) {
+            return [
+                this.sendAction(this.errorResponse(context, authResult.errorCode, authResult.reason, authResult.attributes), input.remoteAddress)
+            ];
+        }
+        return [
+            this.sendAction(this.successResponse(context, authResult?.attributes), input.remoteAddress)
+        ];
+    }
+    sendAction(message, remoteAddress) {
+        return {
+            type: 'send',
+            data: message.bytes,
+            remoteAddress
+        };
+    }
+    successResponse(context, attributes = []) {
+        const response = new message_js_1.Message(const_js_1.methods.BINDING, const_js_1.classes.RESPONSE, context.message.transactionId);
+        response.setAttribute('XOR-MAPPED-ADDRESS', context.remoteAddress);
+        this.addDefaultAttributes(response, context, attributes);
+        return response;
+    }
+    errorResponse(context, errorCode, reason, attributes = []) {
+        const response = new message_js_1.Message(context.message.messageMethod, const_js_1.classes.ERROR, context.message.transactionId);
+        response.setAttribute('ERROR-CODE', [errorCode, reason]);
+        this.addDefaultAttributes(response, context, attributes);
+        return response;
+    }
+    addDefaultAttributes(response, context, attributes) {
+        for (const [key, value] of attributes) {
+            response.setAttribute(key, value);
+        }
+        if (this.software) {
+            response.setAttribute('SOFTWARE', this.software);
+        }
+        if (this.shouldAddFingerprint(context.message)) {
+            response.addFingerprint();
+        }
+    }
+    shouldAddFingerprint(request) {
+        switch (this.fingerprint) {
+            case 'always':
+                return true;
+            case 'if-present':
+                return request.getAttributeValue('FINGERPRINT') !== undefined;
+            default:
+                return false;
+        }
+    }
+}
+exports.StunServerProtocol = StunServerProtocol;

package/dist/cjs/lib/turn/stun/attributes.d.ts

@@ -0,0 +1,37 @@
+import type { Address } from '../../common/index.js';
+import { type AttributeKeys } from './const.js';
+export declare function unpackErrorCode(data: Buffer): [number, string];
+export declare function unpackXorAddress(data: Buffer, transactionId: Buffer): Address;
+export declare function packErrorCode(value: [number, string]): Buffer<ArrayBuffer>;
+export declare function packUnknownAttributes(value: number[]): Buffer<ArrayBuffer>;
+export declare function unpackUnknownAttributes(data: Buffer): number[];
+export declare function packXorAddress(value: Address, transactionId: Buffer): Buffer<ArrayBuffer>;
+export type ATTRIBUTE = [
+    number,
+    AttributeKey,
+    (...args: any[]) => Buffer,
+    (...args: any[]) => any
+];
+export type RawAttribute = {
+    type: number;
+    length?: number;
+    value: Buffer;
+};
+export declare class AttributeRepository {
+    protected attributes: AttributePair[];
+    constructor(attributes?: AttributePair[]);
+    getAttributes(): AttributePair[];
+    setAttribute(key: AttributeKey, value: any): this;
+    getAttributeValue(key: AttributeKey): any;
+    get attributesKeys(): AttributeKey[];
+    removeAttribute(key: AttributeKey): this;
+    clear(): void;
+}
+export type AttributeKey = (typeof AttributeKeys)[number];
+export type AttributePair = [AttributeKey, any];
+export declare const ATTRIBUTES_BY_TYPE: {
+    [key: string]: ATTRIBUTE;
+};
+export declare const ATTRIBUTES_BY_NAME: {
+    [key: string]: ATTRIBUTE;
+};

package/dist/cjs/lib/turn/stun/attributes.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTRIBUTES_BY_NAME = exports.ATTRIBUTES_BY_TYPE = exports.AttributeRepository = void 0;
+exports.unpackErrorCode = unpackErrorCode;
+exports.unpackXorAddress = unpackXorAddress;
+exports.packErrorCode = packErrorCode;
+exports.packUnknownAttributes = packUnknownAttributes;
+exports.unpackUnknownAttributes = unpackUnknownAttributes;
+exports.packXorAddress = packXorAddress;
+const const_js_1 = require("./const.js");
+const ip_js_1 = require("./ip.js");
+function packAddress(value) {
+    const [address] = value;
+    const protocol = (0, ip_js_1.isIpV4Address)(address) ? const_js_1.IPV4_PROTOCOL : const_js_1.IPV6_PROTOCOL;
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt8(0, 0);
+    buffer.writeUInt8(protocol, 1);
+    buffer.writeUInt16BE(value[1], 2);
+    return Buffer.concat([buffer, (0, ip_js_1.ipAddressToBuffer)(address)]);
+}
+function unpackErrorCode(data) {
+    if (data.length < 4) {
+        throw new Error('STUN error code is less than 4 bytes');
+    }
+    const codeHigh = data.readUInt8(2);
+    const codeLow = data.readUInt8(3);
+    const reason = data.slice(4).toString('utf8');
+    return [codeHigh * 100 + codeLow, reason];
+}
+function unpackAddress(data) {
+    if (data.length < 4) {
+        throw new Error('STUN address length is less than 4 bytes');
+    }
+    const protocol = data.readUInt8(1);
+    const port = data.readUInt16BE(2);
+    const address = data.slice(4);
+    switch (protocol) {
+        case const_js_1.IPV4_PROTOCOL:
+            if (address.length !== 4) {
+                throw new Error('STUN address has invalid length for IPv4');
+            }
+            return [(0, ip_js_1.bufferToIpAddress)(address), port];
+        case const_js_1.IPV6_PROTOCOL:
+            if (address.length !== 16) {
+                throw new Error('STUN address has invalid length for IPv6');
+            }
+            return [(0, ip_js_1.bufferToIpAddress)(address), port];
+        default:
+            throw new Error('STUN address has unknown protocol');
+    }
+}
+const cookieBuffer = Buffer.alloc(6);
+cookieBuffer.writeUInt16BE(const_js_1.COOKIE >> 16, 0);
+cookieBuffer.writeUInt32BE(const_js_1.COOKIE, 2);
+function xorAddress(data, transactionId) {
+    const xPad = [...cookieBuffer, ...transactionId];
+    let xData = data.slice(0, 2);
+    for (let i = 2; i < data.length; i++) {
+        const num = data[i] ^ xPad[i - 2];
+        const buf = Buffer.alloc(1);
+        buf.writeUIntBE(num, 0, 1);
+        xData = Buffer.concat([xData, buf]);
+    }
+    return xData;
+}
+function unpackXorAddress(data, transactionId) {
+    return unpackAddress(xorAddress(data, transactionId));
+}
+function packErrorCode(value) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt16BE(0, 0);
+    buffer.writeUInt8(Math.floor(value[0] / 100), 2);
+    buffer.writeUInt8(value[0] % 100, 3);
+    const encoded = Buffer.from(value[1], 'utf8');
+    return Buffer.concat([buffer, encoded]);
+}
+function packUnknownAttributes(value) {
+    const buffer = Buffer.alloc(value.length * 2);
+    value.forEach((attributeType, index) => {
+        buffer.writeUInt16BE(attributeType, index * 2);
+    });
+    return buffer;
+}
+function unpackUnknownAttributes(data) {
+    if (data.length % 2 !== 0) {
+        throw new Error('UNKNOWN-ATTRIBUTES must have an even length');
+    }
+    const attributes = [];
+    for (let offset = 0; offset < data.length; offset += 2) {
+        attributes.push(data.readUInt16BE(offset));
+    }
+    return attributes;
+}
+function packXorAddress(value, transactionId) {
+    return xorAddress(packAddress(value), transactionId);
+}
+const packUnsigned = (value) => {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32BE(value, 0);
+    return buffer;
+};
+const unpackUnsigned = (data) => data.readUInt32BE(0);
+const packUnsignedShort = (value) => {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt16BE(value, 0);
+    return buffer;
+};
+const unpackUnsignedShort = (data) => data.readUInt16BE(0);
+const packUnsigned64 = (value) => {
+    const buffer = Buffer.allocUnsafe(8);
+    buffer.writeBigUInt64BE(value, 0);
+    return buffer;
+};
+const unpackUnsigned64 = (data) => data.readBigUInt64BE(0);
+const packString = (value) => Buffer.from(value, 'utf8');
+const unpackString = (data) => data.toString('utf8');
+const packSoftware = (value) => {
+    if ([...value].length >= 128) {
+        throw new Error('SOFTWARE must be shorter than 128 characters');
+    }
+    return packString(value);
+};
+const packBytes = (value) => value;
+const unpackBytes = (data) => data;
+const packNone = () => Buffer.alloc(0);
+const unpackNone = () => null;
+const ATTRIBUTES = [
+    [0x0001, 'MAPPED-ADDRESS', packAddress, unpackAddress],
+    [0x0003, 'CHANGE-REQUEST', packUnsigned, unpackUnsigned],
+    [0x0004, 'SOURCE-ADDRESS', packAddress, unpackAddress],
+    [0x0005, 'CHANGED-ADDRESS', packAddress, unpackAddress],
+    [0x0006, 'USERNAME', packString, unpackString],
+    [0x0008, 'MESSAGE-INTEGRITY', packBytes, unpackBytes],
+    [0x0009, 'ERROR-CODE', packErrorCode, unpackErrorCode],
+    [
+        0x000a,
+        'UNKNOWN-ATTRIBUTES',
+        packUnknownAttributes,
+        unpackUnknownAttributes
+    ],
+    [0x000c, 'CHANNEL-NUMBER', packUnsignedShort, unpackUnsignedShort],
+    [0x000d, 'LIFETIME', packUnsigned, unpackUnsigned],
+    [0x0012, 'XOR-PEER-ADDRESS', packXorAddress, unpackXorAddress],
+    [0x0013, 'DATA', packBytes, unpackBytes],
+    [0x0014, 'REALM', packString, unpackString],
+    [0x0015, 'NONCE', packBytes, unpackBytes],
+    [0x0016, 'XOR-RELAYED-ADDRESS', packXorAddress, unpackXorAddress],
+    [0x0017, 'REQUESTED-ADDRESS-FAMILY', packUnsigned, unpackUnsigned],
+    [0x0018, 'EVEN-PORT', packBytes, unpackBytes],
+    [0x0019, 'REQUESTED-TRANSPORT', packUnsigned, unpackUnsigned],
+    [0x001c, 'MESSAGE-INTEGRITY-SHA256', packBytes, unpackBytes],
+    [0x001d, 'PASSWORD-ALGORITHM', packBytes, unpackBytes],
+    [0x001e, 'USERHASH', packBytes, unpackBytes],
+    [0x0020, 'XOR-MAPPED-ADDRESS', packXorAddress, unpackXorAddress],
+    [0x0022, 'RESERVATION-TOKEN', packBytes, unpackBytes],
+    [0x0024, 'PRIORITY', packUnsigned, unpackUnsigned],
+    [0x0025, 'USE-CANDIDATE', packNone, unpackNone],
+    [0x8002, 'PASSWORD-ALGORITHMS', packBytes, unpackBytes],
+    [0x8003, 'ALTERNATE-DOMAIN', packString, unpackString],
+    [0x8022, 'SOFTWARE', packSoftware, unpackString],
+    [0x8023, 'ALTERNATE-SERVER', packAddress, unpackAddress],
+    [0x8028, 'FINGERPRINT', packUnsigned, unpackUnsigned],
+    [0x8029, 'ICE-CONTROLLED', packUnsigned64, unpackUnsigned64],
+    [0x802a, 'ICE-CONTROLLING', packUnsigned64, unpackUnsigned64],
+    [0x802b, 'RESPONSE-ORIGIN', packAddress, unpackAddress],
+    [0x802c, 'OTHER-ADDRESS', packAddress, unpackAddress]
+];
+class AttributeRepository {
+    constructor(attributes = []) {
+        this.attributes = attributes;
+    }
+    getAttributes() {
+        return this.attributes;
+    }
+    setAttribute(key, value) {
+        const existing = this.attributes.find((attribute) => attribute[0] === key);
+        if (existing) {
+            existing[1] = value;
+        }
+        else {
+            this.attributes.push([key, value]);
+        }
+        return this;
+    }
+    getAttributeValue(key) {
+        const attribute = this.attributes.find((candidate) => candidate[0] === key);
+        return attribute?.[1];
+    }
+    get attributesKeys() {
+        return this.attributes.map((attribute) => attribute[0]);
+    }
+    removeAttribute(key) {
+        this.attributes = this.attributes.filter((attribute) => attribute[0] !== key);
+        return this;
+    }
+    clear() {
+        this.attributes = [];
+    }
+}
+exports.AttributeRepository = AttributeRepository;
+exports.ATTRIBUTES_BY_TYPE = ATTRIBUTES.reduce((acc, cur) => {
+    acc[cur[0]] = cur;
+    return acc;
+}, {});
+exports.ATTRIBUTES_BY_NAME = ATTRIBUTES.reduce((acc, cur) => {
+    acc[cur[1]] = cur;
+    return acc;
+}, {});

package/dist/cjs/lib/turn/stun/const.d.ts

@@ -0,0 +1,28 @@
+export declare const COOKIE = 554869826;
+export declare const FINGERPRINT_LENGTH = 8;
+export declare const FINGERPRINT_XOR = 1398035790;
+export declare const HEADER_LENGTH = 20;
+export declare const INTEGRITY_LENGTH = 24;
+export declare const IPV4_PROTOCOL = 1;
+export declare const IPV6_PROTOCOL = 2;
+export declare const RETRY_MAX = 6;
+export declare const RETRY_RTO = 50;
+export declare const AttributeKeys: readonly ["FINGERPRINT", "MESSAGE-INTEGRITY", "MESSAGE-INTEGRITY-SHA256", "CHANGE-REQUEST", "PRIORITY", "USERNAME", "USERHASH", "ICE-CONTROLLING", "SOURCE-ADDRESS", "USE-CANDIDATE", "ICE-CONTROLLED", "ERROR-CODE", "UNKNOWN-ATTRIBUTES", "XOR-MAPPED-ADDRESS", "CHANGED-ADDRESS", "LIFETIME", "REQUESTED-TRANSPORT", "NONCE", "REALM", "REQUESTED-ADDRESS-FAMILY", "EVEN-PORT", "PASSWORD-ALGORITHM", "PASSWORD-ALGORITHMS", "XOR-RELAYED-ADDRESS", "RESERVATION-TOKEN", "CHANNEL-NUMBER", "XOR-PEER-ADDRESS", "DATA", "SOFTWARE", "MAPPED-ADDRESS", "ALTERNATE-DOMAIN", "ALTERNATE-SERVER", "RESPONSE-ORIGIN", "OTHER-ADDRESS"];
+export declare enum classes {
+    REQUEST = 0,
+    INDICATION = 16,
+    RESPONSE = 256,
+    ERROR = 272
+}
+export declare enum methods {
+    BINDING = 1,
+    SHARED_SECRET = 2,
+    ALLOCATE = 3,
+    REFRESH = 4,
+    SEND = 6,
+    DATA = 7,
+    CREATE_PERMISSION = 8,
+    CHANNEL_BIND = 9
+}
+export declare function isComprehensionRequiredAttribute(type: number): boolean;
+export declare function isStunMessage(data: Buffer): boolean;

package/dist/cjs/lib/turn/stun/const.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methods = exports.classes = exports.AttributeKeys = exports.RETRY_RTO = exports.RETRY_MAX = exports.IPV6_PROTOCOL = exports.IPV4_PROTOCOL = exports.INTEGRITY_LENGTH = exports.HEADER_LENGTH = exports.FINGERPRINT_XOR = exports.FINGERPRINT_LENGTH = exports.COOKIE = void 0;
+exports.isComprehensionRequiredAttribute = isComprehensionRequiredAttribute;
+exports.isStunMessage = isStunMessage;
+exports.COOKIE = 0x2112a442;
+exports.FINGERPRINT_LENGTH = 8;
+exports.FINGERPRINT_XOR = 0x5354554e;
+exports.HEADER_LENGTH = 20;
+exports.INTEGRITY_LENGTH = 24;
+exports.IPV4_PROTOCOL = 1;
+exports.IPV6_PROTOCOL = 2;
+exports.RETRY_MAX = 6;
+exports.RETRY_RTO = 50;
+exports.AttributeKeys = [
+    'FINGERPRINT',
+    'MESSAGE-INTEGRITY',
+    'MESSAGE-INTEGRITY-SHA256',
+    'CHANGE-REQUEST',
+    'PRIORITY',
+    'USERNAME',
+    'USERHASH',
+    'ICE-CONTROLLING',
+    'SOURCE-ADDRESS',
+    'USE-CANDIDATE',
+    'ICE-CONTROLLED',
+    'ERROR-CODE',
+    'UNKNOWN-ATTRIBUTES',
+    'XOR-MAPPED-ADDRESS',
+    'CHANGED-ADDRESS',
+    'LIFETIME',
+    'REQUESTED-TRANSPORT',
+    'NONCE',
+    'REALM',
+    'REQUESTED-ADDRESS-FAMILY',
+    'EVEN-PORT',
+    'PASSWORD-ALGORITHM',
+    'PASSWORD-ALGORITHMS',
+    'XOR-RELAYED-ADDRESS',
+    'RESERVATION-TOKEN',
+    'CHANNEL-NUMBER',
+    'XOR-PEER-ADDRESS',
+    'DATA',
+    'SOFTWARE',
+    'MAPPED-ADDRESS',
+    'ALTERNATE-DOMAIN',
+    'ALTERNATE-SERVER',
+    'RESPONSE-ORIGIN',
+    'OTHER-ADDRESS'
+];
+var classes;
+(function (classes) {
+    classes[classes["REQUEST"] = 0] = "REQUEST";
+    classes[classes["INDICATION"] = 16] = "INDICATION";
+    classes[classes["RESPONSE"] = 256] = "RESPONSE";
+    classes[classes["ERROR"] = 272] = "ERROR";
+})(classes || (exports.classes = classes = {}));
+var methods;
+(function (methods) {
+    methods[methods["BINDING"] = 1] = "BINDING";
+    methods[methods["SHARED_SECRET"] = 2] = "SHARED_SECRET";
+    methods[methods["ALLOCATE"] = 3] = "ALLOCATE";
+    methods[methods["REFRESH"] = 4] = "REFRESH";
+    methods[methods["SEND"] = 6] = "SEND";
+    methods[methods["DATA"] = 7] = "DATA";
+    methods[methods["CREATE_PERMISSION"] = 8] = "CREATE_PERMISSION";
+    methods[methods["CHANNEL_BIND"] = 9] = "CHANNEL_BIND";
+})(methods || (exports.methods = methods = {}));
+function isComprehensionRequiredAttribute(type) {
+    return type >= 0x0000 && type <= 0x7fff;
+}
+function isStunMessage(data) {
+    if (data.length < exports.HEADER_LENGTH) {
+        return false;
+    }
+    if ((data[0] & 0xc0) !== 0) {
+        return false;
+    }
+    if (data.readUInt32BE(4) !== exports.COOKIE) {
+        return false;
+    }
+    const length = data.readUInt16BE(2);
+    if (length % 4 !== 0) {
+        return false;
+    }
+    return data.length === exports.HEADER_LENGTH + length;
+}

package/dist/cjs/lib/turn/stun/ip.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert an IPv4 / IPv6 text address to the STUN wire binary form.
+ * IPv4 → 4 bytes, IPv6 → 16 bytes (supports :: compression and IPv4-mapped).
+ */
+export declare function ipAddressToBuffer(address: string): Buffer;
+/**
+ * Convert STUN address bytes (4 or 16) back to a text IP address.
+ * IPv6 uses the same zero-run compression style as the previous `ip` helper.
+ */
+export declare function bufferToIpAddress(buf: Buffer): string;
+export declare function isIpV4Address(address: string): boolean;
+export declare function isIpV6Address(address: string): boolean;

package/dist/cjs/lib/turn/stun/ip.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipAddressToBuffer = ipAddressToBuffer;
+exports.bufferToIpAddress = bufferToIpAddress;
+exports.isIpV4Address = isIpV4Address;
+exports.isIpV6Address = isIpV6Address;
+const node_net_1 = require("node:net");
+/**
+ * Convert an IPv4 / IPv6 text address to the STUN wire binary form.
+ * IPv4 → 4 bytes, IPv6 → 16 bytes (supports :: compression and IPv4-mapped).
+ */
+function ipAddressToBuffer(address) {
+    if ((0, node_net_1.isIPv4)(address)) {
+        const buf = Buffer.allocUnsafe(4);
+        const parts = address.split('.');
+        for (let i = 0; i < 4; i++) {
+            buf[i] = Number(parts[i]) & 0xff;
+        }
+        return buf;
+    }
+    if (!(0, node_net_1.isIPv6)(address)) {
+        throw new Error(`Invalid ip address: ${address}`);
+    }
+    const sections = address.split(':', 8);
+    for (let i = 0; i < sections.length; i++) {
+        let v4Buffer;
+        if ((0, node_net_1.isIPv4)(sections[i])) {
+            v4Buffer = ipAddressToBuffer(sections[i]);
+            sections[i] = v4Buffer.subarray(0, 2).toString('hex');
+        }
+        if (v4Buffer && ++i < 8) {
+            sections.splice(i, 0, v4Buffer.subarray(2, 4).toString('hex'));
+        }
+    }
+    if (sections[0] === '') {
+        while (sections.length < 8)
+            sections.unshift('0');
+    }
+    else if (sections[sections.length - 1] === '') {
+        while (sections.length < 8)
+            sections.push('0');
+    }
+    else if (sections.length < 8) {
+        let emptyIndex = 0;
+        for (; emptyIndex < sections.length && sections[emptyIndex] !== ''; emptyIndex++)
+            ;
+        const zeros = [];
+        for (let n = 9 - sections.length; n > 0; n--) {
+            zeros.push('0');
+        }
+        sections.splice(emptyIndex, 1, ...zeros);
+    }
+    const result = Buffer.allocUnsafe(16);
+    let offset = 0;
+    for (const section of sections) {
+        const word = Number.parseInt(section, 16) || 0;
+        result[offset++] = (word >> 8) & 0xff;
+        result[offset++] = word & 0xff;
+    }
+    return result;
+}
+/**
+ * Convert STUN address bytes (4 or 16) back to a text IP address.
+ * IPv6 uses the same zero-run compression style as the previous `ip` helper.
+ */
+function bufferToIpAddress(buf) {
+    if (buf.length === 4) {
+        return `${buf[0]}.${buf[1]}.${buf[2]}.${buf[3]}`;
+    }
+    if (buf.length !== 16) {
+        throw new Error(`Invalid ip address buffer length: ${buf.length}`);
+    }
+    const hextets = [];
+    for (let i = 0; i < 16; i += 2) {
+        hextets.push(buf.readUInt16BE(i).toString(16));
+    }
+    let result = hextets.join(':');
+    result = result.replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3');
+    result = result.replace(/:{3,4}/, '::');
+    return result;
+}
+function isIpV4Address(address) {
+    return (0, node_net_1.isIPv4)(address);
+}
+function isIpV6Address(address) {
+    return (0, node_net_1.isIPv6)(address);
+}

package/dist/cjs/lib/turn/stun/message.d.ts

@@ -0,0 +1,37 @@
+import { type AttributePair, AttributeRepository, type RawAttribute } from './attributes.js';
+import { type classes, type methods } from './const.js';
+export declare function parseMessage(data: Buffer, integrityKey?: Buffer): Message | undefined;
+export declare class Message extends AttributeRepository {
+    messageMethod: methods;
+    messageClass: classes;
+    transactionId: Buffer;
+    rawAttributes: RawAttribute[];
+    constructor(messageMethod: methods, messageClass: classes, transactionId?: Buffer, attributes?: AttributePair[], rawAttributes?: RawAttribute[]);
+    toJSON(): {
+        messageMethod: methods;
+        messageClass: classes;
+        attributes: AttributePair[];
+        rawAttributes: {
+            type: number;
+            length: number;
+        }[];
+    };
+    get json(): {
+        messageMethod: methods;
+        messageClass: classes;
+        attributes: AttributePair[];
+        rawAttributes: {
+            type: number;
+            length: number;
+        }[];
+    };
+    get transactionIdHex(): string;
+    appendRawAttribute(type: number, value: Buffer): this;
+    get unknownAttributeTypes(): number[];
+    get bytes(): Buffer<ArrayBuffer>;
+    addMessageIntegrity(key: Buffer): this;
+    messageIntegrity(key: Buffer): Buffer<ArrayBuffer>;
+    addFingerprint(): this;
+    private get serializedAttributes();
+}
+export declare function paddingLength(length: number): number;