@tosuapp/osu-native-wrapper 1.0.0

package/dist/index.mjs

@@ -0,0 +1,687 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/OsuNativeError.ts
+var _OsuNativeError = class _OsuNativeError extends Error {
+  constructor(operation, errno, message, code, rawMessage) {
+    super(message);
+    __publicField(this, "errno");
+    __publicField(this, "operation");
+    __publicField(this, "rawMessage");
+    __publicField(this, "code");
+    this.name = "OsuNativeError";
+    this.errno = errno;
+    this.operation = operation;
+    this.rawMessage = rawMessage;
+    this.code = code;
+  }
+};
+__name(_OsuNativeError, "OsuNativeError");
+var OsuNativeError = _OsuNativeError;
+
+// src/core/OsuNative.ts
+import raw from "@tosuapp/osu-native-napi";
+var _OsuNative = class _OsuNative {
+  static getLastMessage() {
+    const msg = raw.ErrorHandler_GetLastMessage();
+    const trimmed = msg.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  static errorCodeName(value) {
+    return _OsuNative.errorCodeNameByValue.get(value);
+  }
+  static toError(operation, value) {
+    const name = this.errorCodeName(value);
+    const rawMessage = this.getLastMessage();
+    const suffix = rawMessage ? `: ${rawMessage}` : "";
+    const message = `${operation} failed (${name ?? value})${suffix}`;
+    return new OsuNativeError(operation, value, message, name, rawMessage);
+  }
+  static assertOk(operation, value) {
+    if (value === raw.ErrorCode.SUCCESS) {
+      return;
+    }
+    throw this.toError(operation, value);
+  }
+  static assertSizeQuery(operation, value) {
+    if (value === raw.ErrorCode.BUFFER_SIZE_QUERY) {
+      return;
+    }
+    throw this.toError(operation, value);
+  }
+  static makeNullHandle() {
+    return new raw.ManagedObjectHandle();
+  }
+};
+__name(_OsuNative, "OsuNative");
+__publicField(_OsuNative, "errorCode", raw.ErrorCode);
+__publicField(_OsuNative, "errorCodeNameByValue", new Map(Object.entries(raw.ErrorCode).filter((entry) => typeof entry[1] === "number").map(([name, value]) => [
+  value,
+  name
+])));
+var OsuNative = _OsuNative;
+
+// src/internal/NativeHandleOwner.ts
+var _NativeHandleOwner = class _NativeHandleOwner {
+  constructor(native) {
+    __publicField(this, "native");
+    __publicField(this, "destroyed", false);
+    this.native = native;
+  }
+  get handle() {
+    return this.native.handle;
+  }
+  ensureAlive() {
+    if (!this.destroyed) {
+      return;
+    }
+    throw new Error(`${this.constructor.name} is destroyed`);
+  }
+};
+__name(_NativeHandleOwner, "NativeHandleOwner");
+var NativeHandleOwner = _NativeHandleOwner;
+
+// src/objects/Beatmap.ts
+import raw2 from "@tosuapp/osu-native-napi";
+var _Beatmap = class _Beatmap extends NativeHandleOwner {
+  static fromFile(filePath) {
+    const native = new raw2.NativeBeatmap();
+    OsuNative.assertOk("Beatmap_CreateFromFile", raw2.Beatmap_CreateFromFile(filePath, native));
+    return new _Beatmap(native);
+  }
+  static fromText(text) {
+    const native = new raw2.NativeBeatmap();
+    OsuNative.assertOk("Beatmap_CreateFromText", raw2.Beatmap_CreateFromText(text, native));
+    return new _Beatmap(native);
+  }
+  constructor(native) {
+    super(native);
+  }
+  getTitle() {
+    this.ensureAlive();
+    const bufferSizeArr = new Int32Array([
+      0
+    ]);
+    OsuNative.assertSizeQuery("Beatmap_GetTitle", raw2.Beatmap_GetTitle(this.handle, null, bufferSizeArr));
+    const buffer = Buffer.alloc(bufferSizeArr[0]);
+    OsuNative.assertOk("Beatmap_GetTitle", raw2.Beatmap_GetTitle(this.handle, buffer, bufferSizeArr));
+    return buffer.toString();
+  }
+  getArtist() {
+    this.ensureAlive();
+    const bufferSizeArr = new Int32Array([
+      0
+    ]);
+    OsuNative.assertSizeQuery("Beatmap_GetArtist", raw2.Beatmap_GetArtist(this.handle, null, bufferSizeArr));
+    const buffer = Buffer.alloc(bufferSizeArr[0]);
+    OsuNative.assertOk("Beatmap_GetArtist", raw2.Beatmap_GetArtist(this.handle, buffer, bufferSizeArr));
+    return buffer.toString();
+  }
+  getVersion() {
+    this.ensureAlive();
+    const bufferSizeArr = new Int32Array([
+      0
+    ]);
+    OsuNative.assertSizeQuery("Beatmap_GetVersion", raw2.Beatmap_GetVersion(this.handle, null, bufferSizeArr));
+    const buffer = Buffer.alloc(bufferSizeArr[0]);
+    OsuNative.assertOk("Beatmap_GetArtist", raw2.Beatmap_GetVersion(this.handle, buffer, bufferSizeArr));
+    return buffer.toString();
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("Beatmap_Destroy", raw2.Beatmap_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_Beatmap, "Beatmap");
+var Beatmap = _Beatmap;
+
+// src/objects/Mod.ts
+import raw3 from "@tosuapp/osu-native-napi";
+var _Mod = class _Mod extends NativeHandleOwner {
+  static create(acronym) {
+    const native = new raw3.NativeMod();
+    OsuNative.assertOk("Mod_Create", raw3.Mod_Create(acronym, native));
+    return new _Mod(native);
+  }
+  setSettingBool(key, value) {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_SetSettingBool", raw3.Mod_SetSettingBool(this.handle, key, value));
+  }
+  setSettingInteger(key, value) {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_SetSettingInteger", raw3.Mod_SetSettingInteger(this.handle, key, value));
+  }
+  setSettingFloat(key, value) {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_SetSettingFloat", raw3.Mod_SetSettingFloat(this.handle, key, value));
+  }
+  debug() {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_Debug", raw3.Mod_Debug(this.handle));
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("Mod_Destroy", raw3.Mod_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_Mod, "Mod");
+var Mod = _Mod;
+
+// src/objects/ModsCollection.ts
+import raw4 from "@tosuapp/osu-native-napi";
+var _ModsCollection = class _ModsCollection extends NativeHandleOwner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "mods", []);
+  }
+  static create() {
+    const native = new raw4.NativeModsCollection();
+    OsuNative.assertOk("ModsCollection_Create", raw4.ModsCollection_Create(native));
+    return new _ModsCollection(native);
+  }
+  add(mod) {
+    this.ensureAlive();
+    OsuNative.assertOk("ModsCollection_Add", raw4.ModsCollection_Add(this.handle, mod.handle));
+    this.mods.push(mod.handle);
+  }
+  has(mod) {
+    return this.mods.find((x) => x == mod.handle) !== void 0;
+  }
+  remove(mod) {
+    this.ensureAlive();
+    OsuNative.assertOk("ModsCollection_Remove", raw4.ModsCollection_Remove(this.handle, mod.handle));
+    this.mods = this.mods.filter((x) => x !== mod.handle);
+  }
+  debug() {
+    this.ensureAlive();
+    OsuNative.assertOk("ModsCollection_Debug", raw4.ModsCollection_Debug(this.handle));
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("ModsCollection_Destroy", raw4.ModsCollection_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_ModsCollection, "ModsCollection");
+var ModsCollection = _ModsCollection;
+
+// src/internal/rulesetShortName.ts
+var RULESET_SHORT_NAME_BY_ID = /* @__PURE__ */ new Map([
+  [
+    0,
+    "osu"
+  ],
+  [
+    1,
+    "taiko"
+  ],
+  [
+    2,
+    "catch"
+  ],
+  [
+    3,
+    "mania"
+  ]
+]);
+
+// src/objects/Ruleset.ts
+import raw5 from "@tosuapp/osu-native-napi";
+var _Ruleset = class _Ruleset extends NativeHandleOwner {
+  static fromId(rulesetId) {
+    const native = new raw5.NativeRuleset();
+    OsuNative.assertOk("Ruleset_CreateFromId", raw5.Ruleset_CreateFromId(rulesetId, native));
+    return new _Ruleset(native);
+  }
+  static fromShortName(shortName) {
+    const native = new raw5.NativeRuleset();
+    OsuNative.assertOk("Ruleset_CreateFromShortName", raw5.Ruleset_CreateFromShortName(shortName, native));
+    return new _Ruleset(native);
+  }
+  get rulesetId() {
+    return this.native.rulesetId;
+  }
+  get shortName() {
+    return RULESET_SHORT_NAME_BY_ID.get(this.rulesetId);
+  }
+  getShortName() {
+    this.ensureAlive();
+    return;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("Ruleset_Destroy", raw5.Ruleset_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_Ruleset, "Ruleset");
+var Ruleset = _Ruleset;
+
+// src/calculators/difficulty/CatchDifficultyCalculator.ts
+import raw6 from "@tosuapp/osu-native-napi";
+var _CatchDifficultyCalculator = class _CatchDifficultyCalculator extends NativeHandleOwner {
+  constructor(native, ruleset, beatmap) {
+    super(native);
+    __publicField(this, "ruleset");
+    __publicField(this, "beatmap");
+    this.ruleset = ruleset, this.beatmap = beatmap;
+  }
+  static create(ruleset, beatmap) {
+    const native = new raw6.NativeCatchDifficultyCalculator();
+    OsuNative.assertOk("CatchDifficultyCalculator_Create", raw6.CatchDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _CatchDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new raw6.NativeCatchDifficultyAttributes();
+    OsuNative.assertOk("CatchDifficultyCalculator_Calculate", raw6.CatchDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new raw6.NativeCatchDifficultyAttributes();
+    OsuNative.assertOk("CatchDifficultyCalculator_CalculateMods", raw6.CatchDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("CatchDifficultyCalculator_CalculateTimed", raw6.CatchDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("CatchDifficultyCalculator_CalculateTimed", raw6.CatchDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("CatchDifficultyCalculator_CalculateModsTimed", raw6.CatchDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("CatchDifficultyCalculator_CalculateModsTimed", raw6.CatchDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("CatchDifficultyCalculator_Destroy", raw6.CatchDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_CatchDifficultyCalculator, "CatchDifficultyCalculator");
+var CatchDifficultyCalculator = _CatchDifficultyCalculator;
+
+// src/calculators/difficulty/ManiaDifficultyCalculator.ts
+import raw7 from "@tosuapp/osu-native-napi";
+var _ManiaDifficultyCalculator = class _ManiaDifficultyCalculator extends NativeHandleOwner {
+  constructor(native, ruleset, beatmap) {
+    super(native);
+    __publicField(this, "ruleset");
+    __publicField(this, "beatmap");
+    this.ruleset = ruleset, this.beatmap = beatmap;
+  }
+  static create(ruleset, beatmap) {
+    const native = new raw7.NativeManiaDifficultyCalculator();
+    OsuNative.assertOk("ManiaDifficultyCalculator_Create", raw7.ManiaDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _ManiaDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new raw7.NativeManiaDifficultyAttributes();
+    OsuNative.assertOk("ManiaDifficultyCalculator_Calculate", raw7.ManiaDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new raw7.NativeManiaDifficultyAttributes();
+    OsuNative.assertOk("ManiaDifficultyCalculator_CalculateMods", raw7.ManiaDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("ManiaDifficultyCalculator_CalculateTimed", raw7.ManiaDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("ManiaDifficultyCalculator_CalculateTimed", raw7.ManiaDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("ManiaDifficultyCalculator_CalculateModsTimed", raw7.ManiaDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("ManiaDifficultyCalculator_CalculateModsTimed", raw7.ManiaDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("ManiaDifficultyCalculator_Destroy", raw7.ManiaDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_ManiaDifficultyCalculator, "ManiaDifficultyCalculator");
+var ManiaDifficultyCalculator = _ManiaDifficultyCalculator;
+
+// src/calculators/difficulty/OsuDifficultyCalculator.ts
+import raw8 from "@tosuapp/osu-native-napi";
+var _OsuDifficultyCalculator = class _OsuDifficultyCalculator extends NativeHandleOwner {
+  constructor(native, ruleset, beatmap) {
+    super(native);
+    __publicField(this, "ruleset");
+    __publicField(this, "beatmap");
+    this.ruleset = ruleset, this.beatmap = beatmap;
+  }
+  static create(ruleset, beatmap) {
+    const native = new raw8.NativeOsuDifficultyCalculator();
+    OsuNative.assertOk("OsuDifficultyCalculator_Create", raw8.OsuDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _OsuDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new raw8.NativeOsuDifficultyAttributes();
+    OsuNative.assertOk("OsuDifficultyCalculator_Calculate", raw8.OsuDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new raw8.NativeOsuDifficultyAttributes();
+    OsuNative.assertOk("OsuDifficultyCalculator_CalculateMods", raw8.OsuDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("OsuDifficultyCalculator_CalculateTimed", raw8.OsuDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("OsuDifficultyCalculator_CalculateTimed", raw8.OsuDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("OsuDifficultyCalculator_CalculateModsTimed", raw8.OsuDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("OsuDifficultyCalculator_CalculateModsTimed", raw8.OsuDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("OsuDifficultyCalculator_Destroy", raw8.OsuDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_OsuDifficultyCalculator, "OsuDifficultyCalculator");
+var OsuDifficultyCalculator = _OsuDifficultyCalculator;
+
+// src/calculators/difficulty/TaikoDifficultyCalculator.ts
+import raw9 from "@tosuapp/osu-native-napi";
+var _TaikoDifficultyCalculator = class _TaikoDifficultyCalculator extends NativeHandleOwner {
+  constructor(native, ruleset, beatmap) {
+    super(native);
+    __publicField(this, "ruleset");
+    __publicField(this, "beatmap");
+    this.ruleset = ruleset, this.beatmap = beatmap;
+  }
+  static create(ruleset, beatmap) {
+    const native = new raw9.NativeTaikoDifficultyCalculator();
+    OsuNative.assertOk("TaikoDifficultyCalculator_Create", raw9.TaikoDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _TaikoDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new raw9.NativeTaikoDifficultyAttributes();
+    OsuNative.assertOk("TaikoDifficultyCalculator_Calculate", raw9.TaikoDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new raw9.NativeTaikoDifficultyAttributes();
+    OsuNative.assertOk("TaikoDifficultyCalculator_CalculateMods", raw9.TaikoDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("TaikoDifficultyCalculator_CalculateTimed", raw9.TaikoDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("TaikoDifficultyCalculator_CalculateTimed", raw9.TaikoDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("TaikoDifficultyCalculator_CalculateModsTimed", raw9.TaikoDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("TaikoDifficultyCalculator_CalculateModsTimed", raw9.TaikoDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("TaikoDifficultyCalculator_Destroy", raw9.TaikoDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_TaikoDifficultyCalculator, "TaikoDifficultyCalculator");
+var TaikoDifficultyCalculator = _TaikoDifficultyCalculator;
+
+// src/calculators/performance/CatchPerformanceCalculator.ts
+import raw11 from "@tosuapp/osu-native-napi";
+
+// src/internal/scoreInfo.ts
+import raw10 from "@tosuapp/osu-native-napi";
+function makeScoreInfo(input) {
+  const score = new raw10.NativeScoreInfo();
+  score.rulesetHandle = input.ruleset.handle;
+  score.beatmapHandle = input.beatmap.handle;
+  score.modsHandle = input.mods?.handle ?? OsuNative.makeNullHandle();
+  score.maxCombo = input.maxCombo ?? 0;
+  score.accuracy = input.accuracy ?? 0;
+  score.countMiss = input.countMiss ?? 0;
+  score.countMeh = input.countMeh ?? 0;
+  score.countOk = input.countOk ?? 0;
+  score.countGood = input.countGood ?? 0;
+  score.countGreat = input.countGreat ?? 0;
+  score.countPerfect = input.countPerfect ?? 0;
+  score.countSliderTailHit = input.countSliderTailHit ?? 0;
+  score.countLargeTickMiss = input.countLargeTickMiss ?? 0;
+  return score;
+}
+__name(makeScoreInfo, "makeScoreInfo");
+
+// src/calculators/performance/CatchPerformanceCalculator.ts
+var _CatchPerformanceCalculator = class _CatchPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new raw11.NativeCatchPerformanceCalculator();
+    OsuNative.assertOk("CatchPerformanceCalculator_Create", raw11.CatchPerformanceCalculator_Create(native));
+    return new _CatchPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new raw11.NativeCatchPerformanceAttributes();
+    OsuNative.assertOk("CatchPerformanceCalculator_Calculate", raw11.CatchPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("CatchPerformanceCalculator_Destroy", raw11.CatchPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_CatchPerformanceCalculator, "CatchPerformanceCalculator");
+var CatchPerformanceCalculator = _CatchPerformanceCalculator;
+
+// src/calculators/performance/ManiaPerformanceCalculator.ts
+import raw12 from "@tosuapp/osu-native-napi";
+var _ManiaPerformanceCalculator = class _ManiaPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new raw12.NativeManiaPerformanceCalculator();
+    OsuNative.assertOk("ManiaPerformanceCalculator_Create", raw12.ManiaPerformanceCalculator_Create(native));
+    return new _ManiaPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new raw12.NativeManiaPerformanceAttributes();
+    OsuNative.assertOk("ManiaPerformanceCalculator_Calculate", raw12.ManiaPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("ManiaPerformanceCalculator_Destroy", raw12.ManiaPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_ManiaPerformanceCalculator, "ManiaPerformanceCalculator");
+var ManiaPerformanceCalculator = _ManiaPerformanceCalculator;
+
+// src/calculators/performance/OsuPerformanceCalculator.ts
+import raw13 from "@tosuapp/osu-native-napi";
+var _OsuPerformanceCalculator = class _OsuPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new raw13.NativeOsuPerformanceCalculator();
+    OsuNative.assertOk("OsuPerformanceCalculator_Create", raw13.OsuPerformanceCalculator_Create(native));
+    return new _OsuPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new raw13.NativeOsuPerformanceAttributes();
+    OsuNative.assertOk("OsuPerformanceCalculator_Calculate", raw13.OsuPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("OsuPerformanceCalculator_Destroy", raw13.OsuPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_OsuPerformanceCalculator, "OsuPerformanceCalculator");
+var OsuPerformanceCalculator = _OsuPerformanceCalculator;
+
+// src/calculators/performance/TaikoPerformanceCalculator.ts
+import raw14 from "@tosuapp/osu-native-napi";
+var _TaikoPerformanceCalculator = class _TaikoPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new raw14.NativeTaikoPerformanceCalculator();
+    OsuNative.assertOk("TaikoPerformanceCalculator_Create", raw14.TaikoPerformanceCalculator_Create(native));
+    return new _TaikoPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new raw14.NativeTaikoPerformanceAttributes();
+    OsuNative.assertOk("TaikoPerformanceCalculator_Calculate", raw14.TaikoPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("TaikoPerformanceCalculator_Destroy", raw14.TaikoPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_TaikoPerformanceCalculator, "TaikoPerformanceCalculator");
+var TaikoPerformanceCalculator = _TaikoPerformanceCalculator;
+
+// src/factories/DifficultyCalculatorFactory.ts
+var _DifficultyCalculatorFactory = class _DifficultyCalculatorFactory {
+  static create(ruleset, beatmap) {
+    switch (ruleset.rulesetId) {
+      case 0:
+        return OsuDifficultyCalculator.create(ruleset, beatmap);
+      case 1:
+        return TaikoDifficultyCalculator.create(ruleset, beatmap);
+      case 2:
+        return CatchDifficultyCalculator.create(ruleset, beatmap);
+      case 3:
+        return ManiaDifficultyCalculator.create(ruleset, beatmap);
+      default:
+        throw new Error(`Unsupported rulesetId: ${ruleset.rulesetId}`);
+    }
+  }
+};
+__name(_DifficultyCalculatorFactory, "DifficultyCalculatorFactory");
+var DifficultyCalculatorFactory = _DifficultyCalculatorFactory;
+
+// src/factories/PerformanceCalculatorFactory.ts
+var _PerformanceCalculatorFactory = class _PerformanceCalculatorFactory {
+  static create(ruleset) {
+    switch (ruleset.rulesetId) {
+      case 0:
+        return OsuPerformanceCalculator.create();
+      case 1:
+        return TaikoPerformanceCalculator.create();
+      case 2:
+        return CatchPerformanceCalculator.create();
+      case 3:
+        return ManiaPerformanceCalculator.create();
+      default:
+        throw new Error(`Unsupported rulesetId: ${ruleset.rulesetId}`);
+    }
+  }
+};
+__name(_PerformanceCalculatorFactory, "PerformanceCalculatorFactory");
+var PerformanceCalculatorFactory = _PerformanceCalculatorFactory;
+export {
+  Beatmap,
+  CatchDifficultyCalculator,
+  CatchPerformanceCalculator,
+  DifficultyCalculatorFactory,
+  ManiaDifficultyCalculator,
+  ManiaPerformanceCalculator,
+  Mod,
+  ModsCollection,
+  OsuDifficultyCalculator,
+  OsuNative,
+  OsuNativeError,
+  OsuPerformanceCalculator,
+  PerformanceCalculatorFactory,
+  Ruleset,
+  TaikoDifficultyCalculator,
+  TaikoPerformanceCalculator
+};