@deitylamb/mcping 1.4.2 → 1.5.0

package/dist/cli.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.cts

@@ -0,0 +1,71 @@
+//#region src/java-ping.d.ts
+interface JavaRawResponse {
+  version: {
+    name: string;
+    protocol: number;
+  };
+  players: {
+    max: number;
+    online: number;
+    sample?: {
+      name: string;
+      id: string;
+    }[];
+  };
+  description: any;
+  favicon?: string;
+  enforcesSecureChat?: boolean;
+  previewsChat?: boolean;
+}
+//#endregion
+//#region src/bedrock-ping.d.ts
+interface BedrockRawResponse {
+  edition: string;
+  motdLine1: string;
+  motdLine2: string;
+  protocolVersion: number;
+  versionName: string;
+  playerCount: number;
+  maxPlayerCount: number;
+  serverUniqueId: string;
+  gameMode: string;
+  nintendoLimited: number;
+  ipv4Port: number | null;
+  ipv6Port: number | null;
+}
+//#endregion
+//#region src/cache.d.ts
+interface CacheOptions {
+  ttl: number;
+  strategy: "lazy" | "swr";
+}
+//#endregion
+//#region src/index.d.ts
+interface PingOptions {
+  timeout?: number;
+  type?: "java" | "bedrock" | null;
+  cache?: CacheOptions;
+}
+interface PingResponse {
+  type: "java" | "bedrock";
+  version: {
+    name: string;
+    protocol: number;
+  };
+  players: {
+    online: number;
+    max: number;
+  };
+  motd: string;
+  latency: number;
+  target: {
+    host: string;
+    port: number;
+    ip: string;
+  };
+  raw: JavaRawResponse | BedrockRawResponse;
+  cached?: boolean;
+}
+declare function ping(target: string, options?: PingOptions): Promise<PingResponse>;
+//#endregion
+export { PingOptions, PingResponse, ping };

package/dist/index.d.mts

@@ -0,0 +1,71 @@
+//#region src/java-ping.d.ts
+interface JavaRawResponse {
+  version: {
+    name: string;
+    protocol: number;
+  };
+  players: {
+    max: number;
+    online: number;
+    sample?: {
+      name: string;
+      id: string;
+    }[];
+  };
+  description: any;
+  favicon?: string;
+  enforcesSecureChat?: boolean;
+  previewsChat?: boolean;
+}
+//#endregion
+//#region src/bedrock-ping.d.ts
+interface BedrockRawResponse {
+  edition: string;
+  motdLine1: string;
+  motdLine2: string;
+  protocolVersion: number;
+  versionName: string;
+  playerCount: number;
+  maxPlayerCount: number;
+  serverUniqueId: string;
+  gameMode: string;
+  nintendoLimited: number;
+  ipv4Port: number | null;
+  ipv6Port: number | null;
+}
+//#endregion
+//#region src/cache.d.ts
+interface CacheOptions {
+  ttl: number;
+  strategy: "lazy" | "swr";
+}
+//#endregion
+//#region src/index.d.ts
+interface PingOptions {
+  timeout?: number;
+  type?: "java" | "bedrock" | null;
+  cache?: CacheOptions;
+}
+interface PingResponse {
+  type: "java" | "bedrock";
+  version: {
+    name: string;
+    protocol: number;
+  };
+  players: {
+    online: number;
+    max: number;
+  };
+  motd: string;
+  latency: number;
+  target: {
+    host: string;
+    port: number;
+    ip: string;
+  };
+  raw: JavaRawResponse | BedrockRawResponse;
+  cached?: boolean;
+}
+declare function ping(target: string, options?: PingOptions): Promise<PingResponse>;
+//#endregion
+export { PingOptions, PingResponse, ping };

package/package.json

@@ -1,25 +1,36 @@
 {
   "name": "@deitylamb/mcping",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Minecraft server ping library",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.cts",
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "mcping": "./dist/cli.mjs"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
-      "types": "./dist/index.d.cts"
+      "types": "./dist/index.d.mts"
     }
   },
-  "bin": {
-    "mcping": "./dist/cli.mjs"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/harmoniamc/mcping.git"
   },
   "scripts": {
     "dev": "tsdown src/index.ts --watch",
-    "build": "tsdown src/index.ts src/cli.ts --format cjs,esm --dts",
-    "test": "npm run test:unit && npm run test:e2e",
+    "build": "tsdown src/index.ts src/cli.ts --format esm,cjs --dts",
     "test:unit": "vitest run test/unit",
     "test:e2e": "vitest run test/e2e",
     "format": "prettier --write .",
@@ -28,21 +39,20 @@
   "keywords": [
     "minecraft",
     "ping",
+    "query",
     "server",
     "java",
     "bedrock"
   ],
-  "author": "",
+  "author": "deitylamb",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^25.5.2",
-    "prettier": "^3.8.1",
+    "@emnapi/core": "1.9.2",
+    "@emnapi/runtime": "1.9.2",
+    "@types/node": "^22.13.4",
+    "prettier": "^3.4.2",
     "tsdown": "^0.21.7",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
-  },
-  "dependencies": {
-    "@emnapi/core": "^1.9.2",
-    "@emnapi/runtime": "^1.9.2"
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
   }
 }

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": false,
-  "trailingComma": "all",
-  "tabWidth": 2,
-  "printWidth": 80
-}

package/src/ansi.ts

@@ -1,50 +0,0 @@
-const mcColorMap: Record<string, string> = {
-  "0": "\x1b[30m", // black
-  "1": "\x1b[34m", // dark_blue
-  "2": "\x1b[32m", // dark_green
-  "3": "\x1b[36m", // dark_aqua
-  "4": "\x1b[31m", // dark_red
-  "5": "\x1b[35m", // dark_purple
-  "6": "\x1b[33m", // gold
-  "7": "\x1b[37m", // gray
-  "8": "\x1b[90m", // dark_gray
-  "9": "\x1b[94m", // blue
-  a: "\x1b[92m", // green
-  b: "\x1b[96m", // aqua
-  c: "\x1b[91m", // red
-  d: "\x1b[95m", // light_purple
-  e: "\x1b[93m", // yellow
-  f: "\x1b[97m", // white
-  l: "\x1b[1m", // bold
-  m: "\x1b[9m", // strikethrough
-  n: "\x1b[4m", // underline
-  o: "\x1b[3m", // italic
-  r: "\x1b[0m", // reset
-};
-
-/**
- * Converts Minecraft color codes (§) to ANSI terminal colors.
- */
-export function mcToAnsi(text: string): string {
-  const reset = "\x1b[0m";
-  let result = "";
-  const parts = text.split("§");
-
-  result += parts[0];
-
-  for (let i = 1; i < parts.length; i++) {
-    const part = parts[i];
-    if (part.length === 0) continue;
-
-    const code = part[0].toLowerCase();
-    const ansi = mcColorMap[code];
-
-    if (ansi) {
-      result += ansi + part.substring(1);
-    } else {
-      result += "§" + part;
-    }
-  }
-
-  return result + reset;
-}

package/src/bedrock-ping.ts

@@ -1,88 +0,0 @@
-import * as dgram from "node:dgram";
-import * as crypto from "node:crypto";
-
-export interface BedrockRawResponse {
-  edition: string;
-  motdLine1: string;
-  motdLine2: string;
-  protocolVersion: number;
-  versionName: string;
-  playerCount: number;
-  maxPlayerCount: number;
-  serverUniqueId: string;
-  gameMode: string;
-  nintendoLimited: number;
-  ipv4Port: number | null;
-  ipv6Port: number | null;
-}
-
-const RAKNET_MAGIC = Buffer.from("00ffff00fefefefefdfdfdfd12345678", "hex");
-
-export async function pingBedrock(
-  host: string,
-  port: number,
-  timeout: number,
-): Promise<BedrockRawResponse> {
-  return new Promise((resolve, reject) => {
-    const client = dgram.createSocket("udp4");
-    const timeoutHandler = setTimeout(() => {
-      client.close();
-      reject(new Error(`Bedrock ping timed out after ${timeout}ms`));
-    }, timeout);
-
-    const startTime = BigInt(Date.now());
-    const clientGUID = crypto.randomBytes(8);
-
-    // Unconnected Ping (0x01)
-    const packet = Buffer.alloc(1 + 8 + 16 + 8);
-    packet.writeUInt8(0x01, 0); // Packet ID
-    packet.writeBigInt64BE(startTime, 1); // Time
-    RAKNET_MAGIC.copy(packet, 9); // Magic
-    clientGUID.copy(packet, 25); // Client GUID
-
-    client.send(packet, port, host);
-
-    client.on("message", (msg) => {
-      if (msg.readUInt8(0) === 0x1c) {
-        // Unconnected Pong (0x1C)
-        clearTimeout(timeoutHandler);
-        client.close();
-
-        const time = msg.readBigInt64BE(1);
-        const serverGUID = msg.readBigInt64BE(9);
-        const magic = msg.slice(17, 33);
-
-        if (!magic.equals(RAKNET_MAGIC)) {
-          reject(new Error("Invalid RakNet magic"));
-          return;
-        }
-
-        const stringLength = msg.readUInt16BE(33);
-        const body = msg.toString("utf8", 35, 35 + stringLength);
-
-        const parts = body.split(";");
-        const response: BedrockRawResponse = {
-          edition: parts[0] || "MCPE",
-          motdLine1: parts[1] || "",
-          protocolVersion: parseInt(parts[2]) || 0,
-          versionName: parts[3] || "",
-          playerCount: parseInt(parts[4]) || 0,
-          maxPlayerCount: parseInt(parts[5]) || 0,
-          serverUniqueId: parts[6] || "",
-          motdLine2: parts[7] || "",
-          gameMode: parts[8] || "",
-          nintendoLimited: parseInt(parts[9]) || 0,
-          ipv4Port: parts[10] ? parseInt(parts[10]) : null,
-          ipv6Port: parts[11] ? parseInt(parts[11]) : null,
-        };
-        resolve(response);
-      }
-    });
-
-    client.on("error", (err) => {
-      clearTimeout(timeoutHandler);
-      client.close();
-      reject(err);
-    });
-  });
-}

package/src/cache.ts

@@ -1,42 +0,0 @@
-import type { PingResponse } from "./index.js";
-
-export interface CacheOptions {
-  ttl: number;
-  strategy: "lazy" | "swr";
-}
-
-interface CacheEntry {
-  response: PingResponse;
-  timestamp: number;
-}
-
-const cache = new Map<string, CacheEntry>();
-
-export function getCache(
-  target: string,
-  options: CacheOptions,
-): PingResponse | null {
-  const entry = cache.get(target);
-  if (!entry) return null;
-
-  const age = Date.now() - entry.timestamp;
-  const isExpired = age > options.ttl;
-
-  if (!isExpired || options.strategy === "swr") {
-    return { ...entry.response, cached: true };
-  }
-
-  return null;
-}
-
-export function setCache(target: string, response: PingResponse): void {
-  // Only cache successful, non-cached results
-  if (response.cached) return;
-  cache.set(target, { response, timestamp: Date.now() });
-}
-
-export function isExpired(target: string, options: CacheOptions): boolean {
-  const entry = cache.get(target);
-  if (!entry) return true;
-  return Date.now() - entry.timestamp > options.ttl;
-}

package/src/chat.ts

@@ -1,45 +0,0 @@
-export function parseChat(chat: any): string {
-  if (typeof chat === "string") return chat;
-  if (!chat || typeof chat !== "object") return "";
-
-  let text = "";
-
-  // Minecraft legacy color code mapping in JSON
-  const colorMap: Record<string, string> = {
-    black: "0",
-    dark_blue: "1",
-    dark_green: "2",
-    dark_aqua: "3",
-    dark_red: "4",
-    dark_purple: "5",
-    gold: "6",
-    gray: "7",
-    dark_gray: "8",
-    blue: "9",
-    green: "a",
-    aqua: "b",
-    red: "c",
-    light_purple: "d",
-    yellow: "e",
-    white: "f",
-  };
-
-  if (chat.color && colorMap[chat.color]) {
-    text += `§${colorMap[chat.color]}`;
-  }
-  if (chat.bold) text += "§l";
-  if (chat.italic) text += "§o";
-  if (chat.underlined) text += "§n";
-  if (chat.strikethrough) text += "§m";
-  if (chat.obfuscated) text += "§k";
-
-  text += chat.text || "";
-
-  if (chat.extra && Array.isArray(chat.extra)) {
-    for (const part of chat.extra) {
-      text += parseChat(part);
-    }
-  }
-
-  return text;
-}

package/src/cli.ts

@@ -1,113 +0,0 @@
-#!/usr/bin/env node
-import { ping } from "./index.js";
-import { mcToAnsi } from "./ansi.js";
-
-const colors = {
-  reset: "\x1b[0m",
-  bright: "\x1b[1m",
-  cyan: "\x1b[36m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  magenta: "\x1b[35m",
-  white: "\x1b[37m",
-  gray: "\x1b[90m",
-};
-
-/**
- * Poor man's argument parser
- */
-function parseArgs(args: string[]) {
-  const result: {
-    target?: string;
-    type?: "java" | "bedrock";
-    timeout?: number;
-  } = {};
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--type" || arg === "-t") {
-      const val = args[++i]?.toLowerCase();
-      if (val === "java" || val === "bedrock") {
-        result.type = val;
-      }
-    } else if (arg === "--timeout") {
-      const val = parseInt(args[++i]);
-      if (!isNaN(val)) {
-        result.timeout = val;
-      }
-    } else if (!result.target && !arg.startsWith("-")) {
-      result.target = arg;
-    }
-  }
-  return result;
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const parsed = parseArgs(args);
-
-  if (!parsed.target) {
-    console.log(
-      `\n${colors.bright}Usage:${colors.reset} mcping <host[:port]> [options]`,
-    );
-    console.log(`\n${colors.bright}Options:${colors.reset}`);
-    console.log(`  --type, -t <java|bedrock>  Force protocol type`);
-    console.log(
-      `  --timeout <ms>             Connection timeout (default: 5000)`,
-    );
-    console.log(`\n${colors.bright}Examples:${colors.reset}`);
-    console.log(`  mcping mc.hypixel.net`);
-    console.log(`  mcping geo.hivebedrock.network --type bedrock`);
-    console.log(`  mcping play.example.com --timeout 2000\n`);
-    process.exit(1);
-  }
-
-  try {
-    const res = await ping(parsed.target, {
-      type: parsed.type,
-      timeout: parsed.timeout,
-    });
-
-    // Header Line: Input -> IP:Port
-    const resolvedStr = `${res.target.ip}:${res.target.port}`;
-    const targetDisplay =
-      parsed.target === resolvedStr
-        ? parsed.target
-        : `${parsed.target} ${colors.gray}→${colors.reset} ${resolvedStr}`;
-
-    console.log(`\n ${colors.bright}${targetDisplay}${colors.reset}`);
-
-    // Edition line
-    const editionStr = `${colors.bright}${res.type.toUpperCase()}${colors.reset}`;
-    const versionStr = `${colors.gray}${res.version.name}${colors.reset}`;
-    const latencyStr =
-      res.type === "java"
-        ? ` ${colors.magenta}${res.latency}ms${colors.reset}`
-        : "";
-
-    console.log(
-      ` ${editionStr} ${colors.gray}•${colors.reset} ${versionStr}${latencyStr}`,
-    );
-
-    // Players line
-    console.log(
-      ` ${colors.bright}${res.players.online}${colors.reset} ${colors.gray}/ ${res.players.max} players${colors.reset}`,
-    );
-
-    // MOTD with indent and colors
-    const coloredMotd = mcToAnsi(res.motd);
-    const cleanMotd = coloredMotd
-      .trim()
-      .split("\n")
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0)
-      .join(`\n `);
-
-    console.log(`\n ${cleanMotd}${colors.reset}\n`);
-  } catch (err: any) {
-    console.error(`\n ${colors.yellow}Error:${colors.reset} ${err.message}\n`);
-    process.exit(1);
-  }
-}
-
-main();

package/src/index.ts

@@ -1,143 +0,0 @@
-import { resolveTarget } from "./target.js";
-import { pingJava, JavaRawResponse } from "./java-ping.js";
-import { pingBedrock, BedrockRawResponse } from "./bedrock-ping.js";
-import { parseChat } from "./chat.js";
-import * as cache from "./cache.js";
-
-export interface PingOptions {
-  timeout?: number;
-  type?: "java" | "bedrock" | null;
-  cache?: cache.CacheOptions;
-}
-
-export interface PingResponse {
-  type: "java" | "bedrock";
-  version: {
-    name: string;
-    protocol: number;
-  };
-  players: {
-    online: number;
-    max: number;
-  };
-  motd: string;
-  latency: number;
-  target: {
-    host: string;
-    port: number;
-    ip: string;
-  };
-  raw: JavaRawResponse | BedrockRawResponse;
-  cached?: boolean;
-}
-
-export async function ping(
-  target: string,
-  options?: PingOptions,
-): Promise<PingResponse> {
-  const timeout = options?.timeout || 5000;
-  const type = options?.type || null;
-  const cacheOptions = options?.cache;
-
-  if (cacheOptions) {
-    const cached = cache.getCache(target, cacheOptions);
-    if (cached) {
-      if (
-        cacheOptions.strategy === "swr" &&
-        cache.isExpired(target, cacheOptions)
-      ) {
-        // Refresh in background
-        pingServer(target, timeout, type)
-          .then((refreshed) => cache.setCache(target, refreshed))
-          .catch(() => {});
-      }
-      return cached;
-    }
-  }
-
-  const result = await pingServer(target, timeout, type);
-  if (cacheOptions) {
-    cache.setCache(target, result);
-  }
-
-  return result;
-}
-
-async function pingServer(
-  target: string,
-  timeout: number,
-  type: "java" | "bedrock" | null,
-): Promise<PingResponse> {
-  const resolved = await resolveTarget(target, type);
-
-  let javaError: any;
-  if (type === "java" || type === null) {
-    try {
-      const { response, latency } = await pingJava(
-        resolved.host,
-        resolved.port,
-        timeout,
-      );
-      return {
-        type: "java",
-        version: {
-          name: response.version.name,
-          protocol: response.version.protocol,
-        },
-        players: {
-          online: response.players.online,
-          max: response.players.max,
-        },
-        motd: parseChat(response.description),
-        latency,
-        target: {
-          host: resolved.host,
-          port: resolved.port,
-          ip: resolved.ip,
-        },
-        raw: response,
-      };
-    } catch (e) {
-      javaError = e;
-      if (type === "java") throw e;
-    }
-  }
-
-  try {
-    const bedrockResolved =
-      type === "bedrock" ? resolved : await resolveTarget(target, "bedrock");
-    const response = await pingBedrock(
-      bedrockResolved.host,
-      bedrockResolved.port,
-      timeout,
-    );
-    return {
-      type: "bedrock",
-      version: {
-        name: response.versionName,
-        protocol: response.protocolVersion,
-      },
-      players: {
-        online: response.playerCount,
-        max: response.maxPlayerCount,
-      },
-      motd: response.motdLine2
-        ? `${response.motdLine1}\n${response.motdLine2}`
-        : response.motdLine1,
-      latency: 0,
-      target: {
-        host: bedrockResolved.host,
-        port: bedrockResolved.port,
-        ip: bedrockResolved.ip,
-      },
-      raw: response,
-    };
-  } catch (bedrockErr: any) {
-    if (type === null && javaError) {
-      throw new Error(
-        `Both Java and Bedrock pings failed. Java: ${javaError.message}. Bedrock: ${bedrockErr.message}`,
-      );
-    }
-    throw bedrockErr;
-  }
-}

package/src/java-ping.ts

@@ -1,114 +0,0 @@
-import * as net from "node:net";
-import {
-  encodeVarInt,
-  encodeString,
-  decodeVarInt,
-  decodeString,
-} from "./varint.js";
-
-export interface JavaRawResponse {
-  version: { name: string; protocol: number };
-  players: {
-    max: number;
-    online: number;
-    sample?: { name: string; id: string }[];
-  };
-  description: any;
-  favicon?: string;
-  enforcesSecureChat?: boolean;
-  previewsChat?: boolean;
-}
-
-export async function pingJava(
-  host: string,
-  port: number,
-  timeout: number,
-): Promise<{ response: JavaRawResponse; latency: number }> {
-  return new Promise((resolve, reject) => {
-    const client = new net.Socket();
-    let startTime: number;
-    let response: JavaRawResponse;
-
-    const timeoutHandler = setTimeout(() => {
-      client.destroy();
-      reject(new Error(`Connection timed out after ${timeout}ms`));
-    }, timeout);
-
-    client.connect(port, host, () => {
-      // 1. Handshake
-      const protocolVersion = encodeVarInt(763); // 1.20.1
-      const serverAddress = encodeString(host);
-      const serverPort = Buffer.alloc(2);
-      serverPort.writeUInt16BE(port);
-      const nextState = encodeVarInt(1);
-
-      const handshakePayload = Buffer.concat([
-        protocolVersion,
-        serverAddress,
-        serverPort,
-        nextState,
-      ]);
-      const packetIdBuffer = encodeVarInt(0);
-      const handshake = Buffer.concat([
-        encodeVarInt(handshakePayload.length + packetIdBuffer.length),
-        packetIdBuffer,
-        handshakePayload,
-      ]);
-
-      client.write(handshake);
-
-      // 2. Status Request
-      const statusRequest = Buffer.concat([encodeVarInt(1), encodeVarInt(0)]);
-      client.write(statusRequest);
-      startTime = Date.now();
-    });
-
-    let data = Buffer.alloc(0);
-    client.on("data", (chunk: Buffer) => {
-      data = Buffer.concat([data, chunk]);
-
-      while (data.length > 0) {
-        try {
-          // Read packet length
-          const { value: packetLen, length: varIntLen } = decodeVarInt(data, 0);
-          if (data.length < packetLen + varIntLen) return; // Wait for more data
-
-          const packet = data.subarray(varIntLen, varIntLen + packetLen);
-          data = data.subarray(varIntLen + packetLen); // Consume packet
-
-          // Read packet ID
-          const { value: packetId, length: idLen } = decodeVarInt(packet, 0);
-
-          if (packetId === 0) {
-            const { value: jsonStr } = decodeString(packet, idLen);
-            response = JSON.parse(jsonStr);
-
-            // 3. Ping
-            const pingPayload = Buffer.alloc(8);
-            pingPayload.writeBigInt64BE(BigInt(startTime));
-            const pingPacket = Buffer.concat([
-              encodeVarInt(9),
-              encodeVarInt(1),
-              pingPayload,
-            ]);
-            client.write(pingPacket);
-          } else if (packetId === 1) {
-            const latency = Date.now() - startTime;
-            clearTimeout(timeoutHandler);
-            client.destroy();
-            resolve({ response, latency });
-            return;
-          }
-        } catch (e) {
-          // Return if we can't decode yet
-          return;
-        }
-      }
-    });
-
-    client.on("error", (err) => {
-      clearTimeout(timeoutHandler);
-      reject(err);
-    });
-  });
-}

package/src/target.ts

@@ -1,65 +0,0 @@
-import * as dns from "node:dns/promises";
-
-export interface Target {
-  host: string;
-  port: number;
-  protocol: "java" | "bedrock";
-  ip: string;
-}
-
-/**
- * Resolves host and port, handling SRV records and lookups.
- */
-export async function resolveTarget(
-  targetStr: string,
-  type: "java" | "bedrock" | null,
-): Promise<Target> {
-  let host = targetStr;
-  let port = type === "bedrock" ? 19132 : 25565;
-  const parts = targetStr.split(":");
-
-  if (parts.length === 2 && !isNaN(parseInt(parts[1]))) {
-    host = parts[0];
-    port = parseInt(parts[1]);
-    const ip = await resolveIp(host);
-    return { host, port, protocol: type === null ? "java" : type, ip };
-  }
-
-  // Attempt SRV resolution
-  if (type !== "bedrock") {
-    try {
-      const srv = await dns.resolveSrv(`_minecraft._tcp.${host}`);
-      if (srv && srv.length > 0) {
-        const srvHost = srv[0].name;
-        const srvPort = srv[0].port;
-        const ip = await resolveIp(srvHost);
-        return { host: srvHost, port: srvPort, protocol: "java", ip };
-      }
-    } catch (e) {}
-  }
-
-  if (type === "bedrock" && parts.length === 1) {
-    try {
-      const srv = await dns.resolveSrv(`_minecraft._udp.${host}`);
-      if (srv && srv.length > 0) {
-        const srvHost = srv[0].name;
-        const srvPort = srv[0].port;
-        const ip = await resolveIp(srvHost);
-        return { host: srvHost, port: srvPort, protocol: "bedrock", ip };
-      }
-    } catch (e) {}
-  }
-
-  const ip = await resolveIp(host);
-  return { host, port, protocol: type || "java", ip };
-}
-
-async function resolveIp(host: string): Promise<string> {
-  try {
-    const addresses = await dns.lookup(host);
-    return addresses.address;
-  } catch (e) {
-    // If lookup fails, return the host itself as a fallback
-    return host;
-  }
-}

package/src/varint.ts

@@ -1,53 +0,0 @@
-/**
- * VarInt encoding and decoding for Minecraft protocol.
- * Based on the specification at https://wiki.vg/Protocol#VarInt_and_VarLong
- */
-
-export function encodeVarInt(value: number): Buffer {
-  const bytes: number[] = [];
-  let temp = value >>> 0;
-
-  while (temp >= 0x80) {
-    bytes.push((temp & 0x7f) | 0x80);
-    temp >>>= 7;
-  }
-  bytes.push(temp);
-  return Buffer.from(bytes);
-}
-
-export function decodeVarInt(
-  buffer: Buffer,
-  offset = 0,
-): { value: number; length: number } {
-  let value = 0;
-  let length = 0;
-  let currentByte: number;
-
-  while (true) {
-    currentByte = buffer.readUInt8(offset + length);
-    value |= (currentByte & 0x7f) << (length * 7);
-    length++;
-    if (length > 5) throw new Error("VarInt is too big");
-    if ((currentByte & 0x80) !== 0x80) break;
-  }
-
-  return { value: value | 0, length };
-}
-
-export function encodeString(str: string): Buffer {
-  const content = Buffer.from(str, "utf8");
-  return Buffer.concat([encodeVarInt(content.length), content]);
-}
-
-export function decodeString(
-  buffer: Buffer,
-  offset = 0,
-): { value: string; length: number } {
-  const { value: strLen, length: varIntLen } = decodeVarInt(buffer, offset);
-  const value = buffer.toString(
-    "utf8",
-    offset + varIntLen,
-    offset + varIntLen + strLen,
-  );
-  return { value, length: varIntLen + strLen };
-}