shoukaku-bun 4.2.0-b

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luigi Colantuono
+
+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,88 @@
+## Shoukaku-Bun
+
+> Powerfull, Lightweight wrapper around Lavalink
+
+[![Discord](https://img.shields.io/discord/423116740810244097?style=flat-square)](https://discordapp.com/invite/FVqbtGu)
+[![npm](https://img.shields.io/npm/v/shoukaku?style=flat-square)](https://www.npmjs.com/package/shoukaku)
+![Github Stars](https://img.shields.io/github/stars/Deivu/Shoukaku?style=flat-square)
+![GitHub issues](https://img.shields.io/github/issues-raw/Deivu/Shoukaku?style=flat-square)
+![NPM](https://img.shields.io/npm/l/shoukaku?style=flat-square)
+
+<p align="center">
+    <img src="https://azurlane.netojuu.com/images/thumb/d/dc/ShoukakuWeddingWithoutBG.png/767px-ShoukakuWeddingWithoutBG.png"> 
+</p>
+
+### Features
+
+- **Bun-Native**: Re-engineered to run exclusively on Bun.Purged all Node.js legacy dependencies (like `ws`).
+- **Zero Latency**: Uses Bun's kernel-level WebSocket for maximum throughput.
+- **Ultra Lightweight**: Optimized for minimal memory footprint (production tested at ~33MB).
+- **TypeScript Native**: No build step required. Direct execution from source.
+- **Stable & Updated**: Based on the rock-solid Shoukaku v4.2.0 logic.
+- **Very cute (Very Important)**
+
+### Documentation
+
+> https://guide.shoukaku.shipgirl.moe/
+
+### Installation
+
+This is a specialized fork. Install it directly from GitHub:
+
+```bash
+bun add github:LuigiColantuono/shoukaku-bun
+```
+
+### Documentation
+
+> https://guide.shoukaku.shipgirl.moe/
+
+### Getting Started
+
+> https://guide.shoukaku.shipgirl.moe/guides/1-getting-started/
+
+### Supported Libraries
+
+> https://guide.shoukaku.shipgirl.moe/guides/5-connectors/
+
+### Example Bot
+
+> https://github.com/Deivu/Kongou
+
+### Configuration Options
+
+```js
+// Parameters for main class init, Options is the Configuration Options
+new Shoukaku(new Connectors.DiscordJS(client), Nodes, Options);
+```
+
+| Option                 | Type                   | Default  | Description                                                                                      | Notes                    |
+| ---------------------- | ---------------------- | -------- | ------------------------------------------------------------------------------------------------ | ------------------------ |
+| resume                 | boolean                | false    | If you want to enable resuming when your connection to lavalink disconnects |                          |
+| resumeTimeout          | number                 | 30       | Timeout before lavalink destroys the players on a disconnect                                     | In seconds               |
+| resumeByLibrary        | boolean                | false    | If you want to force resume players no matter what even if it's not resumable by lavalink        |                          |
+| reconnectTries         | number                 | 3        | Number of tries to reconnect to lavalink before disconnecting                                    |                          |
+| reconnectInterval      | number                 | 5        | Timeout between reconnects                                                                       | In seconds               |
+| restTimeout            | number                 | 60       | Maximum amount of time to wait for rest lavalink api requests                                    | In seconds               |
+| moveOnDisconnect       | boolean                | false    | Whether to move players to a different lavalink node when a node disconnects                     |                          |
+| userAgent              | string                 | (auto)   | Changes the user-agent used for lavalink requests                                                | Not recommeded to change |
+| structures             | Object{rest?, player?} | {}       | Custom structures for shoukaku to use                                                            |                          |
+| voiceConnectionTimeout | number                 | 15       | Maximum amount of time to wait for a join voice channel command                                  | In seconds               |
+| nodeResolver           | function               | function | Custom node resolver if you want to have your own method of getting the ideal node               |                          |
+
+### Wrappers
+
+| Name     | Link                                          | Description                                              |
+| -------- | --------------------------------------------- | -------------------------------------------------------- |
+| Kazagumo | [Github](https://github.com/Takiyo0/Kazagumo) | A wrapper for Shoukaku that has an internal queue system |
+
+> Open a pr if you want to add a wrapper here
+
+### Other Links
+
+- [Discord](https://discord.gg/XqJw52d35R)
+
+- [Lavalink](https://github.com/lavalink-devs/Lavalink)
+
+### Code made with ❤ by @ichimakase (Saya) & Luigi
+

package/index.ts

@@ -0,0 +1,9 @@
+export * as Connectors from './src/connectors/libs';
+export * as Constants from './src/Constants';
+export * as Utils from './src/Utils';
+export * from './src/connectors/Connector';
+export * from './src/guild/Connection';
+export * from './src/guild/Player';
+export * from './src/node/Node';
+export * from './src/node/Rest';
+export * from './src/Shoukaku';

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "shoukaku-bun",
+  "version": "4.2.0-b",
+  "description": "Bun-native high-performance fork of Shoukaku. Node-dependencies purged.",
+  "main": "index.ts",
+  "module": "index.ts",
+  "types": "index.ts",
+  "files": [
+    "src",
+    "index.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "import": "./index.ts",
+      "require": "./index.ts"
+    }
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "bun test"
+  },
+  "keywords": [
+    "bot",
+    "music",
+    "lavalink",
+    "bun",
+    "high-performance",
+    "discord"
+  ],
+  "engines": {
+    "bun": "1.3.6"
+  },
+  "author": "Saya",
+  "contributors": [
+    {
+      "name": "Luigi Colantuono",
+      "url": "https://github.com/LuigiColantuono",
+      "info": "Bun Refactor & Optimization"
+    }
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/LuigiColantuono/shoukaku-bun",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LuigiColantuono/shoukaku-bun.git"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@shipgirl/eslint-config": "^0.2.2",
+    "@types/bun": "latest",
+    "eslint": "^9.39.2",
+    "typedoc": "^0.28.16",
+    "typescript": "^5.9.3"
+  }
+}

package/src/Constants.ts

@@ -0,0 +1,55 @@
+import Info from '../package.json';
+import type { NodeOption, ShoukakuOptions } from './Shoukaku';
+
+export enum State {
+	CONNECTING,
+	CONNECTED,
+	DISCONNECTING,
+	DISCONNECTED
+}
+
+export enum VoiceState {
+	SESSION_READY,
+	SESSION_ID_MISSING,
+	SESSION_ENDPOINT_MISSING,
+	SESSION_FAILED_UPDATE
+}
+
+export enum OpCodes {
+	PLAYER_UPDATE = 'playerUpdate',
+	STATS = 'stats',
+	EVENT = 'event',
+	READY = 'ready'
+}
+
+export const Versions = {
+	REST_VERSION: 4,
+	WEBSOCKET_VERSION: 4
+};
+
+export const ShoukakuDefaults: Required<ShoukakuOptions> = {
+	resume: false,
+	resumeTimeout: 30,
+	resumeByLibrary: false,
+	reconnectTries: 3,
+	reconnectInterval: 5,
+	restTimeout: 60,
+	moveOnDisconnect: false,
+	userAgent: 'Discord Bot/unknown (https://github.com/shipgirlproject/Shoukaku.git)',
+	structures: {},
+	voiceConnectionTimeout: 15,
+	nodeResolver: (nodes) => [ ...nodes.values() ]
+		.filter(node => node.state === State.CONNECTED)
+		.sort((a, b) => a.penalties - b.penalties)
+		.shift()
+};
+
+export const ShoukakuClientInfo = `${Info.name}/${Info.version} (${Info.repository.url})`;
+
+export const NodeDefaults: NodeOption = {
+	name: 'Default',
+	url: '',
+	auth: '',
+	secure: false,
+	group: undefined
+};

package/src/Shoukaku.ts

@@ -0,0 +1,295 @@
+import { ShoukakuDefaults, VoiceState } from './Constants';
+import { Node } from './node/Node';
+import { Connector } from './connectors/Connector';
+import { Constructor, mergeDefault, TypedEventEmitter } from './Utils';
+import { Player } from './guild/Player';
+import { Rest } from './node/Rest';
+import { Connection } from './guild/Connection';
+
+export interface Structures {
+	/**
+     * A custom structure that extends the Rest class
+     */
+	rest?: Constructor<Rest>;
+	/**
+     * A custom structure that extends the Player class
+     */
+	player?: Constructor<Player>;
+}
+
+export interface NodeOption {
+	/**
+     * Name of the Lavalink node
+     */
+	name: string;
+	/**
+     * Lavalink node host and port without any prefix
+     */
+	url: string;
+	/**
+     * Credentials to access Lavalink
+     */
+	auth: string;
+	/**
+     * Whether to use secure protocols or not
+     */
+	secure?: boolean;
+	/**
+     * Name of the Lavalink node group
+     */
+	group?: string;
+}
+
+export interface ShoukakuOptions {
+	/**
+     * Whether to resume a connection on disconnect to Lavalink (Server Side) (Note: DOES NOT RESUME WHEN THE LAVALINK SERVER DIES)
+     */
+	resume?: boolean;
+	/**
+     * Time to wait before lavalink starts to destroy the players of the disconnected client
+     */
+	resumeTimeout?: number;
+	/**
+     * Whether to resume the players by doing it in the library side (Client Side) (Note: TRIES TO RESUME REGARDLESS OF WHAT HAPPENED ON A LAVALINK SERVER)
+     */
+	resumeByLibrary?: boolean;
+	/**
+     * Number of times to try and reconnect to Lavalink before giving up
+     */
+	reconnectTries?: number;
+	/**
+     * Timeout before trying to reconnect
+     */
+	reconnectInterval?: number;
+	/**
+     * Time to wait for a response from the Lavalink REST API before giving up
+     */
+	restTimeout?: number;
+	/**
+     * Whether to move players to a different Lavalink node when a node disconnects
+     */
+	moveOnDisconnect?: boolean;
+	/**
+     * User Agent to use when making requests to Lavalink
+     */
+	userAgent?: string;
+	/**
+     * Custom structures for shoukaku to use
+     */
+	structures?: Structures;
+	/**
+     * Timeout before abort connection
+     */
+	voiceConnectionTimeout?: number;
+	/**
+     * Node Resolver to use if you want to customize it
+     */
+	nodeResolver?: (nodes: Map<string, Node>, connection?: Connection) => Node | undefined;
+}
+
+export interface VoiceChannelOptions {
+	guildId: string;
+	shardId: number;
+	channelId: string;
+	deaf?: boolean;
+	mute?: boolean;
+}
+
+// Interfaces are not final, but types are, and therefore has an index signature
+// https://stackoverflow.com/a/64970740
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export type ShoukakuEvents = {
+	/**
+     * Emitted when reconnect tries are occurring and how many tries are left
+     * @eventProperty
+     */
+	'reconnecting': [name: string, reconnectsLeft: number, reconnectInterval: number];
+	/**
+     * Emitted when data useful for debugging is produced
+     * @eventProperty
+     */
+	'debug': [name: string, info: string];
+	/**
+     * Emitted when an error occurs
+     * @eventProperty
+     */
+	'error': [name: string, error: Error];
+	/**
+     * Emitted when Shoukaku is ready to receive operations
+     * @eventProperty
+     */
+	'ready': [name: string, lavalinkResume: boolean, libraryResume: boolean];
+	/**
+     * Emitted when a websocket connection to Lavalink closes
+     * @eventProperty
+     */
+	'close': [name: string, code: number, reason: string];
+	/**
+     * Emitted when a websocket connection to Lavalink disconnects
+     * @eventProperty
+     */
+	'disconnect': [name: string, count: number];
+	/**
+     * Emitted when a raw message is received from Lavalink
+     * @eventProperty
+     */
+	'raw': [name: string, json: unknown];
+};
+
+/**
+ * Main Shoukaku class
+ */
+export class Shoukaku extends TypedEventEmitter<ShoukakuEvents> {
+	/**
+     * Discord library connector
+     */
+	public readonly connector: Connector;
+	/**
+     * Shoukaku options
+     */
+	public readonly options: Required<ShoukakuOptions>;
+	/**
+     * Connected Lavalink nodes
+     */
+	public readonly nodes: Map<string, Node>;
+	/**
+     * Voice connections being handled
+     */
+	public readonly connections: Map<string, Connection>;
+	/**
+     * Players being handled
+     */
+	public readonly players: Map<string, Player>;
+	/**
+     * Shoukaku instance identifier
+     */
+	public id: string | null;
+	/**
+     * @param connector A Discord library connector
+     * @param nodes An array that conforms to the NodeOption type that specifies nodes to connect to
+     * @param options Options to pass to create this Shoukaku instance
+     * @param options.resume Whether to resume a connection on disconnect to Lavalink (Server Side) (Note: DOES NOT RESUME WHEN THE LAVALINK SERVER DIES)
+     * @param options.resumeTimeout Time to wait before lavalink starts to destroy the players of the disconnected client
+     * @param options.resumeByLibrary Whether to resume the players by doing it in the library side (Client Side) (Note: TRIES TO RESUME REGARDLESS OF WHAT HAPPENED ON A LAVALINK SERVER)
+     * @param options.reconnectTries Number of times to try and reconnect to Lavalink before giving up
+     * @param options.reconnectInterval Timeout before trying to reconnect
+     * @param options.restTimeout Time to wait for a response from the Lavalink REST API before giving up
+     * @param options.moveOnDisconnect Whether to move players to a different Lavalink node when a node disconnects
+     * @param options.userAgent User Agent to use when making requests to Lavalink
+     * @param options.structures Custom structures for shoukaku to use
+     * @param options.nodeResolver Used if you have custom lavalink node resolving
+     */
+	constructor(connector: Connector, nodes: NodeOption[], options: ShoukakuOptions = {}) {
+		super();
+		this.connector = connector.set(this);
+		this.options = mergeDefault<ShoukakuOptions>(ShoukakuDefaults, options);
+		this.nodes = new Map();
+		this.connections = new Map();
+		this.players = new Map();
+		this.id = null;
+		this.connector.listen(nodes);
+	}
+
+	/**
+     * Gets an ideal node based on the nodeResolver you provided
+     * @param connection Optional connection class for ideal node selection, if you use it
+     * @returns An ideal node for you to do things with
+     */
+	public getIdealNode(connection?: Connection): Node | undefined {
+		return this.options.nodeResolver(this.nodes, connection);
+	}
+
+	/**
+     * Add a Lavalink node to the pool of available nodes
+     * @param options.name Name of this node
+     * @param options.url URL of Lavalink
+     * @param options.auth Credentials to access Lavalink
+     * @param options.secure Whether to use secure protocols or not
+     * @param options.group Group of this node
+     */
+	public addNode(options: NodeOption): void {
+		const node = new Node(this, options);
+		node.on('debug', (...args) => this.emit('debug', node.name, ...args));
+		node.on('reconnecting', (...args) => this.emit('reconnecting', node.name, ...args));
+		node.on('error', (...args) => this.emit('error', node.name, ...args));
+		node.on('close', (...args) => this.emit('close', node.name, ...args));
+		node.on('ready', (...args) => this.emit('ready', node.name, ...args));
+		node.on('raw', (...args) => this.emit('raw', node.name, ...args));
+		node.once('disconnect', () => this.nodes.delete(node.name));
+		node.connect().catch((error) => this.emit('error', node.name, error as Error));
+		this.nodes.set(node.name, node);
+	}
+
+	/**
+     * Remove a Lavalink node from the pool of available nodes
+     * @param name Name of the node
+     * @param reason Reason of removing the node
+     */
+	public removeNode(name: string, reason = 'Remove node executed'): void {
+		const node = this.nodes.get(name);
+		if (!node) throw new Error('The node name you specified doesn\'t exist');
+		node.disconnect(1000, reason);
+		this.nodes.delete(name);
+	}
+
+	/**
+     * Joins a voice channel
+     * @param options.guildId GuildId in which the ChannelId of the voice channel is located
+     * @param options.shardId ShardId to track where this should send on sharded websockets, put 0 if you are unsharded
+     * @param options.channelId ChannelId of the voice channel you want to connect to
+     * @param options.deaf Optional boolean value to specify whether to deafen or undeafen the current bot user
+     * @param options.mute Optional boolean value to specify whether to mute or unmute the current bot user
+     * @returns The created player
+     */
+	public async joinVoiceChannel(options: VoiceChannelOptions): Promise<Player> {
+		if (this.connections.has(options.guildId))
+			throw new Error('This guild already have an existing connection');
+		const connection = new Connection(this, options);
+		this.connections.set(connection.guildId, connection);
+		try {
+			await connection.connect();
+		} catch (error) {
+			this.connections.delete(options.guildId);
+			throw error;
+		}
+		try {
+			const node = this.getIdealNode(connection);
+			if (!node)
+				throw new Error('Can\'t find any nodes to connect on');
+			const player = this.options.structures.player ? new this.options.structures.player(connection.guildId, node) : new Player(connection.guildId, node);
+			const onUpdate = (state: VoiceState) => {
+				if (state !== VoiceState.SESSION_READY) return;
+				void player.sendServerUpdate(connection);
+			};
+			await player.sendServerUpdate(connection);
+			connection.on('connectionUpdate', onUpdate);
+			this.players.set(player.guildId, player);
+			return player;
+		} catch (error) {
+			connection.disconnect();
+			this.connections.delete(options.guildId);
+			throw error;
+		}
+	}
+
+	/**
+     * Leaves a voice channel
+     * @param guildId The id of the guild you want to delete
+     * @returns The destroyed / disconnected player or undefined if none
+     */
+	public async leaveVoiceChannel(guildId: string): Promise<void> {
+		const connection = this.connections.get(guildId);
+		if (connection) {
+			connection.disconnect();
+			this.connections.delete(guildId);
+		}
+		const player = this.players.get(guildId);
+		if (player) {
+			try {
+				await player.destroy();
+			} catch { /* empty */ }
+			player.clean();
+			this.players.delete(guildId);
+		}
+	}
+}

package/src/Utils.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'node:events';
+
+// https://stackoverflow.com/a/67244127
+export abstract class TypedEventEmitter<T extends Record<string, unknown[]>> extends EventEmitter {
+	protected constructor() {
+		super();
+	}
+
+	on<K extends Extract<keyof T, string> | symbol>(eventName: K, listener: (...args: T[Extract<K, string>]) => void): this {
+		return super.on(eventName, listener);
+	}
+
+	once<K extends Extract<keyof T, string> | symbol>(eventName: K, listener: (...args: T[Extract<K, string>]) => void): this {
+		return super.once(eventName, listener);
+	}
+
+	off<K extends Extract<keyof T, string> | symbol>(eventName: K, listener: (...args: T[Extract<K, string>]) => void): this {
+		return super.off(eventName, listener);
+	}
+
+	emit<K extends Extract<keyof T, string> | symbol>(eventName: K, ...args: T[Extract<K, string>]): boolean {
+		return super.emit(eventName, ...args);
+	}
+}
+
+export type Constructor<T> = new (...args: unknown[]) => T;
+
+/**
+ * Merge the default options to user input
+ * @param def Default options
+ * @param given User input
+ * @returns Merged options
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mergeDefault<T extends Record<string, any>>(def: T, given: T): Required<T> {
+	if (!given) return def as Required<T>;
+	const defaultKeys: (keyof T)[] = Object.keys(def);
+	for (const key in given) {
+		if (defaultKeys.includes(key)) continue;
+		delete given[key];
+	}
+	for (const key of defaultKeys) {
+		if (def[key] === null || (typeof def[key] === 'string' && def[key].length === 0)) {
+			if (!given[key]) throw new Error(`${String(key)} was not found from the given options.`);
+		}
+		given[key] ??= def[key];
+	}
+	return given as Required<T>;
+}
+
+/**
+ * Wait for a specific amount of time (timeout)
+ * @param ms Time to wait in milliseconds
+ * @returns A promise that resolves in x seconds
+ */
+export function wait(ms: number): Promise<void> {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/connectors/Connector.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+import { NodeDefaults } from '../Constants';
+import type { ServerUpdate, StateUpdatePartial } from '../guild/Connection';
+import type { NodeOption, Shoukaku } from '../Shoukaku';
+import { mergeDefault } from '../Utils';
+
+export interface ConnectorMethods {
+	sendPacket: any;
+	getId: any;
+}
+
+export const AllowedPackets = [ 'VOICE_STATE_UPDATE', 'VOICE_SERVER_UPDATE' ];
+
+export abstract class Connector {
+	protected readonly client: any;
+	protected manager: Shoukaku | null;
+	constructor(client: any) {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		this.client = client;
+		this.manager = null;
+	}
+
+	public set(manager: Shoukaku): Connector {
+		this.manager = manager;
+		return this;
+	}
+
+	protected ready(nodes: NodeOption[]): void {
+		this.manager!.id = this.getId();
+		for (const node of nodes) this.manager!.addNode(mergeDefault(NodeDefaults, node));
+	}
+
+	protected raw(packet: any): void {
+		if (!AllowedPackets.includes(packet.t as string)) return;
+		const guildId = packet.d.guild_id as string;
+		const connection = this.manager!.connections.get(guildId);
+		if (!connection) return;
+		if (packet.t === 'VOICE_SERVER_UPDATE') return connection.setServerUpdate(packet.d as ServerUpdate);
+		const userId = packet.d.user_id as string;
+		if (userId !== this.manager!.id) return;
+		connection.setStateUpdate(packet.d as StateUpdatePartial);
+	}
+
+	abstract getId(): string;
+
+	abstract sendPacket(shardId: number, payload: unknown, important: boolean): void;
+
+	abstract listen(nodes: NodeOption[]): void;
+}

package/src/connectors/README.md

@@ -0,0 +1,42 @@
+## Supported Libs
+
+> [Discord.JS](https://discord.js.org/#/) (v13.x.x & 14.x.x)
+
+```js
+const { Shoukaku, Connectors } = require('shoukaku');
+new Shoukaku(new Connectors.DiscordJS(client), servers, options);
+```
+
+> [Eris](https://abal.moe/Eris/) (0.15.x / 0.16.x / 0.17.x)
+
+```js
+const { Shoukaku, Connectors } = require('shoukaku');
+new Shoukaku(new Connectors.Eris(client), servers, options)
+```
+
+> [Oceanic.JS](https://oceanic.ws/) (1.0.x)
+
+```js
+const { Shoukaku, Connectors } = require('shoukaku');
+new Shoukaku(new Connectors.OceanicJS(client), servers, options)
+```
+
+> [Seyfert](https://seyfert-docs.vercel.app/) (0.1.x)
+
+```js
+const { Shoukaku, Connectors } = require('shoukaku');
+new Shoukaku(new Connectors.Seyfert(client), servers, options)
+```
+
+
+> Implement your own 
+
+## Implementing your own
+
+> Check **DiscordJS.ts** or **Eris.ts** inside libs folder for a detailed explanation on how to support a library
+
+> And Submit a PR so other people don't need to do it themselves, yay!
+
+## Support
+
+For questions on how to do so, just ask at my support server at [HERE](https://discord.gg/FVqbtGu) (#Development)