midi-audio-player 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maxime Larrivée-Roy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# midi-audio-player
+
+A lightweight JavaScript MIDI audio player built on top of the Web Audio API using WebAudioFont. This package enables playback of MIDI files directly in the browser with minimal setup and no heavy dependencies.
+
+## Features
+
+* MIDI file playback in modern browsers
+* Built on the Web Audio API
+* Uses WebAudioFont for instrument rendering
+* Lightweight and dependency-minimal
+* Simple programmatic API
+* CLI tool for instrument/font handling
+
+## Installation
+
+```bash
+npm install midi-audio-player
+```
+
+## Usage
+
+### Basic Example
+
+```js
+import MidiAudioPlayer from 'midi-audio-player';
+
+const player = new MidiAudioPlayer({
+	volume: 0.02,
+	instrument: instrumentData,
+	onEndFile: async () => await this.playNextSong()
+});
+
+await player.play('binarycontent');
+```
+
+### Control Playback
+
+```js
+player.play();
+player.pause();
+player.stop();
+```
+
+### Working with AudioContext
+
+Due to browser autoplay restrictions, you should ensure that your AudioContext is resumed after a user interaction:
+
+## CLI
+
+This package provides a CLI tool for downloading and converting WebAudioFont assets. You need to provide a WebAudioFont ID dans the json file for the destination.
+
+```bash
+webaudiofont 0000_Chaos_sf2_file dest/instrument.json
+```
+
+You can find instruments here: [WebAudioFont](https://github.com/surikov/webaudiofont#catalog-of-instruments)
+
+## Browser Compatibility
+
+Requires a modern browser with support for:
+
+* Web Audio API
+* ES Modules
+
+## Limitations
+
+* First playback may be delayed if the AudioContext is not initialized properly
+* Depends on WebAudioFont instrument quality and availability
+* Not intended for high-fidelity or professional audio rendering
+
+
+## License
+
+[LICENCE](LICENSE)
+
+## Author
+
+Maxime Larrivée-Roy
+
+## Repository
+
+[https://github.com/ZmotriN/midi-audio-player](https://github.com/ZmotriN/midi-audio-player)
+
+---
+
+If you want, I can also tailor it more toward your Phaser/game use case or add a section comparing it with other MIDI solutions (which can be useful positioning-wise).

package/bin/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { downloadWebAudioFont } from '../src/downloader.js';
+
+// Récupération des arguments (ex: node cli.js <id> <destination>)
+// process.argv[0] est Node, process.argv[1] est le chemin du script
+const [id, destination] = process.argv.slice(2);
+
+if (!id || !destination) {
+    console.error("\x1b[31m%s\x1b[0m", "Erreur : Arguments manquants.");
+    console.log("\nUsage :");
+    console.log("  webaudiofont <id> <destination.json>");
+    console.log("\nExemple :");
+    console.log("  webaudiofont 0810_GeneralUserGS_sf2_file assets/sound.json\n");
+    process.exit(1);
+}
+
+async function run() {
+    try {
+        await downloadWebAudioFont(id, destination);
+    } catch (error) {
+        // L'erreur est déjà logguée dans downloadWebAudioFont, on quitte proprement
+        process.exit(1);
+    }
+}
+
+run();

package/index.js

@@ -0,0 +1 @@
+export { default } from './src/midiaudioplayer.js';

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "midi-audio-player",
+  "version": "1.0.0",
+  "description": "Javascript Midi Audio Player for WebAudioFont",
+  "keywords": [
+    "audio",
+    "player",
+    "midi",
+    "js",
+    "webaudiofont"
+  ],
+  "homepage": "https://github.com/ZmotriN/midi-audio-player#readme",
+  "bugs": {
+    "url": "https://github.com/ZmotriN/midi-audio-player/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZmotriN/midi-audio-player.git"
+  },
+  "license": "MIT",
+  "author": "Maxime Larrivée-Roy",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "webaudiofont": "./bin/cli.js"
+  },
+  "dependencies": {
+    "midi-player-js": "^2.0.17"
+  }
+}

package/src/defaultinstrument.json

@@ -0,0 +1,116 @@
+{
+  "zones": [
+    {
+      "midi": 81,
+      "originalPitch": 4200,
+      "keyRangeLow": 0,
+      "keyRangeHigh": 43,
+      "loopStart": 256,
+      "loopEnd": 768,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "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",
+      "anchor": 0.00533333
+    },
+    {
+      "midi": 81,
+      "originalPitch": 5400,
+      "keyRangeLow": 44,
+      "keyRangeHigh": 55,
+      "loopStart": 128,
+      "loopEnd": 384,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAAEsADMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJATAAAAAAAAABLAMEvhQAAAAAAAAAAAAAAAAAAAA//vUxAAACSwNaVQwACRXSC6/NYAIAAa9txyS8qHAwMDPlz5QEIIROfLn1AhBBy3lz/BCt5c/wQz5c/RBCXPlw/EEEHLPlz9EEOt8QQQcs+XPykQVh8uH4gcIHLD6w+JgcGkGbGakSCqjColKJDEMCR4mYQ8kQZ1UAiwCAIbAc4b1maEch6LAEVzMhwxuYQGCgLBWbmQSPi+kAzkOM6i/Ei2XrGgFiMbisXednEOO7NP9KJdLKedbxd7vvezh3pl/YdmreFqxnZjEgf+NyN/I1TXaWzqnqWqTOzTyyihuX0cMUlNa3S81TYWrGd63q/RRuno4xSUUbt3YzSYU1fuH8z/uH8zp6OMUlFK6e/KKTG5zKZy+ax/+4fzP+4fzP70rp78opL1PXv0lSzVy+tjjVyyrY41e4fzf91/N/3X83/dfzf91/N/3X5/3D+b/uv5v+6/m/7r/3/6/9/+sst446yy3jVyyrY41csq2ONXLKtjjVyyrKiLXdbW5JI24SEB1CQjhFAAXAIxdxbUKO0ekXEuKphJ5DkSgYKJVFFxQVwUwFDcRcUFcFcCjsTYoK4K4FHYmxQXwrgUdibFBfCvCjsTcRXhXhT8TcRXhXhT8TcRXhXhT8TcRXhXhT8TcakxBTUUzLjk5LjWqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//tkxMWDzQgxS7zzACgAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
+      "anchor": 0.00266667
+    },
+    {
+      "midi": 81,
+      "originalPitch": 6600,
+      "keyRangeLow": 56,
+      "keyRangeHigh": 67,
+      "loopStart": 64,
+      "loopEnd": 192,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAAE4ADs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAXAAAAAAAAABODQyktQAAAAAAAAAAAAAAAAAAAA//vkxAAABywBgbQAACYVyC6/P9AwKAASUcckkt4YWD4fLn1AhBCJz5c+oEFghy5/ghy5+cghy7+GKZd/DHLn1HIYk5d/DHL+6H5d5TOdLnbLTLKrBqyq+vlkqeD4lCzTAngBgvMYACAAGg+NZZoFwogYAGAZCwCsDgBJsJhRJLyYvYUvg4BLFAA9AKpqYxQCumE3hMhEBIkBkBLuNR5oOGzUbs0Jk7jR1yTFgpzGY2TMgWV8qtT4fmaf4xDKgxlNgzTGRZScSFbPVQxarGZbWMLiNMUC1MshXMJx+MRSeaZHnuceOvbGrV2ls6MOQUMAAnMDAzMMgRMAQkMCQufiahT9zMJfim7ul5rIDBEFgJBgHgoHQuBANAwFA1WkUbqzssyns944flv09UjUcU9kjkkk9UjZfjOyzKep8Z2kxucyq9+ax9JFNJNJNZNFNFNVNJNJNbKRRvGQxjKejfJ2Udq/9bf1darY41U0U0U1U0k0k+k0U0U+U0k0k+k0e5/zD+5/zD+5/zX93/Nf3f81/d////////7/9f+//X/v/1/7/9Jop8ppJpJ9Jop6qwppJ7KxJGp6qwpHKrKxI2qqqwo3KrKxI2qqq9RuVWV8jaqqr1G5TEFNRTMuOTkuNVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxNoDwAAB/hwAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
+      "anchor": 0.00133333
+    },
+    {
+      "midi": 81,
+      "originalPitch": 7800,
+      "keyRangeLow": 68,
+      "keyRangeHigh": 79,
+      "loopStart": 32,
+      "loopEnd": 96,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAZAAAAAAAAAA8CsVDBMAAAAAAAAAAAAAAAAAAAA//vExAAABmQBjaAAACGQBa9497AdtbAkWdckklxRyjhQ5BBYYqOFHRAXDHKHOGOUOcMco7nOJHawxynnOU5cMcHOXOcHOl3NXGMqsiEAqoMI8QsSUcIsgeiQgJISFCg5ABAyw+VQaiK8yY18FNiuxBUorwU0FdiC4ivimgrsQXEV4KaCuxBcTfBXAv4isTfiuBf6KxN+L4r8RUU3wXoL+JsU3wXoL+JsV3gvRSpMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqq6goZoAABEOiCXDs8P3G8oicJAhZjVVVBlsStNFVVUT8StNVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxOuDxEQnByYExigAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
+      "anchor": 0.00066667
+    },
+    {
+      "midi": 81,
+      "originalPitch": 9000,
+      "keyRangeLow": 80,
+      "keyRangeHigh": 91,
+      "loopStart": 16,
+      "loopEnd": 48,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaAAAAAAAAAA8ChXkahAAAAAAAAAAAAAAAAAAAA//vExAAABkQDh+AAACGUhq9895iZZVlzMgFEYk0nBACCLQfD6gTB8/qBDBwMflC4f/gQMfqBMH/4OHP4Df+XBw5+UBN/6wJu1fapqZhlttyF2FyUYQ0W0QkFSJiRIro4TAYk8aQCAQCAKjiRIkSr+xQUFOBQUV/5BQU4KChv+CgoL4KCu/4QUN8KCn/8UFN8FFf/wgp/hQ3/8FBXYgoL/+FBX5BQ3/8FBfigopVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxNoDwAAB/gAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
+      "anchor": 0.00033333
+    },
+    {
+      "midi": 81,
+      "originalPitch": 10200,
+      "keyRangeLow": 92,
+      "keyRangeHigh": 103,
+      "loopStart": 8,
+      "loopEnd": 56,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaAAAAAAAAAA8AljJJeAAAAAAAAAAAAAAAAAAAA//vExAAABmgDh+AAACG7Cq649JmAh3unfGYwJRhSgQBBEXB8PjogBDn8EwfP6gQdicP/g4GOXB/lHfgmH905/UclwcOf/8oA/2r/qekIFM1D+AxK8OEgo9IhpLSJFdJaehzC3CbBom0GChJpEiRn/tRxIkSJT6OJJB3BUFXSwNB3BUFQVgqCoaqBoGsqd4iBo8oGgaTWCoaxEDR6VBUFTpUFQV//BoGoiBoO//rxKCv//iIGv/+WTEFNRTMuOTkuNVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxNoDwAAB/gAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
+      "anchor": 0.00016667
+    },
+    {
+      "midi": 81,
+      "originalPitch": 11400,
+      "keyRangeLow": 104,
+      "keyRangeHigh": 115,
+      "loopStart": 12,
+      "loopEnd": 52,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaAAAAAAAAAA8CNr1v4AAAAAAAAAAAAAAAAAAAA//vExAAAB1SVheCEbeI4SC349ApomIy4jYiPtA6x5AACs4xjvkAAPmMY/wAXzGMf4AL/X+IgG4PvwQOfIQQOZcH//wQlwfBA5/1h/iB2sP/17/1GMvIAEJ8BiUYMEW0NSAKQjJWj5HCbB/EGHqQ5m2plUuYL1WvVqeGZmb/VVVf9mZr/1VVX9hYGwKgFgbB9TCwNgbB8BG6lKUreYxjfKUrfQxvylK3oYxjeUKAgICJYoCAgICUvoYxvylL9DGN9SlL9P+UrfMYxjOoYCAgIUb6lL////////qUpSzASTEFNRTMuOTkuNaqqqqpMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//sUxNoDwAAB/gAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
+      "anchor": 0.00008333
+    },
+    {
+      "midi": 81,
+      "originalPitch": 12600,
+      "keyRangeLow": 116,
+      "keyRangeHigh": 127,
+      "loopStart": 6,
+      "loopEnd": 42,
+      "coarseTune": 0,
+      "fineTune": 0,
+      "sampleRate": 48000,
+      "ahdsr": false,
+      "file": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAAEIADo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaQAAAAAAAABCDWHfeqAAAAAAAAAAAAAAAAAAAA//vUxAAACUUrfeCE1eMLSCx88a54l3jMh4t/trUApEAAAUAGYxja+WMYx/yAAH+MY/+AYx/4AAX8xjH/7/8AF//zHyAMdoIAgAAADAYWTt4IA/Kc5/////////y4Pg/v3FZropQkAAAEiDVBBhkjdBSk5JyDlHqDmWi+kJRsJiOZ69eva6x+zAQEBCm/9VVVb/9mVVL/9mZmP/6qqqn/8ZlVV/6zMzM3/VCgICanXX+5I2JRJHaana+SSNwIQEQAwAQAQEw6j5KBCASACACAKAmBGHcdr5RNR2jtJRsed/DkTU1NTra/3Oc5znf+1rWuc7/3Na1ra/9znOc7/9rWtc7/9zWta3/4c5znO/9rTU1NXOvbW4lDtDyHkPI7TqQIQAxMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//sUxNoDwAABpAAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
+      "anchor": 0.00004167
+    }
+  ]
+}

package/src/downloader.js

@@ -0,0 +1,54 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Télécharge une police audio WebAudioFont et la convertit en JSON
+ * @param {string} id - L'ID de la police (ex: "0810_GeneralUserGS_sf2_file")
+ * @param {string} filename - Le nom du fichier de sortie (ex: "ma_police.json")
+ */
+export async function downloadWebAudioFont(id, filename) {
+    // Nettoyage du nom de fichier : s'assurer qu'il finit par .json
+    const cleanFilename = filename.endsWith('.json') ? filename : `${filename}.json`;
+    
+    // On définit la destination par rapport au dossier de travail actuel
+    const destPath = path.join(process.cwd(), cleanFilename);
+    const url = `https://surikov.github.io/webaudiofontdata/sound/${id}.js`;
+
+    try {
+        console.log(`📡 Téléchargement de : ${id}...`);
+        
+        const response = await fetch(url);
+        
+        if (!response.ok) {
+            throw new Error(`Erreur HTTP: ${response.status} (Vérifiez l'ID)`);
+        }
+
+        const rawContent = await response.text();
+
+        // Extraction de l'objet JS entre les premières '{' et les dernières '}'
+        const firstBrace = rawContent.indexOf('{');
+        const lastBrace = rawContent.lastIndexOf('}');
+
+        if (firstBrace === -1 || lastBrace === -1) {
+            throw new Error("Format de fichier invalide : structure d'objet introuvable.");
+        }
+
+        const objectString = rawContent.substring(firstBrace, lastBrace + 1);
+
+        // Transformation de la chaîne en objet JavaScript
+        const data = new Function(`return ${objectString}`)();
+
+        // Création du dossier parent s'il n'existe pas
+        await fs.mkdir(path.dirname(destPath), { recursive: true });
+
+        // Sauvegarde en format JSON
+        await fs.writeFile(destPath, JSON.stringify(data, null, 2));
+
+        console.log(`✅ Terminé ! Fichier créé : ${destPath}`);
+        return data; // Retourne l'objet au cas où on veut l'utiliser immédiatement
+        
+    } catch (error) {
+        console.error(`❌ Échec : ${error.message}`);
+        throw error; // On relance l'erreur pour que l'appelant puisse la gérer
+    }
+}

package/src/midiaudioplayer.js

@@ -0,0 +1,113 @@
+import MidiPlayer from 'midi-player-js';
+import WebAudioFontPlayer from "./webaudiofontplayer";
+import DefaultInstrument from "./defaultinstrument.json";
+
+
+
+export default class MidiAudioPlayer {
+
+	#audioCtx = null;
+	#midiPlayer = null;
+	#audioPlayer = null;
+	#activeNotes = null;
+
+	#opts = {
+		instrument: DefaultInstrument,
+        volume: 0.012,
+		onEndFile: null
+	};
+
+
+	constructor(opts = {}) {
+		this.#opts = { ...this.#opts, ...opts };
+        this.#activeNotes = new Map();
+		this.#audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+		this.#audioPlayer = new WebAudioFontPlayer(this.#audioCtx, this.#opts.instrument);
+		this.#midiPlayer = new MidiPlayer.Player(event => this.#handleMidiPipeline(event));
+        this.#midiPlayer.on('endOfFile', async () => {
+			await new Promise(resolve => requestAnimationFrame(() => setTimeout(resolve, 1)));
+			await this.#endOfFile();
+        });
+	}
+
+
+	async #endOfFile() {
+		if(typeof this.#opts.onEndFile == 'function') await this.#opts.onEndFile();
+	}
+
+
+    async #handleMidiPipeline(event) {
+        if (event.name !== 'Note on' && event.name !== 'Note off') return;
+        if (!this.#midiPlayer.isPlaying()) return;
+        if (event.noteNumber === undefined) return;
+
+        const now = this.#audioCtx.currentTime;
+
+        switch (event.name) {
+            case 'Note on':
+                if (event.velocity > 0 && event.velocity <= 127) {
+                    this.#stopNotePipe(event.noteNumber);
+                    const vol = (event.velocity / 127) * this.#opts.volume;
+                    const envelope = this.#audioPlayer.queueWaveTable(0, event.noteNumber, 2, vol);
+                    this.#activeNotes.set(event.noteNumber, envelope);
+                } else {
+                    this.#stopNotePipe(event.noteNumber);
+                }
+                break;
+
+            case 'Note off':
+                this.#stopNotePipe(event.noteNumber);
+                break;
+        }
+    }
+
+
+    #stopNotePipe(noteNumber) {
+        const envelope = this.#activeNotes.get(noteNumber);
+        if (envelope) {
+            envelope.cancel();
+            this.#activeNotes.delete(noteNumber);
+        }
+    }
+
+
+    #clearActiveNotes() {
+        if (this.#activeNotes) {
+            this.#activeNotes.forEach((envelope, note) => {
+                if (envelope && envelope.cancel) {
+                    envelope.cancel();
+                }
+            });
+            this.#activeNotes.clear();
+        }
+    }
+
+
+	async #load(content) {
+		if(this.#midiPlayer.isPlaying()) this.#midiPlayer.stop();
+		this.#clearActiveNotes();
+		await this.#midiPlayer.loadArrayBuffer(content);
+	}
+
+
+	async play(content = null) {
+		if(content) await this.#load(content);
+        await this.#audioCtx.resume();
+		await this.#midiPlayer.play();
+	}
+
+
+	async pause() {
+        await this.#midiPlayer.pause();
+        await this.#audioCtx.suspend();
+        await this.#clearActiveNotes();
+	}
+
+	
+    async stop() {
+        await this.#midiPlayer.stop();
+        await this.#audioCtx.suspend();
+        await this.#clearActiveNotes();
+	}
+
+}

package/src/webaudiofontplayer.js

@@ -0,0 +1,255 @@
+
+
+class WebAudioFontChannel {
+
+    constructor(audioContext) {
+        this.audioContext = audioContext;
+        this.input = audioContext.createGain();
+
+        let lastNode = this.input;
+        [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384].forEach(freq => {
+            lastNode = this.bandEqualizer(lastNode, freq);
+            this[`band${freq < 1000 ? freq : (freq / 1024) + 'k'}`] = lastNode;
+        });
+
+
+        this.limiter = audioContext.createDynamicsCompressor();
+        this.limiter.threshold.setValueAtTime(-3.0, audioContext.currentTime);
+        this.limiter.ratio.setValueAtTime(40, audioContext.currentTime);
+        this.limiter.attack.setValueAtTime(0.000, audioContext.currentTime);
+        this.limiter.release.setValueAtTime(0.25, audioContext.currentTime);
+        this.output = audioContext.createGain();
+
+        lastNode.connect(this.limiter);
+        this.limiter.connect(this.output);
+
+    }
+
+    bandEqualizer(from, frequency) {
+        const filter = this.audioContext.createBiquadFilter();
+        filter.frequency.setTargetAtTime(frequency, 0, 0.0001);
+        filter.type = "peaking";
+        filter.gain.setTargetAtTime(0, 0, 0.0001);
+        filter.Q.setTargetAtTime(1.0, 0, 0.0001);
+        from.connect(filter);
+        return filter;
+    }
+}
+
+class WebAudioFontPlayer {
+
+    envelopes = [];
+    afterTime = 0.05;
+    nearZero = 0.000001;
+
+    #audioCtx = null;
+    #preset = null;
+    
+    constructor(audioCtx, preset) {
+        this.#audioCtx = audioCtx;
+        this.#preset = preset;
+        this.adjustPreset(this.#audioCtx, this.#preset);
+    }
+
+
+    adjustPreset(audioContext, preset) {
+        return preset.zones.map(zone => this.adjustZone(audioContext, zone));
+    };
+
+
+    adjustZone(audioContext, zone) {
+        if (zone.buffer) return Promise.resolve(zone);
+            zone.delay = 0;
+
+            if (zone.sample) {
+                const decoded = atob(zone.sample);
+                zone.buffer = audioContext.createBuffer(1, decoded.length / 2, zone.sampleRate);
+                const float32Array = zone.buffer.getChannelData(0);
+
+                for (let i = 0; i < decoded.length / 2; i++) {
+                    const b1 = decoded.charCodeAt(i * 2) & 0xFF;
+                    const b2 = decoded.charCodeAt(i * 2 + 1) & 0xFF;
+                    let n = (b2 << 8) | b1;
+                    if (n >= 32768) n -= 65536;
+                    float32Array[i] = n / 32768.0;
+                }
+                this.applyZoneParameters(zone);
+                return zone;
+
+            } else if (zone.file) {
+                const decoded = atob(zone.file);
+                const uint8Array = new Uint8Array(decoded.length);
+                for (let i = 0; i < decoded.length; i++) {
+                    uint8Array[i] = decoded.charCodeAt(i);
+                }
+
+                audioContext.decodeAudioData(
+                    uint8Array.buffer,
+                    audioBuffer => {
+                        zone.buffer = audioBuffer;
+                        this.applyZoneParameters(zone);
+                        return zone;
+                    },
+                    error => {
+                        console.error("Erreur de décodage audio:", error);
+                        return false;
+                    }
+                );
+            } else {
+                this.applyZoneParameters(zone);
+                return zone;
+            }
+    };
+
+    applyZoneParameters = (zone) => {
+        zone.loopStart = this.numValue(zone.loopStart, 0);
+        zone.loopEnd = this.numValue(zone.loopEnd, 0);
+        zone.coarseTune = this.numValue(zone.coarseTune, 0);
+        zone.fineTune = this.numValue(zone.fineTune, 0);
+        zone.originalPitch = this.numValue(zone.originalPitch, 6000);
+        zone.sampleRate = this.numValue(zone.sampleRate, 44100);
+    };
+
+    queueWaveTable(when, pitch, duration, volume, slides) {
+        this.resumeContext(this.#audioCtx);
+        const vol = this.limitVolume(volume);
+        const zone = this.findZone(this.#audioCtx, this.#preset, pitch);
+
+        if (!zone?.buffer) return null;
+
+        const baseDetune = zone.originalPitch - 100.0 * zone.coarseTune - zone.fineTune;
+        const playbackRate = Math.pow(2, (100.0 * pitch - baseDetune) / 1200.0);
+        const startWhen = Math.max(when, this.#audioCtx.currentTime);
+        let waveDuration = duration + this.afterTime;
+
+        const loop = zone.loopStart >= 1 && zone.loopStart < zone.loopEnd;
+        if (!loop) {
+            waveDuration = Math.min(waveDuration, zone.buffer.duration / playbackRate);
+        }
+
+        const envelope = this.findEnvelope(this.#audioCtx, this.#audioCtx.destination);
+        this.setupEnvelope(this.#audioCtx, envelope, zone, vol, startWhen, waveDuration, duration);
+
+        const source = this.#audioCtx.createBufferSource();
+        source.buffer = zone.buffer;
+        source.playbackRate.setValueAtTime(playbackRate, 0);
+
+        if (slides?.length > 0) {
+            source.playbackRate.setValueAtTime(playbackRate, startWhen);
+            slides.forEach(s => {
+                const newRate = Math.pow(2, (100.0 * (pitch + s.delta) - baseDetune) / 1200.0);
+                source.playbackRate.linearRampToValueAtTime(newRate, startWhen + s.when);
+            });
+        }
+
+        source.loop = loop;
+        if (loop) {
+            const d = zone.delay ?? 0;
+            source.loopStart = zone.loopStart / zone.sampleRate + d;
+            source.loopEnd = zone.loopEnd / zone.sampleRate + d;
+        }
+
+        source.connect(envelope);
+        source.start(startWhen, zone.delay ?? 0);
+        source.stop(startWhen + waveDuration);
+
+        envelope.audioBufferSourceNode = source;
+        envelope.when = startWhen;
+        envelope.duration = waveDuration;
+
+        return envelope;
+    }
+
+    setupEnvelope(audioContext, envelope, zone, volume, when, sampleDuration, noteDuration) {
+        envelope.gain.setValueAtTime(this.noZeroVolume(0), audioContext.currentTime);
+
+        const duration = Math.min(noteDuration, sampleDuration - this.afterTime);
+        const ahdsr = (zone.ahdsr && zone.ahdsr.length > 0) ? zone.ahdsr : [
+            { duration: 0, volume: 1 },
+            { duration: duration, volume: 1 }
+        ];
+
+        envelope.gain.cancelScheduledValues(when);
+        const initialVol = (ahdsr[0]?.volume ?? 1) * volume;
+        envelope.gain.setValueAtTime(this.noZeroVolume(initialVol), when);
+
+        let lastTime = 0;
+        let lastVolume = ahdsr[0]?.volume ?? 1;
+
+        for (let i = 0; i < ahdsr.length; i++) {
+            const stage = ahdsr[i];
+            if (stage.duration > 0) {
+                if (stage.duration + lastTime > duration) {
+                    const r = 1 - (stage.duration + lastTime - duration) / stage.duration;
+                    const n = lastVolume - r * (lastVolume - stage.volume);
+                    envelope.gain.linearRampToValueAtTime(this.noZeroVolume(volume * n), when + duration);
+                    break;
+                }
+                lastTime += stage.duration;
+                lastVolume = stage.volume;
+                envelope.gain.linearRampToValueAtTime(this.noZeroVolume(volume * lastVolume), when + lastTime);
+            }
+        }
+        envelope.gain.linearRampToValueAtTime(this.noZeroVolume(0), when + duration + this.afterTime);
+    }
+
+    findEnvelope(audioContext, target) {
+        let envelope = this.envelopes.find(e =>
+            e.target === target && audioContext.currentTime > e.when + e.duration + 0.001
+        );
+
+        if (envelope) {
+            if (envelope.audioBufferSourceNode) {
+                try { envelope.audioBufferSourceNode.stop(0); envelope.audioBufferSourceNode.disconnect(); } catch (e) { }
+                envelope.audioBufferSourceNode = null;
+            }
+        } else {
+            envelope = audioContext.createGain();
+            envelope.target = target;
+            envelope.connect(target);
+            envelope.cancel = () => {
+                if (envelope.when + envelope.duration > audioContext.currentTime) {
+                    envelope.gain.cancelScheduledValues(0);
+                    envelope.gain.setTargetAtTime(0.00001, audioContext.currentTime, 0.1);
+                    envelope.when = audioContext.currentTime + 0.00001;
+                    envelope.duration = 0;
+                }
+            };
+            this.envelopes.push(envelope);
+        }
+        return envelope;
+    }
+
+    findZone = (audioContext, preset, pitch) => {
+        const zone = preset.zones.findLast(z => pitch >= z.keyRangeLow && pitch <= z.keyRangeHigh + 1);
+        if (zone) this.adjustZone(audioContext, zone);
+        return zone;
+    };
+
+    limitVolume = (v) => {
+        const requestedVolume = v ? 1.0 * v : 0.5;
+        return Math.min(requestedVolume, 0.8);
+    };
+    noZeroVolume = (n) => n > this.nearZero ? n : this.nearZero;
+    numValue = (a, b) => typeof a === "number" ? a : b;
+
+    resumeContext(audioContext) {
+        if (audioContext.state === 'suspended') audioContext.resume().catch(() => { });
+    }
+
+    queueChord(ctx, tgt, prst, w, pchs, d, v, s) {
+        const vol = this.limitVolume(v);
+        return pchs.map((p, i) => this.queueWaveTable(ctx, tgt, prst, w, p, d, vol - Math.random() * 0.01, s?.[i])).filter(Boolean);
+    }
+
+    cancelQueue(audioContext) {
+        this.envelopes.forEach(e => {
+            e.gain.cancelScheduledValues(0);
+            e.gain.setValueAtTime(this.nearZero, audioContext.currentTime);
+            e.when = -1;
+            try { e.audioBufferSourceNode?.disconnect(); } catch (e) { }
+        });
+    }
+}
+
+export default WebAudioFontPlayer;