chore: bump version to 1.6.1

docs: update type definitions

README.md

@@ -1,6 +1,6 @@
 # mineping
 
-`mineping` is a Javasript library thar provides Minecraft server ping protocol implementation. It can be used to collect information about the server, such as MODT, current online, server icon (java edition only) and etc.
+This JavaScript library provides an implementation of the Minecraft server ping protocol. **It allows you to gather information about a Minecraft server**, such as the MOTD, current online players, server icon (Java Edition only), and more.
 
 Mirror on my [<img src="https://git.zeldon.ru/assets/img/logo.svg" align="center" width="20" height="20"/> Git](https://git.zeldon.ru/zeldon/mineping)
 
@@ -10,6 +10,8 @@ Mirror on my [<img src="https://git.zeldon.ru/assets/img/logo.svg" align="center
 
 ## Install
 
+To install `mineping`, simply run the following command:
+
 ```
 npm i @minescope/mineping
 ```
@@ -17,6 +19,7 @@ npm i @minescope/mineping
 ## Loading and configuration the module
 
 ### ES Modules (ESM)
+If you are using ES Modules, you can import the library like this:
 
 ```js
 import { pingJava, pingBedrock } from '@minescope/mineping';
@@ -59,5 +62,7 @@ console.log(data);
 
 ## Acknowledgements
 
+Special thanks to the following projects:
+
 - [mcping](https://github.com/Scetch/mcping) crate for Rust
 - [mcping-js](https://github.com/Cryptkeeper/mcping-js) library for quering Minecraft Java Edition servers

example/cli.js

@@ -1,40 +1,83 @@
+#!/usr/bin/env node
+
 /**
  * Usage examples:
  * - Java (with custom timeout): node cli.js -j --host="mc.hypixel.net" --timeout 1000
  * - Bedrock: node cli.js -b --host="play.timecrack.net"
  */
 
-import { pingBedrock, pingJava } from '../index.js';
+import { pingBedrock, pingJava } from "../index.js";
 
-const args = getArgs();
+const DEFAULT_TIMEOUT = 5000;
+const JAVA_DEFAULT_PORT = 25565;
+const BEDROCK_DEFAULT_PORT = 19132;
+
+try {
+	const args = parseArgs(process.argv.slice(2));
 
 	if (shouldShowHelp(args)) {
 		printHelp();
+		process.exit(0);
+	}
+
+	validateArgs(args);
+
+	const port = Number(args.port) || getDefaultPort(args);
+	const timeout = Number(args.timeout) || DEFAULT_TIMEOUT;
+
+	if (args.j) {
+		await pingJavaServer(args.host, port, timeout);
+	} else if (args.b) {
+		await pingBedrockServer(args.host, port, timeout);
+	}
+} catch (err) {
+	console.error(`ERROR: ${err.message}`);
 	process.exit(1);
 }
 
-if (!args.host) {
-    console.error('ERROR: The host argument not found! Use -h or --help.');
-    process.exit(1);
+function parseArgs(rawArgs) {
+	const args = {};
+
+	for (let i = 0; i < rawArgs.length; i++) {
+		const arg = rawArgs[i];
+
+		if (arg.startsWith("--")) {
+			// Handle --key=value and --key value formats
+			const [key, value] = arg.slice(2).split("=");
+			args[key] = value ?? rawArgs[++i] ?? true;
+		} else if (arg.startsWith("-")) {
+			// Handle short flags (-j, -b, -h)
+			const flags = arg.slice(1).split("");
+			flags.forEach((flag) => {
+				args[flag] = true;
+			});
+		}
 	}
 
-// easter egg <3
+	return args;
+}
+
+function validateArgs(args) {
 	if (args.j && args.b) {
 		printInterestingFacts();
 		process.exit(0);
 	}
 
-const port = args.port || getDefaultPort(args);
-const timeout = args.timeout || 500;
+	if (!args.host) {
+		throw new Error("The host argument not found! Use -h or --help.");
+	}
 
-if (args.j) {
-    await pingJavaServer(args.host, port, timeout)
-        .catch(err => console.error(`ERROR: ${err.message}`));
-} else if (args.b) {
-    await pingBedrockServer(args.host, port, timeout)
-        .catch(err => console.error(`ERROR: ${err.message}`));
-} else {
-    console.error('ERROR: Unsupported flag passed. Use -h or --help.');
+	if (!args.j && !args.b) {
+		throw new Error("Must specify either -j or -b flag. Use -h or --help.");
+	}
+
+	if (args.port && (isNaN(args.port) || args.port < 1 || args.port > 65535)) {
+		throw new Error("Port must be a number between 1 and 65535");
+	}
+
+	if (args.timeout && (isNaN(args.timeout) || args.timeout < 0)) {
+		throw new Error("Timeout must be a positive number");
+	}
 }
 
 function shouldShowHelp(args) {
@@ -51,8 +94,13 @@ function printHelp() {
     OPTIONS:
         -j  Use for Minecraft Java Edition
         -b  Use for Minecraft Bedrock Edition
+        -h, --help  Show this help message
         
-        P.S. Don't use them at the same time!`);
+        --host     The server address (required)
+        --port     The server port (default: ${JAVA_DEFAULT_PORT} for Java, ${BEDROCK_DEFAULT_PORT} for Bedrock)
+        --timeout  The socket timeout in milliseconds (default: ${DEFAULT_TIMEOUT})
+        
+        P.S. Don't use -j and -b at the same time!`);
 }
 
 function printInterestingFacts() {
@@ -66,37 +114,27 @@ function printInterestingFacts() {
 }
 
 function getDefaultPort(args) {
-    return args.j ? 25565 : 19132;
+	return args.j ? JAVA_DEFAULT_PORT : BEDROCK_DEFAULT_PORT;
 }
 
 async function pingJavaServer(host, port, timeout) {
 	const data = await pingJava(host, { port, timeout });
-    console.log(`host: ${host}\nprotocol: ${data.version?.protocol}\nonline: ${data.players?.online}`);
+	console.log(`Host: ${host}
+Version: ${data.version?.name} (protocol: ${data.version?.protocol})
+Players: ${data.players?.online}/${data.players?.max}
+Description: ${
+		typeof data.description === "string"
+			? data.description
+			: data.description?.text
+	}`);
 }
 
 async function pingBedrockServer(host, port, timeout) {
 	const data = await pingBedrock(host, { port, timeout });
-    console.log(`host: ${host}\nprotocol: ${data.version.protocol}\nonline: ${data.players.online}`);
-}
-
-// parsing command line arguments
-function getArgs() {
-    const args = {};
-    process.argv.slice(2).forEach(arg => {
-        // long arg
-        if (arg.slice(0, 2) === '--') {
-            const longArg = arg.split('=');
-            const longArgFlag = longArg[0].slice(2, longArg[0].length);
-            const longArgValue = longArg.length > 1 ? longArg[1] : true;
-            args[longArgFlag] = longArgValue;
-            // flags
-        } else if (arg[0] === '-') {
-            const flags = arg.slice(1, arg.length).split('');
-            flags.forEach(flag => {
-                args[flag] = true;
-            });
-        }
-    });
-
-    return args;
+	console.log(`Host: ${host}
+Edition: ${data.edition}
+Version: ${data.version.minecraftVersion} (protocol: ${data.version.protocolVersion})
+Players: ${data.players.online}/${data.players.max}
+Name: ${data.name}
+Gamemode: ${data.gameMode}`);
 }

example/parallel.js

@@ -13,6 +13,7 @@ const results = await Promise.allSettled(pingPromises);
 for (let result of results) {
     if (result.status === 'rejected') {
         console.error(result.reason);
+        break;
     }
 
     console.log(result.value);

example/single.js

@@ -0,0 +1,5 @@
+import { pingBedrock } from "../index.js";
+
+const host = "mc.nevertime.su";
+const ping = await pingBedrock(host);
+console.log(ping);

lib/bedrock.js

@@ -1,124 +1,85 @@
 /**
  * Implementation of the RakNet ping/pong protocol.
- * @see https://wiki.vg/Raknet_Protocol#Unconnected_Ping
- *
- * Data types:
- * @see https://wiki.vg/Raknet_Protocol#Data_types
+ * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Raknet_Protocol
  */
 
-'use strict';
+"use strict";
 
-import dgram from 'dgram';
+import dgram from "node:dgram";
+import crypto from "node:crypto";
 
+const MAGIC = "00ffff00fefefefefdfdfdfd12345678";
 const START_TIME = new Date().getTime();
+const UNCONNECTED_PONG = 0x1c;
 
 /**
- * Creates a buffer with the specified length.
- * @param {number} length - The length of the buffer.
- * @returns {Buffer} - The created buffer.
+ * Creates an Unconnected Ping packet.
+ * @param {number} pingId
+ * @returns {Buffer}
+ * @see {@link https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Raknet_Protocol#Unconnected_Ping}
  */
-const createBuffer = (length) => {
-    const buffer = Buffer.alloc(length);
-    buffer[0] = 0x01;
+const createUnconnectedPingFrame = (timestamp) => {
+	const buffer = Buffer.alloc(33);
+	buffer.writeUInt8(0x01, 0); // Packet ID
+	buffer.writeBigInt64LE(BigInt(timestamp), 1); // Timestamp
+	Buffer.from(MAGIC, "hex").copy(buffer, 9); // OFFLINE_MESSAGE_DATA_ID (Magic)
+	Buffer.from(crypto.randomBytes(8)).copy(buffer, 25); // Client GUID
 	return buffer;
 };
 
 /**
- * Writes a BigInt value to the buffer at the specified offset using big-endian byte order.
- * @param {Buffer} buffer - The buffer to write to.
- * @param {number} value - The BigInt value to write.
- * @param {number} offset - The offset in the buffer to write the value.
+ * Extract Modt from Unconnected Pong Packet and convert to an object
+ * @param {Buffer} unconnectedPongPacket
+ * @returns {Object}
+ * @throws {Error} If packet is malformed or invalid
+ * @see {@link https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Raknet_Protocol#Unconnected_Pong}
  */
-const writeBigInt64BE = (buffer, value, offset) => {
-    buffer.writeBigInt64BE(BigInt(value), offset);
-};
-
-/**
- * Copies the specified hex value to the buffer at the specified offset.
- * @param {Buffer} buffer - The buffer to copy to.
- * @param {string} hex - The hex value to copy.
- * @param {number} offset - The offset in the buffer to copy the value.
- */
-const copyHexToBuffer = (buffer, hex, offset) => {
-    Buffer.from(hex, 'hex').copy(buffer, offset);
-};
-
-/**
- * Reads a BigInt value from the buffer at the specified offset using big-endian byte order.
- * @param {Buffer} buffer - The buffer to read from.
- * @param {number} offset - The offset in the buffer to read the value.
- * @returns {BigInt} - The read BigInt value.
- */
-const readBigInt64BE = (buffer, offset) => {
-    return buffer.readBigInt64BE(offset);
-};
-
-/**
- * Reads a string from the buffer at the specified offset.
- * @param {Buffer} buffer - The buffer to read from.
- * @param {number} offset - The offset in the buffer to read the string.
- * @returns {string} - The read string.
- */
-const readStringFromBuffer = (buffer, offset) => {
-    const length = buffer.readUInt16BE(offset);
-    return buffer.toString('utf8', offset + 2, offset + 2 + length);
-};
-
-/**
- * Parses the advertise string into an object with properties.
- * @param {string} advertiseStr - The advertise string to parse.
- * @returns {Object} - The parsed object with properties.
- */
-const parseAdvertiseString = (advertiseStr) => {
-    const parts = advertiseStr.split(';');
-    return {
-        gameId: parts[0],
-        description: parts[1],
-        protocolVersion: parts[2],
-        gameVersion: parts[3],
-        currentPlayers: parts[4],
-        maxPlayers: parts[5],
-        name: parts[7],
-        mode: parts[8]
-    };
-};
-
-/**
- * Creates an Unconnected Ping buffer.
- * @param {number} pingId - The ping ID.
- * @returns {Buffer} - The Unconnected Ping buffer.
- * @see {@link https://wiki.vg/Raknet_Protocol#Unconnected_Ping}
- */
-const UNCONNECTED_PING = (pingId) => {
-    const buffer = createBuffer(35);
-    writeBigInt64BE(buffer, pingId, 1);
-    copyHexToBuffer(buffer, '00ffff00fefefefefdfdfdfd12345678', 9);
-    writeBigInt64BE(buffer, 0, 25);
-    return buffer;
-};
-
-/**
- * Decodes an Unconnected Pong buffer and returns the parsed data.
- * @param {Buffer} buffer - The Unconnected Pong buffer.
- * @returns {Object} - The parsed Unconnected Pong data.
- * @see {@link https://wiki.vg/Raknet_Protocol#Unconnected_Pong}
- */
-const UNCONNECTED_PONG = (buffer) => {
-    const pingId = readBigInt64BE(buffer, 1);
-    const serverId = readBigInt64BE(buffer, 9);
-    let offset = 25;
-    let advertiseStr;
-
-    try {
-        advertiseStr = readStringFromBuffer(buffer, offset);
-    } catch (err) {
-        const length = parseInt(err.message.substr(err.message.indexOf(',') + 2, 3));
-        advertiseStr = buffer.toString('utf8', offset, offset + length);
+const extractModt = (unconnectedPongPacket) => {
+	if (
+		!Buffer.isBuffer(unconnectedPongPacket) ||
+		unconnectedPongPacket.length < 35
+	) {
+		throw new Error("Invalid pong packet");
 	}
 
-    const parsedAdvertiseStr = parseAdvertiseString(advertiseStr);
+	const offset = 33;
+	const length = unconnectedPongPacket.readUInt16BE(offset);
 
-    return { pingId, advertiseStr, serverId, offset, ...parsedAdvertiseStr };
+	// Check for buffer bounds
+	if (offset + 2 + length > unconnectedPongPacket.length) {
+		throw new Error("Malformed pong packet");
+	}
+
+	let modt = unconnectedPongPacket.toString(
+		"utf-8",
+		offset + 2,
+		offset + 2 + length
+	);
+
+	const components = modt.split(";");
+
+	// Validate required components
+	if (components.length < 9) {
+		throw new Error("Invalid MODT format");
+	}
+
+	const parsedComponents = {
+		edition: components[0],
+		name: components[1],
+		version: {
+			protocolVersion: Number(components[2]),
+			minecraftVersion: components[3],
+		},
+		players: {
+			online: Number(components[4]),
+			max: Number(components[5]),
+		},
+		serverId: components[6],
+		mapName: components[7],
+		gameMode: components[8],
+	};
+
+	return parsedComponents;
 };
 
 /**
@@ -129,12 +90,12 @@ const UNCONNECTED_PONG = (buffer) => {
  * @param {number} [timeout=5000] - The timeout duration in milliseconds.
  */
 const ping = (host, port = 19132, cb, timeout = 5000) => {
-    const socket = dgram.createSocket('udp4');
+	const socket = dgram.createSocket("udp4");
 
 	// Set manual timeout interval.
 	// This ensures the connection will NEVER hang regardless of internal state
 	const timeoutTask = setTimeout(() => {
-        socket.emit('error', new Error('Socket timeout'));
+		socket.emit("error", new Error("Socket timeout"));
 	}, timeout);
 
 	const closeSocket = () => {
@@ -161,44 +122,34 @@ const ping = (host, port = 19132, cb, timeout = 5000) => {
 	};
 
 	try {
-        const ping = UNCONNECTED_PING(new Date().getTime() - START_TIME);
+		const ping = createUnconnectedPingFrame(new Date().getTime() - START_TIME);
 		socket.send(ping, 0, ping.length, port, host);
 	} catch (err) {
 		handleError(err);
 	}
 
-    socket.on('message', (msg) => {
-        const id = msg[0];
+	socket.on("message", (pongPacket) => {
+		if (!Buffer.isBuffer(pongPacket) || pongPacket.length === 0) {
+			handleError(new Error("Invalid packet received"));
+			return;
+		}
 
-        switch (id) {
-            case 0x1c: {
-                const pong = UNCONNECTED_PONG(msg);
-                const clientData = {
-                    version: {
-                        name: pong.name,
-                        protocol: pong.protocolVersion
-                    },
-                    players: {
-                        max: pong.maxPlayers,
-                        online: pong.currentPlayers
-                    },
-                    description: pong.description.replace(/\xA7[0-9A-FK-OR]/ig, ''),
-                    gamemode: pong.mode
-                };
+		const id = pongPacket[0];
+		if (id !== UNCONNECTED_PONG) {
+			handleError(new Error(`Unexpected packet ID: 0x${id.toString(16)}`));
+			return;
+		}
 
+		try {
+			const modtObject = extractModt(pongPacket);
 			closeSocket();
-                cb(clientData, null);
-                break;
-            }
-
-            default: {
-                handleError(new Error('Received unexpected packet'));
-                break;
-            }
+			cb(modtObject, null);
+		} catch (err) {
+			handleError(err);
 		}
 	});
 
-    socket.on('error', handleError);
+	socket.on("error", handleError);
 };
 
 /**
@@ -209,13 +160,18 @@ const ping = (host, port = 19132, cb, timeout = 5000) => {
  * @returns {Promise<import('../types/index.js').BedrockPingResponse>}
  */
 export const pingBedrock = (host, options = {}) => {
-    if (!host) throw new Error('Host argument is not provided');
+	if (!host) throw new Error("Host argument is not provided");
 
 	const { port = 19132, timeout = 5000 } = options;
 
 	return new Promise((resolve, reject) => {
-        ping(host, port, (res, err) => {
+		ping(
+			host,
+			port,
+			(res, err) => {
 				err ? reject(err) : resolve(res);
-        }, timeout);
+			},
+			timeout
+		);
 	});
 };

lib/java.js

@@ -1,29 +1,29 @@
 /**
  * Implementation of the Java Minecraft ping protocol.
- * @see https://wiki.vg/Server_List_Ping
+ * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Server_List_Ping
  */
 
-'use strict';
+"use strict";
 
-import net from 'net';
-import varint from './varint.js';
-
-const PROTOCOL_VERSION = 0;
+import net from "node:net";
+import varint from "./varint.js";
 
 /**
  * Ping a Minecraft Java server.
  * @param {string} host The host of the Java server.
+ * @param {string} virtualHost The host sent in handshake.
  * @param {number} [port=25565] The port of the Java server.
  * @param {function} cb The callback function to handle the ping response.
  * @param {number} [timeout=5000] The timeout duration in milliseconds.
+ * @param {number} [protocolVersion=-1] The protocol version of the Java client.
  */
-function ping(host, port = 25565, cb, timeout = 5000) {
-    const socket = net.createConnection(({ host, port }));
+function ping(host, virtualHost, port = 25565, cb, timeout = 5000, protocolVersion = -1) {
+	const socket = net.createConnection({ host, port });
 
 	// Set manual timeout interval.
 	// This ensures the connection will NEVER hang regardless of internal state
 	const timeoutTask = setTimeout(() => {
-        socket.emit('error', new Error('Socket timeout'));
+		socket.emit("error", new Error("Socket timeout"));
 	}, timeout);
 
 	const closeSocket = () => {
@@ -53,34 +53,32 @@ function ping(host, port = 25565, cb, timeout = 5000) {
 	// This prevents the runtime from delaying the write at all
 	socket.setNoDelay(true);
 
-    socket.on('connect', () => {
+	socket.on("connect", () => {
 		const handshake = varint.concat([
 			varint.encodeInt(0),
-            varint.encodeInt(PROTOCOL_VERSION),
-            varint.encodeInt(host.length),
-            varint.encodeString(host),
+			varint.encodeInt(protocolVersion),
+			varint.encodeInt(virtualHost.length),
+			varint.encodeString(virtualHost),
 			varint.encodeUShort(port),
-            varint.encodeInt(1)
+			varint.encodeInt(1),
 		]);
 
 		socket.write(handshake);
 
-        const request = varint.concat([
-            varint.encodeInt(0)
-        ]);
+		const request = varint.concat([varint.encodeInt(0)]);
 
 		socket.write(request);
 	});
 
 	let incomingBuffer = Buffer.alloc(0);
 
-    socket.on('data', (data) => {
+	socket.on("data", (data) => {
 		incomingBuffer = Buffer.concat([incomingBuffer, data]);
 
 		// Wait until incomingBuffer is at least 5 bytes long to ensure it has captured the first VarInt value
 		// This value is used to determine the full read length of the response
 		// "VarInts are never longer than 5 bytes"
-        // https://wiki.vg/Data_types#VarInt_and_VarLong
+		// https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Data_types#VarInt_and_VarLong
 		if (incomingBuffer.length < 5) {
 			return;
 		}
@@ -93,12 +91,20 @@ function ping(host, port = 25565, cb, timeout = 5000) {
 			return;
 		}
 
-        const packetId = varint.decodeInt(incomingBuffer, varint.decodeLength(packetLength));
+		const packetId = varint.decodeInt(
+			incomingBuffer,
+			varint.decodeLength(packetLength)
+		);
 
 		if (packetId === 0) {
-            const data = incomingBuffer.subarray(varint.decodeLength(packetLength) + varint.decodeLength(packetId));
+			const data = incomingBuffer.subarray(
+				varint.decodeLength(packetLength) + varint.decodeLength(packetId)
+			);
 			const responseLength = varint.decodeInt(data, 0);
-            const response = data.subarray(varint.decodeLength(responseLength), varint.decodeLength(responseLength) + responseLength);
+			const response = data.subarray(
+				varint.decodeLength(responseLength),
+				varint.decodeLength(responseLength) + responseLength
+			);
 
 			try {
 				const message = JSON.parse(response);
@@ -109,28 +115,35 @@ function ping(host, port = 25565, cb, timeout = 5000) {
 				handleError(err);
 			}
 		} else {
-            handleError(new Error('Received unexpected packet'));
+			handleError(new Error("Received unexpected packet"));
 		}
 	});
 
-    socket.on('error', handleError);
+	socket.on("error", handleError);
 }
 
 /**
  * Asynchronously ping Minecraft Java server.
- * The optional `options` argument can be an object with a `ping` (default is `25565`) or/and `timeout` (default is `5000`) property.
+ * The optional `options` argument can be an object with a `port` (default is `25565`) or/and `timeout` (default is `5000`) or/and `protocolVersion` (default is `-1`) property.
  * @param {string} host The Java server address.
  * @param {import('../types/index.js').PingOptions} options The configuration for pinging Minecraft Java server.
  * @returns {Promise<import('../types/index.js').JavaPingResponse>}
  */
 export function pingJava(host, options = {}) {
-    if (!host) throw new Error('Host argument is not provided');
+	if (!host) throw new Error("Host argument is not provided");
 
-    const { port = 25565, timeout = 5000 } = options;
+	const { port = 25565, timeout = 5000, protocolVersion = -1, virtualHost = null } = options;
 
 	return new Promise((resolve, reject) => {
-        ping(host, port, (res, err) => {
+		ping(
+			host,
+			virtualHost || host,
+			port,
+			(res, err) => {
 				err ? reject(err) : resolve(res);
-        }, timeout);
+			},
+			timeout,
+			protocolVersion
+		);
 	});
 }

lib/varint.js

@@ -1,4 +1,4 @@
-// https://wiki.vg/Data_types
+// https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Protocol#Data_types
 
 /**
  * A utility object for encoding and decoding varints.
@@ -10,13 +10,13 @@ const varint = {
 	 * @returns {Buffer}
 	 */
 	encodeInt: (val) => {
-        // "constInts are never longer than 5 bytes"
-        // https://wiki.vg/Data_types#constInt_and_constLong
+		// "VarInts are never longer than 5 bytes"
+		// https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Data_types#VarInt_and_VarLong
 		const buf = Buffer.alloc(5);
 		let written = 0;
 
 		while (true) {
-            const byte = val & 0x7F;
+			const byte = val & 0x7f;
 			val >>>= 7;
 
 			if (val === 0) {
@@ -27,7 +27,7 @@ const varint = {
 			buf.writeUInt8(byte | 0x80, written++);
 		}
 
-        return buf.slice(0, written);
+		return buf.subarray(0, written);
 	},
 
 	/**
@@ -36,7 +36,7 @@ const varint = {
 	 * @returns {Buffer}
 	 */
 	encodeString: (val) => {
-        return Buffer.from(val, 'utf-8');
+		return Buffer.from(val, "utf-8");
 	},
 
 	/**
@@ -45,7 +45,7 @@ const varint = {
 	 * @returns {Buffer}
 	 */
 	encodeUShort: (val) => {
-        return Buffer.from([val >> 8, val & 0xFF]);
+		return Buffer.from([val >> 8, val & 0xff]);
 	},
 
 	/**
@@ -60,68 +60,64 @@ const varint = {
 			length += chunk.length;
 		}
 
-        const buffer = [
-            varint.encodeInt(length),
-            ...chunks
-        ];
+		const buffer = [varint.encodeInt(length), ...chunks];
 
 		return Buffer.concat(buffer);
 	},
 
 	/**
-     * Decodes a varint integer value from a byte buffer.
+	 * Decodes a varint integer value from a buffer.
 	 * @param {Buffer} buffer - The byte buffer to decode from.
 	 * @param {number} offset - The offset in the buffer to start decoding from.
 	 * @returns {number}
 	 */
 	decodeInt: (buffer, offset) => {
-        let val = 0;
-        let count = 0;
-
-        while (true) {
-            const byte = buffer.readUInt8(offset++);
-
-            val |= (byte & 0x7F) << count++ * 7;
-
-            if ((byte & 0x80) !== 0x80) {
-                break;
-            }
+		// Fast path for single-byte varints
+		const firstByte = buffer.readUInt8(offset);
+		if (firstByte < 0x80) {
+			return firstByte;
 		}
 
+		let val = firstByte & 0x7f;
+		let position = 7;
+
+		while (position < 32) {
+			const byte = buffer.readUInt8(++offset);
+			val |= (byte & 0x7f) << position;
+
+			if ((byte & 0x80) === 0) {
 				return val;
+			}
+
+			position += 7;
+		}
+
+		throw new Error("VarInt is too big");
 	},
 
 	/**
-     * Calculates the number of bytes required to decode a varint integer value.
-     * @param {number} val - The varint integer value.
-     * @returns {5 | 7 | 8 | 1 | 2 | 3 | 4 | 6 | 9 | 10}
+	 * Calculates how many bytes are needed to encode a number as a VarInt
+	 * VarInts use a variable number of bytes to efficiently encode integers
+	 * Each byte uses 7 bits for the value and 1 bit to indicate if more bytes follow
+	 * VarInts are never longer than 5 bytes
+	 *
+	 * @param {number} val - The number to calculate the VarInt length for
+	 * @returns {1|2|3|4|5} The number of bytes needed to encode the value
 	 */
 	decodeLength: (val) => {
-        // Constants representing the powers of 2 used for comparison
-        const N1 = Math.pow(2, 7);
-        const N2 = Math.pow(2, 14);
-        const N3 = Math.pow(2, 21);
-        const N4 = Math.pow(2, 28);
-        const N5 = Math.pow(2, 35);
-        const N6 = Math.pow(2, 42);
-        const N7 = Math.pow(2, 49);
-        const N8 = Math.pow(2, 56);
-        const N9 = Math.pow(2, 63);
+		// Using bit shifts to calculate power of 2 thresholds
+		// 1 << 7  = 2^7  = 128      - Numbers below this fit in 1 byte
+		// 1 << 14 = 2^14 = 16,384   - Numbers below this fit in 2 bytes
+		// 1 << 21 = 2^21 = 2,097,152 - Numbers below this fit in 3 bytes
+		// 1 << 28 = 2^28 = 268,435,456 - Numbers below this fit in 4 bytes
+		// Any larger number needs 5 bytes (maximum VarInt size)
 
-        // Return the number of bytes required based on the value
-        return (
-            val < N1 ? 1
-                : val < N2 ? 2
-                    : val < N3 ? 3
-                        : val < N4 ? 4
-                            : val < N5 ? 5
-                                : val < N6 ? 6
-                                    : val < N7 ? 7
-                                        : val < N8 ? 8
-                                            : val < N9 ? 9
-                                                : 10
-        );
-    }
+		if (val < 1 << 7) return 1;
+		if (val < 1 << 14) return 2;
+		if (val < 1 << 21) return 3;
+		if (val < 1 << 28) return 4;
+		return 5;
+	},
 };
 
 export default varint;

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minescope/mineping",
-  "version": "1.1.1",
+	"version": "1.6.1",
 	"description": "Ping both Minecraft Bedrock and Java servers.",
 	"main": "index.js",
 	"types": "types/index.d.ts",

types/lib/bedrock.d.ts

@@ -1,31 +1,33 @@
 /**
- * @param port The server port.
- * @param timeout The read/write socket timeout.
+ * @param port The server port (1-65535).
+ * @param timeout The read/write socket timeout in milliseconds.
  */
-export type PingOptions = {
-    port: number,
-    timeout: number;
+export type BedrockPingOptions = {
+	port?: number & { _brand: "Port" }; // 1-65535
+	timeout?: number & { _brand: "Timeout" }; // > 0
 };
 
 export type BedrockPingResponse = {
-    version: {
+	edition: string;
 	name: string;
-        protocol: string;
+	version: {
+		protocolVersion: number;
+		minecraftVersion: string;
 	};
 	players: {
-        max: string;
-        online: string;
+		online: number;
+		max: number;
 	};
-    description: string;
-    gamemode: string;
+	serverId: string;
+	mapName: string;
+	gameMode: string;
 };
 
 /**
  * Asynchronously ping Minecraft Bedrock server.
  *
- * The optional `options` argument can be an object with a `ping` (default is `19132`) or/and `timeout` (default is `5000`) property.
- * 
  * @param host The Bedrock server address.
+ * @param options The configuration for pinging Minecraft Bedrock server.
  *
  * ```js
  * import { pingBedrock } from '@minescope/mineping';
@@ -37,13 +39,23 @@ export type BedrockPingResponse = {
  * The resulting output will resemble:
  * ```console
  * {
- *   version: { name: 'Mineplex', protocol: '475' },
- *   players: { max: '5207', online: '5206' },
- *   description: ' New Costumes',
- *   gamemode: 'Survival'
+ *   edition: "MCPE",
+ *   name: "Mineplex",
+ *   version: {
+ *     protocolVersion: 475,
+ *     minecraftVersion: "1.18.0"
+ *   },
+ *   players: {
+ *     online: 5206,
+ *     max: 5207
+ *   },
+ *   serverId: "12345678",
+ *   mapName: "Lobby",
+ *   gameMode: "Survival"
  * }
  * ```
- * @see [source](https://github.com/minescope/mineping/blob/915edbec9c9ad811459458600af3531ec0836911/lib/bedrock.js#L204)
  */
-export function pingBedrock(host: string, options?: PingOptions): Promise<BedrockPingResponse>;
-
+export function pingBedrock(
+	host: string,
+	options?: BedrockPingOptions
+): Promise<BedrockPingResponse>;

types/lib/java.d.ts

@@ -1,8 +1,18 @@
-import { PingOptions } from "./bedrock";
+/**
+ * @param port The server port.
+ * @param timeout The read/write socket timeout.
+ * @param protocolVersion The protocol version.
+ */
+export type JavaPingOptions = {
+	port?: number | undefined;
+	timeout?: number | undefined;
+	protocolVersion?: number | undefined;
+	virtualHost?: string | undefined;
+};
 
 /**
  * JSON format chat component used for description field.
- * @see https://wiki.vg/Chat
+ * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Chat
  */
 export type ChatComponent = {
 	text: string;
@@ -16,13 +26,13 @@ export type ChatComponent = {
 };
 
 export type SampleProp = {
-    name: string,
+	name: string;
 	id: string;
 };
 
 /**
  * `JSON Response` field of Response packet.
- * @see https://wiki.vg/Server_List_Ping#Response
+ * @see https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Server_List_Ping#Status_Response
  */
 export type JavaPingResponse = {
 	version: {
@@ -67,5 +77,7 @@ export type JavaPingResponse = {
  * ```
  * @see [source](https://github.com/minescope/mineping/blob/915edbec9c9ad811459458600af3531ec0836911/lib/java.js#L117)
  */
-export function pingJava(host: string, options?: PingOptions): Promise<JavaPingResponse>;
-
+export function pingJava(
+	host: string,
+	options?: JavaPingOptions
+): Promise<JavaPingResponse>;

types/lib/varint.d.ts

@@ -1,10 +1,44 @@
 export default varint;
 declare namespace varint {
+	/**
+	 * Encodes an integer value into a varint byte buffer.
+	 * @param val - The integer value to encode.
+	 */
 	function encodeInt(val: number): Buffer;
+
+	/**
+	 * Encodes a string value into a UTF-8 byte buffer.
+	 * @param val - The string value to encode.
+	 */
 	function encodeString(val: string): Buffer;
+
+	/**
+	 * Encodes an unsigned short value into a byte buffer.
+	 * @param val - The unsigned short value to encode.
+	 */
 	function encodeUShort(val: number): Buffer;
+
+	/**
+	 * Concatenates multiple byte buffers into a single byte buffer.
+	 * @param chunks - An array of byte buffers to concatenate.
+	 */
 	function concat(chunks: Buffer[]): Buffer;
+
+	/**
+	 * Decodes a varint integer value from a buffer.
+	 * @param buffer - The byte buffer to decode from.
+	 * @param offset - The offset in the buffer to start decoding from.
+	 */
 	function decodeInt(buffer: Buffer, offset: number): number;
-    function decodeString(val: Buffer, offset?: number): string;
-    function decodeLength(val: number): 5 | 7 | 8 | 1 | 2 | 3 | 4 | 6 | 9 | 10;
+
+	/**
+	 * Calculates how many bytes are needed to encode a number as a VarInt.
+	 * VarInts use a variable number of bytes to efficiently encode integers.
+	 * Each byte uses 7 bits for the value and 1 bit to indicate if more bytes follow.
+	 * VarInts are never longer than 5 bytes.
+	 *
+	 * @param val - The number to calculate the VarInt length for.
+	 * @returns The number of bytes needed to encode the value (1-5).
+	 */
+	function decodeLength(val: number): 1 | 2 | 3 | 4 | 5;
 }