lavalink-client 2.2.1 → 2.3.0

package/README.md

@@ -2,7 +2,7 @@
 Easy, flexible and feature-rich lavalink@v4 Client. Both for Beginners and Proficients.
 
 <div align="center">
-  <p> 
+  <p>
     <img src="https://madewithlove.now.sh/at?heart=true&template=for-the-badge" alt="Made with love in Austria">
     <img alt="Made with TypeScript" src="https://img.shields.io/badge/typescript-%23007ACC.svg?style=for-the-badge&logo=typescript&logoColor=white">
   </p>
@@ -75,7 +75,7 @@ Check out the [Documentation](https://lc4.gitbook.io/lavalink-client) | or the [
 
 - ✨ Choose able queue stores (maps, collections, redis, databases, ...)
   - You can create your own queueStore, thus make it easy to sync queues accross multiple connections (e.g. dashboard-bot)
-  - Automated Queue Sync methods 
+  - Automated Queue Sync methods
   - Automated unresolveable Tracks (save the queries as Partial Track Objects -> Fetch the tracks only once they are gonna play)
 
 - 😍 Included Filter & Equalizer Management
@@ -91,20 +91,20 @@ Check out the [Documentation](https://lc4.gitbook.io/lavalink-client) | or the [
 
 - 🛡️ Client Validations
   - Allows you to whitelist links and even blacklist links / words / domain names, so that it doesn't allow requests you don't want!
-  - Checks almost all Lavalink Requests for out of bound errors, right before the request is made to prevent process breaking errors. 
+  - Checks almost all Lavalink Requests for out of bound errors, right before the request is made to prevent process breaking errors.
 
 - 🧑‍💻 Memory friendly and easy style
   - Only the required data is displayed, and the store-way & types match Lavalink#IMPLEMENTATION.md
 
 - 😘 Automated Handlings
-  - Skips the songs, on TrackEnd, TrackStuck, TrackError, 
+  - Skips the songs, on TrackEnd, TrackStuck, TrackError,
   - Destroys the player on channeldelete
   - Pauses / resumes the player if it get's muted / unmuted (server-wide) [soon]
   - ...
 
 - 😁 Much much more!
 
-*** 
+***
 
 # All Events:
 
@@ -146,7 +146,7 @@ client.lavalink.on("error", (node, error, payload) => {
 - `error` ➡️ `(node, error, payload) => {}`
 - `resumed` ➡️ `(node, payload, players) => {}`
   - Resuming needs to be handled manually by you *(aka add the players to the manager)*
-- e.g.:
+- e.g. of listening to node events:
 ```js
 client.lavalink.nodeManager.on("create", (node, payload) => {
   console.log(`The Lavalink Node #${node.id} connected`);
@@ -169,10 +169,10 @@ class myCustomWatcher implements QueueChangesWatcher {
         this.client = client;
     }
     shuffled(guildId, oldStoredQueue, newStoredQueue) {
-        console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: Queue got shuffled`)    
+        console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: Queue got shuffled`)
     }
     tracksAdd(guildId, tracks, position, oldStoredQueue, newStoredQueue) {
-        console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: ${tracks.length} Tracks got added into the Queue at position #${position}`);    
+        console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: ${tracks.length} Tracks got added into the Queue at position #${position}`);
     }
     tracksRemoved(guildId, tracks, position, oldStoredQueue, newStoredQueue) {
         console.log(`${this.client.guilds.cache.get(guildId)?.name || guildId}: ${tracks.length} Tracks got removed from the Queue at position #${position}`);
@@ -208,9 +208,77 @@ client.lavalink.nodeManager.on("resumed", (node, payload, fetchedPlayers) => {
     await player.queue.utils.sync(); // only works with a queuestore
     // you can now overwride the player.queue.current track from the fetchedPlayer, or use the one from the queue.uztils.sync function
     // continue with your resuming code...
-  } 
+  }
 })
-``` 
+```
+
+## Resuming full Example
+Full code sample: can be found on the [Testbot in here](https://github.com/Tomato6966/lavalink-client/blob/main/testBot/Utils/handleResuming.ts)
+```js
+// but here is the schema:
+client.lavalink.nodeManager.on("connect", (node) => node.updateSession(true, 360e3));
+client.lavalink.nodeManager.on("resumed", (node, payload, fetchedPlayers) => {
+  // create players:
+  for(const fetchedPlayer of fetchedPlayers) {
+    // fetchedPlayer is the live data from lavalink
+    // saved Player data is the config you should save in a database / file or smt
+    const savedPlayerData = await getSavedPlayerData(fetchedPlayer.guildId);
+    const player = client.lavalink.createPlayer({
+       guildId: fetchedPlayer.guildId,
+    });
+    // if lavalink says the bot got disconnected, we can skip the resuming, or force reconnect whatever you want!, here we choose to not do anything and thus delete the saved player data
+    if(!data.state.connected) {
+        console.log("skipping resuming player, because it already disconnected");
+        await deletedSavedPlayerData(data.guildId);
+        continue;
+    }
+    // now you can create the player based on the live and saved data
+    const player = client.lavalink.createPlayer({
+        guildId: data.guildId,
+        node: node.id,
+        // you need to update the volume of the player by the volume of lavalink which might got decremented by the volume decrementer
+        volume: client.lavalink.options.playerOptions?.volumeDecrementer
+        ? Math.round(data.volume / client.lavalink.options.playerOptions.volumeDecrementer)
+        : data.volume,
+        // all of the following options are needed to be provided by some sort of player saving
+        voiceChannelId: dataOfSaving.voiceChannelId,
+        textChannelId: dataOfSaving.textChannelId,
+        // all of the following options can either be saved too, or you can use pre-defined defaults
+        selfDeaf: dataOfSaving.options?.selfDeaf || true,
+        selfMute: dataOfSaving.options?.selfMute || false,
+
+        applyVolumeAsFilter: dataOfSaving.options.applyVolumeAsFilter,
+        instaUpdateFiltersFix: dataOfSaving.options.instaUpdateFiltersFix,
+        vcRegion: dataOfSaving.options.vcRegion,
+    });
+
+    // player.voice = data.voice;
+    // normally just player.voice is enough, but if you restart the entire bot, you need to create a new connection, thus call player.connect();
+    await player.connect();
+
+    player.filterManager.data = data.filters; // override the filters data
+    await player.queue.utils.sync(true, false); // get the queue data including the current track (for the requester)
+    // override the current track with the data from lavalink
+    if(data.track) player.queue.current = client.lavalink.utils.buildTrack(data.track, player.queue.current?.requester || client.user);
+    // override the position of the player
+    player.lastPosition = data.state.position;
+    player.lastPositionChange = Date.now();
+    // you can also override the ping of the player, or wait about 30s till it's done automatically
+    player.ping.lavalink = data.state.ping;
+    // important to have skipping work correctly later
+    player.paused = data.paused;
+    player.playing = !data.paused && !!data.track;
+    // That's about it
+  }
+})
+client.lavalink.on("playerUpdate", (oldPlayer, newPlayer) => { // automatically sync player data on updates. if you don'T want to save everything you can instead also just save the data on playerCreate
+    setSavedPlayerData(newPlayer.toJSON());
+});
+// delete the player again
+client.lavalink.on("playerDestroy", (player) => {
+    deleteSavedPlayerData(player.guildId);
+})
+```
 
 ***
 
@@ -228,7 +296,7 @@ const extraParams = new URLSearchParams();
 if(voice) extraParams.append(`voice`, voice);
 
 // all params for flowertts can be found here: https://flowery.pw/docs
-const response = await player.search({ 
+const response = await player.search({
   query: `${query}`,
   extraQueryUrlParams: extraParams, // as of my knowledge this is currently only used for flowertts, adjusting the playback url dynamically mid-request
   source: "ftts"
@@ -236,7 +304,7 @@ const response = await player.search({
 ```
 
 
-*** 
+***
 
 
 # UpdateLog
@@ -254,8 +322,8 @@ const response = await player.search({
   - `player.deleteSponsorBlock()` / `node.deleteSponsorBlock()`
     - That Plugin adds following **Events** to the **Manager**: `"SegmentsLoaded"`, `"SegmentSkipped"`, `"ChapterStarted"`, `"ChaptersLoaded"`
 - Example Bot show example in autoplayFunction how to "disable" / "enable" Autoplay with bot data variables.
-- Added `ManagerOptions#emitNewSongsOnly`. If set to true, it won't emit "trackStart" Event, when track.loop is active, or the new current track == the previous (current) track. 
-- Added `ManagerOptions#linksBlacklist` which allows user to specify an array of regExp / strings to match query strings (for links / words) and if a match happens it doesn't allow the request (blacklist) 
+- Added `ManagerOptions#emitNewSongsOnly`. If set to true, it won't emit "trackStart" Event, when track.loop is active, or the new current track == the previous (current) track.
+- Added `ManagerOptions#linksBlacklist` which allows user to specify an array of regExp / strings to match query strings (for links / words) and if a match happens it doesn't allow the request (blacklist)
 - Added `ManagerOptions#linksWhitelist` which allows user to specify an array of regExp / strings to match query strings (for links only) and if a match does NOT HAPPEN it doesn't allow the request (whitelist)
 - Added `ManagerOptions#linksAllowed` if set to false, it does not allow requests which are links
 - Moved `ManaagerOptions#debugOptions` to `ManaagerOptions#advancedOptions.debugOptions`
@@ -263,10 +331,10 @@ const response = await player.search({
 ### **Version 1.2.1**
 - Adjusted `player.stopPlaying()`
   - There are now following parameters. `stopPlaying(clearQueue:boolean = true, executeAutoplay:boolean = false)`.
-    - On Default it now clears the queue and stops playing. Also it does not execute Autoplay on default. IF you want the function to behave differently, you can use the 2 states for that. 
+    - On Default it now clears the queue and stops playing. Also it does not execute Autoplay on default. IF you want the function to behave differently, you can use the 2 states for that.
   - Fixed that it looped the current track if repeatmode === "track" / "queue". (it stops playing and loop stays)
 - Implemented a `parseLavalinkConnUrl(connectionUrl:string)` Util Function.
-  - It allows you to parse Lavalink Connection Data of a Lavalink Connection Url. 
+  - It allows you to parse Lavalink Connection Data of a Lavalink Connection Url.
   Pattern: `lavalink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>`
   - Note that the nodeId and NodeAuthorization must be encoded via encodeURIComponents before you provide it into the function.
   - The function will return the following: `{ id: string, authorization: string, host: string, port: number }`
@@ -298,10 +366,10 @@ const response = await player.search({
 # and after  connecting the nodeManager.on("resumed", (node, payload, players) => {}) will be executed, where you can sync the players!
 
 # Node Options got adjusted # It's a property not a method should be treated readonly
-+ node.resuming: { enabled: boolean, timeout: number | null }; 
++ node.resuming: { enabled: boolean, timeout: number | null };
 
 # Player function got added to stop playing without disconnecting
-+ player.stopPlaying(clearQueue:boolean = true, executeAutoplay:boolean = false); 
++ player.stopPlaying(clearQueue:boolean = true, executeAutoplay:boolean = false);
 
 # Node functions for sponsorBlock Plugin (https://github.com/topi314/Sponsorblock-Plugin) got added
 + deleteSponsorBlock(player:Player)
@@ -321,7 +389,7 @@ const response = await player.search({
 # Lavalink track.userData got added (basically same feature as my custom pluginInfo.clientData system)
 # You only get the track.userData data through playerUpdate object
 ```
-In one of the next updates, there will be more queueWatcher options and more custom nodeevents to trace 
+In one of the next updates, there will be more queueWatcher options and more custom nodeevents to trace
 
 Most features of this update got tested, but if you encounter any bugs feel free to open an issue!
 
@@ -378,9 +446,61 @@ const extraParams = new URLSearchParams();
 if(voice) extraParams.append(`voice`, voice);
 
 // all params for flowertts can be found here: https://flowery.pw/docs
-const response = await player.search({ 
+const response = await player.search({
   query: `${query}`,
   extraQueryUrlParams: extraParams, // as of my knowledge this is currently only used for flowertts, adjusting the playback url dynamically mid-request
   source: "ftts"
 }, interaction.user);
 ```
+
+
+## **Version 2.2.2**
+- Fixed a bug in player.pause() where when you pause the track longer than the left over currentTrack.info.duration is, then it would auto skip the track on resume.
+- Fixed the handling of the previous track array ( sometimes it adds "null", due to lavalink errors )
+- Added new functions for the queue, to make migrations and coding easier for beginners,
+  - ` const previousTrack = await player.queue.shiftPrevious() ` -> removes the previously played track from the player.queue.previous array, and returns it, so you can use it for something like "play previous"
+    - *Neat 1-liner: ` await player.queue.shiftPrevious().then(clientTrack => player.play({ clientTrack })) `*
+  - ` await player.queue.remove(removeQuery) ` -> Remove function to remove stuff from the queue.tracks array., following params are valid:
+    - Array of Tracks / UnresolvedTracks, e.g. ` await player.queue.remove( player.queue.tracks.slice(4, 10) ) ` *(would remove tracks from #4 (incl.) to #10 (excl.) aka those indexes: 4, 5, 6, 7, 8, 9 - this is how array.slice works)*
+    - Single Track / UnresolveTrack, e.g. ` await player.queue.remove(player.queue.tracks[player.queue.tracks.length - 1]); ` *(would remove the last track)*
+    - Array of track-indexes, e.g. ` await player.queue.remove([1, 4, 5]) ` *(Would remove track #1, #4 and #5)*
+    - Single track index, e.g. ` await player.queue.remove(5) ` *(would remove the #5 track from the queue)*
+    - **NOTE:** I still highly recommend, to use the ` player.queue.splice() ` function for mutating the queue:
+       - it is possible to remove single tracks, multiple tracks and insert tracks at specific positions!
+    - *the remove function haven't been fully tested yet*
+  - Added `track.pluginInfo.clientData?.previousTrack` handling:
+    - If a track has this property in the pluginInfo in the clientData object set to "true" then it won't get added to the previous track array. Example:
+```js
+const previousTrack = await player.queue.shiftPrevious();
+if(previousTrack) {
+    const previousClientData = previousTrack.pluginInfo.clientData || {};
+    previousTrack.pluginInfo.clientData = { previousTrack: true, ...previousClientData }
+    await player.play({ clientTrack: previousTrack });
+}
+```
+
+
+## **Version 2.3.0**
+
+- Added a heartbeat + ping-pong system to check wether the client is still connected to the node, if the node doesn't receive a ping in time, it will destroy the node and thus cause a reconnect.
+- For that following new nodeOptions got added:
+  - `enablePingOnStatsCheck: boolean` (default: true)
+  - `heartBeatInterval: number` (default: 30_000)
+  - Added new Property on a node:
+    - `isAlive: boolean` (if it's false, then it's not connected to the node anymore, and will AUTOMATICALLY Cause a reconnect within the heartBeatInterval)
+    - `heartBeatPing: number` (the ping it takes lavalink to respond to the acknowledge of heartbeat)
+  - Added new NodeManager Events:
+    - `reconnectinprogress` (when the client internal reconnect system is triggered, the actual reconnect gets triggered by the node after your retryDelay)
+- Refactored internal code for better readability and maintainability
+- Removed several intermediate promises
+- Added new types for better type safety
+- Updated types for better type safety
+- Reduced default retryDelay from 30s to 10s
+- Added example on the testbot how to store player data easily and how to use the resume feature, and updated the Resuming Example in the README [jump](#how-to-do-resuming) by adding a [full example](#resuming-full-example)
+
+- **"Breaking Change" for providing track / clientTrack for player.play()**
+  - Instead of adding the track to the queue and skipping to it, they get directly played by lavalink through replacing the track.
+  - To make this work, we need to pass the transformed requester object to the userData of the track. (all handled by the client)
+  - *This is technically better than skipping to a track but i wanted to point it out.*
+    - You can play with clientTrack like this: `player.play({ clientTrack: searchResult.tracks[0] })`
+    - You can play with just track like this: `player.play({ track: { encoded: "base64string..." }, requester: interaction.user })`

package/dist/cjs/index.d.ts

@@ -5,5 +5,11 @@ export * from "./structures/Node";
 export * from "./structures/NodeManager";
 export * from "./structures/Player";
 export * from "./structures/Queue";
-export * from "./structures/Track";
 export * from "./structures/Utils";
+export * from "./structures/Types/Track";
+export * from "./structures/Types/Utils";
+export * from "./structures/Types/Filters";
+export * from "./structures/Types/Player";
+export * from "./structures/Types/Queue";
+export * from "./structures/Types/Node";
+export * from "./structures/Constants";

package/dist/cjs/index.js

@@ -8,5 +8,11 @@ tslib_1.__exportStar(require("./structures/Node"), exports);
 tslib_1.__exportStar(require("./structures/NodeManager"), exports);
 tslib_1.__exportStar(require("./structures/Player"), exports);
 tslib_1.__exportStar(require("./structures/Queue"), exports);
-tslib_1.__exportStar(require("./structures/Track"), exports);
 tslib_1.__exportStar(require("./structures/Utils"), exports);
+tslib_1.__exportStar(require("./structures/Types/Track"), exports);
+tslib_1.__exportStar(require("./structures/Types/Utils"), exports);
+tslib_1.__exportStar(require("./structures/Types/Filters"), exports);
+tslib_1.__exportStar(require("./structures/Types/Player"), exports);
+tslib_1.__exportStar(require("./structures/Types/Queue"), exports);
+tslib_1.__exportStar(require("./structures/Types/Node"), exports);
+tslib_1.__exportStar(require("./structures/Constants"), exports);

package/dist/cjs/structures/Constants.d.ts

@@ -0,0 +1,40 @@
+import type { AudioOutputs, ChannelMixFilter, EQBand } from "./Types/Filters";
+export declare enum DestroyReasons {
+    QueueEmpty = "QueueEmpty",
+    NodeDestroy = "NodeDestroy",
+    NodeDeleted = "NodeDeleted",
+    LavalinkNoVoice = "LavalinkNoVoice",
+    NodeReconnectFail = "NodeReconnectFail",
+    Disconnected = "Disconnected",
+    PlayerReconnectFail = "PlayerReconnectFail",
+    ChannelDeleted = "ChannelDeleted",
+    DisconnectAllNodes = "DisconnectAllNodes",
+    ReconnectAllNodes = "ReconnectAllNodes"
+}
+export declare const validSponsorBlocks: string[];
+/**  The audio Outputs Data map declaration */
+export declare const audioOutputsData: Record<AudioOutputs, ChannelMixFilter>;
+export declare const EQList: {
+    /** A Bassboost Equalizer, so high it distorts the audio */
+    BassboostEarrape: EQBand[];
+    /** A High and decent Bassboost Equalizer */
+    BassboostHigh: EQBand[];
+    /** A decent Bassboost Equalizer */
+    BassboostMedium: EQBand[];
+    /** A slight Bassboost Equalizer */
+    BassboostLow: EQBand[];
+    /** Makes the Music slightly "better" */
+    BetterMusic: EQBand[];
+    /** Makes the Music sound like rock music / sound rock music better */
+    Rock: EQBand[];
+    /** Makes the Music sound like Classic music / sound Classic music better */
+    Classic: EQBand[];
+    /** Makes the Music sound like Pop music / sound Pop music better */
+    Pop: EQBand[];
+    /** Makes the Music sound like Electronic music / sound Electronic music better */
+    Electronic: EQBand[];
+    /** Boosts all Bands slightly for louder and fuller sound */
+    FullSound: EQBand[];
+    /** Boosts basses + lower highs for a pro gaming sound */
+    Gaming: EQBand[];
+};

package/dist/cjs/structures/Constants.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EQList = exports.audioOutputsData = exports.validSponsorBlocks = exports.DestroyReasons = void 0;
+var DestroyReasons;
+(function (DestroyReasons) {
+    DestroyReasons["QueueEmpty"] = "QueueEmpty";
+    DestroyReasons["NodeDestroy"] = "NodeDestroy";
+    DestroyReasons["NodeDeleted"] = "NodeDeleted";
+    DestroyReasons["LavalinkNoVoice"] = "LavalinkNoVoice";
+    DestroyReasons["NodeReconnectFail"] = "NodeReconnectFail";
+    DestroyReasons["Disconnected"] = "Disconnected";
+    DestroyReasons["PlayerReconnectFail"] = "PlayerReconnectFail";
+    DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
+    DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
+    DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";
+})(DestroyReasons || (exports.DestroyReasons = DestroyReasons = {}));
+;
+exports.validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];
+/**  The audio Outputs Data map declaration */
+exports.audioOutputsData = {
+    mono: {
+        leftToLeft: 0.5,
+        leftToRight: 0.5,
+        rightToLeft: 0.5,
+        rightToRight: 0.5,
+    },
+    stereo: {
+        leftToLeft: 1,
+        leftToRight: 0,
+        rightToLeft: 0,
+        rightToRight: 1,
+    },
+    left: {
+        leftToLeft: 1,
+        leftToRight: 0,
+        rightToLeft: 1,
+        rightToRight: 0,
+    },
+    right: {
+        leftToLeft: 0,
+        leftToRight: 1,
+        rightToLeft: 0,
+        rightToRight: 1,
+    },
+};
+exports.EQList = {
+    /** A Bassboost Equalizer, so high it distorts the audio */
+    BassboostEarrape: [
+        { band: 0, gain: 0.6 * 0.375 },
+        { band: 1, gain: 0.67 * 0.375 },
+        { band: 2, gain: 0.67 * 0.375 },
+        { band: 3, gain: 0.4 * 0.375 },
+        { band: 4, gain: -0.5 * 0.375 },
+        { band: 5, gain: 0.15 * 0.375 },
+        { band: 6, gain: -0.45 * 0.375 },
+        { band: 7, gain: 0.23 * 0.375 },
+        { band: 8, gain: 0.35 * 0.375 },
+        { band: 9, gain: 0.45 * 0.375 },
+        { band: 10, gain: 0.55 * 0.375 },
+        { band: 11, gain: -0.6 * 0.375 },
+        { band: 12, gain: 0.55 * 0.375 },
+        { band: 13, gain: -0.5 * 0.375 },
+        { band: 14, gain: -0.75 * 0.375 },
+    ],
+    /** A High and decent Bassboost Equalizer */
+    BassboostHigh: [
+        { band: 0, gain: 0.6 * 0.25 },
+        { band: 1, gain: 0.67 * 0.25 },
+        { band: 2, gain: 0.67 * 0.25 },
+        { band: 3, gain: 0.4 * 0.25 },
+        { band: 4, gain: -0.5 * 0.25 },
+        { band: 5, gain: 0.15 * 0.25 },
+        { band: 6, gain: -0.45 * 0.25 },
+        { band: 7, gain: 0.23 * 0.25 },
+        { band: 8, gain: 0.35 * 0.25 },
+        { band: 9, gain: 0.45 * 0.25 },
+        { band: 10, gain: 0.55 * 0.25 },
+        { band: 11, gain: -0.6 * 0.25 },
+        { band: 12, gain: 0.55 * 0.25 },
+        { band: 13, gain: -0.5 * 0.25 },
+        { band: 14, gain: -0.75 * 0.25 },
+    ],
+    /** A decent Bassboost Equalizer */
+    BassboostMedium: [
+        { band: 0, gain: 0.6 * 0.1875 },
+        { band: 1, gain: 0.67 * 0.1875 },
+        { band: 2, gain: 0.67 * 0.1875 },
+        { band: 3, gain: 0.4 * 0.1875 },
+        { band: 4, gain: -0.5 * 0.1875 },
+        { band: 5, gain: 0.15 * 0.1875 },
+        { band: 6, gain: -0.45 * 0.1875 },
+        { band: 7, gain: 0.23 * 0.1875 },
+        { band: 8, gain: 0.35 * 0.1875 },
+        { band: 9, gain: 0.45 * 0.1875 },
+        { band: 10, gain: 0.55 * 0.1875 },
+        { band: 11, gain: -0.6 * 0.1875 },
+        { band: 12, gain: 0.55 * 0.1875 },
+        { band: 13, gain: -0.5 * 0.1875 },
+        { band: 14, gain: -0.75 * 0.1875 },
+    ],
+    /** A slight Bassboost Equalizer */
+    BassboostLow: [
+        { band: 0, gain: 0.6 * 0.125 },
+        { band: 1, gain: 0.67 * 0.125 },
+        { band: 2, gain: 0.67 * 0.125 },
+        { band: 3, gain: 0.4 * 0.125 },
+        { band: 4, gain: -0.5 * 0.125 },
+        { band: 5, gain: 0.15 * 0.125 },
+        { band: 6, gain: -0.45 * 0.125 },
+        { band: 7, gain: 0.23 * 0.125 },
+        { band: 8, gain: 0.35 * 0.125 },
+        { band: 9, gain: 0.45 * 0.125 },
+        { band: 10, gain: 0.55 * 0.125 },
+        { band: 11, gain: -0.6 * 0.125 },
+        { band: 12, gain: 0.55 * 0.125 },
+        { band: 13, gain: -0.5 * 0.125 },
+        { band: 14, gain: -0.75 * 0.125 },
+    ],
+    /** Makes the Music slightly "better" */
+    BetterMusic: [
+        { band: 0, gain: 0.25 },
+        { band: 1, gain: 0.025 },
+        { band: 2, gain: 0.0125 },
+        { band: 3, gain: 0 },
+        { band: 4, gain: 0 },
+        { band: 5, gain: -0.0125 },
+        { band: 6, gain: -0.025 },
+        { band: 7, gain: -0.0175 },
+        { band: 8, gain: 0 },
+        { band: 9, gain: 0 },
+        { band: 10, gain: 0.0125 },
+        { band: 11, gain: 0.025 },
+        { band: 12, gain: 0.25 },
+        { band: 13, gain: 0.125 },
+        { band: 14, gain: 0.125 },
+    ],
+    /** Makes the Music sound like rock music / sound rock music better */
+    Rock: [
+        { band: 0, gain: 0.300 },
+        { band: 1, gain: 0.250 },
+        { band: 2, gain: 0.200 },
+        { band: 3, gain: 0.100 },
+        { band: 4, gain: 0.050 },
+        { band: 5, gain: -0.050 },
+        { band: 6, gain: -0.150 },
+        { band: 7, gain: -0.200 },
+        { band: 8, gain: -0.100 },
+        { band: 9, gain: -0.050 },
+        { band: 10, gain: 0.050 },
+        { band: 11, gain: 0.100 },
+        { band: 12, gain: 0.200 },
+        { band: 13, gain: 0.250 },
+        { band: 14, gain: 0.300 },
+    ],
+    /** Makes the Music sound like Classic music / sound Classic music better */
+    Classic: [
+        { band: 0, gain: 0.375 },
+        { band: 1, gain: 0.350 },
+        { band: 2, gain: 0.125 },
+        { band: 3, gain: 0 },
+        { band: 4, gain: 0 },
+        { band: 5, gain: 0.125 },
+        { band: 6, gain: 0.550 },
+        { band: 7, gain: 0.050 },
+        { band: 8, gain: 0.125 },
+        { band: 9, gain: 0.250 },
+        { band: 10, gain: 0.200 },
+        { band: 11, gain: 0.250 },
+        { band: 12, gain: 0.300 },
+        { band: 13, gain: 0.250 },
+        { band: 14, gain: 0.300 },
+    ],
+    /** Makes the Music sound like Pop music / sound Pop music better */
+    Pop: [
+        { band: 0, gain: 0.2635 },
+        { band: 1, gain: 0.22141 },
+        { band: 2, gain: -0.21141 },
+        { band: 3, gain: -0.1851 },
+        { band: 4, gain: -0.155 },
+        { band: 5, gain: 0.21141 },
+        { band: 6, gain: 0.22456 },
+        { band: 7, gain: 0.237 },
+        { band: 8, gain: 0.237 },
+        { band: 9, gain: 0.237 },
+        { band: 10, gain: -0.05 },
+        { band: 11, gain: -0.116 },
+        { band: 12, gain: 0.192 },
+        { band: 13, gain: 0 },
+    ],
+    /** Makes the Music sound like Electronic music / sound Electronic music better */
+    Electronic: [
+        { band: 0, gain: 0.375 },
+        { band: 1, gain: 0.350 },
+        { band: 2, gain: 0.125 },
+        { band: 3, gain: 0 },
+        { band: 4, gain: 0 },
+        { band: 5, gain: -0.125 },
+        { band: 6, gain: -0.125 },
+        { band: 7, gain: 0 },
+        { band: 8, gain: 0.25 },
+        { band: 9, gain: 0.125 },
+        { band: 10, gain: 0.15 },
+        { band: 11, gain: 0.2 },
+        { band: 12, gain: 0.250 },
+        { band: 13, gain: 0.350 },
+        { band: 14, gain: 0.400 },
+    ],
+    /** Boosts all Bands slightly for louder and fuller sound */
+    FullSound: [
+        { band: 0, gain: 0.25 + 0.375 },
+        { band: 1, gain: 0.25 + 0.025 },
+        { band: 2, gain: 0.25 + 0.0125 },
+        { band: 3, gain: 0.25 + 0 },
+        { band: 4, gain: 0.25 + 0 },
+        { band: 5, gain: 0.25 + -0.0125 },
+        { band: 6, gain: 0.25 + -0.025 },
+        { band: 7, gain: 0.25 + -0.0175 },
+        { band: 8, gain: 0.25 + 0 },
+        { band: 9, gain: 0.25 + 0 },
+        { band: 10, gain: 0.25 + 0.0125 },
+        { band: 11, gain: 0.25 + 0.025 },
+        { band: 12, gain: 0.25 + 0.375 },
+        { band: 13, gain: 0.25 + 0.125 },
+        { band: 14, gain: 0.25 + 0.125 },
+    ],
+    /** Boosts basses + lower highs for a pro gaming sound */
+    Gaming: [
+        { band: 0, gain: 0.350 },
+        { band: 1, gain: 0.300 },
+        { band: 2, gain: 0.250 },
+        { band: 3, gain: 0.200 },
+        { band: 4, gain: 0.150 },
+        { band: 5, gain: 0.100 },
+        { band: 6, gain: 0.050 },
+        { band: 7, gain: -0.0 },
+        { band: 8, gain: -0.050 },
+        { band: 9, gain: -0.100 },
+        { band: 10, gain: -0.150 },
+        { band: 11, gain: -0.200 },
+        { band: 12, gain: -0.250 },
+        { band: 13, gain: -0.300 },
+        { band: 14, gain: -0.350 },
+    ],
+};

package/dist/cjs/structures/CustomSearches/BandCampSearch.d.ts

@@ -1,3 +1,3 @@
-import { Player } from "../Player";
-import { UnresolvedSearchResult } from "../Utils";
+import type { Player } from "../Player";
+import type { UnresolvedSearchResult } from "../Types/Utils";
 export declare const bandCampSearch: (player: Player, query: string, requestUser: unknown) => Promise<UnresolvedSearchResult>;