sonolus-next-rush-engine 0.1.0

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.d.ts

@@ -0,0 +1,109 @@
+declare const FlickType: readonly ["none", "up", "left", "right", "down", "down_left", "down_right"];
+type FlickType = (typeof FlickType)[number];
+declare const StepType: readonly ["visible", "hidden", "ignored"];
+type StepType = (typeof StepType)[number];
+declare const EaseType: readonly ["linear", "easeIn", "easeOut", "easeInOut", "easeOutIn"];
+export type EaseType = (typeof EaseType)[number];
+export interface Score {
+    metadata: {
+        title: string;
+        author: string;
+        artist: string;
+        musicFile: string;
+        musicOffset: number;
+        jacketFile: string;
+    };
+    events: {
+        timeSignatures: {
+            measure: number;
+            numerator: number;
+            denominator: number;
+        }[];
+        bpmChanges: {
+            tick: number;
+            bpm: number;
+        }[];
+        hispeedChanges: {
+            tick: number;
+            speed: number;
+            layer: number;
+            skip?: number;
+            ease?: number;
+            hideNotes?: boolean;
+        }[];
+        skills: number[];
+        fever: {
+            start: number;
+            end: number;
+        };
+    };
+    taps: {
+        tick: number;
+        lane: number;
+        width: number;
+        flickType: FlickType;
+        flags: {
+            critical: boolean;
+            friction: boolean;
+            dummy?: boolean;
+        };
+        layer: number;
+    }[];
+    holds: {
+        flags: {
+            startHidden: boolean;
+            endHidden: boolean;
+            guide: boolean;
+            dummy?: boolean;
+        };
+        start: {
+            tick: number;
+            lane: number;
+            width: number;
+            flags: {
+                critical: boolean;
+                friction: boolean;
+            };
+            layer: number;
+            ease: EaseType;
+        };
+        fadeType: number;
+        guideColor: number;
+        steps: {
+            tick: number;
+            lane: number;
+            width: number;
+            type: StepType;
+            ease: EaseType;
+            layer: number;
+        }[];
+        end: {
+            tick: number;
+            lane: number;
+            width: number;
+            flickType: FlickType;
+            flags: {
+                critical: boolean;
+                friction: boolean;
+            };
+            layer: number;
+        };
+    }[];
+    damages: {
+        tick: number;
+        lane: number;
+        width: number;
+        flickType: FlickType;
+        flags: {
+            critical: boolean;
+            friction: boolean;
+            dummy?: boolean;
+        };
+        layer: number;
+    }[];
+    numLayers: number;
+}
+/** Detect MMWS Type */
+export declare const detectMMWSType: (mmws: Uint8Array) => string;
+export declare const analyze: (mmws: Uint8Array) => Score;
+export {};