@rel-packages/osu-beatmap-parser 0.1.8 → 1.0.3

package/dist/index.d.ts

@@ -1,11 +1,4 @@
 import { OsuKey, OsuInput } from "./types";
-export declare function get_property(location: string, key: OsuKey): string;
-export declare function get_properties(input: string | OsuInput, keys: OsuKey[]): Record<OsuKey, string> & {
-    id?: string;
-};
-export declare function process_beatmaps(inputs: (string | OsuInput)[], keys: OsuKey[]): Promise<(Record<OsuKey, string> & {
-    id?: string;
-})[]>;
-export declare function get_duration(location: string): number;
-export declare function get_audio_duration(location: string): number;
+export declare const get_property: (data: Uint8Array, key: OsuKey) => any;
+export declare const get_properties: (input: Uint8Array | OsuInput, keys: OsuKey[]) => any;
 export { OsuKey, OsuInput };

package/dist/index.js

@@ -1,46 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_properties = exports.get_property = void 0;
+const bindings_1 = require("./lib/bindings");
+const get_property = (data, key) => {
+    return bindings_1.native.get_property(data, key);
+};
 exports.get_property = get_property;
-exports.get_properties = get_properties;
-exports.process_beatmaps = process_beatmaps;
-exports.get_duration = get_duration;
-exports.get_audio_duration = get_audio_duration;
-const node_gyp_build_1 = __importDefault(require("node-gyp-build"));
-const path_1 = __importDefault(require("path"));
-const native = (0, node_gyp_build_1.default)(path_1.default.join(__dirname, ".."));
-function get_property(location, key) {
-    return native.get_property(location, key);
-}
-;
-function get_properties(input, keys) {
-    const location = typeof input === "string" ? input : input.path;
-    const result = native.get_properties(location, keys);
-    if (typeof input !== "string" && input.id) {
+const get_properties = (input, keys) => {
+    const data = input instanceof Uint8Array ? input : input.data;
+    const result = bindings_1.native.get_properties(data, keys);
+    if (!(input instanceof Uint8Array) && input.id) {
         return { ...result, id: input.id };
     }
     return result;
-}
-;
-async function process_beatmaps(inputs, keys) {
-    const locations = inputs.map(i => typeof i === "string" ? i : i.path);
-    const results = await native.process_beatmaps(locations, keys);
-    return results.map((res, i) => {
-        const input = inputs[i];
-        if (typeof input !== "string" && input.id) {
-            return { ...res, id: input.id };
-        }
-        return res;
-    });
-}
-;
-function get_duration(location) {
-    return native.get_duration(location);
-}
-;
-function get_audio_duration(location) {
-    return native.get_audio_duration(location);
-}
-;
+};
+exports.get_properties = get_properties;

package/dist/lib/bindings.d.ts

@@ -0,0 +1 @@
+export declare let native: any;

package/dist/lib/bindings.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.native = void 0;
+const IS_BROWSER = globalThis.window != undefined;
+const load_native_module = () => {
+    if (IS_BROWSER) {
+        const wasm_proxy = {
+            instance: null,
+            get_property: (data, key) => {
+                if (wasm_proxy.instance == null) {
+                    throw Error("WASM not loaded yet");
+                }
+                const wasm_inst = wasm_proxy.instance;
+                const buffer_ptr = wasm_inst._malloc(data.length);
+                wasm_inst.HEAPU8.set(data, buffer_ptr);
+                const result_val = wasm_inst.get_property(buffer_ptr, data.length, key);
+                wasm_inst._free(buffer_ptr);
+                return result_val;
+            },
+            get_properties: (data, keys) => {
+                if (wasm_proxy.instance == null) {
+                    throw Error("WASM not loaded yet");
+                }
+                const wasm_inst = wasm_proxy.instance;
+                const buffer_ptr = wasm_inst._malloc(data.length);
+                wasm_inst.HEAPU8.set(data, buffer_ptr);
+                const results_obj = wasm_inst.get_properties(buffer_ptr, data.length, keys);
+                wasm_inst._free(buffer_ptr);
+                return results_obj;
+            },
+        };
+        const create_func = globalThis.create_osu_parser;
+        if (create_func != undefined) {
+            create_func().then((instance) => {
+                wasm_proxy.instance = instance;
+            });
+        }
+        return wasm_proxy;
+    }
+    try {
+        const fs_mod = require("fs");
+        const path_mod = require("path");
+        const load_prebuilt = () => {
+            const OS_PLATFORM = process.platform;
+            const CPU_ARCH = process.arch;
+            const SCAN_PATHS = [
+                path_mod.join(__dirname, "..", "..", "prebuilds", `${OS_PLATFORM}-${CPU_ARCH}`, "osu-beatmap-parser.node"),
+                path_mod.join(__dirname, "prebuilds", `${OS_PLATFORM}-${CPU_ARCH}`, "osu-beatmap-parser.node"),
+            ];
+            for (const path_str of SCAN_PATHS) {
+                if (fs_mod.existsSync(path_str)) {
+                    return require(path_str);
+                }
+            }
+            return false;
+        };
+        const load_local = () => {
+            const SCAN_PATHS = [
+                path_mod.join(__dirname, "..", "..", "build", "osu-beatmap-parser.node"),
+                path_mod.join(__dirname, "..", "..", "build", "Release", "osu-beatmap-parser.node"),
+                path_mod.join(__dirname, "..", "build", "osu-beatmap-parser.node"),
+                path_mod.join(__dirname, "build", "osu-beatmap-parser.node"),
+            ];
+            for (const path_str of SCAN_PATHS) {
+                if (fs_mod.existsSync(path_str)) {
+                    return require(path_str);
+                }
+            }
+            return false;
+        };
+        const bin_module = load_prebuilt() || load_local();
+        if (bin_module) {
+            return bin_module;
+        }
+    }
+    catch (e) { }
+    return false;
+};
+exports.native = load_native_module();
+try {
+    if (exports.native == false && IS_BROWSER == false) {
+        throw Error("failed to find native module...");
+    }
+}
+catch (err) {
+    if (IS_BROWSER) {
+        exports.native = {};
+    }
+    else {
+        throw new Error("failed to load native module...\n" + err);
+    }
+}

package/dist/types.d.ts

@@ -1,12 +1,9 @@
 export type OsuKey = "AudioFilename" | "AudioLeadIn" | "PreviewTime" | "Countdown" | "SampleSet" | "StackLeniency" | "Mode" | "LetterboxInBreaks" | "WidescreenStoryboard" | "Bookmarks" | "DistanceSpacing" | "BeatDivisor" | "GridSize" | "TimelineZoom" | "Title" | "TitleUnicode" | "Artist" | "ArtistUnicode" | "Creator" | "Version" | "Source" | "Tags" | "BeatmapID" | "BeatmapSetID" | "HPDrainRate" | "CircleSize" | "OverallDifficulty" | "ApproachRate" | "SliderMultiplier" | "SliderTickRate" | "Background" | "Video" | "Storyboard" | "Duration";
 export interface OsuInput {
-    path: string;
+    data: Uint8Array;
     id?: string;
 }
 export interface INativeExporter {
-    get_property(location: string, key: string): string;
-    get_properties(location: string, keys: string[]): Record<string, string>;
-    process_beatmaps(locations: string[], keys: string[]): Promise<Record<string, string>[]>;
-    get_duration(location: string): number;
-    get_audio_duration(location: string): number;
+    get_property(data: Uint8Array, key: string): string;
+    get_properties(data: Uint8Array, keys: string[]): Record<string, string>;
 }

package/package.json

@@ -1,24 +1,43 @@
 {
   "name": "@rel-packages/osu-beatmap-parser",
-  "version": "0.1.8",
+  "version": "1.0.3",
   "description": ".osu parser for nodejs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "homepage": "https://github.com/mezleca/osu-beatmap-parser",
   "scripts": {
-    "dev": "npm run compile:native && tsx scripts/verify.ts",
-    "compile": "npm run compile:native && npm run compile:tsc",
+    "update:patch": "npm version patch && git push --follow-tags",
+    "update:minor": "npm version minor && git push --follow-tags",
+    "update:major": "npm version major && git push --follow-tags",
+    "prepublishOnly": "npm run compile:tsc && mkdir -p lib",
+    "compile:native": "tsx scripts/build.ts native",
+    "compile:wasm": "tsx scripts/build.ts wasm",
     "compile:tsc": "tsc",
-    "compile:native": "cmake-js build",
-    "prebuild": "prebuild --backend cmake-js --strip --verbose"
+    "build": "tsx scripts/build.ts all && npm run compile:tsc",
+    "example:wasm": "bun run compile:wasm && bun run examples/wasm/server.ts",
+    "example:node": "bun run compile:native && tsx examples/node/index.ts"
   },
-  "keywords": [],
+  "keywords": [
+    "osu",
+    "beatmap",
+    "parser",
+    "native"
+  ],
   "author": "",
   "license": "ISC",
   "repository": {
     "url": "https://github.com/mezleca/osu-beatmap-parser.git"
   },
   "type": "commonjs",
+  "files": [
+    "dist/",
+    "prebuilds/",
+    "build/*.node",
+    "build/*.wasm",
+    "build/*.js",
+    "lib/bindings.ts",
+    "README.md"
+  ],
   "devDependencies": {
     "@types/bindings": "^1.5.5",
     "@types/node": "^24.10.1",
@@ -27,7 +46,6 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "dependencies": {
-    "node-gyp-build": "^4.8.4"
-  }
-}
+  "dependencies": {},
+  "optionalDependencies": {}
+}

package/.prebuildrc

@@ -1,6 +0,0 @@
-{
-  "upload": "gh release upload {tag_name} {file_path} --repo={owner}/{repo} --clobber",
-  "download": "https://github.com/{owner}/{repo}/releases/download/{tag}/{file_name}",
-  "tag-prefix": "v",
-  "backend": "cmake-js"
-}

package/CMakeLists.txt

@@ -1,68 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-
-if(WIN32)
-    if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
-        if(EXISTS "${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake")
-            set(CMAKE_TOOLCHAIN_FILE "${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake")
-        elseif(EXISTS "C:/vcpkg/scripts/buildsystems/vcpkg.cmake")
-            set(CMAKE_TOOLCHAIN_FILE "C:/vcpkg/scripts/buildsystems/vcpkg.cmake")
-        endif()
-    endif()
-    set(VCPKG_TARGET_TRIPLET "x64-windows-static")
-endif()
-
-project(osu-beatmap-parser VERSION 0.0.1)
-
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(BUILD_TESTING OFF CACHE BOOL "Build tests" FORCE)
-set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries")
-
-file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "src/native/*.cpp")
-file(GLOB_RECURSE HEADERS CONFIGURE_DEPENDS "src/native/*.hpp")
-
-if(WIN32)
-    find_package(SndFile CONFIG REQUIRED)
-    set(SNDFILE_LIBRARIES SndFile::sndfile)
-else()
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(SNDFILE REQUIRED sndfile)
-endif()
-
-execute_process(
-  COMMAND node -p "require('node-addon-api').include"
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  OUTPUT_VARIABLE NODE_ADDON_API_DIR
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-
-string(REPLACE "\"" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
-
-add_library(${PROJECT_NAME} SHARED ${SOURCES} ${HEADERS} ${CMAKE_JS_SRC})
-
-set_target_properties(${PROJECT_NAME} PROPERTIES 
-    PREFIX "" 
-    SUFFIX ".node"
-    CXX_STANDARD 17
-    CXX_STANDARD_REQUIRED ON
-)
-
-if (MSVC)
-    set(MSVC_RUNTIME_LIBRARY OFF)
-    add_compile_definitions(_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING)
-    execute_process(COMMAND ${CMAKE_AR} /def:${CMAKE_JS_NODELIB_DEF} /out:${CMAKE_JS_NODELIB_TARGET} ${CMAKE_STATIC_LINKER_FLAGS})
-    target_compile_options(${PROJECT_NAME} PRIVATE /Zc:__cplusplus)
-endif()
-
-target_include_directories(${PROJECT_NAME} PRIVATE
-    ${NODE_ADDON_API_DIR}
-    ${CMAKE_JS_INC}
-    ${SNDFILE_INCLUDE_DIRS}
-)
-
-target_link_libraries(
-    ${PROJECT_NAME} 
-    ${CMAKE_JS_LIB}
-    ${SNDFILE_LIBRARIES}
-)

package/src/native/addon.cpp

@@ -1,265 +0,0 @@
-#include <filesystem>
-#include <napi.h>
-#include <iostream>
-#include <sndfile.h>
-#include <string>
-#include <thread>
-#include <fstream>
-#include <vector>
-#include <atomic>
-#include "osu/parser.hpp"
-#include "osu/audio.hpp"
-#include "addon.hpp"
-#include "pool.hpp"
-
-#define NOOP_FUNC(env) Napi::Function::New(env, [](const Napi::CallbackInfo& info){})
-
-AudioAnalyzer audio_analizer;
-
-std::filesystem::path dirname(const std::string &path) {
-    std::filesystem::path p(path);
-    return p.parent_path();
-}
-
-std::string read_file(const std::string& path) {
-    std::ifstream file(path, std::ios::binary | std::ios::ate);
-
-    if (!file.is_open()) {
-        return "";
-    }
-
-    std::streamsize size = file.tellg();
-    file.seekg(0, std::ios::beg);
-
-    std::string buffer(size, ' ');
-
-    if (file.read(buffer.data(), size)) {
-        return buffer;
-    }
-
-    return "";
-}
-
-Napi::Value ParserAddon::get_property(const Napi::CallbackInfo& info) {
-    if (info.Length() < 2) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    if (!info[0].IsString() || !info[1].IsString()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    std::string key = info[1].As<Napi::String>().Utf8Value();
-    std::string content = read_file(location);
-
-    if (content.empty()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    return Napi::String::From(info.Env(), osu_parser::get_property(content, key));
-}
-
-Napi::Value ParserAddon::get_properties(const Napi::CallbackInfo& info) {
-    if (info.Length() < 2) {
-        return Napi::Object::New(info.Env());
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    Napi::Array keys_array = info[1].As<Napi::Array>();
-    
-    std::vector<std::string> keys;
-
-    for (uint32_t i = 0; i < keys_array.Length(); i++) {
-        Napi::Value val = keys_array[i];
-        if (val.IsString()) {
-            keys.push_back(val.As<Napi::String>().Utf8Value());
-        }
-    }
-
-    std::string content = read_file(location);
-
-    if (content.empty()) {
-        return Napi::Object::New(info.Env());
-    }
-
-    auto results = osu_parser::get_properties(content, keys);
-
-    Napi::Object obj = Napi::Object::New(info.Env());
-
-    for (const auto& [k, v] : results) {
-        obj.Set(k, v);
-    }
-    
-    return obj;
-}
-
-struct BatchContext {
-    std::vector<std::string> paths;
-    std::vector<std::string> keys;
-    std::vector<std::unordered_map<std::string, std::string>> results;
-    std::atomic<size_t> completed_count{0};
-    Napi::ThreadSafeFunction tsfn;
-    Napi::Promise::Deferred deferred;
-    bool needs_duration = false;
-    
-    BatchContext(Napi::Env env) : deferred(Napi::Promise::Deferred::New(env)) {}
-};
-
-void process_chunk(BatchContext* context, size_t start, size_t end) {
-    for (size_t i = start; i < end; i++) {
-        std::string content = read_file(context->paths[i]);
-        if (!content.empty()) {
-            context->results[i] = osu_parser::get_properties(content, context->keys);
-            
-            if (context->needs_duration) {
-                std::string audio_file_name = osu_parser::get_property(content, "AudioFilename");
-                if (!audio_file_name.empty()) {
-                    std::filesystem::path audio_path = dirname(context->paths[i]) / audio_file_name;
-                    double duration = audio_analizer.get_audio_duration(audio_path.string());
-                    context->results[i]["Duration"] = std::to_string(duration);
-                }
-            }
-        }
-    }
-    
-    size_t completed = context->completed_count.fetch_add(end - start) + (end - start);
-    
-    if (completed == context->paths.size()) {
-        auto callback = [context](Napi::Env env, Napi::Function jsCallback) {
-            Napi::Array result_array = Napi::Array::New(env, context->results.size());
-            
-            for (size_t i = 0; i < context->results.size(); i++) {
-                Napi::Object obj = Napi::Object::New(env);
-                for (const auto& [k, v] : context->results[i]) {
-                    obj.Set(k, v);
-                }
-                result_array[i] = obj;
-            }
-            
-            context->deferred.Resolve(result_array);
-        };
-        
-        context->tsfn.BlockingCall(callback);
-        context->tsfn.Release();
-    }
-}
-
-Napi::Value ParserAddon::process_beatmaps(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 2) {
-        auto deferred = Napi::Promise::Deferred::New(env);
-        deferred.Reject(Napi::String::New(env, "Invalid arguments"));
-        return deferred.Promise();
-    }
-
-    Napi::Array paths_array = info[0].As<Napi::Array>();
-    Napi::Array keys_array = info[1].As<Napi::Array>();
-
-    auto context = new BatchContext(env);
-    
-    for (uint32_t i = 0; i < paths_array.Length(); i++) {
-        context->paths.push_back(Napi::Value(paths_array[i]).As<Napi::String>().Utf8Value());
-    }
-    
-    for (uint32_t i = 0; i < keys_array.Length(); i++) {
-        std::string key = Napi::Value(keys_array[i]).As<Napi::String>().Utf8Value();
-        context->keys.push_back(key);
-        if (key == "Duration") {
-            context->needs_duration = true;
-        }
-    }
-    
-    context->results.resize(context->paths.size());
-    
-    context->tsfn = Napi::ThreadSafeFunction::New(
-        env,
-        NOOP_FUNC(env),
-        "ProcessBeatmaps",
-        0,
-        1,
-        [context](Napi::Env) {
-            delete context;
-        }
-    );
-
-    size_t total_files = context->paths.size();
-    size_t thread_count = std::thread::hardware_concurrency();
-
-    if (thread_count == 0) {
-        thread_count = 1;
-    }
-    
-    size_t chunk_size = (total_files + thread_count - 1) / thread_count;
-    
-    for (size_t t = 0; t < thread_count; t++) {
-        size_t start = t * chunk_size;
-        size_t end = std::min(start + chunk_size, total_files);
-        
-        if (start >= end) {
-            break;
-        }
-
-        pool.enqueue([context, start, end]() {
-            process_chunk(context, start, end);
-        });
-    }
-
-    return context->deferred.Promise();
-}
-
-Napi::Value ParserAddon::get_duration(const Napi::CallbackInfo& info) {
-    if (info.Length() < 1) {
-        return Napi::Number::New(info.Env(), 0.0);
-    }
-
-    if (!info[0].IsString()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    std::string content = read_file(location);
-
-    if (content.empty()) {
-        return Napi::Number::New(info.Env(), 0.0);
-    }
-
-    std::string audio_file_name = osu_parser::get_property(content, "AudioFilename");
-    std::filesystem::path audio_path = dirname(location) / audio_file_name;
-
-    return Napi::Number::From(info.Env(), audio_analizer.get_audio_duration(audio_path.string()));
-}
-
-Napi::Value ParserAddon::get_audio_duration(const Napi::CallbackInfo& info) {
-    if (info.Length() < 1) {
-        return Napi::Number::New(info.Env(), 0.0);
-    }
-
-    if (!info[0].IsString()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    std::filesystem::path audio_path(location);
-
-    return Napi::Number::From(info.Env(), audio_analizer.get_audio_duration(audio_path.string()));
-}
-
-Napi::Value ParserAddon::test_promise(const Napi::CallbackInfo& info) {
-    auto deffered = Napi::Promise::Deferred::New(info.Env());
-    auto tsfn = Napi::ThreadSafeFunction::New(info.Env(), NOOP_FUNC(info.Env()), "tsfn", 0, 1);
-
-    std::thread([tsfn, deffered]() {
-        tsfn.NonBlockingCall([deffered](Napi::Env env, Napi::Function) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(2000));
-            deffered.Resolve(Napi::Boolean::New(env, true));
-        });
-
-        tsfn.Release();
-    }).detach();
-
-    return deffered.Promise();
-}
-
-NODE_API_ADDON(ParserAddon)

package/src/native/addon.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <napi.h>
-#include "pool.hpp"
-
-class ParserAddon : public Napi::Addon<ParserAddon> {
-public:
-    ParserAddon(Napi::Env env, Napi::Object exports) {
-        pool.initialize(std::thread::hardware_concurrency());
-        DefineAddon(exports, {
-            InstanceMethod("get_property", &ParserAddon::get_property),
-            InstanceMethod("get_properties", &ParserAddon::get_properties),
-            InstanceMethod("process_beatmaps", &ParserAddon::process_beatmaps),
-            InstanceMethod("get_duration", &ParserAddon::get_duration),
-            InstanceMethod("get_audio_duration", &ParserAddon::get_audio_duration),
-            InstanceMethod("test_promise", &ParserAddon::test_promise)
-        });
-    }
-
-    Napi::Value get_property(const Napi::CallbackInfo& info);
-    Napi::Value get_properties(const Napi::CallbackInfo& info);
-    Napi::Value process_beatmaps(const Napi::CallbackInfo& info);
-    Napi::Value get_duration(const Napi::CallbackInfo& info);
-    Napi::Value get_audio_duration(const Napi::CallbackInfo& info);
-    Napi::Value test_promise(const Napi::CallbackInfo& info);
-};

package/src/native/definitions.hpp

@@ -1,56 +0,0 @@
-#pragma once
-#include <string>
-#include <unordered_set>
-#include <unordered_map>
-
-enum OSU_SECTIONS {
-    General = 0,
-    Editor,
-    Metadata,
-    Difficulty,
-    Events,
-    TimingPoints,
-    Colours,
-    HitObjects
-};
-
-const std::unordered_map<std::string_view, std::string_view> KEY_TO_SECTION = {
-    {"AudioFilename", "[General]"},
-    {"AudioLeadIn", "[General]"},
-    {"PreviewTime", "[General]"},
-    {"Countdown", "[General]"},
-    {"SampleSet", "[General]"},
-    {"StackLeniency", "[General]"},
-    {"Mode", "[General]"},
-    {"LetterboxInBreaks", "[General]"},
-    {"WidescreenStoryboard", "[General]"},
-    {"Bookmarks", "[Editor]"},
-    {"DistanceSpacing", "[Editor]"},
-    {"BeatDivisor", "[Editor]"},
-    {"GridSize", "[Editor]"},
-    {"TimelineZoom", "[Editor]"},
-    {"Title", "[Metadata]"},
-    {"TitleUnicode", "[Metadata]"},
-    {"Artist", "[Metadata]"},
-    {"ArtistUnicode", "[Metadata]"},
-    {"Creator", "[Metadata]"},
-    {"Version", "[Metadata]"},
-    {"Source", "[Metadata]"},
-    {"Tags", "[Metadata]"},
-    {"BeatmapID", "[Metadata]"},
-    {"BeatmapSetID", "[Metadata]"},
-    {"HPDrainRate", "[Difficulty]"},
-    {"CircleSize", "[Difficulty]"},
-    {"OverallDifficulty", "[Difficulty]"},
-    {"ApproachRate", "[Difficulty]"},
-    {"SliderMultiplier", "[Difficulty]"},
-    {"SliderTickRate", "[Difficulty]"},
-    // special ones (doenst have keys)
-    {"Background", "[Events]"},
-    {"Video", "[Events]"},
-    {"Storyboard", "[Events]"},
-    // extra special ones (why not)
-    {"Duration", "[General]"}
-};
-
-const std::unordered_set<std::string_view> SPECIAL_KEYS {"Background", "Video", "Storyboard"};