@rel-packages/osu-beatmap-parser 0.1.7

package/.prebuildrc

@@ -0,0 +1,6 @@
+{
+  "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

@@ -0,0 +1,68 @@
+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/README.md

@@ -0,0 +1,16 @@
+## osu-beatmap-parser
+
+.osu parser for nodejs used by [osu-stuff](https://github.com/mezleca/osu-stuff)
+
+## installation
+
+```bash
+npm install osu-beatmap-parser
+```
+
+## development
+
+```bash
+npm install
+npm run compile
+```

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+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 { OsuKey, OsuInput };

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 bindings_1 = __importDefault(require("bindings"));
+const native = (0, bindings_1.default)("osu-beatmap-parser");
+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) {
+        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);
+}
+;

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+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;
+    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;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@rel-packages/osu-beatmap-parser",
+  "version": "0.1.7",
+  "description": ".osu parser for nodejs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "homepage": "https://github.com/mezleca/osu-beatmap-parser",
+  "scripts": {
+    "install": "prebuild-install || npm run compile",
+    "dev": "npm run compile:native && tsx scripts/verify.ts",
+    "compile": "npm run compile:native && npm run compile:tsc",
+    "compile:tsc": "tsc",
+    "compile:native": "cmake-js build",
+    "prebuild": "prebuild --backend cmake-js --strip --verbose"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "url": "https://github.com/mezleca/osu-beatmap-parser.git"
+  },
+  "binary": {
+    "module_name": "osu-beatmap-parser",
+    "module_path": "./build/Release/",
+    "host": "https://github.com/mezleca/osu-beatmap-parser/releases/download/",
+    "remote_path": "{version}"
+  },
+  "type": "commonjs",
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "prebuild-install": "^7.1.2"
+  },
+  "devDependencies": {
+    "@types/bindings": "^1.5.5",
+    "@types/node": "^24.10.1",
+    "cmake-js": "^7.4.0",
+    "node-addon-api": "^8.5.0",
+    "prebuild": "^13.0.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/native/addon.cpp

@@ -0,0 +1,265 @@
+#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

@@ -0,0 +1,26 @@
+#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

@@ -0,0 +1,56 @@
+#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"};

package/src/native/osu/audio.cpp

@@ -0,0 +1,30 @@
+#include <iostream>
+#include <filesystem>
+#include <sndfile.h>
+#include "audio.hpp"
+
+double AudioAnalyzer::get_audio_duration(std::string location) {
+    double duration = 0.0;
+    
+    if (get_cache(location, duration)) {
+        return duration;
+    }
+
+    if (!std::filesystem::exists(location)) {
+        std::cout << location << " does not exists\n";
+        return 0.0;
+    }
+
+    SF_INFO sfinfo{};
+    SNDFILE *file = sf_open(location.c_str(), SFM_READ, &sfinfo);
+
+    if (!file) {
+        return 0.0;
+    }
+
+    duration = static_cast<double>(sfinfo.frames) / sfinfo.samplerate;
+    
+    sf_close(file);
+    set_cache(location, duration);
+    return duration;
+}

package/src/native/osu/audio.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+class AudioAnalyzer
+{
+private:
+    std::unordered_map<std::string, double> cache;
+    mutable std::mutex cache_mutex;
+    
+    bool get_cache(const std::string &key, double &duration) const {
+        std::lock_guard<std::mutex> lock(cache_mutex);
+        auto it = cache.find(key);
+        if (it != cache.end())
+        {
+            duration = it->second;
+            return true;
+        }
+        return false;
+    }
+
+    void set_cache(const std::string &key, double duration) {
+        std::lock_guard<std::mutex> lock(cache_mutex);
+        cache[key] = duration;
+    }
+
+    void clear_cache() {
+        std::lock_guard<std::mutex> lock(cache_mutex);
+        cache.clear();
+    }
+public:
+    double get_audio_duration(std::string location);
+};

package/src/native/osu/parser.cpp

@@ -0,0 +1,294 @@
+#include <algorithm>
+#include <cstdio>
+#include <iostream>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+#include <unordered_map>
+#include "./parser.hpp"
+#include "../definitions.hpp"
+
+const std::unordered_set<std::string_view> VIDEO_EXTENSIONS = {
+    ".mp4", ".avi", ".flv", ".mov", ".wmv", ".m4v", ".mpg", ".mpeg"
+};
+
+const std::unordered_set<std::string_view> IMAGE_EXTENSIONS = {
+    ".jpg", ".jpeg", ".png", ".bmp", ".gif"
+};
+
+std::string_view trim_view(std::string_view s) {
+    size_t start = s.find_first_not_of(" \t\r\n");
+
+    if (start == std::string_view::npos) {
+        return "";
+    }
+
+    size_t end = s.find_last_not_of(" \t\r\n");
+    return s.substr(start, end - start + 1);
+}
+
+std::string trim(const std::string &s) {
+    std::string_view result = trim_view(s);
+    return std::string(result);
+}
+
+std::vector<std::string_view> split_view(std::string_view s, char delim) {
+    std::vector<std::string_view> result;
+
+    size_t start = 0;
+    size_t end = s.find(delim);
+    
+    while (end != std::string_view::npos) {
+        result.push_back(s.substr(start, end - start));
+        start = end + 1;
+        end = s.find(delim, start);
+    }
+
+    result.push_back(s.substr(start));
+    return result;
+}
+
+std::string normalize_path(const std::string &path) {
+#ifdef _WIN32
+    std::string normalized = path;
+    std::replace(normalized.begin(), normalized.end(), '/', '\\');
+    return normalized;
+#else
+    return path;
+#endif
+}
+
+std::string_view get_extension(std::string_view filename) {
+    size_t dot_pos = filename.find_last_of('.');
+
+    if (dot_pos == std::string_view::npos) {
+        return "";
+    }
+
+    return filename.substr(dot_pos);
+}
+
+std::optional<std::string> get_special_key(std::string_view key, std::string_view line) {
+    if (key == "Background" || key == "Video") {
+        std::vector<std::string_view> parts = split_view(line, ',');
+
+        if (parts.size() < 3) {
+            return std::nullopt;
+        }
+        
+        std::string_view event_type = trim_view(parts[0]);
+        std::string_view start_time = trim_view(parts[1]);
+
+        if (event_type != "0" || start_time != "0") {
+            return std::nullopt;
+        }
+        
+        std::string_view filename = trim_view(parts[2]);
+        
+        // remove quotes if present
+        if (filename.size() >= 2 && filename.front() == '"' && filename.back() == '"') {
+            filename = filename.substr(1, filename.size() - 2);
+        }
+        
+        std::string_view ext = get_extension(filename);
+        std::string ext_lower(ext);
+        std::transform(ext_lower.begin(), ext_lower.end(), ext_lower.begin(), ::tolower);
+        
+        if (key == "Video") {
+            if (VIDEO_EXTENSIONS.count(ext_lower) == 0) {
+                return std::nullopt;
+            }
+        } else {
+            if (IMAGE_EXTENSIONS.count(ext_lower) == 0) {
+                return std::nullopt;
+            }
+        }
+        
+        return normalize_path(std::string(filename));
+    } else if (key == "Storyboard") {
+        // TODO:
+        return std::nullopt;
+    }
+    
+    return std::nullopt;
+}
+
+std::string osu_parser::get_property(std::string_view content, std::string_view key) {
+    bool is_special_key = SPECIAL_KEYS.count(key) > 0;
+    std::string current_section;
+    std::string special_section;
+    
+    if (is_special_key) {
+        if (KEY_TO_SECTION.find(key) == KEY_TO_SECTION.end()) {
+            std::cout << "failed to find special key: " << key << "\n";
+            return "";
+        }
+        special_section = KEY_TO_SECTION.at(key);
+    }
+
+    size_t start = 0;
+    size_t end = content.find('\n');
+
+    while (end != std::string_view::npos) {
+        std::string_view line_view = trim_view(content.substr(start, end - start));
+        start = end + 1;
+        end = content.find('\n', start);
+
+        if (line_view.empty() || line_view[0] == '/') {
+            continue;
+        }
+        
+        if (line_view[0] == '[') {
+            current_section = std::string(line_view);
+            continue;
+        }
+        
+        if (is_special_key) {
+            if (special_section != current_section) {
+                continue;
+            }
+            
+            auto result = get_special_key(key, line_view);
+
+            if (result.has_value()) {
+                return result.value();
+            }
+
+            continue;
+        }
+        
+        size_t delimiter_i = line_view.find(':');
+
+        if (delimiter_i == std::string_view::npos) {
+            continue;
+        }
+        
+        std::string_view current_key = trim_view(line_view.substr(0, delimiter_i));
+
+        if (current_key == key) {
+            std::string_view value = trim_view(line_view.substr(delimiter_i + 1));
+            return std::string(value);
+        }
+    }
+    
+    // check last line if no newline at end
+    if (start < content.size()) {
+        std::string_view line_view = trim_view(content.substr(start));
+        if (line_view.empty() || line_view[0] == '/') {
+            return "";
+        }
+
+         // section change at end
+        if (line_view[0] == '[') {
+            return ""; 
+        }
+
+        if (is_special_key) {
+            if (special_section == current_section) {
+                auto result = get_special_key(key, line_view);
+                if (result.has_value()) {
+                    return result.value();
+                }
+            }
+            return "";
+        } 
+        
+        size_t delimiter_i = line_view.find(':');
+        
+        if (delimiter_i != std::string_view::npos) {
+            std::string_view current_key = trim_view(line_view.substr(0, delimiter_i));
+            if (current_key == key) {
+                std::string_view value = trim_view(line_view.substr(delimiter_i + 1));
+                return std::string(value);
+            }
+        }
+    }
+
+    return "";
+}
+
+std::unordered_map<std::string, std::string> osu_parser::get_properties(std::string_view content, const std::vector<std::string>& keys) {
+    std::unordered_map<std::string, std::string> results;
+    std::unordered_map<std::string_view, std::string_view> key_to_section_map;
+    std::unordered_set<std::string_view> keys_to_find;
+    
+    for (const auto& key : keys) {
+        keys_to_find.insert(key);
+        if (KEY_TO_SECTION.count(key)) {
+            key_to_section_map[key] = KEY_TO_SECTION.at(key);
+        }
+    }
+
+    std::string current_section;
+    size_t start = 0;
+    size_t end = content.find('\n');
+
+    auto process_line = [&](std::string_view line_view) {
+        if (line_view.empty() || line_view[0] == '/') {
+            return;
+        }
+        
+        if (line_view[0] == '[') {
+            current_section = std::string(line_view);
+            return;
+        }
+        
+        size_t delimiter_i = line_view.find(':');
+        if (delimiter_i != std::string_view::npos) {
+            std::string_view current_key = trim_view(line_view.substr(0, delimiter_i));
+            
+            if (keys_to_find.count(current_key)) {
+                bool correct_section = !key_to_section_map.count(current_key) || 
+                                       key_to_section_map.at(current_key) == current_section;
+
+                bool not_found_yet = results.find(std::string(current_key)) == results.end();
+                
+                if (correct_section && not_found_yet) {
+                     std::string_view value = trim_view(line_view.substr(delimiter_i + 1));
+                     results[std::string(current_key)] = std::string(value);
+                }
+            }
+        }
+
+        for (const auto& key : keys) {
+            if (!SPECIAL_KEYS.count(key)) {
+                continue;
+            }
+            
+            if (results.find(key) != results.end()) {
+                continue;
+            }
+            
+            if (key_to_section_map.count(key) && key_to_section_map.at(key) == current_section) {
+                auto result = get_special_key(key, line_view);
+                if (result.has_value()) {
+                    results[key] = result.value();
+                }
+            }
+        }
+    };
+
+    while (end != std::string_view::npos) {
+        std::string_view line_view = trim_view(content.substr(start, end - start));
+        process_line(line_view);
+        start = end + 1;
+        end = content.find('\n', start);
+    }
+    
+    if (start < content.size()) {
+        std::string_view line_view = trim_view(content.substr(start));
+        process_line(line_view);
+    }
+
+    return results;
+}
+
+std::vector<std::string> osu_parser::get_section() {
+    std::vector<std::string> result;
+    return result;
+}
+
+std::map<std::string, std::string> osu_parser::parse(std::string_view content) {
+    return {};
+}

package/src/native/osu/parser.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include <map>
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+namespace osu_parser {
+    std::string get_property(std::string_view content, std::string_view key);
+    std::unordered_map<std::string, std::string> get_properties(std::string_view content, const std::vector<std::string>& keys);
+
+    // TODO:
+    std::vector<std::string> get_section();
+    std::map<std::string, std::string> parse(std::string_view content); 
+};

package/src/native/pool.hpp

@@ -0,0 +1,80 @@
+#pragma once 
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <vector>
+#include <atomic>
+
+class ThreadPool {
+public:
+    void initialize(int count) {
+        for (int i = 0; i < count; i++) {
+            // add new worker
+            workers.emplace_back([this]() {
+                // initialize task loop
+                while (true) {
+                    std::function<void()> task;
+                    // wait for new task
+                    {
+                        std::unique_lock<std::mutex> lock(queue_mutex);
+
+                        // use condition variable to make threads go zzz until we actually have a task to do
+                        cv.wait(lock, [this] { 
+                            return stop || !tasks.empty();
+                        });
+
+                        // ensure we have a task
+                        if (stop && tasks.empty()) {
+                            break;
+                        }
+
+                        // move task from queue to var
+                        task = std::move(tasks.front());
+
+                        // if i recall correctly "move" moves the pointer data from the queue
+                        // but the pointer is still there pointing to nothing
+                        // so remove it anyway
+                        tasks.pop();
+                    }
+
+                    // execute it :)
+                    task();
+                }
+            });
+        }
+    }
+
+    ~ThreadPool() {
+        stop = true;
+
+        // wake up all lazy ass threads
+        cv.notify_all();
+
+        // free them
+        for (std::thread& t : workers) {
+            if (t.joinable()) {
+                t.join();
+            }
+        }
+    }
+
+    template<class T>
+    void enqueue(T&& f) {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex);
+            tasks.emplace(std::forward<T>(f));
+        }
+        cv.notify_one();
+    }
+private:
+    std::atomic<bool> stop{false};
+    std::vector<std::thread> workers;
+    std::queue<std::function<void()>> tasks;
+    std::mutex queue_mutex;
+    std::condition_variable cv;
+};
+
+inline ThreadPool pool;

package/src/types.ts

@@ -0,0 +1,48 @@
+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;
+    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;
+}