@harmonia-audio/voice 0.1.0

package/dist/index.js

@@ -0,0 +1,919 @@
+import { EventEmitter } from 'events';
+import dgram from 'dgram';
+import WebSocket from 'ws';
+import { parseRtpHeader, buildRtpHeader, configureSocketForAudio, xchacha20Encrypt, secretboxEncrypt, randomBytes, xchacha20Decrypt, secretboxDecrypt } from '@harmonia-audio/native';
+import { OpusDecoder, OpusEncoderStream } from '@harmonia-audio/codec';
+import { Readable } from 'stream';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var NONCE_SIZE_XSALSA20 = 24;
+var NONCE_SIZE_LITE = 4;
+var EncryptionMode = /* @__PURE__ */ ((EncryptionMode2) => {
+  EncryptionMode2["XSalsa20Poly1305"] = "xsalsa20_poly1305";
+  EncryptionMode2["XSalsa20Poly1305Suffix"] = "xsalsa20_poly1305_suffix";
+  EncryptionMode2["XSalsa20Poly1305Lite"] = "xsalsa20_poly1305_lite";
+  EncryptionMode2["AeadAes256Gcm"] = "aead_aes256_gcm";
+  EncryptionMode2["AeadXChaCha20Poly1305"] = "aead_xchacha20_poly1305_rtpsize";
+  return EncryptionMode2;
+})(EncryptionMode || {});
+var PREFERRED_MODES = [
+  "aead_xchacha20_poly1305_rtpsize" /* AeadXChaCha20Poly1305 */,
+  "aead_aes256_gcm" /* AeadAes256Gcm */,
+  "xsalsa20_poly1305_lite" /* XSalsa20Poly1305Lite */,
+  "xsalsa20_poly1305_suffix" /* XSalsa20Poly1305Suffix */,
+  "xsalsa20_poly1305" /* XSalsa20Poly1305 */
+];
+function selectEncryptionMode(available) {
+  for (const preferred of PREFERRED_MODES) {
+    if (available.includes(preferred)) {
+      return preferred;
+    }
+  }
+  const first = available[0];
+  if (first !== void 0) {
+    return first;
+  }
+  return "xsalsa20_poly1305" /* XSalsa20Poly1305 */;
+}
+function encryptOpusPacket(rtpHeader, payload, secretKey, mode, nonceCounter) {
+  switch (mode) {
+    case "xsalsa20_poly1305" /* XSalsa20Poly1305 */: {
+      const nonce = Buffer.alloc(NONCE_SIZE_XSALSA20);
+      rtpHeader.copy(nonce, 0, 0, 12);
+      const encrypted = secretboxEncrypt(payload, nonce, secretKey);
+      return Buffer.concat([rtpHeader, encrypted]);
+    }
+    case "xsalsa20_poly1305_suffix" /* XSalsa20Poly1305Suffix */: {
+      const nonce = randomBytes(NONCE_SIZE_XSALSA20);
+      const encrypted = secretboxEncrypt(payload, nonce, secretKey);
+      return Buffer.concat([rtpHeader, encrypted, nonce]);
+    }
+    case "xsalsa20_poly1305_lite" /* XSalsa20Poly1305Lite */: {
+      const nonce = Buffer.alloc(NONCE_SIZE_XSALSA20);
+      nonce.writeUInt32BE(nonceCounter, 0);
+      const encrypted = secretboxEncrypt(payload, nonce, secretKey);
+      const nonceAppend = Buffer.alloc(NONCE_SIZE_LITE);
+      nonceAppend.writeUInt32BE(nonceCounter, 0);
+      return Buffer.concat([rtpHeader, encrypted, nonceAppend]);
+    }
+    case "aead_xchacha20_poly1305_rtpsize" /* AeadXChaCha20Poly1305 */: {
+      const nonce = Buffer.alloc(24);
+      nonce.writeUInt32BE(nonceCounter, 0);
+      const encrypted = xchacha20Encrypt(payload, nonce, secretKey, rtpHeader);
+      const nonceAppend = Buffer.alloc(4);
+      nonceAppend.writeUInt32BE(nonceCounter, 0);
+      return Buffer.concat([rtpHeader, encrypted, nonceAppend]);
+    }
+    default:
+      return Buffer.concat([rtpHeader, payload]);
+  }
+}
+function decryptOpusPacket(packet, secretKey, mode) {
+  const rtpHeader = packet.subarray(0, 12);
+  switch (mode) {
+    case "xsalsa20_poly1305" /* XSalsa20Poly1305 */: {
+      const nonce = Buffer.alloc(NONCE_SIZE_XSALSA20);
+      rtpHeader.copy(nonce, 0, 0, 12);
+      const ciphertext = packet.subarray(12);
+      return secretboxDecrypt(ciphertext, nonce, secretKey);
+    }
+    case "xsalsa20_poly1305_suffix" /* XSalsa20Poly1305Suffix */: {
+      const nonce = packet.subarray(packet.length - NONCE_SIZE_XSALSA20);
+      const ciphertext = packet.subarray(12, packet.length - NONCE_SIZE_XSALSA20);
+      return secretboxDecrypt(ciphertext, nonce, secretKey);
+    }
+    case "xsalsa20_poly1305_lite" /* XSalsa20Poly1305Lite */: {
+      const nonce = Buffer.alloc(NONCE_SIZE_XSALSA20);
+      const nonceFragment = packet.subarray(packet.length - NONCE_SIZE_LITE);
+      nonceFragment.copy(nonce, 0, 0, NONCE_SIZE_LITE);
+      const ciphertext = packet.subarray(12, packet.length - NONCE_SIZE_LITE);
+      return secretboxDecrypt(ciphertext, nonce, secretKey);
+    }
+    case "aead_xchacha20_poly1305_rtpsize" /* AeadXChaCha20Poly1305 */: {
+      const nonce = Buffer.alloc(24);
+      const nonceFragment = packet.subarray(packet.length - 4);
+      nonceFragment.copy(nonce, 0, 0, 4);
+      const ciphertext = packet.subarray(12, packet.length - 4);
+      return xchacha20Decrypt(ciphertext, nonce, secretKey, rtpHeader);
+    }
+    default: {
+      return packet.subarray(12);
+    }
+  }
+}
+
+// src/errors.ts
+var HarmoniaVoiceError = class extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}) {
+    super(message);
+    this.name = "HarmoniaVoiceError";
+    this.code = code;
+    this.context = context;
+  }
+};
+
+// src/store.ts
+var connections = /* @__PURE__ */ new Map();
+function getVoiceConnection(guildId) {
+  return connections.get(guildId);
+}
+function getVoiceConnections() {
+  return connections;
+}
+function setVoiceConnection(guildId, connection) {
+  connections.set(guildId, connection);
+}
+function removeVoiceConnection(guildId) {
+  connections.delete(guildId);
+}
+
+// src/types.ts
+var VoiceConnectionState = /* @__PURE__ */ ((VoiceConnectionState2) => {
+  VoiceConnectionState2["Idle"] = "idle";
+  VoiceConnectionState2["Signalling"] = "signalling";
+  VoiceConnectionState2["Connecting"] = "connecting";
+  VoiceConnectionState2["Ready"] = "ready";
+  VoiceConnectionState2["Resuming"] = "resuming";
+  VoiceConnectionState2["Disconnected"] = "disconnected";
+  VoiceConnectionState2["Destroyed"] = "destroyed";
+  return VoiceConnectionState2;
+})(VoiceConnectionState || {});
+var AudioPlayerState = /* @__PURE__ */ ((AudioPlayerState2) => {
+  AudioPlayerState2["Idle"] = "idle";
+  AudioPlayerState2["Buffering"] = "buffering";
+  AudioPlayerState2["Playing"] = "playing";
+  AudioPlayerState2["Paused"] = "paused";
+  AudioPlayerState2["AutoPaused"] = "autopaused";
+  return AudioPlayerState2;
+})(AudioPlayerState || {});
+var UserAudioStream = class extends Readable {
+  userId;
+  constructor(userId) {
+    super({ objectMode: false });
+    this.userId = userId;
+  }
+  _read() {
+  }
+};
+var AudioReceiver = class extends EventEmitter {
+  connection;
+  ssrcMap = /* @__PURE__ */ new Map();
+  userSsrcMap = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Map();
+  constructor(connection) {
+    super();
+    this.connection = connection;
+  }
+  /**
+   * Subscribe to audio from a specific user.
+   *
+   * @param userId - The Discord user ID to receive audio from
+   * @returns A readable stream of PCM audio from that user
+   *
+   * @example
+   * ```ts
+   * const stream = receiver.subscribe('123456789');
+   * stream.pipe(fileWriteStream);
+   * ```
+   */
+  subscribe(userId) {
+    const existing = this.subscriptions.get(userId);
+    if (existing) {
+      return existing;
+    }
+    const stream = new UserAudioStream(userId);
+    this.subscriptions.set(userId, stream);
+    stream.on("close", () => {
+      this.subscriptions.delete(userId);
+    });
+    return stream;
+  }
+  /**
+   * Unsubscribe from a user's audio.
+   *
+   * @example
+   * ```ts
+   * receiver.unsubscribe('123456789');
+   * ```
+   */
+  unsubscribe(userId) {
+    const stream = this.subscriptions.get(userId);
+    if (stream) {
+      stream.destroy();
+      this.subscriptions.delete(userId);
+    }
+  }
+  /** @internal */
+  mapSsrcToUser(ssrc, userId) {
+    let state = this.ssrcMap.get(ssrc);
+    if (!state) {
+      state = {
+        userId,
+        decoder: new OpusDecoder({ sampleRate: 48e3, channels: 2 }),
+        stream: new UserAudioStream(userId)
+      };
+      this.ssrcMap.set(ssrc, state);
+    } else {
+      state.userId = userId;
+    }
+    this.userSsrcMap.set(userId, ssrc);
+    this.emit("userConnected", userId, ssrc);
+  }
+  /** @internal */
+  removeUser(userId) {
+    const ssrc = this.userSsrcMap.get(userId);
+    if (ssrc !== void 0) {
+      const state = this.ssrcMap.get(ssrc);
+      if (state) {
+        state.stream.destroy();
+        this.ssrcMap.delete(ssrc);
+      }
+      this.userSsrcMap.delete(userId);
+    }
+    this.subscriptions.get(userId)?.destroy();
+    this.subscriptions.delete(userId);
+    this.emit("userDisconnected", userId);
+  }
+  /** @internal */
+  handlePacket(rawPacket, decryptedPayload) {
+    try {
+      const header = parseRtpHeader(rawPacket);
+      const state = this.ssrcMap.get(header.ssrc);
+      if (!state?.userId) {
+        return;
+      }
+      const pcm = state.decoder.decode(decryptedPayload);
+      const subscription = this.subscriptions.get(state.userId);
+      if (subscription && !subscription.destroyed) {
+        subscription.push(pcm);
+      }
+      this.emit("audio", state.userId, pcm, header);
+    } catch {
+    }
+  }
+  /**
+   * Destroy all streams and clean up.
+   *
+   * @example
+   * ```ts
+   * receiver.destroy();
+   * ```
+   */
+  destroy() {
+    for (const [, stream] of this.subscriptions) {
+      stream.destroy();
+    }
+    this.subscriptions.clear();
+    this.ssrcMap.clear();
+    this.userSsrcMap.clear();
+    return this;
+  }
+};
+
+// src/connection.ts
+var VOICE_GATEWAY_VERSION = 8;
+var HEARTBEAT_MAX_MISSED = 3;
+var IP_DISCOVERY_PACKET_SIZE = 74;
+var VoiceConnection = class extends EventEmitter {
+  _state = "idle" /* Idle */;
+  guildId;
+  channelId;
+  selfDeaf;
+  selfMute;
+  adapter;
+  sessionId;
+  voiceToken;
+  endpoint;
+  ws;
+  udpSocket;
+  ssrc = 0;
+  remoteIp = "";
+  remotePort = 0;
+  localIp = "";
+  localPort = 0;
+  secretKey;
+  encryptionMode = "xsalsa20_poly1305" /* XSalsa20Poly1305 */;
+  sequence = 0;
+  timestamp = 0;
+  nonceCounter = 0;
+  heartbeatInterval;
+  heartbeatNonce = 0;
+  missedHeartbeats = 0;
+  lastHeartbeatAck = 0;
+  subscribedPlayer;
+  audioThread;
+  ringBuffer;
+  receiver;
+  voiceStateResolve;
+  voiceServerResolve;
+  constructor(options) {
+    super();
+    this.guildId = options.guildId;
+    this.channelId = options.channelId;
+    this.selfDeaf = options.selfDeaf ?? false;
+    this.selfMute = options.selfMute ?? false;
+    this.receiver = new AudioReceiver(this);
+    this.adapter = options.adapterCreator({
+      onVoiceStateUpdate: (data) => this.handleVoiceStateUpdate(data),
+      onVoiceServerUpdate: (data) => this.handleVoiceServerUpdate(data),
+      destroy: () => this.destroy()
+    });
+    setVoiceConnection(this.guildId, this);
+    this.sendVoiceStateUpdate();
+  }
+  /**
+   * Current connection state.
+   *
+   * @example
+   * ```ts
+   * if (connection.state === VoiceConnectionState.Ready) { ... }
+   * ```
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Get the audio receiver for this connection.
+   *
+   * @example
+   * ```ts
+   * const receiver = connection.getReceiver();
+   * ```
+   */
+  getReceiver() {
+    return this.receiver;
+  }
+  /**
+   * Subscribe an audio player to this connection.
+   *
+   * @example
+   * ```ts
+   * connection.subscribe(player);
+   * ```
+   */
+  subscribe(player) {
+    this.subscribedPlayer = player;
+  }
+  /**
+   * Unsubscribe the current audio player.
+   *
+   * @example
+   * ```ts
+   * connection.unsubscribe();
+   * ```
+   */
+  unsubscribe() {
+    this.subscribedPlayer = void 0;
+  }
+  /**
+   * Destroy the connection and clean up all resources.
+   *
+   * @example
+   * ```ts
+   * connection.destroy();
+   * ```
+   */
+  destroy() {
+    if (this._state === "destroyed" /* Destroyed */) {
+      return;
+    }
+    this.transitionTo("destroyed" /* Destroyed */);
+    this.cleanup();
+    removeVoiceConnection(this.guildId);
+    if (this.adapter) {
+      this.adapter.sendPayload({
+        op: 4,
+        d: {
+          guild_id: this.guildId,
+          channel_id: null,
+          self_mute: false,
+          self_deaf: false
+        }
+      });
+      this.adapter.destroy();
+      this.adapter = void 0;
+    }
+    this.emit("destroyed");
+  }
+  /**
+   * Send an Opus packet through the voice connection.
+   *
+   * @example
+   * ```ts
+   * connection.sendOpusPacket(opusBuffer);
+   * ```
+   */
+  sendOpusPacket(opusPacket) {
+    if (this._state !== "ready" /* Ready */) {
+      return;
+    }
+    if (!this.secretKey || !this.udpSocket) {
+      return;
+    }
+    const header = buildRtpHeader(this.sequence, this.timestamp, this.ssrc, 120);
+    const encrypted = encryptOpusPacket(
+      header,
+      opusPacket,
+      this.secretKey,
+      this.encryptionMode,
+      this.nonceCounter
+    );
+    this.udpSocket.send(encrypted, this.remotePort, this.remoteIp);
+    this.sequence = this.sequence + 1 & 65535;
+    this.timestamp = this.timestamp + 960 >>> 0;
+    this.nonceCounter = this.nonceCounter + 1 >>> 0;
+  }
+  sendVoiceStateUpdate() {
+    this.transitionTo("signalling" /* Signalling */);
+    this.adapter?.sendPayload({
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: this.channelId,
+        self_mute: this.selfMute,
+        self_deaf: this.selfDeaf
+      }
+    });
+  }
+  handleVoiceStateUpdate(data) {
+    this.sessionId = data.session_id;
+    if (this.voiceStateResolve) {
+      this.voiceStateResolve();
+      this.voiceStateResolve = void 0;
+    }
+    this.tryConnect();
+  }
+  handleVoiceServerUpdate(data) {
+    this.voiceToken = data.token;
+    this.endpoint = data.endpoint ?? void 0;
+    if (this.voiceServerResolve) {
+      this.voiceServerResolve();
+      this.voiceServerResolve = void 0;
+    }
+    this.tryConnect();
+  }
+  tryConnect() {
+    if (!this.sessionId || !this.voiceToken || !this.endpoint) {
+      return;
+    }
+    this.transitionTo("connecting" /* Connecting */);
+    this.connectWebSocket();
+  }
+  connectWebSocket() {
+    const wsUrl = `wss://${this.endpoint}/?v=${VOICE_GATEWAY_VERSION}`;
+    this.ws?.close();
+    this.ws = new WebSocket(wsUrl);
+    this.ws.on("open", () => {
+      this.sendIdentify();
+    });
+    this.ws.on("message", (raw) => {
+      const data = JSON.parse(raw.toString());
+      this.handleGatewayMessage(data.op, data.d);
+    });
+    this.ws.on("close", (code) => {
+      this.stopHeartbeat();
+      if (this._state !== "destroyed" /* Destroyed */) {
+        if (code === 4014 || code === 4006) {
+          this.transitionTo("disconnected" /* Disconnected */);
+          this.emit("disconnected");
+        } else if (this._state !== "disconnected" /* Disconnected */) {
+          this.transitionTo("resuming" /* Resuming */);
+          setTimeout(() => this.connectWebSocket(), 1e3);
+        }
+      }
+    });
+    this.ws.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  sendIdentify() {
+    this.wsSend(0, {
+      server_id: this.guildId,
+      user_id: "",
+      // filled by adapter
+      session_id: this.sessionId,
+      token: this.voiceToken
+    });
+  }
+  handleGatewayMessage(op, d) {
+    switch (op) {
+      case 2:
+        this.handleReady(d);
+        break;
+      case 4:
+        this.handleSessionDescription(d);
+        break;
+      case 5:
+        this.handleSpeaking(d);
+        break;
+      case 6:
+        this.handleHeartbeatAck(d);
+        break;
+      case 8:
+        this.handleHello(d);
+        break;
+      case 9:
+        this.transitionTo("ready" /* Ready */);
+        break;
+      case 12:
+        this.handleClientConnect(d);
+        break;
+      case 13:
+        this.handleClientDisconnect(d);
+        break;
+    }
+  }
+  handleReady(data) {
+    this.ssrc = data.ssrc;
+    this.remoteIp = data.ip;
+    this.remotePort = data.port;
+    this.encryptionMode = selectEncryptionMode(data.modes);
+    this.connectUdp();
+  }
+  connectUdp() {
+    this.udpSocket?.close();
+    this.udpSocket = dgram.createSocket("udp4");
+    this.udpSocket.on("message", (msg) => {
+      this.handleUdpMessage(msg);
+    });
+    this.udpSocket.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.udpSocket.bind(0, () => {
+      const address = this.udpSocket?.address();
+      if (address) {
+        this.localPort = address.port;
+        const fd = this.udpSocket?._handle?.fd;
+        if (typeof fd === "number" && fd >= 0) {
+          try {
+            configureSocketForAudio(fd);
+          } catch {
+          }
+        }
+      }
+      this.performIpDiscovery();
+    });
+  }
+  performIpDiscovery() {
+    const discoveryPacket = Buffer.alloc(IP_DISCOVERY_PACKET_SIZE);
+    discoveryPacket.writeUInt16BE(1, 0);
+    discoveryPacket.writeUInt16BE(70, 2);
+    discoveryPacket.writeUInt32BE(this.ssrc, 4);
+    this.udpSocket?.send(
+      discoveryPacket,
+      this.remotePort,
+      this.remoteIp
+    );
+  }
+  handleUdpMessage(msg) {
+    if (msg.length === IP_DISCOVERY_PACKET_SIZE) {
+      this.handleIpDiscoveryResponse(msg);
+      return;
+    }
+    if (msg.length > 12 && this.secretKey) {
+      try {
+        const decrypted = decryptOpusPacket(msg, this.secretKey, this.encryptionMode);
+        this.receiver.handlePacket(msg, decrypted);
+      } catch {
+      }
+    }
+  }
+  handleIpDiscoveryResponse(response) {
+    const ipEnd = response.indexOf(0, 8);
+    this.localIp = response.subarray(8, ipEnd > 8 ? ipEnd : 72).toString("utf8").replace(/\0/g, "");
+    this.localPort = response.readUInt16BE(72);
+    this.wsSend(1, {
+      protocol: "udp",
+      data: {
+        address: this.localIp,
+        port: this.localPort,
+        mode: this.encryptionMode
+      }
+    });
+  }
+  handleSessionDescription(d) {
+    const keyArray = d["secret_key"];
+    this.secretKey = Buffer.from(keyArray);
+    this.encryptionMode = d["mode"];
+    this.sequence = 0;
+    this.timestamp = 0;
+    this.nonceCounter = 0;
+    this.transitionTo("ready" /* Ready */);
+    this.emit("ready");
+    this.setSpeaking(1);
+  }
+  handleSpeaking(d) {
+    const userId = d["user_id"];
+    const ssrc = d["ssrc"];
+    this.receiver.mapSsrcToUser(ssrc, userId);
+  }
+  handleClientConnect(d) {
+    const userId = d["user_id"];
+    const audioSsrc = d["audio_ssrc"];
+    if (audioSsrc) {
+      this.receiver.mapSsrcToUser(audioSsrc, userId);
+    }
+  }
+  handleClientDisconnect(d) {
+    const userId = d["user_id"];
+    this.receiver.removeUser(userId);
+  }
+  handleHello(d) {
+    const interval = d["heartbeat_interval"];
+    this.startHeartbeat(interval);
+  }
+  handleHeartbeatAck(_d) {
+    this.missedHeartbeats = 0;
+    this.lastHeartbeatAck = Date.now();
+  }
+  startHeartbeat(intervalMs) {
+    this.stopHeartbeat();
+    this.missedHeartbeats = 0;
+    this.heartbeatInterval = setInterval(() => {
+      if (this.missedHeartbeats >= HEARTBEAT_MAX_MISSED) {
+        this.ws?.close(4009);
+        return;
+      }
+      this.heartbeatNonce = Date.now();
+      this.wsSend(3, this.heartbeatNonce);
+      this.missedHeartbeats++;
+    }, intervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+    }
+  }
+  /**
+   * Set the speaking flags.
+   *
+   * @example
+   * ```ts
+   * connection.setSpeaking(1); // speaking
+   * ```
+   */
+  setSpeaking(flags) {
+    this.wsSend(5, {
+      speaking: flags,
+      delay: 0,
+      ssrc: this.ssrc
+    });
+  }
+  wsSend(op, d) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ op, d }));
+    }
+  }
+  transitionTo(newState) {
+    const oldState = this._state;
+    if (oldState === newState) {
+      return;
+    }
+    this._state = newState;
+    this.emit("stateChange", oldState, newState);
+  }
+  cleanup() {
+    this.stopHeartbeat();
+    if (this.audioThread) {
+      this.audioThread.stop();
+      this.audioThread = void 0;
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws.close();
+      this.ws = void 0;
+    }
+    if (this.udpSocket) {
+      this.udpSocket.removeAllListeners();
+      this.udpSocket.close();
+      this.udpSocket = void 0;
+    }
+    this.secretKey = void 0;
+  }
+};
+var AudioPlayer = class extends EventEmitter {
+  _state = "idle" /* Idle */;
+  resource;
+  connections = /* @__PURE__ */ new Set();
+  playbackTimer;
+  noSubscriberBehavior;
+  constructor(options = {}) {
+    super();
+    this.noSubscriberBehavior = options.noSubscriber ?? "pause";
+  }
+  /**
+   * Current player state.
+   *
+   * @example
+   * ```ts
+   * if (player.state === AudioPlayerState.Playing) { ... }
+   * ```
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Start playing an audio resource.
+   *
+   * @example
+   * ```ts
+   * player.play(audioResource);
+   * ```
+   */
+  play(resource) {
+    this.stopInternal();
+    this.resource = resource;
+    this.transitionTo("playing" /* Playing */);
+    this.startPlaybackLoop();
+  }
+  /**
+   * Pause playback.
+   *
+   * @example
+   * ```ts
+   * player.pause();
+   * ```
+   */
+  pause() {
+    if (this._state === "playing" /* Playing */) {
+      this.transitionTo("paused" /* Paused */);
+    }
+  }
+  /**
+   * Resume playback.
+   *
+   * @example
+   * ```ts
+   * player.resume();
+   * ```
+   */
+  resume() {
+    if (this._state === "paused" /* Paused */ || this._state === "autopaused" /* AutoPaused */) {
+      this.transitionTo("playing" /* Playing */);
+    }
+  }
+  /**
+   * Stop playback and release the resource.
+   *
+   * @example
+   * ```ts
+   * player.stop();
+   * ```
+   */
+  stop() {
+    this.stopInternal();
+    this.transitionTo("idle" /* Idle */);
+    this.emit("idle");
+  }
+  /** @internal */
+  addConnection(connection) {
+    this.connections.add(connection);
+  }
+  /** @internal */
+  removeConnection(connection) {
+    this.connections.delete(connection);
+  }
+  startPlaybackLoop() {
+    this.playbackTimer = setInterval(() => {
+      this.processFrame();
+    }, 20);
+  }
+  processFrame() {
+    if (this._state !== "playing" /* Playing */) {
+      return;
+    }
+    if (!this.resource) {
+      this.stop();
+      return;
+    }
+    if (this.resource.ended) {
+      this.stopInternal();
+      this.transitionTo("idle" /* Idle */);
+      this.emit("idle");
+      return;
+    }
+    const packet = this.resource.read();
+    if (!packet) {
+      return;
+    }
+    for (const connection of this.connections) {
+      connection.sendOpusPacket(packet);
+    }
+  }
+  stopInternal() {
+    if (this.playbackTimer) {
+      clearInterval(this.playbackTimer);
+      this.playbackTimer = void 0;
+    }
+    if (this.resource) {
+      this.resource.destroy();
+      this.resource = void 0;
+    }
+  }
+  transitionTo(newState) {
+    const oldState = this._state;
+    if (oldState === newState) {
+      return;
+    }
+    this._state = newState;
+    this.emit("stateChange", oldState, newState);
+  }
+};
+
+// src/join.ts
+function joinVoiceChannel(options) {
+  const existing = getVoiceConnection(options.guildId);
+  if (existing) {
+    existing.destroy();
+  }
+  return new VoiceConnection(options);
+}
+var AudioResource = class {
+  stream;
+  packets = [];
+  _ended = false;
+  draining = false;
+  constructor(stream) {
+    this.stream = stream;
+    stream.on("data", (chunk) => {
+      this.packets.push(chunk);
+    });
+    stream.on("end", () => {
+      this._ended = true;
+    });
+    stream.on("error", () => {
+      this._ended = true;
+    });
+  }
+  /**
+   * Read the next Opus packet.
+   *
+   * @example
+   * ```ts
+   * const packet = resource.read();
+   * ```
+   */
+  read() {
+    return this.packets.shift() ?? null;
+  }
+  /** Whether the resource has finished producing packets. */
+  get ended() {
+    return this._ended && this.packets.length === 0;
+  }
+  /**
+   * Destroy the resource and release underlying streams.
+   *
+   * @example
+   * ```ts
+   * resource.destroy();
+   * ```
+   */
+  destroy() {
+    this.stream.destroy();
+    this.packets.length = 0;
+    this._ended = true;
+  }
+};
+function createAudioResource(input, options = {}) {
+  let readable;
+  if (typeof input === "string") {
+    const { createReadStream } = __require("fs");
+    readable = createReadStream(input);
+  } else if (Buffer.isBuffer(input)) {
+    readable = Readable.from(input);
+  } else {
+    readable = input;
+  }
+  if (options.inputType === "opus") {
+    return new AudioResource(readable);
+  }
+  const encoder = new OpusEncoderStream({
+    sampleRate: 48e3,
+    channels: 2,
+    application: "audio"
+  });
+  readable.pipe(encoder);
+  if (options.signal) {
+    options.signal.addEventListener(
+      "abort",
+      () => {
+        readable.destroy();
+        encoder.destroy();
+      },
+      { once: true }
+    );
+  }
+  return new AudioResource(encoder);
+}
+
+export { AudioPlayer, AudioPlayerState, AudioReceiver, EncryptionMode, HarmoniaVoiceError, VoiceConnection, VoiceConnectionState, createAudioResource, getVoiceConnection, getVoiceConnections, joinVoiceChannel };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map