@r2o3/rgskin-nodejs 0.0.3 → 0.0.4

package/rgskin.js

@@ -2,7 +2,7 @@
 let imports = {};
 imports['__wbindgen_placeholder__'] = module.exports;
 
-const { createDirAll, isDirectory, joinPath, readDir, readFileBytes, readFileString, writeFile } = require(String.raw`./snippets/rgskin-ff9cecd6cd32cd1f/inline0.js`);
+const { createDirAll, isDirectory, joinPath, readDir, readFileBytes, readFileString, writeFile } = require(String.raw`./snippets/rgskin-1ac328c7fce651f2/inline0.js`);
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -288,6 +288,14 @@ const KeymodeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_keymode_free(ptr >>> 0, 1));
 
+const MainMenuFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mainmenu_free(ptr >>> 0, 1));
+
+const MenuBorderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_menuborder_free(ptr >>> 0, 1));
+
 const OsuKeymodeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_osukeymode_free(ptr >>> 0, 1));
@@ -300,14 +308,38 @@ const OsuSkinIniFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_osuskinini_free(ptr >>> 0, 1));
 
+const QuaGeneralFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_quageneral_free(ptr >>> 0, 1));
+
+const QuaKeymodeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_quakeymode_free(ptr >>> 0, 1));
+
+const QuaSkinFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_quaskin_free(ptr >>> 0, 1));
+
+const QuaSkinIniFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_quaskinini_free(ptr >>> 0, 1));
+
 const RawBytesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rawbytes_free(ptr >>> 0, 1));
 
+const ResultsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_results_free(ptr >>> 0, 1));
+
 const SkinJsonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_skinjson_free(ptr >>> 0, 1));
 
+const SongSelectFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_songselect_free(ptr >>> 0, 1));
+
 const TextureFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_texture_free(ptr >>> 0, 1));
@@ -334,19 +366,22 @@ class BinaryStore {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_binarystore_free(ptr, 0);
     }
-    constructor() {
-        const ret = wasm.binarystore_new_wasm();
-        this.__wbg_ptr = ret >>> 0;
-        BinaryStoreFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * @returns {boolean}
+     */
+    allLoaded() {
+        const ret = wasm.binarystore_allLoaded(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * @param {RawBytes} binary
+     * @param {string} path
+     * @returns {boolean}
      */
-    insertBinary(binary) {
-        _assertClass(binary, RawBytes);
-        var ptr0 = binary.__destroy_into_raw();
-        wasm.binarystore_insertBinary(this.__wbg_ptr, ptr0);
+    hasBinary(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.binarystore_contains(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
     }
     /**
      * @param {string} new_path
@@ -369,37 +404,6 @@ class BinaryStore {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
-    /**
-     * @param {string} path
-     * @param {ArrayBuffer} buffer
-     */
-    loadFromArrayBuffer(path, buffer) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_loadFromArrayBuffer(this.__wbg_ptr, ptr0, len0, buffer);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @param {string} path
-     * @param {Uint8Array} array
-     */
-    loadFromUint8Array(path, array) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_loadFromUint8Array(this.__wbg_ptr, ptr0, len0, array);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @returns {boolean}
-     */
-    allLoaded() {
-        const ret = wasm.binarystore_allLoaded(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {number}
      */
@@ -407,6 +411,14 @@ class BinaryStore {
         const ret = wasm.binarystore_loadedCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @param {RawBytes} binary
+     */
+    insertBinary(binary) {
+        _assertClass(binary, RawBytes);
+        var ptr0 = binary.__destroy_into_raw();
+        wasm.binarystore_insertBinary(this.__wbg_ptr, ptr0);
+    }
     /**
      * @returns {Array<any>}
      */
@@ -418,12 +430,22 @@ class BinaryStore {
      * @param {string} path
      * @returns {boolean}
      */
-    hasBinary(path) {
+    binaryHasData(path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_contains(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.binarystore_binaryHasData(this.__wbg_ptr, ptr0, len0);
         return ret !== 0;
     }
+    /**
+     * @param {string} path
+     * @returns {Uint8Array | undefined}
+     */
+    getBinaryData(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.binarystore_getBinaryData(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * @param {string} path
      * @returns {string | undefined}
@@ -441,33 +463,50 @@ class BinaryStore {
     }
     /**
      * @param {string} path
-     * @returns {boolean}
+     * @param {Uint8Array} array
      */
-    binaryHasData(path) {
+    loadFromUint8Array(path, array) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_binaryHasData(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
+        const ret = wasm.binarystore_loadFromUint8Array(this.__wbg_ptr, ptr0, len0, array);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * @param {string} path
-     * @returns {Uint8Array | undefined}
+     * @param {ArrayBuffer} buffer
      */
-    getBinaryData(path) {
+    loadFromArrayBuffer(path, buffer) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_getBinaryData(this.__wbg_ptr, ptr0, len0);
-        return ret;
+        const ret = wasm.binarystore_loadFromArrayBuffer(this.__wbg_ptr, ptr0, len0, buffer);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.binarystore_new_wasm();
+        this.__wbg_ptr = ret >>> 0;
+        BinaryStoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    clear() {
+        wasm.binarystore_clear(this.__wbg_ptr);
     }
     /**
-     * @param {string} path
-     * @returns {boolean}
+     * @returns {number}
      */
-    contains(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_contains(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
+    getLength() {
+        const ret = wasm.binarystore_getLength(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {BinaryStore} other
+     */
+    extend(other) {
+        _assertClass(other, BinaryStore);
+        wasm.binarystore_extend(this.__wbg_ptr, other.__wbg_ptr);
     }
     /**
      * @param {string} path
@@ -480,11 +519,14 @@ class BinaryStore {
         return ret !== 0;
     }
     /**
-     * @returns {number}
+     * @param {string} path
+     * @returns {boolean}
      */
-    getLength() {
-        const ret = wasm.binarystore_getLength(this.__wbg_ptr);
-        return ret >>> 0;
+    contains(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.binarystore_contains(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
     }
     /**
      * @returns {boolean}
@@ -500,20 +542,17 @@ class BinaryStore {
         const ret = wasm.binarystore_getPaths(this.__wbg_ptr);
         return ret;
     }
-    clear() {
-        wasm.binarystore_clear(this.__wbg_ptr);
-    }
     /**
      * @param {string} original_path
-     * @param {string} new_path
+     * @param {string} new_base_path
      * @returns {string | undefined}
      */
-    copy(original_path, new_path) {
+    makeUniqueCopy(original_path, new_base_path) {
         const ptr0 = passStringToWasm0(original_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(new_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(new_base_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_copy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.binarystore_makeUniqueCopy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         let v3;
         if (ret[0] !== 0) {
             v3 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -523,15 +562,15 @@ class BinaryStore {
     }
     /**
      * @param {string} original_path
-     * @param {string} new_base_path
+     * @param {string} new_path
      * @returns {string | undefined}
      */
-    makeUniqueCopy(original_path, new_base_path) {
+    copy(original_path, new_path) {
         const ptr0 = passStringToWasm0(original_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(new_base_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(new_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.binarystore_makeUniqueCopy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.binarystore_copy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         let v3;
         if (ret[0] !== 0) {
             v3 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -539,17 +578,20 @@ class BinaryStore {
         }
         return v3;
     }
-    /**
-     * @param {BinaryStore} other
-     */
-    extend(other) {
-        _assertClass(other, BinaryStore);
-        wasm.binarystore_extend(this.__wbg_ptr, other.__wbg_ptr);
-    }
 }
 if (Symbol.dispose) BinaryStore.prototype[Symbol.dispose] = BinaryStore.prototype.free;
 exports.BinaryStore = BinaryStore;
 
+/**
+ * @enum {0 | 1 | 2}
+ */
+const DefaultSkin = Object.freeze({
+    Arrow: 0, "0": "Arrow",
+    Bar: 1, "1": "Bar",
+    Circle: 2, "2": "Circle",
+});
+exports.DefaultSkin = DefaultSkin;
+
 class FluXisKeymode {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -854,22 +896,18 @@ class FluXisSkin {
         return this;
     }
     /**
-     * @returns {GenericManiaSkin}
+     * @param {number} keymode
+     * @returns {FluXisKeymode | undefined}
      */
-    toGenericMania() {
-        const ret = wasm.fluxisskin_toGenericMania(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return GenericManiaSkin.__wrap(ret[0]);
+    getKeymode(keymode) {
+        const ret = wasm.fluxisskin_getKeymode(this.__wbg_ptr, keymode);
+        return ret === 0 ? undefined : FluXisKeymode.__wrap(ret);
     }
     /**
-     * @param {FluXisLayout} layout
      * @returns {GenericManiaSkin}
      */
-    toGenericManiaWithLayout(layout) {
-        _assertClass(layout, FluXisLayout);
-        const ret = wasm.fluxisskin_toGenericManiaWithLayout(this.__wbg_ptr, layout.__wbg_ptr);
+    toGenericMania() {
+        const ret = wasm.fluxisskin_toGenericMania(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -888,12 +926,13 @@ class FluXisSkin {
         return FluXisSkinWithLayout.__wrap(ret[0]);
     }
     /**
-     * @param {number} keymode
-     * @returns {FluXisKeymode | undefined}
+     * @returns {string[]}
      */
-    getKeymode(keymode) {
-        const ret = wasm.fluxisskin_getKeymode(this.__wbg_ptr, keymode);
-        return ret === 0 ? undefined : FluXisKeymode.__wrap(ret);
+    getRequiredSamplePaths() {
+        const ret = wasm.fluxisskin_getRequiredSamplePaths(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
      * @returns {string[]}
@@ -905,13 +944,16 @@ class FluXisSkin {
         return v1;
     }
     /**
-     * @returns {string[]}
+     * @param {FluXisLayout} layout
+     * @returns {GenericManiaSkin}
      */
-    getRequiredSamplePaths() {
-        const ret = wasm.fluxisskin_getRequiredSamplePaths(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    toGenericManiaWithLayout(layout) {
+        _assertClass(layout, FluXisLayout);
+        const ret = wasm.fluxisskin_toGenericManiaWithLayout(this.__wbg_ptr, layout.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GenericManiaSkin.__wrap(ret[0]);
     }
 }
 if (Symbol.dispose) FluXisSkin.prototype[Symbol.dispose] = FluXisSkin.prototype.free;
@@ -1322,6 +1364,14 @@ class GenericManiaSkin {
         var ptr0 = arg0.__destroy_into_raw();
         wasm.__wbg_set_genericmaniaskin_samples(this.__wbg_ptr, ptr0);
     }
+    /**
+     * @param {number} keymode
+     * @returns {Keymode | undefined}
+     */
+    getKeymode(keymode) {
+        const ret = wasm.genericmaniaskin_getKeymode(this.__wbg_ptr, keymode);
+        return ret === 0 ? undefined : Keymode.__wrap(ret);
+    }
     /**
      * @returns {GenericManiaSkin}
      */
@@ -1344,19 +1394,11 @@ class GenericManiaSkin {
         }
         return GenericManiaSkin.__wrap(ret[0]);
     }
-    /**
-     * @param {number} keymode
-     * @returns {Keymode | undefined}
-     */
-    getKeymode(keymode) {
-        const ret = wasm.genericmaniaskin_getKeymode(this.__wbg_ptr, keymode);
-        return ret === 0 ? undefined : Keymode.__wrap(ret);
-    }
     /**
      * @returns {string[]}
      */
-    getRequiredTexturePaths() {
-        const ret = wasm.genericmaniaskin_getRequiredTexturePaths(this.__wbg_ptr);
+    getRequiredSamplePaths() {
+        const ret = wasm.genericmaniaskin_getRequiredSamplePaths(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -1364,8 +1406,8 @@ class GenericManiaSkin {
     /**
      * @returns {string[]}
      */
-    getRequiredSamplePaths() {
-        const ret = wasm.genericmaniaskin_getRequiredSamplePaths(this.__wbg_ptr);
+    getRequiredTexturePaths() {
+        const ret = wasm.genericmaniaskin_getRequiredTexturePaths(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -1374,15 +1416,55 @@ class GenericManiaSkin {
 if (Symbol.dispose) GenericManiaSkin.prototype[Symbol.dispose] = GenericManiaSkin.prototype.free;
 exports.GenericManiaSkin = GenericManiaSkin;
 
-class Info {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Info.prototype);
-        obj.__wbg_ptr = ptr;
-        InfoFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
+/**
+ * @enum {0 | 1 | 2}
+ */
+const HealthBarKeysAlignment = Object.freeze({
+    LeftStage: 0, "0": "LeftStage",
+    RightStage: 1, "1": "RightStage",
+    TopLeft: 2, "2": "TopLeft",
+});
+exports.HealthBarKeysAlignment = HealthBarKeysAlignment;
+
+/**
+ * @enum {0 | 1}
+ */
+const HealthBarType = Object.freeze({
+    Horizontal: 0, "0": "Horizontal",
+    Vertical: 1, "1": "Vertical",
+});
+exports.HealthBarType = HealthBarType;
+
+/**
+ * @enum {0 | 1 | 2}
+ */
+const HitBubblesAlignment = Object.freeze({
+    LeftStage: 0, "0": "LeftStage",
+    RightStage: 1, "1": "RightStage",
+    BelowStage: 2, "2": "BelowStage",
+});
+exports.HitBubblesAlignment = HitBubblesAlignment;
+
+/**
+ * @enum {0 | 1 | 2 | 3}
+ */
+const HitBubblesType = Object.freeze({
+    FallDown: 0, "0": "FallDown",
+    FallUp: 1, "1": "FallUp",
+    FallLeft: 2, "2": "FallLeft",
+    FallRight: 3, "3": "FallRight",
+});
+exports.HitBubblesType = HitBubblesType;
+
+class Info {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Info.prototype);
+        obj.__wbg_ptr = ptr;
+        InfoFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         InfoFinalization.unregister(this);
@@ -1484,17 +1566,17 @@ class Keymode {
         wasm.__wbg_keymode_free(ptr, 0);
     }
     /**
-     * @param {string} content
-     * @returns {OsuKeymode}
+     * @returns {number}
      */
-    static fromStr(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.keymode_fromStr(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return OsuKeymode.__wrap(ret[0]);
+    get keymode() {
+        const ret = wasm.__wbg_get_keymode_keymode(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set keymode(arg0) {
+        wasm.__wbg_set_keymode_keymode(this.__wbg_ptr, arg0);
     }
     /**
      * @returns {string}
@@ -1511,6 +1593,19 @@ class Keymode {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {string} content
+     * @returns {OsuKeymode}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keymode_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OsuKeymode.__wrap(ret[0]);
+    }
     /**
      * @returns {string[]}
      */
@@ -1520,22 +1615,148 @@ class Keymode {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+}
+if (Symbol.dispose) Keymode.prototype[Symbol.dispose] = Keymode.prototype.free;
+exports.Keymode = Keymode;
+
+class MainMenu {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MainMenu.prototype);
+        obj.__wbg_ptr = ptr;
+        MainMenuFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MainMenuFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mainmenu_free(ptr, 0);
+    }
     /**
      * @returns {number}
      */
-    get keymode() {
-        const ret = wasm.__wbg_get_keymode_keymode(this.__wbg_ptr);
+    get navigation_button_hovered_alpha() {
+        const ret = wasm.__wbg_get_mainmenu_navigation_button_hovered_alpha(this.__wbg_ptr);
         return ret;
     }
     /**
      * @param {number} arg0
      */
-    set keymode(arg0) {
-        wasm.__wbg_set_keymode_keymode(this.__wbg_ptr, arg0);
+    set navigation_button_hovered_alpha(arg0) {
+        wasm.__wbg_set_mainmenu_navigation_button_hovered_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get audio_visualizer_opacity() {
+        const ret = wasm.__wbg_get_mainmenu_audio_visualizer_opacity(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set audio_visualizer_opacity(arg0) {
+        wasm.__wbg_set_mainmenu_audio_visualizer_opacity(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get note_visualizer_opacity() {
+        const ret = wasm.__wbg_get_mainmenu_note_visualizer_opacity(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set note_visualizer_opacity(arg0) {
+        wasm.__wbg_set_mainmenu_note_visualizer_opacity(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} content
+     * @returns {MainMenu}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mainmenu_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MainMenu.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mainmenu_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
     }
 }
-if (Symbol.dispose) Keymode.prototype[Symbol.dispose] = Keymode.prototype.free;
-exports.Keymode = Keymode;
+if (Symbol.dispose) MainMenu.prototype[Symbol.dispose] = MainMenu.prototype.free;
+exports.MainMenu = MainMenu;
+
+class MenuBorder {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MenuBorder.prototype);
+        obj.__wbg_ptr = ptr;
+        MenuBorderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MenuBorderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_menuborder_free(ptr, 0);
+    }
+    /**
+     * @param {string} content
+     * @returns {MenuBorder}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.menuborder_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MenuBorder.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.menuborder_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) MenuBorder.prototype[Symbol.dispose] = MenuBorder.prototype.free;
+exports.MenuBorder = MenuBorder;
 
 class OsuKeymode {
     static __wrap(ptr) {
@@ -2388,7 +2609,7 @@ class OsuSkin {
      * @returns {TextureStore}
      */
     get textures() {
-        const ret = wasm.__wbg_get_osuskin_textures(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_genericmaniaskin_textures(this.__wbg_ptr);
         return TextureStore.__wrap(ret);
     }
     /**
@@ -2397,13 +2618,13 @@ class OsuSkin {
     set textures(arg0) {
         _assertClass(arg0, TextureStore);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_osuskin_textures(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_genericmaniaskin_textures(this.__wbg_ptr, ptr0);
     }
     /**
      * @returns {BinaryStore}
      */
     get samples() {
-        const ret = wasm.__wbg_get_osuskin_samples(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_genericmaniaskin_samples(this.__wbg_ptr);
         return BinaryStore.__wrap(ret);
     }
     /**
@@ -2412,7 +2633,7 @@ class OsuSkin {
     set samples(arg0) {
         _assertClass(arg0, BinaryStore);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_osuskin_samples(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_genericmaniaskin_samples(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {OsuSkinIni} skin_ini
@@ -2437,6 +2658,14 @@ class OsuSkin {
         OsuSkinFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {number} keymode
+     * @returns {OsuKeymode | undefined}
+     */
+    getKeymode(keymode) {
+        const ret = wasm.osuskin_getKeymode(this.__wbg_ptr, keymode);
+        return ret === 0 ? undefined : OsuKeymode.__wrap(ret);
+    }
     /**
      * @returns {GenericManiaSkin}
      */
@@ -2459,19 +2688,11 @@ class OsuSkin {
         }
         return OsuSkin.__wrap(ret[0]);
     }
-    /**
-     * @param {number} keymode
-     * @returns {OsuKeymode | undefined}
-     */
-    getKeymode(keymode) {
-        const ret = wasm.osuskin_getKeymode(this.__wbg_ptr, keymode);
-        return ret === 0 ? undefined : OsuKeymode.__wrap(ret);
-    }
     /**
      * @returns {string[]}
      */
-    getRequiredTexturePaths() {
-        const ret = wasm.osuskin_getRequiredTexturePaths(this.__wbg_ptr);
+    getRequiredSamplePaths() {
+        const ret = wasm.osuskin_getRequiredSamplePaths(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -2479,8 +2700,8 @@ class OsuSkin {
     /**
      * @returns {string[]}
      */
-    getRequiredSamplePaths() {
-        const ret = wasm.osuskin_getRequiredSamplePaths(this.__wbg_ptr);
+    getRequiredTexturePaths() {
+        const ret = wasm.osuskin_getRequiredTexturePaths(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -2539,12 +2760,6 @@ class OsuSkinIni {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_osuskinini_keymodes(this.__wbg_ptr, ptr0, len0);
     }
-    constructor() {
-        const ret = wasm.osuskinini_new();
-        this.__wbg_ptr = ret >>> 0;
-        OsuSkinIniFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * @param {string} json_str
      * @returns {OsuSkinIni}
@@ -2574,13 +2789,12 @@ class OsuSkinIni {
         }
     }
     /**
-     * @returns {string[]}
+     * @param {number} keymode
+     * @returns {OsuKeymode | undefined}
      */
-    getRequiredTexturePaths() {
-        const ret = wasm.osuskinini_getRequiredTexturePaths(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    getKeymode(keymode) {
+        const ret = wasm.osuskinini_getKeymode(this.__wbg_ptr, keymode);
+        return ret === 0 ? undefined : OsuKeymode.__wrap(ret);
     }
     /**
      * @returns {string[]}
@@ -2592,43 +2806,50 @@ class OsuSkinIni {
         return v1;
     }
     /**
-     * @param {number} keymode
-     * @returns {OsuKeymode | undefined}
+     * @returns {string[]}
      */
-    getKeymode(keymode) {
-        const ret = wasm.osuskinini_getKeymode(this.__wbg_ptr, keymode);
-        return ret === 0 ? undefined : OsuKeymode.__wrap(ret);
+    getRequiredTexturePaths() {
+        const ret = wasm.osuskinini_getRequiredTexturePaths(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.osuskinini_new();
+        this.__wbg_ptr = ret >>> 0;
+        OsuSkinIniFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
 if (Symbol.dispose) OsuSkinIni.prototype[Symbol.dispose] = OsuSkinIni.prototype.free;
 exports.OsuSkinIni = OsuSkinIni;
 
-class RawBytes {
+class QuaGeneral {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(RawBytes.prototype);
+        const obj = Object.create(QuaGeneral.prototype);
         obj.__wbg_ptr = ptr;
-        RawBytesFinalization.register(obj, obj.__wbg_ptr, obj);
+        QuaGeneralFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RawBytesFinalization.unregister(this);
+        QuaGeneralFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rawbytes_free(ptr, 0);
+        wasm.__wbg_quageneral_free(ptr, 0);
     }
     /**
      * @returns {string}
      */
-    get path() {
+    get name() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.__wbg_get_rawbytes_path(this.__wbg_ptr);
+            const ret = wasm.__wbg_get_quageneral_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -2639,34 +2860,1693 @@ class RawBytes {
     /**
      * @param {string} arg0
      */
-    set path(arg0) {
+    set name(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_rawbytes_path(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_general_name(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {string} path
+     * @returns {string}
      */
-    constructor(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rawbytes_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        RawBytesFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    get author() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_quageneral_author(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * @param {string} path
-     * @param {Uint8Array} bytes
-     * @returns {RawBytes}
+     * @param {string} arg0
      */
-    static fromBytes(path, bytes) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    set author(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_general_author(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_quageneral_version(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set version(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_general_version(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get center_cursor() {
+        const ret = wasm.__wbg_get_quageneral_center_cursor(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set center_cursor(arg0) {
+        wasm.__wbg_set_quageneral_center_cursor(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get use_skin_backgrounds() {
+        const ret = wasm.__wbg_get_quageneral_use_skin_backgrounds(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set use_skin_backgrounds(arg0) {
+        wasm.__wbg_set_quageneral_use_skin_backgrounds(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} content
+     * @returns {QuaGeneral}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.quageneral_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QuaGeneral.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.quageneral_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) QuaGeneral.prototype[Symbol.dispose] = QuaGeneral.prototype.free;
+exports.QuaGeneral = QuaGeneral;
+
+class QuaKeymode {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(QuaKeymode.prototype);
+        obj.__wbg_ptr = ptr;
+        QuaKeymodeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof QuaKeymode)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuaKeymodeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quakeymode_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get keymode() {
+        const ret = wasm.__wbg_get_quakeymode_keymode(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set keymode(arg0) {
+        wasm.__wbg_set_quakeymode_keymode(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {DefaultSkin}
+     */
+    get default_skin() {
+        const ret = wasm.__wbg_get_quakeymode_default_skin(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {DefaultSkin} arg0
+     */
+    set default_skin(arg0) {
+        wasm.__wbg_set_quakeymode_default_skin(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get color_objects_by_snap_distance() {
+        const ret = wasm.__wbg_get_quakeymode_color_objects_by_snap_distance(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set color_objects_by_snap_distance(arg0) {
+        wasm.__wbg_set_quakeymode_color_objects_by_snap_distance(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get use_hit_object_sheet() {
+        const ret = wasm.__wbg_get_quakeymode_use_hit_object_sheet(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set use_hit_object_sheet(arg0) {
+        wasm.__wbg_set_quakeymode_use_hit_object_sheet(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get rotate_hit_objects_by_column() {
+        const ret = wasm.__wbg_get_quakeymode_rotate_hit_objects_by_column(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set rotate_hit_objects_by_column(arg0) {
+        wasm.__wbg_set_quakeymode_rotate_hit_objects_by_column(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get flip_note_images_on_upscroll() {
+        const ret = wasm.__wbg_get_quakeymode_flip_note_images_on_upscroll(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set flip_note_images_on_upscroll(arg0) {
+        wasm.__wbg_set_quakeymode_flip_note_images_on_upscroll(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get flip_note_end_images_on_upscroll() {
+        const ret = wasm.__wbg_get_quakeymode_flip_note_end_images_on_upscroll(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set flip_note_end_images_on_upscroll(arg0) {
+        wasm.__wbg_set_quakeymode_flip_note_end_images_on_upscroll(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get draw_long_note_end() {
+        const ret = wasm.__wbg_get_quakeymode_draw_long_note_end(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set draw_long_note_end(arg0) {
+        wasm.__wbg_set_quakeymode_draw_long_note_end(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get note_padding() {
+        const ret = wasm.__wbg_get_quakeymode_note_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set note_padding(arg0) {
+        wasm.__wbg_set_quakeymode_note_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get width_for_note_height_scale() {
+        const ret = wasm.__wbg_get_quakeymode_width_for_note_height_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set width_for_note_height_scale(arg0) {
+        wasm.__wbg_set_quakeymode_width_for_note_height_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bg_mask_alpha() {
+        const ret = wasm.__wbg_get_quakeymode_bg_mask_alpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set bg_mask_alpha(arg0) {
+        wasm.__wbg_set_quakeymode_bg_mask_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bg_mask_padding() {
+        const ret = wasm.__wbg_get_quakeymode_bg_mask_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set bg_mask_padding(arg0) {
+        wasm.__wbg_set_quakeymode_bg_mask_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get column_alignment() {
+        const ret = wasm.__wbg_get_quakeymode_column_alignment(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set column_alignment(arg0) {
+        wasm.__wbg_set_quakeymode_column_alignment(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get column_size() {
+        const ret = wasm.__wbg_get_quakeymode_column_size(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set column_size(arg0) {
+        wasm.__wbg_set_quakeymode_column_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get column_lighting_offset_y() {
+        const ret = wasm.__wbg_get_quakeymode_column_lighting_offset_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set column_lighting_offset_y(arg0) {
+        wasm.__wbg_set_quakeymode_column_lighting_offset_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get column_lighting_scale() {
+        const ret = wasm.__wbg_get_quakeymode_column_lighting_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set column_lighting_scale(arg0) {
+        wasm.__wbg_set_quakeymode_column_lighting_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_pos_offset_y() {
+        const ret = wasm.__wbg_get_quakeymode_hit_pos_offset_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_pos_offset_y(arg0) {
+        wasm.__wbg_set_quakeymode_hit_pos_offset_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get receptor_pos_offset_y() {
+        const ret = wasm.__wbg_get_quakeymode_receptor_pos_offset_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set receptor_pos_offset_y(arg0) {
+        wasm.__wbg_set_quakeymode_receptor_pos_offset_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get receptors_over_hit_objects() {
+        const ret = wasm.__wbg_get_quakeymode_receptors_over_hit_objects(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set receptors_over_hit_objects(arg0) {
+        wasm.__wbg_set_quakeymode_receptors_over_hit_objects(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get stage_receptor_padding() {
+        const ret = wasm.__wbg_get_quakeymode_stage_receptor_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set stage_receptor_padding(arg0) {
+        wasm.__wbg_set_quakeymode_stage_receptor_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get coop_playfield_padding() {
+        const ret = wasm.__wbg_get_quakeymode_coop_playfield_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set coop_playfield_padding(arg0) {
+        wasm.__wbg_set_quakeymode_coop_playfield_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_error_chevron_size() {
+        const ret = wasm.__wbg_get_quakeymode_hit_error_chevron_size(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_error_chevron_size(arg0) {
+        wasm.__wbg_set_quakeymode_hit_error_chevron_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_error_height() {
+        const ret = wasm.__wbg_get_quakeymode_hit_error_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_error_height(arg0) {
+        wasm.__wbg_set_quakeymode_hit_error_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_error_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_hit_error_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_error_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_hit_error_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_error_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_hit_error_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_error_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_hit_error_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_error_alpha() {
+        const ret = wasm.__wbg_get_quakeymode_hit_error_alpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_error_alpha(arg0) {
+        wasm.__wbg_set_quakeymode_hit_error_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_hit_burst_fps() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_hit_burst_fps(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_hit_burst_fps(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_hit_burst_fps(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_burst_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_burst_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_burst_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_burst_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_hit_burst_bump_y() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_hit_burst_bump_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_hit_burst_bump_y(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_hit_burst_bump_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_hit_burst_bump_time() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_hit_burst_bump_time(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_hit_burst_bump_time(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_hit_burst_bump_time(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_hit_burst_scale() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_hit_burst_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_hit_burst_scale(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_hit_burst_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_lighting_x() {
+        const ret = wasm.__wbg_get_quakeymode_hit_lighting_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_lighting_x(arg0) {
+        wasm.__wbg_set_quakeymode_hit_lighting_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_lighting_y() {
+        const ret = wasm.__wbg_get_quakeymode_hit_lighting_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_lighting_y(arg0) {
+        wasm.__wbg_set_quakeymode_hit_lighting_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_lighting_fps() {
+        const ret = wasm.__wbg_get_quakeymode_hit_lighting_fps(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_lighting_fps(arg0) {
+        wasm.__wbg_set_quakeymode_hit_lighting_fps(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_lighting_scale() {
+        const ret = wasm.__wbg_get_quakeymode_hit_lighting_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_lighting_scale(arg0) {
+        wasm.__wbg_set_quakeymode_hit_lighting_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get hit_lighting_column_rotation() {
+        const ret = wasm.__wbg_get_quakeymode_hit_lighting_column_rotation(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set hit_lighting_column_rotation(arg0) {
+        wasm.__wbg_set_quakeymode_hit_lighting_column_rotation(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hold_lighting_fps() {
+        const ret = wasm.__wbg_get_quakeymode_hold_lighting_fps(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hold_lighting_fps(arg0) {
+        wasm.__wbg_set_quakeymode_hold_lighting_fps(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hold_lighting_scale() {
+        const ret = wasm.__wbg_get_quakeymode_hold_lighting_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hold_lighting_scale(arg0) {
+        wasm.__wbg_set_quakeymode_hold_lighting_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get hold_lighting_column_rotation() {
+        const ret = wasm.__wbg_get_quakeymode_hold_lighting_column_rotation(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set hold_lighting_column_rotation(arg0) {
+        wasm.__wbg_set_quakeymode_hold_lighting_column_rotation(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {HealthBarKeysAlignment}
+     */
+    get health_bar_keys_alignment() {
+        const ret = wasm.__wbg_get_quakeymode_health_bar_keys_alignment(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {HealthBarKeysAlignment} arg0
+     */
+    set health_bar_keys_alignment(arg0) {
+        wasm.__wbg_set_quakeymode_health_bar_keys_alignment(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {HealthBarType}
+     */
+    get health_bar_type() {
+        const ret = wasm.__wbg_get_quakeymode_health_bar_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {HealthBarType} arg0
+     */
+    set health_bar_type(arg0) {
+        wasm.__wbg_set_quakeymode_health_bar_type(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get health_bar_pos_offset_x() {
+        const ret = wasm.__wbg_get_quakeymode_health_bar_pos_offset_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set health_bar_pos_offset_x(arg0) {
+        wasm.__wbg_set_quakeymode_health_bar_pos_offset_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get health_bar_pos_offset_y() {
+        const ret = wasm.__wbg_get_quakeymode_health_bar_pos_offset_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set health_bar_pos_offset_y(arg0) {
+        wasm.__wbg_set_quakeymode_health_bar_pos_offset_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get health_bar_scale() {
+        const ret = wasm.__wbg_get_quakeymode_health_bar_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set health_bar_scale(arg0) {
+        wasm.__wbg_set_quakeymode_health_bar_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {HitBubblesAlignment}
+     */
+    get hit_bubbles_alignment() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubbles_alignment(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {HitBubblesAlignment} arg0
+     */
+    set hit_bubbles_alignment(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubbles_alignment(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {HitBubblesType}
+     */
+    get hit_bubbles_type() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubbles_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {HitBubblesType} arg0
+     */
+    set hit_bubbles_type(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubbles_type(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_bubbles_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubbles_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_bubbles_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubbles_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_bubbles_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubbles_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_bubbles_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubbles_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_bubbles_scale() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubbles_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_bubbles_scale(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubbles_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_bubble_scale() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubble_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_bubble_scale(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubble_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_bubble_border_padding() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubble_border_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_bubble_border_padding(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubble_border_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get hit_bubble_padding() {
+        const ret = wasm.__wbg_get_quakeymode_hit_bubble_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set hit_bubble_padding(arg0) {
+        wasm.__wbg_set_quakeymode_hit_bubble_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get combo_display_scale() {
+        const ret = wasm.__wbg_get_quakeymode_combo_display_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set combo_display_scale(arg0) {
+        wasm.__wbg_set_quakeymode_combo_display_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get combo_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_combo_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set combo_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_combo_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get combo_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_combo_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set combo_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_combo_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get combo_display_bump_y() {
+        const ret = wasm.__wbg_get_quakeymode_combo_display_bump_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set combo_display_bump_y(arg0) {
+        wasm.__wbg_set_quakeymode_combo_display_bump_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get combo_display_bump_time() {
+        const ret = wasm.__wbg_get_quakeymode_combo_display_bump_time(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set combo_display_bump_time(arg0) {
+        wasm.__wbg_set_quakeymode_combo_display_bump_time(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get rating_display_scale() {
+        const ret = wasm.__wbg_get_quakeymode_rating_display_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set rating_display_scale(arg0) {
+        wasm.__wbg_set_quakeymode_rating_display_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get rating_display_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_rating_display_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set rating_display_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_rating_display_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get rating_display_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_rating_display_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set rating_display_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_rating_display_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get accuracy_display_scale() {
+        const ret = wasm.__wbg_get_quakeymode_accuracy_display_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set accuracy_display_scale(arg0) {
+        wasm.__wbg_set_quakeymode_accuracy_display_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get accuracy_display_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_accuracy_display_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set accuracy_display_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_accuracy_display_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get accuracy_display_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_accuracy_display_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set accuracy_display_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_accuracy_display_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get kps_display_scale() {
+        const ret = wasm.__wbg_get_quakeymode_kps_display_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set kps_display_scale(arg0) {
+        wasm.__wbg_set_quakeymode_kps_display_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get kps_display_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_kps_display_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set kps_display_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_kps_display_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get kps_display_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_kps_display_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set kps_display_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_kps_display_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get score_display_scale() {
+        const ret = wasm.__wbg_get_quakeymode_score_display_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set score_display_scale(arg0) {
+        wasm.__wbg_set_quakeymode_score_display_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get score_display_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_score_display_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set score_display_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_score_display_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get score_display_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_score_display_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set score_display_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_score_display_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get battle_royale_alert_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_battle_royale_alert_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set battle_royale_alert_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_battle_royale_alert_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get battle_royale_alert_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_battle_royale_alert_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set battle_royale_alert_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_battle_royale_alert_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get battle_royale_alert_scale() {
+        const ret = wasm.__wbg_get_quakeymode_battle_royale_alert_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set battle_royale_alert_scale(arg0) {
+        wasm.__wbg_set_quakeymode_battle_royale_alert_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get battle_royale_eliminated_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_battle_royale_eliminated_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set battle_royale_eliminated_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_battle_royale_eliminated_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get battle_royale_eliminated_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_battle_royale_eliminated_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set battle_royale_eliminated_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_battle_royale_eliminated_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_counter_alpha() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_alpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_counter_alpha(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_counter_size() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_size(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_counter_size(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_counter_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_counter_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_counter_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_counter_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get judgement_counter_padding() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_padding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set judgement_counter_padding(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_padding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get judgement_counter_horizontal() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_horizontal(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set judgement_counter_horizontal(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_horizontal(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get judgement_counter_fade_to_alpha() {
+        const ret = wasm.__wbg_get_quakeymode_judgement_counter_fade_to_alpha(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set judgement_counter_fade_to_alpha(arg0) {
+        wasm.__wbg_set_quakeymode_judgement_counter_fade_to_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get use_judgement_color_for_numbers() {
+        const ret = wasm.__wbg_get_quakeymode_use_judgement_color_for_numbers(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set use_judgement_color_for_numbers(arg0) {
+        wasm.__wbg_set_quakeymode_use_judgement_color_for_numbers(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get song_time_progress_scale() {
+        const ret = wasm.__wbg_get_quakeymode_song_time_progress_scale(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set song_time_progress_scale(arg0) {
+        wasm.__wbg_set_quakeymode_song_time_progress_scale(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get song_time_progress_position_at_top() {
+        const ret = wasm.__wbg_get_quakeymode_song_time_progress_position_at_top(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set song_time_progress_position_at_top(arg0) {
+        wasm.__wbg_set_quakeymode_song_time_progress_position_at_top(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get show_mini_song_bar() {
+        const ret = wasm.__wbg_get_quakeymode_show_mini_song_bar(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set show_mini_song_bar(arg0) {
+        wasm.__wbg_set_quakeymode_show_mini_song_bar(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get mini_song_bar_display_pos_x() {
+        const ret = wasm.__wbg_get_quakeymode_mini_song_bar_display_pos_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set mini_song_bar_display_pos_x(arg0) {
+        wasm.__wbg_set_quakeymode_mini_song_bar_display_pos_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get mini_song_bar_display_pos_y() {
+        const ret = wasm.__wbg_get_quakeymode_mini_song_bar_display_pos_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set mini_song_bar_display_pos_y(arg0) {
+        wasm.__wbg_set_quakeymode_mini_song_bar_display_pos_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get mini_song_bar_display_width_factor() {
+        const ret = wasm.__wbg_get_quakeymode_mini_song_bar_display_width_factor(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set mini_song_bar_display_width_factor(arg0) {
+        wasm.__wbg_set_quakeymode_mini_song_bar_display_width_factor(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get mini_song_bar_display_height() {
+        const ret = wasm.__wbg_get_quakeymode_mini_song_bar_display_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set mini_song_bar_display_height(arg0) {
+        wasm.__wbg_set_quakeymode_mini_song_bar_display_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get use_fallback() {
+        const ret = wasm.__wbg_get_quakeymode_use_fallback(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set use_fallback(arg0) {
+        wasm.__wbg_set_quakeymode_use_fallback(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {string}
+     */
+    toStr() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.quakeymode_toStr(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} content
+     * @returns {QuaKeymode}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.quakeymode_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QuaKeymode.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) QuaKeymode.prototype[Symbol.dispose] = QuaKeymode.prototype.free;
+exports.QuaKeymode = QuaKeymode;
+
+class QuaSkin {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(QuaSkin.prototype);
+        obj.__wbg_ptr = ptr;
+        QuaSkinFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuaSkinFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quaskin_free(ptr, 0);
+    }
+    /**
+     * @returns {QuaSkinIni}
+     */
+    get skin_ini() {
+        const ret = wasm.__wbg_get_quaskin_skin_ini(this.__wbg_ptr);
+        return QuaSkinIni.__wrap(ret);
+    }
+    /**
+     * @param {QuaSkinIni} arg0
+     */
+    set skin_ini(arg0) {
+        _assertClass(arg0, QuaSkinIni);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_quaskin_skin_ini(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {TextureStore}
+     */
+    get textures() {
+        const ret = wasm.__wbg_get_genericmaniaskin_textures(this.__wbg_ptr);
+        return TextureStore.__wrap(ret);
+    }
+    /**
+     * @param {TextureStore} arg0
+     */
+    set textures(arg0) {
+        _assertClass(arg0, TextureStore);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_genericmaniaskin_textures(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {BinaryStore}
+     */
+    get samples() {
+        const ret = wasm.__wbg_get_genericmaniaskin_samples(this.__wbg_ptr);
+        return BinaryStore.__wrap(ret);
+    }
+    /**
+     * @param {BinaryStore} arg0
+     */
+    set samples(arg0) {
+        _assertClass(arg0, BinaryStore);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_genericmaniaskin_samples(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {QuaSkinIni} skin_ini
+     * @param {TextureStore | null} [textures]
+     * @param {BinaryStore | null} [samples]
+     */
+    constructor(skin_ini, textures, samples) {
+        _assertClass(skin_ini, QuaSkinIni);
+        var ptr0 = skin_ini.__destroy_into_raw();
+        let ptr1 = 0;
+        if (!isLikeNone(textures)) {
+            _assertClass(textures, TextureStore);
+            ptr1 = textures.__destroy_into_raw();
+        }
+        let ptr2 = 0;
+        if (!isLikeNone(samples)) {
+            _assertClass(samples, BinaryStore);
+            ptr2 = samples.__destroy_into_raw();
+        }
+        const ret = wasm.quaskin_new(ptr0, ptr1, ptr2);
+        this.__wbg_ptr = ret >>> 0;
+        QuaSkinFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} keymode
+     * @returns {QuaKeymode | undefined}
+     */
+    getKeymode(keymode) {
+        const ret = wasm.quaskin_getKeymode(this.__wbg_ptr, keymode);
+        return ret === 0 ? undefined : QuaKeymode.__wrap(ret);
+    }
+    /**
+     * @returns {GenericManiaSkin}
+     */
+    toGenericMania() {
+        const ret = wasm.quaskin_toGenericMania(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GenericManiaSkin.__wrap(ret[0]);
+    }
+    /**
+     * @param {GenericManiaSkin} skin
+     * @returns {QuaSkin}
+     */
+    static fromGenericMania(skin) {
+        _assertClass(skin, GenericManiaSkin);
+        const ret = wasm.quaskin_fromGenericMania(skin.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QuaSkin.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string[]}
+     */
+    getRequiredSamplePaths() {
+        const ret = wasm.quaskin_getRequiredSamplePaths(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {string[]}
+     */
+    getRequiredTexturePaths() {
+        const ret = wasm.quaskin_getRequiredTexturePaths(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) QuaSkin.prototype[Symbol.dispose] = QuaSkin.prototype.free;
+exports.QuaSkin = QuaSkin;
+
+class QuaSkinIni {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(QuaSkinIni.prototype);
+        obj.__wbg_ptr = ptr;
+        QuaSkinIniFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuaSkinIniFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quaskinini_free(ptr, 0);
+    }
+    /**
+     * @returns {QuaGeneral}
+     */
+    get general() {
+        const ret = wasm.__wbg_get_quaskinini_general(this.__wbg_ptr);
+        return QuaGeneral.__wrap(ret);
+    }
+    /**
+     * @param {QuaGeneral} arg0
+     */
+    set general(arg0) {
+        _assertClass(arg0, QuaGeneral);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_quaskinini_general(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {MainMenu}
+     */
+    get main_menu() {
+        const ret = wasm.__wbg_get_quaskinini_main_menu(this.__wbg_ptr);
+        return MainMenu.__wrap(ret);
+    }
+    /**
+     * @param {MainMenu} arg0
+     */
+    set main_menu(arg0) {
+        _assertClass(arg0, MainMenu);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_quaskinini_main_menu(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {MenuBorder}
+     */
+    get menu_border() {
+        const ret = wasm.__wbg_get_quaskinini_menu_border(this.__wbg_ptr);
+        return MenuBorder.__wrap(ret);
+    }
+    /**
+     * @param {MenuBorder} arg0
+     */
+    set menu_border(arg0) {
+        _assertClass(arg0, MenuBorder);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_quaskinini_menu_border(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {SongSelect}
+     */
+    get song_select() {
+        const ret = wasm.__wbg_get_quaskinini_song_select(this.__wbg_ptr);
+        return SongSelect.__wrap(ret);
+    }
+    /**
+     * @param {SongSelect} arg0
+     */
+    set song_select(arg0) {
+        _assertClass(arg0, SongSelect);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_quaskinini_song_select(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {Results}
+     */
+    get results() {
+        const ret = wasm.__wbg_get_quaskinini_results(this.__wbg_ptr);
+        return Results.__wrap(ret);
+    }
+    /**
+     * @param {Results} arg0
+     */
+    set results(arg0) {
+        _assertClass(arg0, Results);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_quaskinini_results(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {QuaKeymode[]}
+     */
+    get keymodes() {
+        const ret = wasm.__wbg_get_quaskinini_keymodes(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {QuaKeymode[]} arg0
+     */
+    set keymodes(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.rawbytes_fromBytes(ptr0, len0, ptr1, len1);
-        return RawBytes.__wrap(ret);
+        wasm.__wbg_set_quaskinini_keymodes(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {QuaKeymode | undefined}
+     */
+    get shared_keymode() {
+        const ret = wasm.__wbg_get_quaskinini_shared_keymode(this.__wbg_ptr);
+        return ret === 0 ? undefined : QuaKeymode.__wrap(ret);
+    }
+    /**
+     * @param {QuaKeymode | null} [arg0]
+     */
+    set shared_keymode(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, QuaKeymode);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_quaskinini_shared_keymode(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {string} ini_str
+     * @returns {QuaSkinIni}
+     */
+    static fromStr(ini_str) {
+        const ptr0 = passStringToWasm0(ini_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.quaskinini_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QuaSkinIni.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.quaskinini_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {number} keymode
+     * @returns {QuaKeymode | undefined}
+     */
+    getKeymode(keymode) {
+        const ret = wasm.quaskinini_getKeymode(this.__wbg_ptr, keymode);
+        return ret === 0 ? undefined : QuaKeymode.__wrap(ret);
+    }
+    constructor() {
+        const ret = wasm.quaskinini_new();
+        this.__wbg_ptr = ret >>> 0;
+        QuaSkinIniFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) QuaSkinIni.prototype[Symbol.dispose] = QuaSkinIni.prototype.free;
+exports.QuaSkinIni = QuaSkinIni;
+
+class RawBytes {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RawBytes.prototype);
+        obj.__wbg_ptr = ptr;
+        RawBytesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RawBytesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rawbytes_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get path() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_rawbytes_path(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set path(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_fluxislayout_name(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @returns {Uint8Array | undefined}
@@ -2675,6 +4555,100 @@ class RawBytes {
         const ret = wasm.rawbytes_getData(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getHash() {
+        const ret = wasm.rawbytes_getHash(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @param {string} path
+     * @param {Uint8Array} bytes
+     * @returns {RawBytes}
+     */
+    static fromBytes(path, bytes) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.rawbytes_fromBytes(ptr0, len0, ptr1, len1);
+        return RawBytes.__wrap(ret);
+    }
+    /**
+     * @param {string} path
+     */
+    constructor(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rawbytes_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        RawBytesFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    unload() {
+        const ret = wasm.rawbytes_unload(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    getPath() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.rawbytes_getPath(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    hasData() {
+        const ret = wasm.rawbytes_hasData(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.rawbytes_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isLoaded() {
+        const ret = wasm.rawbytes_isLoaded(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isUnloaded() {
+        const ret = wasm.rawbytes_isUnloaded(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} path
+     * @param {Uint8Array} array
+     * @returns {RawBytes}
+     */
+    static fromUint8Array(path, array) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rawbytes_fromUint8Array(ptr0, len0, array);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RawBytes.__wrap(ret[0]);
+    }
     /**
      * @param {string} path
      * @param {ArrayBuffer} buffer
@@ -2691,13 +4665,13 @@ class RawBytes {
     }
     /**
      * @param {string} path
-     * @param {ArrayBuffer} buffer
+     * @param {Uint8Array} array
      * @returns {RawBytes}
      */
-    static fromArrayBufferUnloaded(path, buffer) {
+    static fromUint8ArrayUnloaded(path, array) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rawbytes_fromArrayBufferUnloaded(ptr0, len0, buffer);
+        const ret = wasm.rawbytes_fromUint8ArrayUnloaded(ptr0, len0, array);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -2705,40 +4679,93 @@ class RawBytes {
     }
     /**
      * @param {string} path
-     * @param {Uint8Array} array
+     * @param {ArrayBuffer} buffer
      * @returns {RawBytes}
      */
-    static fromUint8Array(path, array) {
+    static fromArrayBufferUnloaded(path, buffer) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rawbytes_fromUint8Array(ptr0, len0, array);
+        const ret = wasm.rawbytes_fromArrayBufferUnloaded(ptr0, len0, buffer);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return RawBytes.__wrap(ret[0]);
     }
+    load() {
+        const ret = wasm.rawbytes_load(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) RawBytes.prototype[Symbol.dispose] = RawBytes.prototype.free;
+exports.RawBytes = RawBytes;
+
+class Results {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Results.prototype);
+        obj.__wbg_ptr = ptr;
+        ResultsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ResultsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_results_free(ptr, 0);
+    }
+    /**
+     * @returns {ResultsBackgroundType}
+     */
+    get results_background_type() {
+        const ret = wasm.__wbg_get_results_results_background_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {ResultsBackgroundType} arg0
+     */
+    set results_background_type(arg0) {
+        wasm.__wbg_set_results_results_background_type(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get results_background_filter_alpha() {
+        const ret = wasm.__wbg_get_results_results_background_filter_alpha(this.__wbg_ptr);
+        return ret;
+    }
     /**
-     * @param {string} path
-     * @param {Uint8Array} array
-     * @returns {RawBytes}
+     * @param {number} arg0
      */
-    static fromUint8ArrayUnloaded(path, array) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    set results_background_filter_alpha(arg0) {
+        wasm.__wbg_set_results_results_background_filter_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} content
+     * @returns {Results}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rawbytes_fromUint8ArrayUnloaded(ptr0, len0, array);
+        const ret = wasm.results_fromStr(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return RawBytes.__wrap(ret[0]);
+        return Results.__wrap(ret[0]);
     }
     /**
      * @returns {string}
      */
-    getPath() {
+    toString() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.rawbytes_getPath(this.__wbg_ptr);
+            const ret = wasm.results_toString(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -2746,49 +4773,19 @@ class RawBytes {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @returns {boolean}
-     */
-    hasData() {
-        const ret = wasm.rawbytes_hasData(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @returns {boolean}
-     */
-    isLoaded() {
-        const ret = wasm.rawbytes_isLoaded(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @returns {boolean}
-     */
-    isUnloaded() {
-        const ret = wasm.rawbytes_isUnloaded(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @returns {boolean}
-     */
-    isEmpty() {
-        const ret = wasm.rawbytes_isEmpty(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    load() {
-        const ret = wasm.rawbytes_load(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    unload() {
-        const ret = wasm.rawbytes_unload(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
 }
-if (Symbol.dispose) RawBytes.prototype[Symbol.dispose] = RawBytes.prototype.free;
-exports.RawBytes = RawBytes;
+if (Symbol.dispose) Results.prototype[Symbol.dispose] = Results.prototype.free;
+exports.Results = Results;
+
+/**
+ * @enum {0 | 1 | 2}
+ */
+const ResultsBackgroundType = Object.freeze({
+    Header: 0, "0": "Header",
+    Background: 1, "1": "Background",
+    None: 2, "2": "None",
+});
+exports.ResultsBackgroundType = ResultsBackgroundType;
 
 class SkinJson {
     static __wrap(ptr) {
@@ -2840,12 +4837,6 @@ class SkinJson {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_skinjson_keymodes(this.__wbg_ptr, ptr0, len0);
     }
-    constructor() {
-        const ret = wasm.skinjson_new();
-        this.__wbg_ptr = ret >>> 0;
-        SkinJsonFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * @param {string} json_str
      * @returns {SkinJson}
@@ -2874,10 +4865,105 @@ class SkinJson {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    constructor() {
+        const ret = wasm.skinjson_new();
+        this.__wbg_ptr = ret >>> 0;
+        SkinJsonFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
 }
 if (Symbol.dispose) SkinJson.prototype[Symbol.dispose] = SkinJson.prototype.free;
 exports.SkinJson = SkinJson;
 
+class SongSelect {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SongSelect.prototype);
+        obj.__wbg_ptr = ptr;
+        SongSelectFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SongSelectFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_songselect_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get mapset_panel_hovering_alpha() {
+        const ret = wasm.__wbg_get_songselect_mapset_panel_hovering_alpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set mapset_panel_hovering_alpha(arg0) {
+        wasm.__wbg_set_songselect_mapset_panel_hovering_alpha(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get map_background_brightness() {
+        const ret = wasm.__wbg_get_songselect_map_background_brightness(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set map_background_brightness(arg0) {
+        wasm.__wbg_set_songselect_map_background_brightness(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get display_map_background() {
+        const ret = wasm.__wbg_get_songselect_display_map_background(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set display_map_background(arg0) {
+        wasm.__wbg_set_songselect_display_map_background(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {string} content
+     * @returns {SongSelect}
+     */
+    static fromStr(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.songselect_fromStr(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SongSelect.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.songselect_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) SongSelect.prototype[Symbol.dispose] = SongSelect.prototype.free;
+exports.SongSelect = SongSelect;
+
 class Texture {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -2919,17 +5005,6 @@ class Texture {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_texture_path(this.__wbg_ptr, ptr0, len0);
     }
-    /**
-     * @param {string} path
-     */
-    constructor(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texture_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        TextureFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * @param {string} path
      * @returns {Texture}
@@ -2941,60 +5016,28 @@ class Texture {
         return Texture.__wrap(ret);
     }
     /**
-     * @param {string} path
-     * @param {ArrayBuffer} buffer
-     * @returns {Texture}
-     */
-    static fromArrayBuffer(path, buffer) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texture_fromArrayBuffer(ptr0, len0, buffer);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Texture.__wrap(ret[0]);
-    }
-    /**
-     * @param {string} path
-     * @param {ArrayBuffer} buffer
-     * @returns {Texture}
+     * @returns {bigint | undefined}
      */
-    static fromArrayBufferUnloaded(path, buffer) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texture_fromArrayBufferUnloaded(ptr0, len0, buffer);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Texture.__wrap(ret[0]);
+    getHash() {
+        const ret = wasm.texture_getHash(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
     /**
      * @param {string} path
-     * @param {Uint8Array} array
-     * @returns {Texture}
      */
-    static fromUint8Array(path, array) {
+    constructor(path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texture_fromUint8Array(ptr0, len0, array);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Texture.__wrap(ret[0]);
+        const ret = wasm.texture_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        TextureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
-    /**
-     * @param {string} path
-     * @param {Uint8Array} array
-     * @returns {Texture}
-     */
-    static fromUint8ArrayUnloaded(path, array) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texture_fromUint8ArrayUnloaded(ptr0, len0, array);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    unload() {
+        const ret = wasm.texture_unload(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
-        return Texture.__wrap(ret[0]);
     }
     /**
      * @returns {string}
@@ -3018,6 +5061,13 @@ class Texture {
         const ret = wasm.texture_hasData(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.texture_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {boolean}
      */
@@ -3033,11 +5083,60 @@ class Texture {
         return ret !== 0;
     }
     /**
-     * @returns {boolean}
+     * @param {string} path
+     * @param {Uint8Array} array
+     * @returns {Texture}
+     */
+    static fromUint8Array(path, array) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texture_fromUint8Array(ptr0, len0, array);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Texture.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} path
+     * @param {ArrayBuffer} buffer
+     * @returns {Texture}
+     */
+    static fromArrayBuffer(path, buffer) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texture_fromArrayBuffer(ptr0, len0, buffer);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Texture.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} path
+     * @param {Uint8Array} array
+     * @returns {Texture}
+     */
+    static fromUint8ArrayUnloaded(path, array) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texture_fromUint8ArrayUnloaded(ptr0, len0, array);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Texture.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} path
+     * @param {ArrayBuffer} buffer
+     * @returns {Texture}
      */
-    isEmpty() {
-        const ret = wasm.texture_isEmpty(this.__wbg_ptr);
-        return ret !== 0;
+    static fromArrayBufferUnloaded(path, buffer) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texture_fromArrayBufferUnloaded(ptr0, len0, buffer);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Texture.__wrap(ret[0]);
     }
     load() {
         const ret = wasm.texture_load(this.__wbg_ptr);
@@ -3045,12 +5144,6 @@ class Texture {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    unload() {
-        const ret = wasm.texture_unload(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
 }
 if (Symbol.dispose) Texture.prototype[Symbol.dispose] = Texture.prototype.free;
 exports.Texture = Texture;
@@ -3073,19 +5166,22 @@ class TextureStore {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_texturestore_free(ptr, 0);
     }
-    constructor() {
-        const ret = wasm.texturestore_new_wasm();
-        this.__wbg_ptr = ret >>> 0;
-        TextureStoreFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * @returns {boolean}
+     */
+    allLoaded() {
+        const ret = wasm.texturestore_allLoaded(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * @param {Texture} texture
+     * @param {string} path
+     * @returns {boolean}
      */
-    insertTexture(texture) {
-        _assertClass(texture, Texture);
-        var ptr0 = texture.__destroy_into_raw();
-        wasm.texturestore_insertTexture(this.__wbg_ptr, ptr0);
+    hasTexture(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texturestore_contains(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
     }
     /**
      * @param {string} new_path
@@ -3108,37 +5204,6 @@ class TextureStore {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
-    /**
-     * @param {string} path
-     * @param {ArrayBuffer} buffer
-     */
-    loadFromArrayBuffer(path, buffer) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_loadFromArrayBuffer(this.__wbg_ptr, ptr0, len0, buffer);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @param {string} path
-     * @param {Uint8Array} array
-     */
-    loadFromUint8Array(path, array) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_loadFromUint8Array(this.__wbg_ptr, ptr0, len0, array);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @returns {boolean}
-     */
-    allLoaded() {
-        const ret = wasm.texturestore_allLoaded(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {number}
      */
@@ -3146,6 +5211,14 @@ class TextureStore {
         const ret = wasm.texturestore_loadedCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @param {Texture} texture
+     */
+    insertTexture(texture) {
+        _assertClass(texture, Texture);
+        var ptr0 = texture.__destroy_into_raw();
+        wasm.texturestore_insertTexture(this.__wbg_ptr, ptr0);
+    }
     /**
      * @returns {Array<any>}
      */
@@ -3153,16 +5226,6 @@ class TextureStore {
         const ret = wasm.texturestore_unloadedPaths(this.__wbg_ptr);
         return ret;
     }
-    /**
-     * @param {string} path
-     * @returns {boolean}
-     */
-    hasTexture(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_contains(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
-    }
     /**
      * @param {string} path
      * @returns {string | undefined}
@@ -3190,23 +5253,36 @@ class TextureStore {
     }
     /**
      * @param {string} path
-     * @returns {boolean}
+     * @param {Uint8Array} array
      */
-    contains(path) {
+    loadFromUint8Array(path, array) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_contains(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
+        const ret = wasm.texturestore_loadFromUint8Array(this.__wbg_ptr, ptr0, len0, array);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * @param {string} path
-     * @returns {boolean}
+     * @param {ArrayBuffer} buffer
      */
-    remove(path) {
+    loadFromArrayBuffer(path, buffer) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_remove(this.__wbg_ptr, ptr0, len0);
-        return ret !== 0;
+        const ret = wasm.texturestore_loadFromArrayBuffer(this.__wbg_ptr, ptr0, len0, buffer);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    constructor() {
+        const ret = wasm.texturestore_new_wasm();
+        this.__wbg_ptr = ret >>> 0;
+        TextureStoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    clear() {
+        wasm.texturestore_clear(this.__wbg_ptr);
     }
     /**
      * @returns {number}
@@ -3215,6 +5291,33 @@ class TextureStore {
         const ret = wasm.texturestore_getLength(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @param {TextureStore} other
+     */
+    extend(other) {
+        _assertClass(other, TextureStore);
+        wasm.texturestore_extend(this.__wbg_ptr, other.__wbg_ptr);
+    }
+    /**
+     * @param {string} path
+     * @returns {boolean}
+     */
+    remove(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texturestore_remove(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} path
+     * @returns {boolean}
+     */
+    contains(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.texturestore_contains(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * @returns {boolean}
      */
@@ -3229,20 +5332,17 @@ class TextureStore {
         const ret = wasm.texturestore_getPaths(this.__wbg_ptr);
         return ret;
     }
-    clear() {
-        wasm.texturestore_clear(this.__wbg_ptr);
-    }
     /**
      * @param {string} original_path
-     * @param {string} new_path
+     * @param {string} new_base_path
      * @returns {string | undefined}
      */
-    copy(original_path, new_path) {
+    makeUniqueCopy(original_path, new_base_path) {
         const ptr0 = passStringToWasm0(original_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(new_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(new_base_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_copy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.texturestore_makeUniqueCopy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         let v3;
         if (ret[0] !== 0) {
             v3 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -3252,15 +5352,15 @@ class TextureStore {
     }
     /**
      * @param {string} original_path
-     * @param {string} new_base_path
+     * @param {string} new_path
      * @returns {string | undefined}
      */
-    makeUniqueCopy(original_path, new_base_path) {
+    copy(original_path, new_path) {
         const ptr0 = passStringToWasm0(original_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(new_base_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(new_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.texturestore_makeUniqueCopy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.texturestore_copy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         let v3;
         if (ret[0] !== 0) {
             v3 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -3268,13 +5368,6 @@ class TextureStore {
         }
         return v3;
     }
-    /**
-     * @param {TextureStore} other
-     */
-    extend(other) {
-        _assertClass(other, TextureStore);
-        wasm.texturestore_extend(this.__wbg_ptr, other.__wbg_ptr);
-    }
 }
 if (Symbol.dispose) TextureStore.prototype[Symbol.dispose] = TextureStore.prototype.free;
 exports.TextureStore = TextureStore;
@@ -3296,12 +5389,15 @@ exports.allSamplesFromDir = allSamplesFromDir;
 
 /**
  * @param {string} path
+ * @param {string[] | null} [load_only]
  * @returns {TextureStore}
  */
-function allTexturesFromDir(path) {
+function allTexturesFromDir(path, load_only) {
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.allTexturesFromDir(ptr0, len0);
+    var ptr1 = isLikeNone(load_only) ? 0 : passArrayJsValueToWasm0(load_only, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.allTexturesFromDir(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -3311,12 +5407,13 @@ exports.allTexturesFromDir = allTexturesFromDir;
 
 /**
  * @param {string} path
+ * @param {boolean | null} [import_all]
  * @returns {FluXisSkin}
  */
-function fluXisSkinFromDir(path) {
+function fluXisSkinFromDir(path, import_all) {
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.fluXisSkinFromDir(ptr0, len0);
+    const ret = wasm.fluXisSkinFromDir(ptr0, len0, isLikeNone(import_all) ? 0xFFFFFF : import_all ? 1 : 0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -3343,13 +5440,13 @@ exports.fluXisSkinToDir = fluXisSkinToDir;
  * @param {string} path
  * @returns {string}
  */
-function iniStrFromDir(path) {
+function fluxisJsonStrFromDir(path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.iniStrFromDir(ptr0, len0);
+        const ret = wasm.fluxisJsonStrFromDir(ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3357,34 +5454,49 @@ function iniStrFromDir(path) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
-exports.iniStrFromDir = iniStrFromDir;
+exports.fluxisJsonStrFromDir = fluxisJsonStrFromDir;
 
 /**
- * @param {OsuSkinIni} skin_ini
+ * @param {SkinJson} skin_json
  * @param {string} path
  */
-function iniToDir(skin_ini, path) {
-    _assertClass(skin_ini, OsuSkinIni);
+function fluxisJsonToDir(skin_json, path) {
+    _assertClass(skin_json, SkinJson);
+    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fluxisJsonToDir(skin_json.__wbg_ptr, ptr0, len0);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.fluxisJsonToDir = fluxisJsonToDir;
+
+/**
+ * @param {FluXisLayout} layout_json
+ * @param {string} path
+ */
+function fluxisLayoutToDir(layout_json, path) {
+    _assertClass(layout_json, FluXisLayout);
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.iniToDir(skin_ini.__wbg_ptr, ptr0, len0);
+    const ret = wasm.fluxisLayoutToDir(layout_json.__wbg_ptr, ptr0, len0);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-exports.iniToDir = iniToDir;
+exports.fluxisLayoutToDir = fluxisLayoutToDir;
 
 /**
  * @param {string} path
  * @returns {string}
  */
-function jsonStrFromDir(path) {
+function osuIniStrFromDir(path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jsonStrFromDir(ptr0, len0);
+        const ret = wasm.osuIniStrFromDir(ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3392,67 +5504,119 @@ function jsonStrFromDir(path) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
-exports.jsonStrFromDir = jsonStrFromDir;
+exports.osuIniStrFromDir = osuIniStrFromDir;
 
 /**
- * @param {SkinJson} skin_json
+ * @param {OsuSkinIni} skin_ini
  * @param {string} path
  */
-function jsonToDir(skin_json, path) {
-    _assertClass(skin_json, SkinJson);
+function osuIniToDir(skin_ini, path) {
+    _assertClass(skin_ini, OsuSkinIni);
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.jsonToDir(skin_json.__wbg_ptr, ptr0, len0);
+    const ret = wasm.osuIniToDir(skin_ini.__wbg_ptr, ptr0, len0);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-exports.jsonToDir = jsonToDir;
+exports.osuIniToDir = osuIniToDir;
 
 /**
- * @param {FluXisLayout} layout_json
  * @param {string} path
+ * @param {boolean | null} [import_all]
+ * @returns {OsuSkin}
  */
-function layoutToDir(layout_json, path) {
-    _assertClass(layout_json, FluXisLayout);
+function osuSkinFromDir(path, import_all) {
+    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.osuSkinFromDir(ptr0, len0, isLikeNone(import_all) ? 0xFFFFFF : import_all ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return OsuSkin.__wrap(ret[0]);
+}
+exports.osuSkinFromDir = osuSkinFromDir;
+
+/**
+ * @param {OsuSkin} skin
+ * @param {string} path
+ */
+function osuSkinToDir(skin, path) {
+    _assertClass(skin, OsuSkin);
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.layoutToDir(layout_json.__wbg_ptr, ptr0, len0);
+    const ret = wasm.osuSkinToDir(skin.__wbg_ptr, ptr0, len0);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-exports.layoutToDir = layoutToDir;
+exports.osuSkinToDir = osuSkinToDir;
 
 /**
  * @param {string} path
- * @returns {OsuSkin}
+ * @returns {string}
+ */
+function quaverIniStrFromDir(path) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.quaverIniStrFromDir(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.quaverIniStrFromDir = quaverIniStrFromDir;
+
+/**
+ * @param {QuaSkinIni} skin_ini
+ * @param {string} path
+ */
+function quaverIniToDir(skin_ini, path) {
+    _assertClass(skin_ini, QuaSkinIni);
+    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.quaverIniToDir(skin_ini.__wbg_ptr, ptr0, len0);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.quaverIniToDir = quaverIniToDir;
+
+/**
+ * @param {string} path
+ * @param {boolean | null} [import_all]
+ * @returns {QuaSkin}
  */
-function osuSkinFromDir(path) {
+function quaverSkinFromDir(path, import_all) {
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.osuSkinFromDir(ptr0, len0);
+    const ret = wasm.quaverSkinFromDir(ptr0, len0, isLikeNone(import_all) ? 0xFFFFFF : import_all ? 1 : 0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return OsuSkin.__wrap(ret[0]);
+    return QuaSkin.__wrap(ret[0]);
 }
-exports.osuSkinFromDir = osuSkinFromDir;
+exports.quaverSkinFromDir = quaverSkinFromDir;
 
 /**
- * @param {OsuSkin} skin
+ * @param {QuaSkin} skin
  * @param {string} path
  */
-function osuSkinToDir(skin, path) {
-    _assertClass(skin, OsuSkin);
+function quaverSkinToDir(skin, path) {
+    _assertClass(skin, QuaSkin);
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.osuSkinToDir(skin.__wbg_ptr, ptr0, len0);
+    const ret = wasm.quaverSkinToDir(skin.__wbg_ptr, ptr0, len0);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
-exports.osuSkinToDir = osuSkinToDir;
+exports.quaverSkinToDir = quaverSkinToDir;
 
 /**
  * @param {string} path
@@ -3542,7 +5706,7 @@ exports.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 };
 
-exports.__wbg_createDirAll_b4ab3f4be6b815d3 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_createDirAll_12a67205521e99f7 = function() { return handleError(function (arg0, arg1) {
     createDirAll(getStringFromWasm0(arg0, arg1));
 }, arguments) };
 
@@ -3561,12 +5725,12 @@ exports.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
     return ret;
 };
 
-exports.__wbg_isDirectory_b8396ef27601feb9 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_isDirectory_c077b41f3b7b2df7 = function() { return handleError(function (arg0, arg1) {
     const ret = isDirectory(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-exports.__wbg_joinPath_56fee88db03b855c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+exports.__wbg_joinPath_bff79219513ef55a = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     const ret = joinPath(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -3618,17 +5782,27 @@ exports.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
     return ret;
 };
 
-exports.__wbg_readDir_cb6d41e9444bdebf = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_quakeymode_new = function(arg0) {
+    const ret = QuaKeymode.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_quakeymode_unwrap = function(arg0) {
+    const ret = QuaKeymode.__unwrap(arg0);
+    return ret;
+};
+
+exports.__wbg_readDir_cc088e74c8a41f13 = function() { return handleError(function (arg0, arg1) {
     const ret = readDir(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-exports.__wbg_readFileBytes_4ed95deb280a788e = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_readFileBytes_395b9d2be29cedd1 = function() { return handleError(function (arg0, arg1) {
     const ret = readFileBytes(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-exports.__wbg_readFileString_e878ad0e1ac6272c = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_readFileString_2a9c67574a6580d7 = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = readFileString(getStringFromWasm0(arg1, arg2));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -3636,7 +5810,7 @@ exports.__wbg_readFileString_e878ad0e1ac6272c = function() { return handleError(
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }, arguments) };
 
-exports.__wbg_writeFile_f73926b68eea6ec7 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+exports.__wbg_writeFile_f3f5d75134f8e6ee = function() { return handleError(function (arg0, arg1, arg2, arg3) {
     writeFile(getStringFromWasm0(arg0, arg1), getArrayU8FromWasm0(arg2, arg3));
 }, arguments) };