sonolus-next-rush-plus-engine 1.3.4 → 1.3.5

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { USC } from './usc/index.js';
 export { susToUSC, mmwsToUSC, uscToLevelData };
 export * from './usc/index.js';
 export declare const convertToLevelData: (input: string | Uint8Array | USC | LevelData, offset?: number) => LevelData;
-export declare const version = "1.3.4";
+export declare const version = "1.3.5";
 export declare const databaseEngineItem: {
     readonly name: "next-rush-plus";
     readonly version: 13;

package/dist/index.js

@@ -48,7 +48,7 @@ function isLevelData(data) {
         'entities' in data &&
         Array.isArray(data.entities));
 }
-export const version = '1.3.4';
+export const version = '1.3.5';
 export const databaseEngineItem = {
     name: 'next-rush-plus',
     version: 13,

package/dist/lib/binaryseeker/mod.d.ts

@@ -0,0 +1,14 @@
+export * from './reader.js';
+export * from './writer.js';
+import { BinaryReader } from './reader.js';
+/**
+ * Alias of BinaryReader, for compatibility with the old name.
+ * @deprecated Use BinaryReader instead.
+ */
+export declare const BinarySeeker: typeof BinaryReader;
+/**
+ * Alias of BinaryReader, for compatibility with the old name.
+ * @deprecated Use BinaryReader instead.
+ */
+export type BinarySeeker = BinaryReader;
+export default BinarySeeker;

package/dist/lib/binaryseeker/mod.js

@@ -0,0 +1,9 @@
+export * from './reader.js';
+export * from './writer.js';
+import { BinaryReader } from './reader.js';
+/**
+ * Alias of BinaryReader, for compatibility with the old name.
+ * @deprecated Use BinaryReader instead.
+ */
+export const BinarySeeker = BinaryReader;
+export default BinarySeeker;

package/dist/lib/binaryseeker/reader.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Simple cursor-based binary reader.
+ * @module
+ */
+/**
+ * Simple cursor-based binary reader.
+ */
+export declare class BinaryReader {
+    #private;
+    /**
+     * Create a new BinarySeeker instance.
+     * @param data - The ArrayBuffer to read from.
+     * @returns A new BinarySeeker instance.
+     */
+    constructor(data: ArrayBufferLike);
+    /**
+     * Returns the current cursor position.
+     */
+    get cursor(): number;
+    /**
+     * Seek to a specific offset in the buffer.
+     * @param offset - The offset to seek to.
+     */
+    seek(offset: number): void;
+    /**
+     * Read a single byte from the buffer.
+     * @returns The byte read.
+     */
+    readUInt8(): number;
+    /**
+     * Read a single signed byte from the buffer.
+     * @returns The byte read.
+     */
+    readInt8(): number;
+    /**
+     * Read a number from the buffer.
+     *
+     * > [!NOTE]
+     * > In most cases, you should use the `read[Type][Endian]` method instead.
+     *
+     * @param type - The type of number to read.
+     * @param endian - The endianness to read the number in.
+     * @returns The number read.
+     */
+    read(kind: 'u32' | 'u16' | 'i32' | 'i16' | 'f32' | 'f64' | 'u8' | 'i8', endian?: 'le' | 'be'): number;
+    /**
+     * Read unsigned 64-bit integer (u64) from the buffer.
+     * @returns The number read.
+     */
+    readUInt64LE(): bigint;
+    /**
+     * Read unsigned 32-bit integer (u32) from the buffer.
+     * @returns The number read.
+     */
+    readUInt32LE(): number;
+    /**
+     * Read unsigned 16-bit integer (u16) from the buffer.
+     * @returns The number read.
+     */
+    readUInt16LE(): number;
+    /**
+     * Read signed 64-bit integer (i64) from the buffer.
+     * @returns The number read.
+     */
+    readInt64LE(): bigint;
+    /**
+     * Read signed 32-bit integer (i32) from the buffer.
+     * @returns The number read.
+     */
+    readInt32LE(): number;
+    /**
+     * Read signed 16-bit integer from the buffer.
+     * @returns The number read.
+     */
+    readInt16LE(): number;
+    /**
+     * Read unsigned 64-bit integer (u64) from the buffer.
+     * @returns The number read.
+     */
+    readUInt64BE(): bigint;
+    /**
+     * Read unsigned 32-bit integer (u32) from the buffer.
+     * @returns The number read.
+     */
+    readUInt32BE(): number;
+    /**
+     * Read unsigned 16-bit integer (u16) from the buffer.
+     * @returns The number read.
+     */
+    readUInt16BE(): number;
+    /**
+     * Read signed 64-bit integer (i64) from the buffer.
+     * @returns The number read.
+     */
+    readInt64BE(): bigint;
+    /**
+     * Read signed 32-bit integer (i32) from the buffer.
+     * @returns The number read.
+     */
+    readInt32BE(): number;
+    /**
+     * Read signed 16-bit integer from the buffer.
+     * @returns The number read.
+     */
+    readInt16BE(): number;
+    /**
+     * Read a 32-bit floating point number (f32, float) from the buffer.
+     * @returns The number read.
+     */
+    readFloat32BE(): number;
+    /**
+     * Read a 64-bit floating point number (f64, double) from the buffer.
+     * @returns The number read.
+     */
+    readFloat64BE(): number;
+    /** Alias for `readFloat32BE` */
+    readFloat32(): number;
+    /** Alias for `readFloat64BE` */
+    readFloat64(): number;
+    /**
+     * Read a 32-bit floating point number (f32, float) in little-endian from the buffer.
+     * @returns The number read.
+     */
+    readFloat32LE(): number;
+    /**
+     * Read a 64-bit floating point number (f64, double) in little-endian from the buffer.
+     * @returns The number read.
+     */
+    readFloat64LE(): number;
+    /**
+     * Read a null-terminated string from the buffer.
+     * @returns The string read.
+     */
+    readString(): string;
+    /**
+     * Read a fixed-length buffer from the buffer.
+     * @param length - The length of the buffer to read.
+     * @returns The buffer read.
+     */
+    readBytes(length: number): Uint8Array;
+    /**
+     * Read buffer from the current cursor to the end of the buffer.
+     * @returns The buffer read.
+     */
+    readToEnd(): Uint8Array;
+    /**
+     * Read a fixed-length string from the buffer.
+     * This is a shorthand for `readBytes` and `TextDecoder`.
+     * @param length - The length of the string to read.
+     * @returns The string read.
+     */
+    readChars(length: number): string;
+    /**
+     * Returns if there are more data to read.
+     */
+    get hasMoreData(): boolean;
+}

package/dist/lib/binaryseeker/reader.js

@@ -0,0 +1,305 @@
+/**
+ * Simple cursor-based binary reader.
+ * @module
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BinaryReader_data, _BinaryReader_cursor;
+/**
+ * Simple cursor-based binary reader.
+ */
+export class BinaryReader {
+    /**
+     * Create a new BinarySeeker instance.
+     * @param data - The ArrayBuffer to read from.
+     * @returns A new BinarySeeker instance.
+     */
+    constructor(data) {
+        _BinaryReader_data.set(this, void 0);
+        _BinaryReader_cursor.set(this, void 0);
+        __classPrivateFieldSet(this, _BinaryReader_data, new DataView(data), "f");
+        __classPrivateFieldSet(this, _BinaryReader_cursor, 0, "f");
+    }
+    /**
+     * Returns the current cursor position.
+     */
+    get cursor() {
+        return __classPrivateFieldGet(this, _BinaryReader_cursor, "f");
+    }
+    /**
+     * Seek to a specific offset in the buffer.
+     * @param offset - The offset to seek to.
+     */
+    seek(offset) {
+        __classPrivateFieldSet(this, _BinaryReader_cursor, offset, "f");
+    }
+    /**
+     * Read a single byte from the buffer.
+     * @returns The byte read.
+     */
+    readUInt8() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint8(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"));
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 1, "f");
+        return value;
+    }
+    /**
+     * Read a single signed byte from the buffer.
+     * @returns The byte read.
+     */
+    readInt8() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getInt8(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"));
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 1, "f");
+        return value;
+    }
+    /**
+     * Read a number from the buffer.
+     *
+     * > [!NOTE]
+     * > In most cases, you should use the `read[Type][Endian]` method instead.
+     *
+     * @param type - The type of number to read.
+     * @param endian - The endianness to read the number in.
+     * @returns The number read.
+     */
+    read(kind, endian = 'le') {
+        switch (kind) {
+            case 'u8':
+                return this.readUInt8();
+            case 'i8':
+                return this.readInt8();
+            case 'u32':
+                return endian === 'le' ? this.readUInt32LE() : this.readUInt32BE();
+            case 'u16':
+                return endian === 'le' ? this.readUInt16LE() : this.readUInt16BE();
+            case 'i32':
+                return endian === 'le' ? this.readInt32LE() : this.readInt32BE();
+            case 'i16':
+                return endian === 'le' ? this.readInt16LE() : this.readInt16BE();
+            case 'f32':
+                return endian === 'le' ? this.readFloat32LE() : this.readFloat32BE();
+            case 'f64':
+                return endian === 'le' ? this.readFloat64LE() : this.readFloat64BE();
+            default:
+                kind;
+                throw new Error(`Unknown type: ${kind}`);
+        }
+    }
+    /**
+     * Read unsigned 64-bit integer (u64) from the buffer.
+     * @returns The number read.
+     */
+    readUInt64LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getBigUint64(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 8, "f");
+        return value;
+    }
+    /**
+     * Read unsigned 32-bit integer (u32) from the buffer.
+     * @returns The number read.
+     */
+    readUInt32LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint32(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 4, "f");
+        return value;
+    }
+    /**
+     * Read unsigned 16-bit integer (u16) from the buffer.
+     * @returns The number read.
+     */
+    readUInt16LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint16(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 2, "f");
+        return value;
+    }
+    /**
+     * Read signed 64-bit integer (i64) from the buffer.
+     * @returns The number read.
+     */
+    readInt64LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getBigInt64(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 8, "f");
+        return value;
+    }
+    /**
+     * Read signed 32-bit integer (i32) from the buffer.
+     * @returns The number read.
+     */
+    readInt32LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getInt32(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 4, "f");
+        return value;
+    }
+    /**
+     * Read signed 16-bit integer from the buffer.
+     * @returns The number read.
+     */
+    readInt16LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getInt16(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 2, "f");
+        return value;
+    }
+    /**
+     * Read unsigned 64-bit integer (u64) from the buffer.
+     * @returns The number read.
+     */
+    readUInt64BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getBigUint64(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 8, "f");
+        return value;
+    }
+    /**
+     * Read unsigned 32-bit integer (u32) from the buffer.
+     * @returns The number read.
+     */
+    readUInt32BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint32(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 4, "f");
+        return value;
+    }
+    /**
+     * Read unsigned 16-bit integer (u16) from the buffer.
+     * @returns The number read.
+     */
+    readUInt16BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint16(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 2, "f");
+        return value;
+    }
+    /**
+     * Read signed 64-bit integer (i64) from the buffer.
+     * @returns The number read.
+     */
+    readInt64BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getBigInt64(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 8, "f");
+        return value;
+    }
+    /**
+     * Read signed 32-bit integer (i32) from the buffer.
+     * @returns The number read.
+     */
+    readInt32BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getInt32(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 4, "f");
+        return value;
+    }
+    /**
+     * Read signed 16-bit integer from the buffer.
+     * @returns The number read.
+     */
+    readInt16BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getInt16(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 2, "f");
+        return value;
+    }
+    /**
+     * Read a 32-bit floating point number (f32, float) from the buffer.
+     * @returns The number read.
+     */
+    readFloat32BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getFloat32(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 4, "f");
+        return value;
+    }
+    /**
+     * Read a 64-bit floating point number (f64, double) from the buffer.
+     * @returns The number read.
+     */
+    readFloat64BE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getFloat64(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), false);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 8, "f");
+        return value;
+    }
+    /** Alias for `readFloat32BE` */
+    readFloat32() {
+        return this.readFloat32BE();
+    }
+    /** Alias for `readFloat64BE` */
+    readFloat64() {
+        return this.readFloat64BE();
+    }
+    /**
+     * Read a 32-bit floating point number (f32, float) in little-endian from the buffer.
+     * @returns The number read.
+     */
+    readFloat32LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getFloat32(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 4, "f");
+        return value;
+    }
+    /**
+     * Read a 64-bit floating point number (f64, double) in little-endian from the buffer.
+     * @returns The number read.
+     */
+    readFloat64LE() {
+        const value = __classPrivateFieldGet(this, _BinaryReader_data, "f").getFloat64(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"), true);
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 8, "f");
+        return value;
+    }
+    /**
+     * Read a null-terminated string from the buffer.
+     * @returns The string read.
+     */
+    readString() {
+        const buffer = [];
+        while (true) {
+            const charCode = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint8(__classPrivateFieldGet(this, _BinaryReader_cursor, "f"));
+            __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + 1, "f");
+            if (charCode === 0) {
+                break;
+            }
+            buffer.push(charCode);
+        }
+        const decoder = new TextDecoder();
+        return decoder.decode(new Uint8Array(buffer));
+    }
+    /**
+     * Read a fixed-length buffer from the buffer.
+     * @param length - The length of the buffer to read.
+     * @returns The buffer read.
+     */
+    readBytes(length) {
+        const buffer = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            buffer[i] = __classPrivateFieldGet(this, _BinaryReader_data, "f").getUint8(__classPrivateFieldGet(this, _BinaryReader_cursor, "f") + i);
+        }
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_cursor, "f") + length, "f");
+        return buffer;
+    }
+    /**
+     * Read buffer from the current cursor to the end of the buffer.
+     * @returns The buffer read.
+     */
+    readToEnd() {
+        const buffer = new Uint8Array(__classPrivateFieldGet(this, _BinaryReader_data, "f").buffer, __classPrivateFieldGet(this, _BinaryReader_cursor, "f"));
+        __classPrivateFieldSet(this, _BinaryReader_cursor, __classPrivateFieldGet(this, _BinaryReader_data, "f").byteLength, "f");
+        return buffer;
+    }
+    /**
+     * Read a fixed-length string from the buffer.
+     * This is a shorthand for `readBytes` and `TextDecoder`.
+     * @param length - The length of the string to read.
+     * @returns The string read.
+     */
+    readChars(length) {
+        const buffer = this.readBytes(length);
+        const decoder = new TextDecoder();
+        return decoder.decode(buffer);
+    }
+    /**
+     * Returns if there are more data to read.
+     */
+    get hasMoreData() {
+        return __classPrivateFieldGet(this, _BinaryReader_cursor, "f") < __classPrivateFieldGet(this, _BinaryReader_data, "f").byteLength;
+    }
+}
+_BinaryReader_data = new WeakMap(), _BinaryReader_cursor = new WeakMap();

package/dist/lib/binaryseeker/writer.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Simple cursor-based binary writer.
+ * @module
+ */
+/**
+ * Simple cursor-based binary writer.
+ *
+ * On initialization, the writer creates a buffer with a default size of 256 bytes.
+ * The buffer will grow automatically as needed, but you can use {@link ensureSize} to reduce the number of resizing.
+ */
+export declare class BinaryWriter {
+    #private;
+    /**
+     * Create a new BinaryWriter instance.
+     * @param initialSize - The initial size of the buffer. The buffer will grow automatically as needed, but this parameter can help reduce the number of resizing.
+     * @returns A new BinaryWriter instance.
+     */
+    constructor(initialSize?: number);
+    /**
+     * Returns the current cursor position.
+     */
+    get cursor(): number;
+    /**
+     * Seek to a specific offset in the buffer.
+     */
+    seek(offset: number): void;
+    /**
+     * Write a single byte to the buffer.
+     * @param value - The byte to write.
+     */
+    writeUInt8(value: number): void;
+    /**
+     * Write a single signed byte to the buffer.
+     * @param value - The byte to write.
+     */
+    writeInt8(value: number): void;
+    /**
+     * Write a number to the buffer.
+     *
+     * > [!NOTE]
+     * > In most cases, you should use the `write[Type][Endian]` method instead.
+     *
+     * @param value - The number to write.
+     * @param kind - The type of number to write.
+     * @param endian - The endianness to write the number in.
+     */
+    write(value: number, kind: 'u32' | 'u16' | 'i32' | 'i16' | 'f32' | 'f64' | 'u8' | 'i8', endian?: 'le' | 'be'): void;
+    /**
+     * Write a 32-bit unsigned integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt32LE(value: number): void;
+    /**
+     * Write a 32-bit unsigned integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt32BE(value: number): void;
+    /**
+     * Write a 16-bit unsigned integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt16LE(value: number): void;
+    /**
+     * Write a 16-bit unsigned integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt16BE(value: number): void;
+    /**
+     * Write a signed 32-bit integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeInt32LE(value: number): void;
+    /**
+     * Write a signed 32-bit integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeInt32BE(value: number): void;
+    /**
+     * Write a signed 16-bit integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeInt16LE(value: number): void;
+    /**
+     * Write a signed 16-bit integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeInt16BE(value: number): void;
+    /**
+     * Write a 64-bit unsigned integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt64LE(value: bigint): void;
+    /**
+     * Write a 64-bit unsigned integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt64BE(value: bigint): void;
+    /**
+     * Write a 64-bit signed integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeInt64LE(value: bigint): void;
+    /**
+     * Write a 64-bit signed integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeInt64BE(value: bigint): void;
+    /**
+     * Write a 32-bit floating point number (f32, float) to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat32LE(value: number): void;
+    /**
+     * Write a 64-bit floating point number (f64, double) to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat64LE(value: number): void;
+    /**
+     * Write a 32-bit floating point number (f32, float) to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat32BE(value: number): void;
+    /**
+     * Write a 64-bit floating point number (f64, double) to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat64BE(value: number): void;
+    /** Alias for `writeFloat32LE` */
+    writeFloat32(value: number): void;
+    /** Alias for `writeFloat64LE` */
+    writeFloat64(value: number): void;
+    /**
+     * Write a null-terminated string to the buffer.
+     *
+     * @param value - The string to write.
+     */
+    writeString(value: string): void;
+    /**
+     * Write a buffer to the buffer.
+     *
+     * @param value - The buffer to write.
+     */
+    writeBytes(value: Uint8Array): void;
+    /**
+     * Write a string to the buffer, without null-terminating it.
+     *
+     * @param value - The string to write.
+     */
+    writeChars(value: string): void;
+    /**
+     * Save the buffer as a Uint8Array.
+     * @returns The buffer as a Uint8Array.
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Increase the buffer size to the specified size if the buffer is too small.
+     * @param size - The size to increase the buffer to.
+     * @returns The new buffer size.
+     */
+    ensureSize(size: number): number;
+    /** Get the current length of the buffer. */
+    get length(): number;
+    /** Get the current capacity of the buffer. */
+    get capacity(): number;
+    /** Allocate more space in the buffer, if needed. */
+    private preWrite;
+    /** Allocate more space in the buffer. */
+    private extendBuffer;
+    /** Update the cursor after writing to the buffer. */
+    private postWrite;
+}

package/dist/lib/binaryseeker/writer.js

@@ -0,0 +1,360 @@
+/**
+ * Simple cursor-based binary writer.
+ * @module
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BinaryWriter_data, _BinaryWriter_view, _BinaryWriter_maxCursor, _BinaryWriter_cursor;
+/**
+ * Simple cursor-based binary writer.
+ *
+ * On initialization, the writer creates a buffer with a default size of 256 bytes.
+ * The buffer will grow automatically as needed, but you can use {@link ensureSize} to reduce the number of resizing.
+ */
+export class BinaryWriter {
+    /**
+     * Create a new BinaryWriter instance.
+     * @param initialSize - The initial size of the buffer. The buffer will grow automatically as needed, but this parameter can help reduce the number of resizing.
+     * @returns A new BinaryWriter instance.
+     */
+    constructor(initialSize = 256) {
+        _BinaryWriter_data.set(this, void 0);
+        _BinaryWriter_view.set(this, void 0);
+        _BinaryWriter_maxCursor.set(this, void 0);
+        _BinaryWriter_cursor.set(this, void 0);
+        __classPrivateFieldSet(this, _BinaryWriter_data, new Uint8Array(initialSize), "f");
+        __classPrivateFieldSet(this, _BinaryWriter_view, new DataView(__classPrivateFieldGet(this, _BinaryWriter_data, "f").buffer), "f");
+        __classPrivateFieldSet(this, _BinaryWriter_cursor, 0, "f");
+        __classPrivateFieldSet(this, _BinaryWriter_maxCursor, 0, "f");
+    }
+    /**
+     * Returns the current cursor position.
+     */
+    get cursor() {
+        return __classPrivateFieldGet(this, _BinaryWriter_cursor, "f");
+    }
+    /**
+     * Seek to a specific offset in the buffer.
+     */
+    seek(offset) {
+        this.preWrite(offset - __classPrivateFieldGet(this, _BinaryWriter_cursor, "f"));
+        __classPrivateFieldSet(this, _BinaryWriter_cursor, offset, "f");
+        this.postWrite(0);
+    }
+    /**
+     * Write a single byte to the buffer.
+     * @param value - The byte to write.
+     */
+    writeUInt8(value) {
+        this.preWrite(1);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setUint8(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value);
+        this.postWrite(1);
+    }
+    /**
+     * Write a single signed byte to the buffer.
+     * @param value - The byte to write.
+     */
+    writeInt8(value) {
+        this.preWrite(1);
+        __classPrivateFieldGet(this, _BinaryWriter_data, "f")[__classPrivateFieldGet(this, _BinaryWriter_cursor, "f")] = value;
+        this.postWrite(1);
+    }
+    /**
+     * Write a number to the buffer.
+     *
+     * > [!NOTE]
+     * > In most cases, you should use the `write[Type][Endian]` method instead.
+     *
+     * @param value - The number to write.
+     * @param kind - The type of number to write.
+     * @param endian - The endianness to write the number in.
+     */
+    write(value, kind, endian = 'le') {
+        switch (kind) {
+            case 'u8':
+                this.writeUInt8(value);
+                break;
+            case 'i8':
+                this.writeInt8(value);
+                break;
+            case 'u32':
+                endian === 'le' ? this.writeUInt32LE(value) : this.writeUInt32BE(value);
+                break;
+            case 'u16':
+                endian === 'le' ? this.writeUInt16LE(value) : this.writeUInt16BE(value);
+                break;
+            case 'i32':
+                endian === 'le' ? this.writeInt32LE(value) : this.writeInt32BE(value);
+                break;
+            case 'i16':
+                endian === 'le' ? this.writeInt16LE(value) : this.writeInt16BE(value);
+                break;
+            case 'f32':
+                endian === 'le' ? this.writeFloat32LE(value) : this.writeFloat32BE(value);
+                break;
+            case 'f64':
+                endian === 'le' ? this.writeFloat64LE(value) : this.writeFloat64BE(value);
+                break;
+            default:
+                kind;
+                throw new Error(`Unknown kind: ${kind}`);
+        }
+    }
+    /**
+     * Write a 32-bit unsigned integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt32LE(value) {
+        this.preWrite(4);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setUint32(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(4);
+    }
+    /**
+     * Write a 32-bit unsigned integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt32BE(value) {
+        this.preWrite(4);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setUint32(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(4);
+    }
+    /**
+     * Write a 16-bit unsigned integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt16LE(value) {
+        this.preWrite(2);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setUint16(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(2);
+    }
+    /**
+     * Write a 16-bit unsigned integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt16BE(value) {
+        this.preWrite(2);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setUint16(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(2);
+    }
+    /**
+     * Write a signed 32-bit integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeInt32LE(value) {
+        this.preWrite(4);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setInt32(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(4);
+    }
+    /**
+     * Write a signed 32-bit integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeInt32BE(value) {
+        this.preWrite(4);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setInt32(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(4);
+    }
+    /**
+     * Write a signed 16-bit integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeInt16LE(value) {
+        this.preWrite(2);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setInt16(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(2);
+    }
+    /**
+     * Write a signed 16-bit integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeInt16BE(value) {
+        this.preWrite(2);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setInt16(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(2);
+    }
+    /**
+     * Write a 64-bit unsigned integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt64LE(value) {
+        this.preWrite(8);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setBigUint64(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(8);
+    }
+    /**
+     * Write a 64-bit unsigned integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeUInt64BE(value) {
+        this.preWrite(8);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setBigUint64(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(8);
+    }
+    /**
+     * Write a 64-bit signed integer to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeInt64LE(value) {
+        this.preWrite(8);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setBigInt64(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(8);
+    }
+    /**
+     * Write a 64-bit signed integer to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeInt64BE(value) {
+        this.preWrite(8);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setBigInt64(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(8);
+    }
+    /**
+     * Write a 32-bit floating point number (f32, float) to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat32LE(value) {
+        this.preWrite(4);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setFloat32(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(4);
+    }
+    /**
+     * Write a 64-bit floating point number (f64, double) to the buffer in little-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat64LE(value) {
+        this.preWrite(8);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setFloat64(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, true);
+        this.postWrite(8);
+    }
+    /**
+     * Write a 32-bit floating point number (f32, float) to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat32BE(value) {
+        this.preWrite(4);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setFloat32(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(4);
+    }
+    /**
+     * Write a 64-bit floating point number (f64, double) to the buffer in big-endian format.
+     * @param value - The number to write.
+     */
+    writeFloat64BE(value) {
+        this.preWrite(8);
+        __classPrivateFieldGet(this, _BinaryWriter_view, "f").setFloat64(__classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), value, false);
+        this.postWrite(8);
+    }
+    /** Alias for `writeFloat32LE` */
+    writeFloat32(value) {
+        this.writeFloat32LE(value);
+    }
+    /** Alias for `writeFloat64LE` */
+    writeFloat64(value) {
+        this.writeFloat64LE(value);
+    }
+    /**
+     * Write a null-terminated string to the buffer.
+     *
+     * @param value - The string to write.
+     */
+    writeString(value) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(value);
+        this.preWrite(bytes.length + 1);
+        for (let i = 0; i < bytes.length; i++) {
+            __classPrivateFieldGet(this, _BinaryWriter_data, "f")[__classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + i] = bytes[i];
+        }
+        __classPrivateFieldGet(this, _BinaryWriter_data, "f")[__classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + bytes.length] = 0;
+        this.postWrite(bytes.length + 1);
+    }
+    /**
+     * Write a buffer to the buffer.
+     *
+     * @param value - The buffer to write.
+     */
+    writeBytes(value) {
+        this.preWrite(value.length);
+        __classPrivateFieldGet(this, _BinaryWriter_data, "f").set(value, __classPrivateFieldGet(this, _BinaryWriter_cursor, "f"));
+        this.postWrite(value.length);
+    }
+    /**
+     * Write a string to the buffer, without null-terminating it.
+     *
+     * @param value - The string to write.
+     */
+    writeChars(value) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(value);
+        this.preWrite(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+            __classPrivateFieldGet(this, _BinaryWriter_data, "f")[__classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + i] = bytes[i];
+        }
+        this.postWrite(bytes.length);
+    }
+    /**
+     * Save the buffer as a Uint8Array.
+     * @returns The buffer as a Uint8Array.
+     */
+    toUint8Array() {
+        return Uint8Array.from(__classPrivateFieldGet(this, _BinaryWriter_data, "f").slice(0, __classPrivateFieldGet(this, _BinaryWriter_maxCursor, "f")));
+    }
+    /**
+     * Increase the buffer size to the specified size if the buffer is too small.
+     * @param size - The size to increase the buffer to.
+     * @returns The new buffer size.
+     */
+    ensureSize(size) {
+        if (__classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength < size) {
+            this.extendBuffer(size);
+        }
+        return __classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength;
+    }
+    /** Get the current length of the buffer. */
+    get length() {
+        return __classPrivateFieldGet(this, _BinaryWriter_maxCursor, "f");
+    }
+    /** Get the current capacity of the buffer. */
+    get capacity() {
+        return __classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength;
+    }
+    /** Allocate more space in the buffer, if needed. */
+    preWrite(size) {
+        if (__classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + size > __classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength) {
+            let newSize;
+            if (__classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength >= 2048) {
+                newSize = __classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength + 2048;
+            }
+            else {
+                newSize = __classPrivateFieldGet(this, _BinaryWriter_data, "f").byteLength * 2;
+            }
+            if (__classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + size > newSize) {
+                newSize = __classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + size;
+            }
+            this.extendBuffer(newSize);
+        }
+    }
+    /** Allocate more space in the buffer. */
+    extendBuffer(length) {
+        const newData = new Uint8Array(length);
+        newData.set(__classPrivateFieldGet(this, _BinaryWriter_data, "f"));
+        __classPrivateFieldSet(this, _BinaryWriter_data, newData, "f");
+        __classPrivateFieldSet(this, _BinaryWriter_view, new DataView(newData.buffer), "f");
+    }
+    /** Update the cursor after writing to the buffer. */
+    postWrite(size) {
+        __classPrivateFieldSet(this, _BinaryWriter_cursor, __classPrivateFieldGet(this, _BinaryWriter_cursor, "f") + size, "f");
+        if (__classPrivateFieldGet(this, _BinaryWriter_cursor, "f") > __classPrivateFieldGet(this, _BinaryWriter_maxCursor, "f")) {
+            __classPrivateFieldSet(this, _BinaryWriter_maxCursor, __classPrivateFieldGet(this, _BinaryWriter_cursor, "f"), "f");
+        }
+    }
+}
+_BinaryWriter_data = new WeakMap(), _BinaryWriter_view = new WeakMap(), _BinaryWriter_maxCursor = new WeakMap(), _BinaryWriter_cursor = new WeakMap();

package/dist/mmw/analyze.js

@@ -1,4 +1,4 @@
-import BinarySeeker from '@sevenc-nanashi/binaryseeker';
+import { BinarySeeker } from "../lib/binaryseeker/mod.js";
 const FlickType = ['none', 'up', 'left', 'right'];
 const StepType = ['visible', 'hidden', 'ignored'];
 const EaseType = ['linear', 'easeIn', 'easeOut', 'easeInOut', 'easeOutIn'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonolus-next-rush-plus-engine",
-  "version": "1.3.4",
+  "version": "1.3.5",
   "description": "A new Project Sekai inspired engine for Sonolus",
   "author": "Hyeon2",
   "repository": {
@@ -33,7 +33,6 @@
     "build": "tsc -p . && node ./build.js"
   },
   "dependencies": {
-    "@sevenc-nanashi/binaryseeker": "npm:@jsr/sevenc-nanashi__binaryseeker@^1.2.1",
     "@sonolus/core": "~7.14.2"
   },
   "devDependencies": {