osu-stable-db 0.1.0

package/dist/scores-7qsAMzUc.mjs

@@ -0,0 +1,665 @@
+//#region src/types.ts
+/**
+* The minimum legacy database version supported by this library.
+*
+* Only the latest stable structure introduced in version 20250107 is modeled.
+*/
+const MINIMUM_SUPPORTED_VERSION = 20250107;
+/**
+* Legacy gameplay mode identifiers used by osu!stable database files.
+*/
+const GameplayModes = {
+	Osu: 0,
+	Taiko: 1,
+	Catch: 2,
+	Mania: 3
+};
+/**
+* Beatmap ranked status values stored in osu!.db.
+*/
+const RankedStatuses = {
+	Unknown: 0,
+	Unsubmitted: 1,
+	Pending: 2,
+	Unused: 3,
+	Ranked: 4,
+	Approved: 5,
+	Qualified: 6,
+	Loved: 7
+};
+/**
+* Grade values stored in osu!.db for each ruleset.
+*
+* This matches legacy stable grade byte values used by osu!.db.
+*/
+const Grades = {
+	XH: 0,
+	SH: 1,
+	X: 2,
+	S: 3,
+	A: 4,
+	B: 5,
+	C: 6,
+	D: 7,
+	F: 8,
+	N: 9
+};
+/**
+* User permission flags stored in osu!.db.
+*/
+const UserPermissions = {
+	None: 0,
+	Normal: 1,
+	Moderator: 2,
+	Supporter: 4,
+	Friend: 8,
+	Peppy: 16,
+	WorldCupStaff: 32
+};
+/**
+* Legacy mod flags used by scores.db, osu!.db star ratings, and replay-derived data.
+*
+* This is a flag enum expressed as a const object. Values are intended to be combined
+* with bitwise operations such as `Hidden | HardRock`.
+*/
+const Mods = {
+	None: 0,
+	NoFail: 1,
+	Easy: 2,
+	TouchDevice: 4,
+	Hidden: 8,
+	HardRock: 16,
+	SuddenDeath: 32,
+	DoubleTime: 64,
+	Relax: 128,
+	HalfTime: 256,
+	Nightcore: 512,
+	Flashlight: 1024,
+	Autoplay: 2048,
+	SpunOut: 4096,
+	Autopilot: 8192,
+	Perfect: 16384,
+	Key4: 32768,
+	Key5: 65536,
+	Key6: 131072,
+	Key7: 262144,
+	Key8: 524288,
+	FadeIn: 1048576,
+	Random: 2097152,
+	Cinema: 4194304,
+	TargetPractice: 8388608,
+	Key9: 16777216,
+	KeyCoop: 33554432,
+	Key1: 67108864,
+	Key3: 134217728,
+	Key2: 268435456,
+	ScoreV2: 536870912,
+	Mirror: 1073741824
+};
+//#endregion
+//#region src/core/binary.ts
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+function toUint8Array(input) {
+	return input instanceof Uint8Array ? input : new Uint8Array(input);
+}
+var BinaryReader = class {
+	bytes;
+	view;
+	offset = 0;
+	constructor(input) {
+		this.bytes = toUint8Array(input);
+		this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+	}
+	get position() {
+		return this.offset;
+	}
+	get length() {
+		return this.bytes.byteLength;
+	}
+	get remaining() {
+		return this.length - this.offset;
+	}
+	readByte() {
+		this.ensureAvailable(1);
+		const value = this.view.getUint8(this.offset);
+		this.offset += 1;
+		return value;
+	}
+	readBoolean() {
+		return this.readByte() !== 0;
+	}
+	readInt16() {
+		this.ensureAvailable(2);
+		const value = this.view.getInt16(this.offset, true);
+		this.offset += 2;
+		return value;
+	}
+	readUInt16() {
+		this.ensureAvailable(2);
+		const value = this.view.getUint16(this.offset, true);
+		this.offset += 2;
+		return value;
+	}
+	readInt32() {
+		this.ensureAvailable(4);
+		const value = this.view.getInt32(this.offset, true);
+		this.offset += 4;
+		return value;
+	}
+	readUInt32() {
+		this.ensureAvailable(4);
+		const value = this.view.getUint32(this.offset, true);
+		this.offset += 4;
+		return value;
+	}
+	readInt64() {
+		this.ensureAvailable(8);
+		const value = this.view.getBigInt64(this.offset, true);
+		this.offset += 8;
+		return value;
+	}
+	readSingle() {
+		this.ensureAvailable(4);
+		const value = this.view.getFloat32(this.offset, true);
+		this.offset += 4;
+		return value;
+	}
+	readDouble() {
+		this.ensureAvailable(8);
+		const value = this.view.getFloat64(this.offset, true);
+		this.offset += 8;
+		return value;
+	}
+	readDateTimeTicks() {
+		return this.readInt64();
+	}
+	readBytes(length) {
+		if (!Number.isInteger(length) || length < 0) throw new RangeError(`Byte length must be a non-negative integer, got ${length}.`);
+		this.ensureAvailable(length);
+		const value = this.bytes.slice(this.offset, this.offset + length);
+		this.offset += length;
+		return value;
+	}
+	readUleb128() {
+		let value = 0;
+		let shift = 0;
+		while (true) {
+			const byte = this.readByte();
+			value |= (byte & 127) << shift;
+			if ((byte & 128) === 0) return value;
+			shift += 7;
+			if (shift > 35) throw new RangeError("ULEB128 value is too large for a JavaScript number.");
+		}
+	}
+	readString() {
+		const marker = this.readByte();
+		if (marker === 0) return null;
+		if (marker !== 11) throw new Error(`Invalid string marker 0x${marker.toString(16)}.`);
+		const length = this.readUleb128();
+		const value = this.readBytes(length);
+		return textDecoder.decode(value);
+	}
+	readIntFloatPair() {
+		const intMarker = this.readByte();
+		if (intMarker !== 8) throw new Error(`Invalid Int-Float pair int marker 0x${intMarker.toString(16)}.`);
+		const mods = this.readInt32();
+		const floatMarker = this.readByte();
+		if (floatMarker !== 12) throw new Error(`Invalid Int-Float pair float marker 0x${floatMarker.toString(16)}.`);
+		return {
+			mods,
+			starRating: this.readSingle()
+		};
+	}
+	readTimingPoint() {
+		return {
+			bpm: this.readDouble(),
+			offsetMs: this.readDouble(),
+			isUninherited: this.readBoolean()
+		};
+	}
+	ensureAvailable(byteLength) {
+		if (this.offset + byteLength > this.length) throw new RangeError(`Attempted to read ${byteLength} byte(s) at offset ${this.offset}, but only ${this.remaining} remain.`);
+	}
+};
+var BinaryWriter = class {
+	buffer;
+	view;
+	bytes;
+	offset = 0;
+	constructor(initialCapacity = 64) {
+		if (!Number.isInteger(initialCapacity) || initialCapacity <= 0) throw new RangeError(`Initial capacity must be a positive integer, got ${initialCapacity}.`);
+		this.buffer = new ArrayBuffer(initialCapacity);
+		this.view = new DataView(this.buffer);
+		this.bytes = new Uint8Array(this.buffer);
+	}
+	get position() {
+		return this.offset;
+	}
+	writeByte(value) {
+		this.ensureCapacity(1);
+		this.view.setUint8(this.offset, value);
+		this.offset += 1;
+	}
+	writeBoolean(value) {
+		this.writeByte(value ? 1 : 0);
+	}
+	writeInt16(value) {
+		this.ensureCapacity(2);
+		this.view.setInt16(this.offset, value, true);
+		this.offset += 2;
+	}
+	writeUInt16(value) {
+		this.ensureCapacity(2);
+		this.view.setUint16(this.offset, value, true);
+		this.offset += 2;
+	}
+	writeInt32(value) {
+		this.ensureCapacity(4);
+		this.view.setInt32(this.offset, value, true);
+		this.offset += 4;
+	}
+	writeUInt32(value) {
+		this.ensureCapacity(4);
+		this.view.setUint32(this.offset, value, true);
+		this.offset += 4;
+	}
+	writeInt64(value) {
+		this.ensureCapacity(8);
+		this.view.setBigInt64(this.offset, value, true);
+		this.offset += 8;
+	}
+	writeSingle(value) {
+		this.ensureCapacity(4);
+		this.view.setFloat32(this.offset, value, true);
+		this.offset += 4;
+	}
+	writeDouble(value) {
+		this.ensureCapacity(8);
+		this.view.setFloat64(this.offset, value, true);
+		this.offset += 8;
+	}
+	writeDateTimeTicks(value) {
+		this.writeInt64(value);
+	}
+	writeBytes(value) {
+		this.ensureCapacity(value.byteLength);
+		this.bytes.set(value, this.offset);
+		this.offset += value.byteLength;
+	}
+	writeUleb128(value) {
+		if (!Number.isInteger(value) || value < 0) throw new RangeError(`ULEB128 value must be a non-negative integer, got ${value}.`);
+		let remaining = value;
+		do {
+			let byte = remaining & 127;
+			remaining >>>= 7;
+			if (remaining !== 0) byte |= 128;
+			this.writeByte(byte);
+		} while (remaining !== 0);
+	}
+	writeString(value) {
+		if (value === null) {
+			this.writeByte(0);
+			return;
+		}
+		this.writeByte(11);
+		const encoded = textEncoder.encode(value);
+		this.writeUleb128(encoded.byteLength);
+		this.writeBytes(encoded);
+	}
+	writeIntFloatPair(value) {
+		this.writeByte(8);
+		this.writeInt32(value.mods);
+		this.writeByte(12);
+		this.writeSingle(value.starRating);
+	}
+	writeTimingPoint(value) {
+		this.writeDouble(value.bpm);
+		this.writeDouble(value.offsetMs);
+		this.writeBoolean(value.isUninherited);
+	}
+	toUint8Array() {
+		return this.bytes.slice(0, this.offset);
+	}
+	ensureCapacity(additionalBytes) {
+		const required = this.offset + additionalBytes;
+		if (required <= this.buffer.byteLength) return;
+		let nextCapacity = this.buffer.byteLength;
+		while (nextCapacity < required) nextCapacity *= 2;
+		const nextBuffer = new ArrayBuffer(nextCapacity);
+		const nextBytes = new Uint8Array(nextBuffer);
+		nextBytes.set(this.bytes.subarray(0, this.offset));
+		this.buffer = nextBuffer;
+		this.bytes = nextBytes;
+		this.view = new DataView(nextBuffer);
+	}
+};
+//#endregion
+//#region src/db/shared.ts
+function createReader(input) {
+	return new BinaryReader(input);
+}
+function createWriter() {
+	return new BinaryWriter();
+}
+function assertSupportedVersion(version) {
+	if (version < 20250107) throw new RangeError(`Unsupported legacy database version ${version}. Minimum supported version is ${MINIMUM_SUPPORTED_VERSION}.`);
+}
+//#endregion
+//#region src/db/collection.ts
+function readCollectionDatabase(input) {
+	const reader = createReader(input);
+	const version = reader.readInt32();
+	assertSupportedVersion(version);
+	const collectionCount = reader.readInt32();
+	const collections = [];
+	for (let index = 0; index < collectionCount; index += 1) {
+		const name = reader.readString();
+		const beatmapCount = reader.readInt32();
+		const beatmapMd5Hashes = [];
+		for (let beatmapIndex = 0; beatmapIndex < beatmapCount; beatmapIndex += 1) beatmapMd5Hashes.push(reader.readString());
+		collections.push({
+			name,
+			beatmapMd5Hashes
+		});
+	}
+	return {
+		version,
+		collections
+	};
+}
+function writeCollectionDatabase(database) {
+	assertSupportedVersion(database.version);
+	const writer = createWriter();
+	writer.writeInt32(database.version);
+	writer.writeInt32(database.collections.length);
+	for (const collection of database.collections) {
+		writer.writeString(collection.name);
+		writer.writeInt32(collection.beatmapMd5Hashes.length);
+		for (const beatmapMd5Hash of collection.beatmapMd5Hashes) writer.writeString(beatmapMd5Hash);
+	}
+	return writer.toUint8Array();
+}
+//#endregion
+//#region src/db/osu.ts
+function readIntFloatPairArray(reader) {
+	const count = reader.readInt32();
+	const values = [];
+	for (let index = 0; index < count; index += 1) values.push(reader.readIntFloatPair());
+	return values;
+}
+function writeIntFloatPairArray(writer, values) {
+	writer.writeInt32(values.length);
+	for (const value of values) writer.writeIntFloatPair(value);
+}
+function readTimingPointArray(reader) {
+	const count = reader.readInt32();
+	const values = [];
+	for (let index = 0; index < count; index += 1) values.push(reader.readTimingPoint());
+	return values;
+}
+function writeTimingPointArray(writer, values) {
+	writer.writeInt32(values.length);
+	for (const value of values) writer.writeTimingPoint(value);
+}
+function readBeatmapEntry(reader) {
+	return {
+		artist: reader.readString(),
+		artistUnicode: reader.readString(),
+		title: reader.readString(),
+		titleUnicode: reader.readString(),
+		creator: reader.readString(),
+		difficultyName: reader.readString(),
+		audioFileName: reader.readString(),
+		md5Hash: reader.readString(),
+		osuFileName: reader.readString(),
+		rankedStatus: reader.readByte(),
+		hitCircleCount: reader.readUInt16(),
+		sliderCount: reader.readUInt16(),
+		spinnerCount: reader.readUInt16(),
+		lastModificationTime: reader.readDateTimeTicks(),
+		approachRate: reader.readSingle(),
+		circleSize: reader.readSingle(),
+		hpDrain: reader.readSingle(),
+		overallDifficulty: reader.readSingle(),
+		sliderVelocity: reader.readDouble(),
+		standardStarRatings: readIntFloatPairArray(reader),
+		taikoStarRatings: readIntFloatPairArray(reader),
+		catchStarRatings: readIntFloatPairArray(reader),
+		maniaStarRatings: readIntFloatPairArray(reader),
+		drainTimeSeconds: reader.readInt32(),
+		totalTimeMs: reader.readInt32(),
+		previewOffsetMs: reader.readInt32(),
+		timingPoints: readTimingPointArray(reader),
+		difficultyId: reader.readInt32(),
+		beatmapId: reader.readInt32(),
+		threadId: reader.readInt32(),
+		standardGrade: reader.readByte(),
+		taikoGrade: reader.readByte(),
+		catchGrade: reader.readByte(),
+		maniaGrade: reader.readByte(),
+		localOffset: reader.readInt16(),
+		stackLeniency: reader.readSingle(),
+		gameplayMode: reader.readByte(),
+		source: reader.readString(),
+		tags: reader.readString(),
+		onlineOffset: reader.readInt16(),
+		titleFont: reader.readString(),
+		isUnplayed: reader.readBoolean(),
+		lastPlayedAt: reader.readDateTimeTicks(),
+		isOsz2: reader.readBoolean(),
+		beatmapFolderName: reader.readString(),
+		lastCheckedAgainstRepositoryAt: reader.readDateTimeTicks(),
+		ignoreBeatmapSound: reader.readBoolean(),
+		ignoreBeatmapSkin: reader.readBoolean(),
+		disableStoryboard: reader.readBoolean(),
+		disableVideo: reader.readBoolean(),
+		visualOverride: reader.readBoolean(),
+		lastModificationTimeUnknown: reader.readInt32(),
+		maniaScrollSpeed: reader.readByte()
+	};
+}
+function writeBeatmapEntry(writer, beatmap) {
+	writer.writeString(beatmap.artist);
+	writer.writeString(beatmap.artistUnicode);
+	writer.writeString(beatmap.title);
+	writer.writeString(beatmap.titleUnicode);
+	writer.writeString(beatmap.creator);
+	writer.writeString(beatmap.difficultyName);
+	writer.writeString(beatmap.audioFileName);
+	writer.writeString(beatmap.md5Hash);
+	writer.writeString(beatmap.osuFileName);
+	writer.writeByte(beatmap.rankedStatus);
+	writer.writeUInt16(beatmap.hitCircleCount);
+	writer.writeUInt16(beatmap.sliderCount);
+	writer.writeUInt16(beatmap.spinnerCount);
+	writer.writeDateTimeTicks(beatmap.lastModificationTime);
+	writer.writeSingle(beatmap.approachRate);
+	writer.writeSingle(beatmap.circleSize);
+	writer.writeSingle(beatmap.hpDrain);
+	writer.writeSingle(beatmap.overallDifficulty);
+	writer.writeDouble(beatmap.sliderVelocity);
+	writeIntFloatPairArray(writer, beatmap.standardStarRatings);
+	writeIntFloatPairArray(writer, beatmap.taikoStarRatings);
+	writeIntFloatPairArray(writer, beatmap.catchStarRatings);
+	writeIntFloatPairArray(writer, beatmap.maniaStarRatings);
+	writer.writeInt32(beatmap.drainTimeSeconds);
+	writer.writeInt32(beatmap.totalTimeMs);
+	writer.writeInt32(beatmap.previewOffsetMs);
+	writeTimingPointArray(writer, beatmap.timingPoints);
+	writer.writeInt32(beatmap.difficultyId);
+	writer.writeInt32(beatmap.beatmapId);
+	writer.writeInt32(beatmap.threadId);
+	writer.writeByte(beatmap.standardGrade);
+	writer.writeByte(beatmap.taikoGrade);
+	writer.writeByte(beatmap.catchGrade);
+	writer.writeByte(beatmap.maniaGrade);
+	writer.writeInt16(beatmap.localOffset);
+	writer.writeSingle(beatmap.stackLeniency);
+	writer.writeByte(beatmap.gameplayMode);
+	writer.writeString(beatmap.source);
+	writer.writeString(beatmap.tags);
+	writer.writeInt16(beatmap.onlineOffset);
+	writer.writeString(beatmap.titleFont);
+	writer.writeBoolean(beatmap.isUnplayed);
+	writer.writeDateTimeTicks(beatmap.lastPlayedAt);
+	writer.writeBoolean(beatmap.isOsz2);
+	writer.writeString(beatmap.beatmapFolderName);
+	writer.writeDateTimeTicks(beatmap.lastCheckedAgainstRepositoryAt);
+	writer.writeBoolean(beatmap.ignoreBeatmapSound);
+	writer.writeBoolean(beatmap.ignoreBeatmapSkin);
+	writer.writeBoolean(beatmap.disableStoryboard);
+	writer.writeBoolean(beatmap.disableVideo);
+	writer.writeBoolean(beatmap.visualOverride);
+	writer.writeInt32(beatmap.lastModificationTimeUnknown);
+	writer.writeByte(beatmap.maniaScrollSpeed);
+}
+function readOsuDatabase(input) {
+	const reader = createReader(input);
+	const version = reader.readInt32();
+	assertSupportedVersion(version);
+	const folderCount = reader.readInt32();
+	const accountUnlocked = reader.readBoolean();
+	const accountUnlockDate = reader.readDateTimeTicks();
+	const playerName = reader.readString();
+	const beatmapCount = reader.readInt32();
+	const beatmaps = [];
+	for (let index = 0; index < beatmapCount; index += 1) beatmaps.push(readBeatmapEntry(reader));
+	return {
+		version,
+		folderCount,
+		accountUnlocked,
+		accountUnlockDate,
+		playerName,
+		beatmaps,
+		userPermissions: reader.readInt32()
+	};
+}
+function writeOsuDatabase(database) {
+	assertSupportedVersion(database.version);
+	const writer = createWriter();
+	writer.writeInt32(database.version);
+	writer.writeInt32(database.folderCount);
+	writer.writeBoolean(database.accountUnlocked);
+	writer.writeDateTimeTicks(database.accountUnlockDate);
+	writer.writeString(database.playerName);
+	writer.writeInt32(database.beatmaps.length);
+	for (const beatmap of database.beatmaps) writeBeatmapEntry(writer, beatmap);
+	writer.writeInt32(database.userPermissions);
+	return writer.toUint8Array();
+}
+Object.values(Mods).filter((value) => value !== Mods.None);
+/**
+* Tests whether all bits from a mod mask are present in the flags value.
+*/
+function hasMod(flags, mod) {
+	return (flags & mod) === mod;
+}
+//#endregion
+//#region src/db/scores.ts
+function readScoreAdditionalModInfo(reader) {
+	return { targetPracticeAccuracy: reader.readDouble() };
+}
+function writeScoreAdditionalModInfo(writer, value) {
+	writer.writeDouble(value.targetPracticeAccuracy);
+}
+function readScoreEntry(reader) {
+	const gameplayMode = reader.readByte();
+	const version = reader.readInt32();
+	const beatmapMd5Hash = reader.readString();
+	const playerName = reader.readString();
+	const replayMd5Hash = reader.readString();
+	const count300 = reader.readUInt16();
+	const count100 = reader.readUInt16();
+	const count50 = reader.readUInt16();
+	const countGeki = reader.readUInt16();
+	const countKatu = reader.readUInt16();
+	const countMiss = reader.readUInt16();
+	const totalScore = reader.readInt32();
+	const maxCombo = reader.readUInt16();
+	const perfectCombo = reader.readBoolean();
+	const mods = reader.readInt32();
+	const score = {
+		gameplayMode,
+		version,
+		beatmapMd5Hash,
+		playerName,
+		replayMd5Hash,
+		count300,
+		count100,
+		count50,
+		countGeki,
+		countKatu,
+		countMiss,
+		totalScore,
+		maxCombo,
+		perfectCombo,
+		mods,
+		reservedEmptyString: reader.readString(),
+		replayTimestamp: reader.readDateTimeTicks(),
+		reservedInt32: reader.readInt32(),
+		onlineScoreId: reader.readInt64()
+	};
+	if (hasMod(mods, Mods.TargetPractice)) score.additionalModInfo = readScoreAdditionalModInfo(reader);
+	return score;
+}
+function writeScoreEntry(writer, score) {
+	writer.writeByte(score.gameplayMode);
+	writer.writeInt32(score.version);
+	writer.writeString(score.beatmapMd5Hash);
+	writer.writeString(score.playerName);
+	writer.writeString(score.replayMd5Hash);
+	writer.writeUInt16(score.count300);
+	writer.writeUInt16(score.count100);
+	writer.writeUInt16(score.count50);
+	writer.writeUInt16(score.countGeki);
+	writer.writeUInt16(score.countKatu);
+	writer.writeUInt16(score.countMiss);
+	writer.writeInt32(score.totalScore);
+	writer.writeUInt16(score.maxCombo);
+	writer.writeBoolean(score.perfectCombo);
+	writer.writeInt32(score.mods);
+	writer.writeString(score.reservedEmptyString);
+	writer.writeDateTimeTicks(score.replayTimestamp);
+	writer.writeInt32(score.reservedInt32);
+	writer.writeInt64(score.onlineScoreId);
+	if (hasMod(score.mods, Mods.TargetPractice)) {
+		if (score.additionalModInfo === void 0) throw new Error("Target Practice scores require additionalModInfo to be present.");
+		writeScoreAdditionalModInfo(writer, score.additionalModInfo);
+	}
+}
+function readScoresDatabase(input) {
+	const reader = createReader(input);
+	const version = reader.readInt32();
+	assertSupportedVersion(version);
+	const beatmapCount = reader.readInt32();
+	const beatmaps = [];
+	for (let beatmapIndex = 0; beatmapIndex < beatmapCount; beatmapIndex += 1) {
+		const beatmapMd5Hash = reader.readString();
+		const scoreCount = reader.readInt32();
+		const scores = [];
+		for (let scoreIndex = 0; scoreIndex < scoreCount; scoreIndex += 1) scores.push(readScoreEntry(reader));
+		beatmaps.push({
+			beatmapMd5Hash,
+			scores
+		});
+	}
+	return {
+		version,
+		beatmaps
+	};
+}
+function writeScoresDatabase(database) {
+	assertSupportedVersion(database.version);
+	const writer = createWriter();
+	writer.writeInt32(database.version);
+	writer.writeInt32(database.beatmaps.length);
+	for (const beatmap of database.beatmaps) {
+		writer.writeString(beatmap.beatmapMd5Hash);
+		writer.writeInt32(beatmap.scores.length);
+		for (const score of beatmap.scores) writeScoreEntry(writer, score);
+	}
+	return writer.toUint8Array();
+}
+//#endregion
+export { readCollectionDatabase as a, Grades as c, RankedStatuses as d, UserPermissions as f, writeOsuDatabase as i, MINIMUM_SUPPORTED_VERSION as l, writeScoresDatabase as n, writeCollectionDatabase as o, readOsuDatabase as r, GameplayModes as s, readScoresDatabase as t, Mods as u };