@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.format.js

@@ -1,191 +0,0 @@
-export class EncodingToolHandlersFormat {
-    collector;
-    constructor(collector) {
-        this.collector = collector;
-    }
-    isMostlyPrintableText(text) {
-        if (text.length === 0) {
-            return true;
-        }
-        let printable = 0;
-        for (const ch of text) {
-            const code = ch.charCodeAt(0);
-            if ((code >= 0x20 && code <= 0x7e) || code === 0x09 || code === 0x0a || code === 0x0d) {
-                printable += 1;
-            }
-        }
-        return printable / text.length >= 0.85;
-    }
-    previewHex(buffer, maxBytes) {
-        const sample = buffer.subarray(0, maxBytes);
-        return Array.from(sample.values())
-            .map((value) => value.toString(16).padStart(2, '0'))
-            .join(' ');
-    }
-    hexDump(buffer, bytesPerRow = 16) {
-        const lines = [];
-        for (let offset = 0; offset < buffer.length; offset += bytesPerRow) {
-            const row = buffer.subarray(offset, offset + bytesPerRow);
-            const hex = Array.from(row.values())
-                .map((value) => value.toString(16).padStart(2, '0'))
-                .join(' ');
-            const ascii = Array.from(row.values())
-                .map((value) => value >= 0x20 && value <= 0x7e ? String.fromCharCode(value) : '.')
-                .join('');
-            lines.push(`${offset.toString(16).padStart(8, '0')}  ${hex.padEnd(47)}  |${ascii}|`);
-        }
-        return lines.join('\n');
-    }
-    decodeHexString(value) {
-        const cleaned = value
-            .trim()
-            .replace(/^0x/i, '')
-            .replace(/[\s:,-]/g, '');
-        if (cleaned.length === 0) {
-            return Buffer.alloc(0);
-        }
-        if (cleaned.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleaned)) {
-            throw new Error('Invalid hex string');
-        }
-        return Buffer.from(cleaned, 'hex');
-    }
-    decodeBase64String(value) {
-        const cleaned = value.trim().replace(/\s+/g, '');
-        if (cleaned.length === 0) {
-            return Buffer.alloc(0);
-        }
-        if (!this.looksLikeBase64(cleaned)) {
-            throw new Error('Invalid base64 string');
-        }
-        return Buffer.from(cleaned, 'base64');
-    }
-    decodeBinaryAuto(value) {
-        const trimmed = value.trim();
-        if (trimmed.length === 0) {
-            return Buffer.alloc(0);
-        }
-        if (this.looksLikeHex(trimmed)) {
-            return this.decodeHexString(trimmed);
-        }
-        if (this.looksLikeBase64(trimmed)) {
-            return this.decodeBase64String(trimmed);
-        }
-        return Buffer.from(trimmed, 'utf8');
-    }
-    looksLikeHex(value) {
-        const cleaned = value
-            .trim()
-            .replace(/^0x/i, '')
-            .replace(/[\s:,-]/g, '');
-        return cleaned.length > 0 && cleaned.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(cleaned);
-    }
-    looksLikeBase64(value) {
-        const cleaned = value.trim().replace(/\s+/g, '');
-        if (cleaned.length === 0 || cleaned.length % 4 !== 0) {
-            return false;
-        }
-        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(cleaned)) {
-            return false;
-        }
-        try {
-            const decoded = Buffer.from(cleaned, 'base64');
-            const normalizedInput = cleaned.replace(/=+$/, '');
-            const normalizedRoundtrip = decoded.toString('base64').replace(/=+$/, '');
-            return normalizedInput === normalizedRoundtrip;
-        }
-        catch {
-            return false;
-        }
-    }
-    looksLikeUrlEncoded(value) {
-        return /%[0-9a-fA-F]{2}/.test(value) || /\+/.test(value);
-    }
-    decodeUrl(value) {
-        return decodeURIComponent(value.replace(/\+/g, '%20'));
-    }
-    encodeUrlBytes(buffer) {
-        let encoded = '';
-        for (const value of buffer.values()) {
-            const isAlphaNum = (value >= 0x30 && value <= 0x39) ||
-                (value >= 0x41 && value <= 0x5a) ||
-                (value >= 0x61 && value <= 0x7a);
-            const isUnreserved = value === 0x2d || value === 0x2e || value === 0x5f || value === 0x7e;
-            if (isAlphaNum || isUnreserved) {
-                encoded += String.fromCharCode(value);
-            }
-            else {
-                encoded += `%${value.toString(16).toUpperCase().padStart(2, '0')}`;
-            }
-        }
-        return encoded;
-    }
-    toSafeUtf8(buffer) {
-        const text = buffer.toString('utf8');
-        if ((text.match(/\uFFFD/g) ?? []).length > 0) {
-            return null;
-        }
-        return text;
-    }
-    tryParseJson(text) {
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return null;
-        }
-    }
-    renderDecodedOutput(params) {
-        const { encoding, outputFormat, buffer, jsonValue } = params;
-        if (outputFormat === 'hex') {
-            return this.ok({
-                success: true,
-                encoding,
-                outputFormat,
-                byteLength: buffer.length,
-                result: buffer.toString('hex'),
-                hexDump: this.hexDump(buffer),
-            });
-        }
-        if (outputFormat === 'utf8') {
-            return this.ok({
-                success: true,
-                encoding,
-                outputFormat,
-                byteLength: buffer.length,
-                result: buffer.toString('utf8'),
-            });
-        }
-        const utf8 = this.toSafeUtf8(buffer);
-        const maybeJson = utf8 === null ? null : this.tryParseJson(utf8);
-        return this.ok({
-            success: true,
-            encoding,
-            outputFormat,
-            byteLength: buffer.length,
-            result: jsonValue ??
-                {
-                    parsedJson: maybeJson,
-                    utf8,
-                    hex: buffer.toString('hex'),
-                },
-        });
-    }
-    ok(payload) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(payload, null, 2),
-                },
-            ],
-        };
-    }
-    fail(tool, error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return this.ok({
-            success: false,
-            tool,
-            error: message,
-        });
-    }
-}

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.msgpack.d.ts

@@ -1,10 +0,0 @@
-import { EncodingToolHandlersProtobuf } from '../../domains/encoding/handlers.impl.core.runtime.protobuf.js';
-import type { MsgPackDecodeResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersMsgPack extends EncodingToolHandlersProtobuf {
-    protected decodeMsgPack(buffer: Buffer): unknown;
-    protected decodeMsgPackValue(buffer: Buffer, startOffset: number, depth: number): MsgPackDecodeResult;
-    protected decodeMsgPackArray(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
-    protected decodeMsgPackMap(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
-    protected msgPackMapKey(value: unknown): string;
-    protected ensureRange(buffer: Buffer, offset: number, length: number): void;
-}

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.msgpack.js

@@ -1,268 +0,0 @@
-import { EncodingToolHandlersProtobuf } from '../../domains/encoding/handlers.impl.core.runtime.protobuf.js';
-export class EncodingToolHandlersMsgPack extends EncodingToolHandlersProtobuf {
-    decodeMsgPack(buffer) {
-        const decoded = this.decodeMsgPackValue(buffer, 0, 0);
-        if (decoded.offset !== buffer.length) {
-            throw new Error(`MessagePack decode ended early: consumed ${decoded.offset} of ${buffer.length} bytes`);
-        }
-        return decoded.value;
-    }
-    decodeMsgPackValue(buffer, startOffset, depth) {
-        if (depth > 64) {
-            throw new Error('MessagePack decode depth exceeds safety limit');
-        }
-        const prefix = buffer[startOffset];
-        if (prefix === undefined) {
-            throw new Error(`Unexpected EOF at offset ${startOffset}`);
-        }
-        let offset = startOffset + 1;
-        if (prefix <= 0x7f) {
-            return { value: prefix, offset };
-        }
-        if (prefix >= 0xe0) {
-            return { value: prefix - 0x100, offset };
-        }
-        if (prefix >= 0xa0 && prefix <= 0xbf) {
-            const length = prefix & 0x1f;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix >= 0x90 && prefix <= 0x9f) {
-            const length = prefix & 0x0f;
-            return this.decodeMsgPackArray(buffer, offset, length, depth + 1);
-        }
-        if (prefix >= 0x80 && prefix <= 0x8f) {
-            const length = prefix & 0x0f;
-            return this.decodeMsgPackMap(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xc0)
-            return { value: null, offset };
-        if (prefix === 0xc2)
-            return { value: false, offset };
-        if (prefix === 0xc3)
-            return { value: true, offset };
-        if (prefix === 0xcc) {
-            this.ensureRange(buffer, offset, 1);
-            const value = buffer.readUInt8(offset);
-            return { value, offset: offset + 1 };
-        }
-        if (prefix === 0xcd) {
-            this.ensureRange(buffer, offset, 2);
-            const value = buffer.readUInt16BE(offset);
-            return { value, offset: offset + 2 };
-        }
-        if (prefix === 0xce) {
-            this.ensureRange(buffer, offset, 4);
-            const value = buffer.readUInt32BE(offset);
-            return { value, offset: offset + 4 };
-        }
-        if (prefix === 0xcf) {
-            this.ensureRange(buffer, offset, 8);
-            const value = buffer.readBigUInt64BE(offset);
-            return { value: this.bigIntToSafeValue(value), offset: offset + 8 };
-        }
-        if (prefix === 0xd0) {
-            this.ensureRange(buffer, offset, 1);
-            const value = buffer.readInt8(offset);
-            return { value, offset: offset + 1 };
-        }
-        if (prefix === 0xd1) {
-            this.ensureRange(buffer, offset, 2);
-            const value = buffer.readInt16BE(offset);
-            return { value, offset: offset + 2 };
-        }
-        if (prefix === 0xd2) {
-            this.ensureRange(buffer, offset, 4);
-            const value = buffer.readInt32BE(offset);
-            return { value, offset: offset + 4 };
-        }
-        if (prefix === 0xd3) {
-            this.ensureRange(buffer, offset, 8);
-            const value = buffer.readBigInt64BE(offset);
-            return { value: this.bigIntToSafeValue(value), offset: offset + 8 };
-        }
-        if (prefix === 0xca) {
-            this.ensureRange(buffer, offset, 4);
-            const value = buffer.readFloatBE(offset);
-            return { value, offset: offset + 4 };
-        }
-        if (prefix === 0xcb) {
-            this.ensureRange(buffer, offset, 8);
-            const value = buffer.readDoubleBE(offset);
-            return { value, offset: offset + 8 };
-        }
-        if (prefix === 0xd9) {
-            this.ensureRange(buffer, offset, 1);
-            const length = buffer.readUInt8(offset);
-            offset += 1;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix === 0xda) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix === 0xdb) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix === 0xc4) {
-            this.ensureRange(buffer, offset, 1);
-            const length = buffer.readUInt8(offset);
-            offset += 1;
-            this.ensureRange(buffer, offset, length);
-            const payload = buffer.subarray(offset, offset + length);
-            return {
-                value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
-                offset: offset + length,
-            };
-        }
-        if (prefix === 0xc5) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            this.ensureRange(buffer, offset, length);
-            const payload = buffer.subarray(offset, offset + length);
-            return {
-                value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
-                offset: offset + length,
-            };
-        }
-        if (prefix === 0xc6) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            this.ensureRange(buffer, offset, length);
-            const payload = buffer.subarray(offset, offset + length);
-            return {
-                value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
-                offset: offset + length,
-            };
-        }
-        if (prefix === 0xdc) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            return this.decodeMsgPackArray(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xdd) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            return this.decodeMsgPackArray(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xde) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            return this.decodeMsgPackMap(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xdf) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            return this.decodeMsgPackMap(buffer, offset, length, depth + 1);
-        }
-        if (prefix >= 0xd4 && prefix <= 0xd8) {
-            const sizeByPrefix = {
-                0xd4: 1,
-                0xd5: 2,
-                0xd6: 4,
-                0xd7: 8,
-                0xd8: 16,
-            };
-            const size = sizeByPrefix[prefix];
-            this.ensureRange(buffer, offset, 1 + size);
-            const extType = buffer.readInt8(offset);
-            const payload = buffer.subarray(offset + 1, offset + 1 + size);
-            return {
-                value: {
-                    type: 'ext',
-                    extType,
-                    base64: payload.toString('base64'),
-                    hex: payload.toString('hex'),
-                },
-                offset: offset + 1 + size,
-            };
-        }
-        if (prefix === 0xc7 || prefix === 0xc8 || prefix === 0xc9) {
-            const lengthBytes = prefix === 0xc7 ? 1 : prefix === 0xc8 ? 2 : 4;
-            this.ensureRange(buffer, offset, lengthBytes);
-            const length = lengthBytes === 1
-                ? buffer.readUInt8(offset)
-                : lengthBytes === 2
-                    ? buffer.readUInt16BE(offset)
-                    : buffer.readUInt32BE(offset);
-            offset += lengthBytes;
-            this.ensureRange(buffer, offset, 1 + length);
-            const extType = buffer.readInt8(offset);
-            const payload = buffer.subarray(offset + 1, offset + 1 + length);
-            return {
-                value: {
-                    type: 'ext',
-                    extType,
-                    base64: payload.toString('base64'),
-                    hex: payload.toString('hex'),
-                },
-                offset: offset + 1 + length,
-            };
-        }
-        throw new Error(`Unsupported MessagePack prefix 0x${prefix.toString(16)} at offset ${startOffset}`);
-    }
-    decodeMsgPackArray(buffer, startOffset, length, depth) {
-        let offset = startOffset;
-        const values = [];
-        for (let index = 0; index < length; index += 1) {
-            const decoded = this.decodeMsgPackValue(buffer, offset, depth);
-            values.push(decoded.value);
-            offset = decoded.offset;
-        }
-        return { value: values, offset };
-    }
-    decodeMsgPackMap(buffer, startOffset, length, depth) {
-        let offset = startOffset;
-        const mapValue = {};
-        for (let index = 0; index < length; index += 1) {
-            const keyDecoded = this.decodeMsgPackValue(buffer, offset, depth);
-            offset = keyDecoded.offset;
-            const valueDecoded = this.decodeMsgPackValue(buffer, offset, depth);
-            offset = valueDecoded.offset;
-            const key = this.msgPackMapKey(keyDecoded.value);
-            mapValue[key] = valueDecoded.value;
-        }
-        return { value: mapValue, offset };
-    }
-    msgPackMapKey(value) {
-        if (typeof value === 'string')
-            return value;
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'boolean')
-            return String(value);
-        if (typeof value === 'bigint')
-            return value.toString();
-        if (value === null)
-            return 'null';
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return String(value);
-        }
-    }
-    ensureRange(buffer, offset, length) {
-        if (offset < 0 || length < 0 || offset + length > buffer.length) {
-            throw new Error(`Unexpected EOF while reading ${length} bytes at offset ${offset}`);
-        }
-    }
-}

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.parsers.d.ts

@@ -1 +0,0 @@
-export { EncodingToolHandlersMsgPack as EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.msgpack.js';

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.parsers.js

@@ -1 +0,0 @@
-export { EncodingToolHandlersMsgPack as EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.msgpack.js';

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.protobuf.d.ts

@@ -1,13 +0,0 @@
-import { EncodingToolHandlersAnalysis } from '../../domains/encoding/handlers.impl.core.runtime.analysis.js';
-import type { ProtobufParseResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersProtobuf extends EncodingToolHandlersAnalysis {
-    protected parseProtobufMessage(buffer: Buffer, depth: number, maxDepth: number): ProtobufParseResult;
-    protected decodeLengthDelimited(payload: Buffer, depth: number, maxDepth: number): unknown;
-    protected tryParseVarint(buffer: Buffer, startOffset: number): {
-        value?: bigint;
-        offset?: number;
-        error?: string;
-    };
-    protected protobufWireTypeName(wireType: number): string;
-    protected bigIntToSafeValue(value: bigint): number | string;
-}

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.protobuf.js

@@ -1,204 +0,0 @@
-import { EncodingToolHandlersAnalysis } from '../../domains/encoding/handlers.impl.core.runtime.analysis.js';
-export class EncodingToolHandlersProtobuf extends EncodingToolHandlersAnalysis {
-    parseProtobufMessage(buffer, depth, maxDepth) {
-        const fields = [];
-        let offset = 0;
-        let fieldIndex = 0;
-        while (offset < buffer.length) {
-            const keyInfo = this.tryParseVarint(buffer, offset);
-            if (keyInfo.error) {
-                return {
-                    fields,
-                    bytesConsumed: offset,
-                    error: keyInfo.error,
-                };
-            }
-            const keyValue = keyInfo.value;
-            offset = keyInfo.offset;
-            const fieldNumber = Number(keyValue >> 3n);
-            const wireType = Number(keyValue & 0x07n);
-            if (fieldNumber <= 0) {
-                return {
-                    fields,
-                    bytesConsumed: offset,
-                    error: `Invalid field number ${fieldNumber} at offset ${offset}`,
-                };
-            }
-            if (wireType === 0) {
-                const varintInfo = this.tryParseVarint(buffer, offset);
-                if (varintInfo.error) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: varintInfo.error,
-                    };
-                }
-                offset = varintInfo.offset;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: this.bigIntToSafeValue(varintInfo.value),
-                });
-            }
-            else if (wireType === 1) {
-                if (offset + 8 > buffer.length) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Unexpected EOF for fixed64 at offset ${offset}`,
-                    };
-                }
-                const raw = buffer.subarray(offset, offset + 8);
-                const fixed64 = raw.readBigUInt64LE(0);
-                offset += 8;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: {
-                        uint64: this.bigIntToSafeValue(fixed64),
-                        hex: raw.toString('hex'),
-                    },
-                });
-            }
-            else if (wireType === 2) {
-                const lengthInfo = this.tryParseVarint(buffer, offset);
-                if (lengthInfo.error) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: lengthInfo.error,
-                    };
-                }
-                offset = lengthInfo.offset;
-                const lengthBigInt = lengthInfo.value;
-                if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Length-delimited field is too large at offset ${offset}`,
-                    };
-                }
-                const length = Number(lengthBigInt);
-                if (length < 0 || offset + length > buffer.length) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Invalid length-delimited field length=${length} at offset ${offset}`,
-                    };
-                }
-                const payload = buffer.subarray(offset, offset + length);
-                offset += length;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: this.decodeLengthDelimited(payload, depth, maxDepth),
-                });
-            }
-            else if (wireType === 5) {
-                if (offset + 4 > buffer.length) {
-                    return {
-                        fields,
-                        bytesConsumed: offset,
-                        error: `Unexpected EOF for fixed32 at offset ${offset}`,
-                    };
-                }
-                const raw = buffer.subarray(offset, offset + 4);
-                const fixed32 = raw.readUInt32LE(0);
-                offset += 4;
-                fields.push({
-                    index: fieldIndex,
-                    fieldNumber,
-                    wireType,
-                    wireTypeName: this.protobufWireTypeName(wireType),
-                    value: {
-                        uint32: fixed32,
-                        hex: raw.toString('hex'),
-                    },
-                });
-            }
-            else {
-                return {
-                    fields,
-                    bytesConsumed: offset,
-                    error: `Unsupported wire type ${wireType} at offset ${offset}`,
-                };
-            }
-            fieldIndex += 1;
-        }
-        return {
-            fields,
-            bytesConsumed: offset,
-        };
-    }
-    decodeLengthDelimited(payload, depth, maxDepth) {
-        if (payload.length === 0) {
-            return { kind: 'empty', length: 0 };
-        }
-        if (depth < maxDepth) {
-            const nested = this.parseProtobufMessage(payload, depth + 1, maxDepth);
-            if (!nested.error && nested.bytesConsumed === payload.length && nested.fields.length > 0) {
-                return {
-                    kind: 'message',
-                    fields: nested.fields,
-                };
-            }
-        }
-        const text = this.toSafeUtf8(payload);
-        if (text !== null && this.isMostlyPrintableText(text)) {
-            return {
-                kind: 'string',
-                value: text,
-            };
-        }
-        return {
-            kind: 'bytes',
-            length: payload.length,
-            hex: payload.toString('hex'),
-            base64: payload.toString('base64'),
-        };
-    }
-    tryParseVarint(buffer, startOffset) {
-        let result = 0n;
-        let shift = 0n;
-        let offset = startOffset;
-        for (let index = 0; index < 10; index += 1) {
-            const current = buffer[offset];
-            if (current === undefined) {
-                return { error: `Unexpected EOF while parsing varint at offset ${offset}` };
-            }
-            const byte = BigInt(current);
-            result |= (byte & 0x7fn) << shift;
-            offset += 1;
-            if ((byte & 0x80n) === 0n) {
-                return { value: result, offset };
-            }
-            shift += 7n;
-        }
-        return { error: `Varint exceeds 10 bytes at offset ${startOffset}` };
-    }
-    protobufWireTypeName(wireType) {
-        if (wireType === 0)
-            return 'varint';
-        if (wireType === 1)
-            return 'fixed64';
-        if (wireType === 2)
-            return 'length-delimited';
-        if (wireType === 5)
-            return 'fixed32';
-        return 'unknown';
-    }
-    bigIntToSafeValue(value) {
-        const max = BigInt(Number.MAX_SAFE_INTEGER);
-        const min = BigInt(Number.MIN_SAFE_INTEGER);
-        if (value <= max && value >= min) {
-            return Number(value);
-        }
-        return value.toString();
-    }
-}