@tosuapp/osu-native-wrapper 1.0.0

package/dist/index.cjs

@@ -0,0 +1,737 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  Beatmap: () => Beatmap,
+  CatchDifficultyCalculator: () => CatchDifficultyCalculator,
+  CatchPerformanceCalculator: () => CatchPerformanceCalculator,
+  DifficultyCalculatorFactory: () => DifficultyCalculatorFactory,
+  ManiaDifficultyCalculator: () => ManiaDifficultyCalculator,
+  ManiaPerformanceCalculator: () => ManiaPerformanceCalculator,
+  Mod: () => Mod,
+  ModsCollection: () => ModsCollection,
+  OsuDifficultyCalculator: () => OsuDifficultyCalculator,
+  OsuNative: () => OsuNative,
+  OsuNativeError: () => OsuNativeError,
+  OsuPerformanceCalculator: () => OsuPerformanceCalculator,
+  PerformanceCalculatorFactory: () => PerformanceCalculatorFactory,
+  Ruleset: () => Ruleset,
+  TaikoDifficultyCalculator: () => TaikoDifficultyCalculator,
+  TaikoPerformanceCalculator: () => TaikoPerformanceCalculator
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_osu_native_napi = __toESM(require("@tosuapp/osu-native-napi"));
+var _OsuNative = class _OsuNative {
+  static getLastMessage() {
+    const msg = import_osu_native_napi.default.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 === import_osu_native_napi.default.ErrorCode.SUCCESS) {
+      return;
+    }
+    throw this.toError(operation, value);
+  }
+  static assertSizeQuery(operation, value) {
+    if (value === import_osu_native_napi.default.ErrorCode.BUFFER_SIZE_QUERY) {
+      return;
+    }
+    throw this.toError(operation, value);
+  }
+  static makeNullHandle() {
+    return new import_osu_native_napi.default.ManagedObjectHandle();
+  }
+};
+__name(_OsuNative, "OsuNative");
+__publicField(_OsuNative, "errorCode", import_osu_native_napi.default.ErrorCode);
+__publicField(_OsuNative, "errorCodeNameByValue", new Map(Object.entries(import_osu_native_napi.default.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
+var import_osu_native_napi2 = __toESM(require("@tosuapp/osu-native-napi"));
+var _Beatmap = class _Beatmap extends NativeHandleOwner {
+  static fromFile(filePath) {
+    const native = new import_osu_native_napi2.default.NativeBeatmap();
+    OsuNative.assertOk("Beatmap_CreateFromFile", import_osu_native_napi2.default.Beatmap_CreateFromFile(filePath, native));
+    return new _Beatmap(native);
+  }
+  static fromText(text) {
+    const native = new import_osu_native_napi2.default.NativeBeatmap();
+    OsuNative.assertOk("Beatmap_CreateFromText", import_osu_native_napi2.default.Beatmap_CreateFromText(text, native));
+    return new _Beatmap(native);
+  }
+  constructor(native) {
+    super(native);
+  }
+  getTitle() {
+    this.ensureAlive();
+    const bufferSizeArr = new Int32Array([
+      0
+    ]);
+    OsuNative.assertSizeQuery("Beatmap_GetTitle", import_osu_native_napi2.default.Beatmap_GetTitle(this.handle, null, bufferSizeArr));
+    const buffer = Buffer.alloc(bufferSizeArr[0]);
+    OsuNative.assertOk("Beatmap_GetTitle", import_osu_native_napi2.default.Beatmap_GetTitle(this.handle, buffer, bufferSizeArr));
+    return buffer.toString();
+  }
+  getArtist() {
+    this.ensureAlive();
+    const bufferSizeArr = new Int32Array([
+      0
+    ]);
+    OsuNative.assertSizeQuery("Beatmap_GetArtist", import_osu_native_napi2.default.Beatmap_GetArtist(this.handle, null, bufferSizeArr));
+    const buffer = Buffer.alloc(bufferSizeArr[0]);
+    OsuNative.assertOk("Beatmap_GetArtist", import_osu_native_napi2.default.Beatmap_GetArtist(this.handle, buffer, bufferSizeArr));
+    return buffer.toString();
+  }
+  getVersion() {
+    this.ensureAlive();
+    const bufferSizeArr = new Int32Array([
+      0
+    ]);
+    OsuNative.assertSizeQuery("Beatmap_GetVersion", import_osu_native_napi2.default.Beatmap_GetVersion(this.handle, null, bufferSizeArr));
+    const buffer = Buffer.alloc(bufferSizeArr[0]);
+    OsuNative.assertOk("Beatmap_GetArtist", import_osu_native_napi2.default.Beatmap_GetVersion(this.handle, buffer, bufferSizeArr));
+    return buffer.toString();
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("Beatmap_Destroy", import_osu_native_napi2.default.Beatmap_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_Beatmap, "Beatmap");
+var Beatmap = _Beatmap;
+
+// src/objects/Mod.ts
+var import_osu_native_napi3 = __toESM(require("@tosuapp/osu-native-napi"));
+var _Mod = class _Mod extends NativeHandleOwner {
+  static create(acronym) {
+    const native = new import_osu_native_napi3.default.NativeMod();
+    OsuNative.assertOk("Mod_Create", import_osu_native_napi3.default.Mod_Create(acronym, native));
+    return new _Mod(native);
+  }
+  setSettingBool(key, value) {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_SetSettingBool", import_osu_native_napi3.default.Mod_SetSettingBool(this.handle, key, value));
+  }
+  setSettingInteger(key, value) {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_SetSettingInteger", import_osu_native_napi3.default.Mod_SetSettingInteger(this.handle, key, value));
+  }
+  setSettingFloat(key, value) {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_SetSettingFloat", import_osu_native_napi3.default.Mod_SetSettingFloat(this.handle, key, value));
+  }
+  debug() {
+    this.ensureAlive();
+    OsuNative.assertOk("Mod_Debug", import_osu_native_napi3.default.Mod_Debug(this.handle));
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("Mod_Destroy", import_osu_native_napi3.default.Mod_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_Mod, "Mod");
+var Mod = _Mod;
+
+// src/objects/ModsCollection.ts
+var import_osu_native_napi4 = __toESM(require("@tosuapp/osu-native-napi"));
+var _ModsCollection = class _ModsCollection extends NativeHandleOwner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "mods", []);
+  }
+  static create() {
+    const native = new import_osu_native_napi4.default.NativeModsCollection();
+    OsuNative.assertOk("ModsCollection_Create", import_osu_native_napi4.default.ModsCollection_Create(native));
+    return new _ModsCollection(native);
+  }
+  add(mod) {
+    this.ensureAlive();
+    OsuNative.assertOk("ModsCollection_Add", import_osu_native_napi4.default.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", import_osu_native_napi4.default.ModsCollection_Remove(this.handle, mod.handle));
+    this.mods = this.mods.filter((x) => x !== mod.handle);
+  }
+  debug() {
+    this.ensureAlive();
+    OsuNative.assertOk("ModsCollection_Debug", import_osu_native_napi4.default.ModsCollection_Debug(this.handle));
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("ModsCollection_Destroy", import_osu_native_napi4.default.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
+var import_osu_native_napi5 = __toESM(require("@tosuapp/osu-native-napi"));
+var _Ruleset = class _Ruleset extends NativeHandleOwner {
+  static fromId(rulesetId) {
+    const native = new import_osu_native_napi5.default.NativeRuleset();
+    OsuNative.assertOk("Ruleset_CreateFromId", import_osu_native_napi5.default.Ruleset_CreateFromId(rulesetId, native));
+    return new _Ruleset(native);
+  }
+  static fromShortName(shortName) {
+    const native = new import_osu_native_napi5.default.NativeRuleset();
+    OsuNative.assertOk("Ruleset_CreateFromShortName", import_osu_native_napi5.default.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", import_osu_native_napi5.default.Ruleset_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_Ruleset, "Ruleset");
+var Ruleset = _Ruleset;
+
+// src/calculators/difficulty/CatchDifficultyCalculator.ts
+var import_osu_native_napi6 = __toESM(require("@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 import_osu_native_napi6.default.NativeCatchDifficultyCalculator();
+    OsuNative.assertOk("CatchDifficultyCalculator_Create", import_osu_native_napi6.default.CatchDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _CatchDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi6.default.NativeCatchDifficultyAttributes();
+    OsuNative.assertOk("CatchDifficultyCalculator_Calculate", import_osu_native_napi6.default.CatchDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi6.default.NativeCatchDifficultyAttributes();
+    OsuNative.assertOk("CatchDifficultyCalculator_CalculateMods", import_osu_native_napi6.default.CatchDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("CatchDifficultyCalculator_CalculateTimed", import_osu_native_napi6.default.CatchDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("CatchDifficultyCalculator_CalculateTimed", import_osu_native_napi6.default.CatchDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("CatchDifficultyCalculator_CalculateModsTimed", import_osu_native_napi6.default.CatchDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("CatchDifficultyCalculator_CalculateModsTimed", import_osu_native_napi6.default.CatchDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("CatchDifficultyCalculator_Destroy", import_osu_native_napi6.default.CatchDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_CatchDifficultyCalculator, "CatchDifficultyCalculator");
+var CatchDifficultyCalculator = _CatchDifficultyCalculator;
+
+// src/calculators/difficulty/ManiaDifficultyCalculator.ts
+var import_osu_native_napi7 = __toESM(require("@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 import_osu_native_napi7.default.NativeManiaDifficultyCalculator();
+    OsuNative.assertOk("ManiaDifficultyCalculator_Create", import_osu_native_napi7.default.ManiaDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _ManiaDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi7.default.NativeManiaDifficultyAttributes();
+    OsuNative.assertOk("ManiaDifficultyCalculator_Calculate", import_osu_native_napi7.default.ManiaDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi7.default.NativeManiaDifficultyAttributes();
+    OsuNative.assertOk("ManiaDifficultyCalculator_CalculateMods", import_osu_native_napi7.default.ManiaDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("ManiaDifficultyCalculator_CalculateTimed", import_osu_native_napi7.default.ManiaDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("ManiaDifficultyCalculator_CalculateTimed", import_osu_native_napi7.default.ManiaDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("ManiaDifficultyCalculator_CalculateModsTimed", import_osu_native_napi7.default.ManiaDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("ManiaDifficultyCalculator_CalculateModsTimed", import_osu_native_napi7.default.ManiaDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("ManiaDifficultyCalculator_Destroy", import_osu_native_napi7.default.ManiaDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_ManiaDifficultyCalculator, "ManiaDifficultyCalculator");
+var ManiaDifficultyCalculator = _ManiaDifficultyCalculator;
+
+// src/calculators/difficulty/OsuDifficultyCalculator.ts
+var import_osu_native_napi8 = __toESM(require("@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 import_osu_native_napi8.default.NativeOsuDifficultyCalculator();
+    OsuNative.assertOk("OsuDifficultyCalculator_Create", import_osu_native_napi8.default.OsuDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _OsuDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi8.default.NativeOsuDifficultyAttributes();
+    OsuNative.assertOk("OsuDifficultyCalculator_Calculate", import_osu_native_napi8.default.OsuDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi8.default.NativeOsuDifficultyAttributes();
+    OsuNative.assertOk("OsuDifficultyCalculator_CalculateMods", import_osu_native_napi8.default.OsuDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("OsuDifficultyCalculator_CalculateTimed", import_osu_native_napi8.default.OsuDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("OsuDifficultyCalculator_CalculateTimed", import_osu_native_napi8.default.OsuDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("OsuDifficultyCalculator_CalculateModsTimed", import_osu_native_napi8.default.OsuDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("OsuDifficultyCalculator_CalculateModsTimed", import_osu_native_napi8.default.OsuDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("OsuDifficultyCalculator_Destroy", import_osu_native_napi8.default.OsuDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_OsuDifficultyCalculator, "OsuDifficultyCalculator");
+var OsuDifficultyCalculator = _OsuDifficultyCalculator;
+
+// src/calculators/difficulty/TaikoDifficultyCalculator.ts
+var import_osu_native_napi9 = __toESM(require("@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 import_osu_native_napi9.default.NativeTaikoDifficultyCalculator();
+    OsuNative.assertOk("TaikoDifficultyCalculator_Create", import_osu_native_napi9.default.TaikoDifficultyCalculator_Create(ruleset.handle, beatmap.handle, native));
+    return new _TaikoDifficultyCalculator(native, ruleset, beatmap);
+  }
+  calculate() {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi9.default.NativeTaikoDifficultyAttributes();
+    OsuNative.assertOk("TaikoDifficultyCalculator_Calculate", import_osu_native_napi9.default.TaikoDifficultyCalculator_Calculate(this.handle, attrs));
+    return attrs;
+  }
+  calculateWithMods(mods) {
+    this.ensureAlive();
+    const attrs = new import_osu_native_napi9.default.NativeTaikoDifficultyAttributes();
+    OsuNative.assertOk("TaikoDifficultyCalculator_CalculateMods", import_osu_native_napi9.default.TaikoDifficultyCalculator_CalculateMods(this.handle, mods.handle, attrs));
+    return attrs;
+  }
+  calculateTimed() {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("TaikoDifficultyCalculator_CalculateTimed", import_osu_native_napi9.default.TaikoDifficultyCalculator_CalculateTimed(this.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("TaikoDifficultyCalculator_CalculateTimed", import_osu_native_napi9.default.TaikoDifficultyCalculator_CalculateTimed(this.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  calculateWithModsTimed(mods) {
+    this.ensureAlive();
+    const bufferSize = new Int32Array(1);
+    OsuNative.assertSizeQuery("TaikoDifficultyCalculator_CalculateModsTimed", import_osu_native_napi9.default.TaikoDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, null, bufferSize));
+    if (bufferSize[0] <= 0) {
+      return [];
+    }
+    const outAttrs = new Array(bufferSize[0]);
+    OsuNative.assertOk("TaikoDifficultyCalculator_CalculateModsTimed", import_osu_native_napi9.default.TaikoDifficultyCalculator_CalculateModsTimed(this.handle, mods.handle, outAttrs, bufferSize));
+    return outAttrs;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("TaikoDifficultyCalculator_Destroy", import_osu_native_napi9.default.TaikoDifficultyCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_TaikoDifficultyCalculator, "TaikoDifficultyCalculator");
+var TaikoDifficultyCalculator = _TaikoDifficultyCalculator;
+
+// src/calculators/performance/CatchPerformanceCalculator.ts
+var import_osu_native_napi11 = __toESM(require("@tosuapp/osu-native-napi"));
+
+// src/internal/scoreInfo.ts
+var import_osu_native_napi10 = __toESM(require("@tosuapp/osu-native-napi"));
+function makeScoreInfo(input) {
+  const score = new import_osu_native_napi10.default.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 import_osu_native_napi11.default.NativeCatchPerformanceCalculator();
+    OsuNative.assertOk("CatchPerformanceCalculator_Create", import_osu_native_napi11.default.CatchPerformanceCalculator_Create(native));
+    return new _CatchPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new import_osu_native_napi11.default.NativeCatchPerformanceAttributes();
+    OsuNative.assertOk("CatchPerformanceCalculator_Calculate", import_osu_native_napi11.default.CatchPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("CatchPerformanceCalculator_Destroy", import_osu_native_napi11.default.CatchPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_CatchPerformanceCalculator, "CatchPerformanceCalculator");
+var CatchPerformanceCalculator = _CatchPerformanceCalculator;
+
+// src/calculators/performance/ManiaPerformanceCalculator.ts
+var import_osu_native_napi12 = __toESM(require("@tosuapp/osu-native-napi"));
+var _ManiaPerformanceCalculator = class _ManiaPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new import_osu_native_napi12.default.NativeManiaPerformanceCalculator();
+    OsuNative.assertOk("ManiaPerformanceCalculator_Create", import_osu_native_napi12.default.ManiaPerformanceCalculator_Create(native));
+    return new _ManiaPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new import_osu_native_napi12.default.NativeManiaPerformanceAttributes();
+    OsuNative.assertOk("ManiaPerformanceCalculator_Calculate", import_osu_native_napi12.default.ManiaPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("ManiaPerformanceCalculator_Destroy", import_osu_native_napi12.default.ManiaPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_ManiaPerformanceCalculator, "ManiaPerformanceCalculator");
+var ManiaPerformanceCalculator = _ManiaPerformanceCalculator;
+
+// src/calculators/performance/OsuPerformanceCalculator.ts
+var import_osu_native_napi13 = __toESM(require("@tosuapp/osu-native-napi"));
+var _OsuPerformanceCalculator = class _OsuPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new import_osu_native_napi13.default.NativeOsuPerformanceCalculator();
+    OsuNative.assertOk("OsuPerformanceCalculator_Create", import_osu_native_napi13.default.OsuPerformanceCalculator_Create(native));
+    return new _OsuPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new import_osu_native_napi13.default.NativeOsuPerformanceAttributes();
+    OsuNative.assertOk("OsuPerformanceCalculator_Calculate", import_osu_native_napi13.default.OsuPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("OsuPerformanceCalculator_Destroy", import_osu_native_napi13.default.OsuPerformanceCalculator_Destroy(this.handle));
+    this.destroyed = true;
+  }
+};
+__name(_OsuPerformanceCalculator, "OsuPerformanceCalculator");
+var OsuPerformanceCalculator = _OsuPerformanceCalculator;
+
+// src/calculators/performance/TaikoPerformanceCalculator.ts
+var import_osu_native_napi14 = __toESM(require("@tosuapp/osu-native-napi"));
+var _TaikoPerformanceCalculator = class _TaikoPerformanceCalculator extends NativeHandleOwner {
+  static create() {
+    const native = new import_osu_native_napi14.default.NativeTaikoPerformanceCalculator();
+    OsuNative.assertOk("TaikoPerformanceCalculator_Create", import_osu_native_napi14.default.TaikoPerformanceCalculator_Create(native));
+    return new _TaikoPerformanceCalculator(native);
+  }
+  calculate(score, difficulty) {
+    this.ensureAlive();
+    const out = new import_osu_native_napi14.default.NativeTaikoPerformanceAttributes();
+    OsuNative.assertOk("TaikoPerformanceCalculator_Calculate", import_osu_native_napi14.default.TaikoPerformanceCalculator_Calculate(this.handle, makeScoreInfo(score), difficulty, out));
+    return out;
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    OsuNative.assertOk("TaikoPerformanceCalculator_Destroy", import_osu_native_napi14.default.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Beatmap,
+  CatchDifficultyCalculator,
+  CatchPerformanceCalculator,
+  DifficultyCalculatorFactory,
+  ManiaDifficultyCalculator,
+  ManiaPerformanceCalculator,
+  Mod,
+  ModsCollection,
+  OsuDifficultyCalculator,
+  OsuNative,
+  OsuNativeError,
+  OsuPerformanceCalculator,
+  PerformanceCalculatorFactory,
+  Ruleset,
+  TaikoDifficultyCalculator,
+  TaikoPerformanceCalculator
+});