@vaitosoi/minejs 0.4.2 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaitosoi/minejs",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "A Minecraft client package",
   "license": "MIT",
   "repository": {
@@ -28,19 +28,17 @@
     "@clean-jsdoc-theme/typedoc": "5.0.5",
     "@eslint/js": "^10.0.1",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "@types/bun": "latest",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.4.0",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "eslint": "^10.4.1",
-    "globals": "^17.6.0",
-    "tsx": "^4.22.4",
+    "eslint": "^10.9.1",
+    "globals": "^17.11.0",
+    "tsx": "^4.23.12",
     "typedoc": "^0.28.20",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "typescript-eslint": "^8.60.1"
+    "typescript-eslint": "^8.68.0"
   },
   "dependencies": {
-    "bitset": "^5.2.3",
-    "zod": "^4.4.3"
+    "zod": "^4.5.2"
   },
-  "packageManager": "pnpm@11.15.1+sha512.81350b07e53c9538a02f1f2303b4290fa2d7be04e56e2a970c4cc4b417dc761de196edabd49d55c7dc9580db81007c44143e4e3d7e462b3000d23c255122d065"
+  "packageManager": "pnpm@11.24.0"
 }

package/src/base/bitset.ts

@@ -1,42 +1,323 @@
-import BitSet_ from "bitset";
+import assert from "node:assert";
+import { UnexpectedValue } from "./error";
+import { numberOfLeadingZeros, numberOfTrailingZeros } from "./math";
+
 
 /**
- * Custom implementation of BitSet to implement missing method
+ * Simplified implementation of the Java's BitSet class
+ * 
+ * @see https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/BitSet.java
+ * @hidden
  */
-export class BitSet extends BitSet_ {
-    public nextClearBit(fromIndex: number) {
-        fromIndex = fromIndex || 0;
-        const data = (this as any)['data'];
-        let wordIndex = fromIndex >>> 5;
+export class BitSet {
+    public static readonly ADDRESS_BITS_PER_WORD = 6;
+    public static readonly BITS_PER_WORD = 1 << this.ADDRESS_BITS_PER_WORD;
+    public static readonly WORD_MASK = 0xffffffffffffffffn;
+
+    public words: BigUint64Array;
+    public wordsInUse: number = 0;
+
+    private static wordIndex(bitIndex: number) {
+        return bitIndex >> this.ADDRESS_BITS_PER_WORD;
+    }
+
+    private static bitIndexInWord(bitIndex: number) {
+        return bitIndex & (this.BITS_PER_WORD - 1); // should be bitIndex & 63
+    }
+
+    /**
+     * Create a mask with lowest `n` bits set to 1
+     * 
+     * For example:
+     * * n = 0 -> `0b0n`
+     * * n = 3 -> `0b111n`
+     * * n = 5 -> `0b11111n`
+     * 
+     * @param nBits 
+     * @returns 
+     */
+    private static lowBits(nBits: number) {
+        return (1n << BigInt(nBits)) - 1n;
+    }
+
+    private initWords(nBits: number) {
+        return new BigUint64Array(BitSet.wordIndex(nBits - 1) + 1);
+    }
+
+    private static checkRange(fromIndex: number, toIndex: number) {
+        if (fromIndex < 0)
+            throw new UnexpectedValue("value of fromIndex", fromIndex.toString(), "non-negative number");
+        if (toIndex < 0)
+            throw new UnexpectedValue("value of toIndex", toIndex.toString(), "non-negative number");
+        if (fromIndex > toIndex)
+            throw new UnexpectedValue("fromIndex and toIndex", `fromIndex ${fromIndex}; toIndex ${toIndex}`, "fromIndex has to be smaller than toIndex");
+    }
+
+
+    constructor(nBits?: number) {
+        if (nBits && nBits < 0)
+            throw new UnexpectedValue("length of bitset", nBits.toString(), "non-negative number");
+        this.words = this.initWords(nBits ?? BitSet.BITS_PER_WORD);
+    }
+
+    public clone() {
+        const bitset = new BitSet(0);
+        bitset.words = structuredClone(this.words);
+        bitset.wordsInUse = this.wordsInUse;
+        bitset.checkInvariants();
+        return bitset;
+    }
 
-        if (wordIndex >= data.length) {
-            // Past the stored words — depends on the infinite tail bit
-            return (this as any)['_'] === 0 ? fromIndex : Infinity;
+    private expandTo(wordIndex: number) {
+        const wordsRequired = wordIndex + 1;
+        if (this.wordsInUse < wordsRequired) {
+            this.ensureCapacity(wordsRequired);
+            this.wordsInUse = wordsRequired;
         }
+    }
 
-        // ~word marks clear bits; mask off anything before fromIndex.
-        // JS's << only uses the low 5 bits of the shift amount, so
-        // `-1 << fromIndex` masks correctly even when fromIndex > 31.
-        let word = ~data[wordIndex] & (-1 << fromIndex);
+    private ensureCapacity(wordsRequired: number) {
+        if (wordsRequired > this.words.length) {
+            // Allocate larger of doubled size or required size
+            const request = Math.max(2 * this.words.length, wordsRequired);
+            const newWords = new BigUint64Array(request);
+            newWords.set(this.words);
+            this.words = newWords;
+        }
+    }
 
-        while (true) {
-            if (word !== 0) {
-                const lowestSet = word & -word;   // isolate lowest set bit
-                let c = 0;
-                for (let v = lowestSet; (v >>>= 1); c++) {
-                    //
-                }
-                return wordIndex * 32 + c;
-            }
-            wordIndex++;
-            if (wordIndex >= data.length) {
-                return (this as any)['_'] === 0 ? wordIndex * 32 : Infinity;
+    private recalculateWordsInUse() {
+        let i = this.wordsInUse - 1;
+        while (i >= 0 && this.words[i] === 0n) i--;
+        this.wordsInUse = i + 1; // The new logical size
+    }
+
+    private checkInvariants() {
+        assert(this.wordsInUse === 0 || this.words[this.wordsInUse - 1] !== 0n);
+        assert(this.wordsInUse >= 0 && this.wordsInUse <= this.words.length);
+        assert(this.wordsInUse === this.words.length || this.words[this.wordsInUse] === 0n);
+    }
+
+
+    public toByteArray() {
+        const n = this.wordsInUse;
+        if (n == 0)
+            return [];
+
+        const bytes: number[] = [];
+        for (const word of this.words) {
+            let coppiedWord = structuredClone(word);
+            // Slice a 64-bit (or 8-byte word) into 8 8-bit (or 1-byte) slices
+            for (let i = 0; i < 8; i++) {
+                bytes.push(Number(coppiedWord & 0xffn));
+                coppiedWord >>= 8n;
             }
-            word = ~data[wordIndex];
         }
-    };
 
-    public override clone(): BitSet {
-        return new BitSet(this.toString());
+        while (bytes.length > 0 && bytes.at(-1) === 0) bytes.pop();
+        return bytes;
+    }
+
+    public flip(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        this.expandTo(wordIndex);
+
+        this.words[wordIndex]! ^= BigInt(BitSet.bitIndexInWord(bitIndex));
+
+        this.recalculateWordsInUse();
+        this.checkInvariants();
     }
-}
+
+    public set(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        this.expandTo(wordIndex);
+
+        this.words[wordIndex]! |= 1n << BigInt(BitSet.bitIndexInWord(bitIndex)); // Restores invariants
+
+        this.checkInvariants();
+    }
+    public setRange(fromIndex: number, toIndex: number) {
+        BitSet.checkRange(fromIndex, toIndex);
+
+        if (fromIndex == toIndex)
+            return;
+
+        // Increase capacity if necessary
+        const startWordIndex = BitSet.wordIndex(fromIndex);
+        const endWordIndex = BitSet.wordIndex(toIndex - 1);
+        this.expandTo(endWordIndex);
+
+        const fromBit = BitSet.bitIndexInWord(fromIndex),
+            toBitInclusive = BitSet.bitIndexInWord(toIndex - 1) + 1,
+
+            /**
+             * The NOT (~) bitwise meaning:
+             * 
+             * Let say we want to set 2 to 6:
+             * ```
+             * 110010100
+             *    ^   ^
+             *    |   +-- this is the 2nd bit
+             *  and this is the 6th bit
+             * ```
+             * 
+             * So we call lowBits(2) and it return `...0011`
+             * 
+             * Then we have to flip it to `...1100` to access the '2nd bit and the bits after it'
+             */
+            firstWordMask = ~BitSet.lowBits(fromBit),
+            lastWordMask = BitSet.lowBits(toBitInclusive);
+        if (startWordIndex == endWordIndex) {
+            // Case 1: One word
+            this.words[startWordIndex]! |= (firstWordMask & lastWordMask);
+        } else {
+            // Case 2: Multiple words
+            // Handle first word
+            this.words[startWordIndex]! |= firstWordMask;
+
+            // Handle intermediate words, if any
+            for (let i = startWordIndex + 1; i < endWordIndex; i++)
+                this.words[i] = BitSet.WORD_MASK;
+
+            // Handle last word (restores invariants)
+            this.words[endWordIndex]! |= lastWordMask;
+        }
+
+        this.checkInvariants();
+    }
+
+
+    public clear(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        if (wordIndex >= this.wordsInUse)
+            return;
+
+        this.words[wordIndex]! &= ~(1n << BigInt(bitIndex));
+
+        this.recalculateWordsInUse();
+        this.checkInvariants();
+    }
+    public clearRange(fromIndex: number, toIndex: number) {
+        BitSet.checkRange(fromIndex, toIndex);
+
+        if (fromIndex == toIndex)
+            return;
+
+        const startWordIndex = BitSet.wordIndex(fromIndex);
+        if (startWordIndex >= this.wordsInUse)
+            return;
+
+        let endWordIndex = BitSet.wordIndex(toIndex - 1);
+        if (endWordIndex >= this.wordsInUse) {
+            toIndex = this.length();
+            endWordIndex = this.wordsInUse - 1;
+        }
+
+        const fromBit = BitSet.bitIndexInWord(fromIndex),
+            toBitInclusive = BitSet.bitIndexInWord(toIndex - 1) + 1,
+            /**
+             * See the explaination in the setRange function
+             */
+            firstWordMask = ~BitSet.lowBits(fromBit),
+            lastWordMask = BitSet.lowBits(toBitInclusive);
+        if (startWordIndex == endWordIndex) {
+            // Case 1: One word
+            this.words[startWordIndex]! &= ~(firstWordMask & lastWordMask);
+        } else {
+            // Case 2: Multiple words
+            // Handle first word
+            this.words[startWordIndex]! &= ~firstWordMask;
+
+            // Handle intermediate words, if any
+            for (let i = startWordIndex + 1; i < endWordIndex; i++)
+                this.words[i]! = 0n;
+
+            // Handle last word
+            this.words[endWordIndex]! &= ~lastWordMask;
+        }
+
+        this.recalculateWordsInUse();
+        this.checkInvariants();
+    }
+
+
+    public get(bitIndex: number) {
+        if (bitIndex < 0)
+            throw new UnexpectedValue("value of bitIndex", bitIndex.toString(), "non-negative number");
+
+        this.checkInvariants();
+
+        const wordIndex = BitSet.wordIndex(bitIndex);
+        if (wordIndex >= this.wordsInUse) return false;
+
+        const bit = 1n << BigInt(BitSet.bitIndexInWord(bitIndex));
+        return (Number(this.words[wordIndex]! & bit) != 0);
+    }
+
+    public nextSetBit(fromIndex: number) {
+        if (fromIndex < 0)
+            throw new UnexpectedValue("value of fromIndex", fromIndex.toString(), "non-negative number");
+
+        this.checkInvariants();
+
+        let u = BitSet.wordIndex(fromIndex);
+        if (u >= this.wordsInUse)
+            return -1;
+
+        let word = this.words[u]! & (~0n << BigInt(BitSet.bitIndexInWord(fromIndex)));
+
+        while (true) {
+            if (word != 0n)
+                return (u * BitSet.BITS_PER_WORD) + numberOfTrailingZeros(word);
+            if (++u == this.wordsInUse)
+                return -1;
+            word = this.words[u]!;
+        }
+    }
+
+    public nextClearBit(fromIndex: number) {
+        // Neither spec nor implementation handle bitsets of maximal length.
+        // See 4816253.
+        if (fromIndex < 0)
+            throw new UnexpectedValue("value of fromIndex", fromIndex.toString(), "non-negative number");
+
+        this.checkInvariants();
+
+        let u = BitSet.wordIndex(fromIndex);
+        if (u >= this.wordsInUse)
+            return fromIndex;
+
+        let word = ~this.words[u]! & (BitSet.WORD_MASK << BigInt(fromIndex));
+
+        while (true) {
+            if (word != 0n)
+                return (u * BitSet.BITS_PER_WORD) + numberOfTrailingZeros(word);
+            if (++u == this.wordsInUse)
+                return this.wordsInUse * BitSet.BITS_PER_WORD;
+            word = ~this.words[u]!;
+        }
+    }
+
+    public length() {
+        if (this.wordsInUse == 0)
+            return 0;
+
+        return BitSet.BITS_PER_WORD * (this.wordsInUse - 1) +
+            (BitSet.BITS_PER_WORD - numberOfLeadingZeros(this.words[this.wordsInUse - 1]!));
+    }
+
+    public isEmpty() {
+        return this.wordsInUse == 0;
+    }
+}
+
+export default BitSet;

package/src/base/cache.ts

@@ -0,0 +1,62 @@
+/**
+ * The base implementation for the Cache class
+ */
+export abstract class CacheImplementation<T = any> {
+    public abstract put(key: string, item: T): void;
+    public abstract get(key: string): T | undefined;
+    public abstract del(key: string): void;
+}
+
+/**
+ * The LRU cache implementation.
+ * 
+ * @see https://en.wikipedia.org/wiki/Cache_replacement_policies#Time-Aware,_Least_Recently_Used_(TLRU)
+ */
+export class LRUCache<T> extends CacheImplementation<T> {
+    private hash: Map<string, T> = new Map();
+    private list: string[] = [];
+
+    constructor(private capacity: number) {
+        super();
+    }
+
+    public put(key: string, item: T): void {
+        if (this.hash.has(key)) {
+            const oldIndex = this.list.indexOf(key);
+            if (oldIndex > -1)
+                this.list.splice(oldIndex, 1);
+        }
+
+        this.hash.set(key, item);
+        this.list.push(key);
+
+        this.truncateHash();
+    }
+
+    public get(key: string) {
+        if (!this.hash.has(key)) return undefined;
+
+        const item = this.hash.get(key);
+        const oldIndex = this.list.indexOf(key);
+        if (oldIndex > -1)
+            this.list.splice(oldIndex, 1);
+        this.list.push(key);
+        
+        return item;
+    }
+
+    public del(key: string): void {
+        const oldIndex = this.list.indexOf(key);
+        if (oldIndex > -1)
+            this.list.splice(oldIndex, 1);
+        this.hash.delete(key);
+    }
+
+    private truncateHash() {
+        while (this.list.length > this.capacity) {
+            const popping = this.list.pop();
+            if (popping)
+                this.hash.delete(popping);
+        }
+    }
+}

package/src/base/error.ts

@@ -131,6 +131,7 @@ export class MissingAuthOption extends Error {
     }
 }
 
+/** @hidden */
 export class AuthRelatedNotFound extends Error {
     constructor(public component: string) {
         super(`auth option is enabled, but the auth related component (${component}) is not found`);
@@ -190,18 +191,33 @@ export class NotImplemented extends Error {
     }
 }
 
+
+/** @hidden */
+export class SkippableNotImplemented extends Error {}
+
 /*
  * Messages
  */
 
+/** @hidden */
 export class MessageLinkNotFound extends Error {
     constructor(public senderUUID: string) {
         super(`message link of sender ${senderUUID} not found, maybe because server has sent out of order packet`);
     }
 }
 
+/** @hidden */
 export class HaveSignatureButNotIndex extends Error {
     constructor() {
         super (`expecting both shouldVerifyMessageOrder set to true when shouldVerifyMessageSignature set to true`);
     }
+}
+
+/**
+ * @hidden
+ */
+export class MessageTooLong extends Error {
+    constructor(public message: string) {
+        super(`your message is exceeding the 256 characters long limit, got ${message.length} characters`);
+    }
 }

package/src/base/math.ts

@@ -112,4 +112,46 @@ export function minecraftSha1(
 function mcHexDigest(digest: Buffer | Uint8Array): string {
     const bigint = BigInt(`0x${digest.toString('hex')}`);
     return BigInt.asIntN(digest.length * 8, bigint).toString(16);
-}
+}
+
+/**
+ * Simplified implementation of Java's Long.numberOfTrailingZeros
+ * @param n 
+ * @returns 
+ */
+export function numberOfTrailingZeros(n: bigint): number {
+    if (n === 0n) {
+        return 64;
+    }
+
+    let count = 0;
+    while ((n & 1n) === 0n) {
+        count++;
+        n >>= 1n;
+    }
+
+    return count;
+}
+
+/**
+ * Simplified implementation of Java's Long.numberOfLeadingZeros
+ * @param n 
+ * @returns 
+ */
+export function numberOfLeadingZeros(n: bigint): number {
+    if (n === 0n) {
+        return 64;
+    }
+
+    let count = 0;
+    // Start checking from bit 63 (the most significant bit)
+    for (let i = 63; i >= 0; i--) {
+        if ((n & (1n << BigInt(i))) === 0n) {
+            count++;
+        } else {
+            break; // Stop at the first 1 bit
+        }
+    }
+
+    return count;
+}

package/src/base/typing.ts

@@ -8,3 +8,8 @@ export type If<Condition extends boolean, True, False = null> = Condition extend
  * @see https://minecraft.wiki/w/Text_component_format
  */
 export type TextComponent = Record<string, any>;
+
+export interface RegistryData {
+    registry_id: string,
+    entries: { entry_id: string, data: Record<string, any> | null }[]
+}

package/src/{packet → binary}/encoder.ts

@@ -62,9 +62,13 @@ export class BinaryEncoder {
      */
     public writeInt(val: number) { return this.write(4, val, (buf) => buf.writeInt32BE); }
     /**
-     * Write 6 bytes singed integer
+     * Write 8 bytes singed integer
      */
-    public writeLong(val: bigint) { return this.write(8, val, (buf) => buf.writeBigInt64BE); }
+    public writeLong(val: bigint | number) {
+        // Cast to BigInt 
+        const v = typeof val === "bigint" ? val : BigInt(val);
+        return this.write(8, v, (buf) => buf.writeBigInt64BE); 
+    }
     /**
      * Write 4 bytes float
      */