audio-channel-queue 1.5.0 → 1.7.0

package/dist/index.js

@@ -1,45 +1,65 @@
 "use strict";
 /**
  * @fileoverview Main entry point for the audio-channel-queue package
- *
- * A comprehensive audio queue management system with real-time progress tracking,
- * multi-channel support, and extensive event handling capabilities.
- *
- * @example Basic Usage
- * ```typescript
- * import { queueAudio, onAudioProgress } from 'audio-channel-queue';
- *
- * // Queue an audio file
- * await queueAudio('song.mp3');
- *
- * // Track progress
- * onAudioProgress(0, (info) => {
- *   console.log(`Progress: ${info.progress * 100}%`);
- * });
- * ```
+ * Exports all public functions and types for audio queue management, pause/resume controls,
+ * volume management with ducking, progress tracking, and comprehensive event system
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAudioInfoFromElement = exports.extractFileName = exports.createQueueSnapshot = exports.cleanWebpackFilename = exports.offQueueChange = exports.onQueueChange = exports.onAudioStart = exports.onAudioProgress = exports.onAudioComplete = exports.offAudioProgress = exports.getQueueSnapshot = exports.getCurrentAudioInfo = exports.getAllChannelsInfo = exports.audioChannels = exports.stopCurrentAudioInChannel = exports.stopAllAudioInChannel = exports.stopAllAudio = exports.queueAudio = exports.playAudioQueue = void 0;
-// Export core queue management functions
+exports.getAudioInfoFromElement = exports.extractFileName = exports.createQueueSnapshot = exports.cleanWebpackFilename = exports.audioChannels = exports.onQueueChange = exports.onAudioStart = exports.onAudioResume = exports.onAudioProgress = exports.onAudioPause = exports.onAudioComplete = exports.offQueueChange = exports.offAudioResume = exports.offAudioProgress = exports.offAudioPause = exports.getQueueSnapshot = exports.getCurrentAudioInfo = exports.getAllChannelsInfo = exports.setVolumeDucking = exports.setChannelVolume = exports.setAllChannelsVolume = exports.getChannelVolume = exports.getAllChannelsVolume = exports.clearVolumeDucking = exports.togglePauseChannel = exports.togglePauseAllChannels = exports.resumeChannel = exports.resumeAllChannels = exports.pauseChannel = exports.pauseAllChannels = exports.isChannelPaused = exports.getAllChannelsPauseState = exports.setRetryConfig = exports.setErrorRecovery = exports.retryFailedAudio = exports.onAudioError = exports.offAudioError = exports.getRetryConfig = exports.getErrorRecovery = exports.playAudioQueue = exports.stopAllAudio = exports.stopAllAudioInChannel = exports.stopCurrentAudioInChannel = exports.queueAudioPriority = exports.queueAudio = void 0;
+// Core queue management functions
 var core_1 = require("./core");
-Object.defineProperty(exports, "playAudioQueue", { enumerable: true, get: function () { return core_1.playAudioQueue; } });
 Object.defineProperty(exports, "queueAudio", { enumerable: true, get: function () { return core_1.queueAudio; } });
-Object.defineProperty(exports, "stopAllAudio", { enumerable: true, get: function () { return core_1.stopAllAudio; } });
-Object.defineProperty(exports, "stopAllAudioInChannel", { enumerable: true, get: function () { return core_1.stopAllAudioInChannel; } });
+Object.defineProperty(exports, "queueAudioPriority", { enumerable: true, get: function () { return core_1.queueAudioPriority; } });
 Object.defineProperty(exports, "stopCurrentAudioInChannel", { enumerable: true, get: function () { return core_1.stopCurrentAudioInChannel; } });
-// Export audio information and progress tracking functions
+Object.defineProperty(exports, "stopAllAudioInChannel", { enumerable: true, get: function () { return core_1.stopAllAudioInChannel; } });
+Object.defineProperty(exports, "stopAllAudio", { enumerable: true, get: function () { return core_1.stopAllAudio; } });
+Object.defineProperty(exports, "playAudioQueue", { enumerable: true, get: function () { return core_1.playAudioQueue; } });
+// Error handling and recovery functions
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "getErrorRecovery", { enumerable: true, get: function () { return errors_1.getErrorRecovery; } });
+Object.defineProperty(exports, "getRetryConfig", { enumerable: true, get: function () { return errors_1.getRetryConfig; } });
+Object.defineProperty(exports, "offAudioError", { enumerable: true, get: function () { return errors_1.offAudioError; } });
+Object.defineProperty(exports, "onAudioError", { enumerable: true, get: function () { return errors_1.onAudioError; } });
+Object.defineProperty(exports, "retryFailedAudio", { enumerable: true, get: function () { return errors_1.retryFailedAudio; } });
+Object.defineProperty(exports, "setErrorRecovery", { enumerable: true, get: function () { return errors_1.setErrorRecovery; } });
+Object.defineProperty(exports, "setRetryConfig", { enumerable: true, get: function () { return errors_1.setRetryConfig; } });
+// Pause and resume management functions
+var pause_1 = require("./pause");
+Object.defineProperty(exports, "getAllChannelsPauseState", { enumerable: true, get: function () { return pause_1.getAllChannelsPauseState; } });
+Object.defineProperty(exports, "isChannelPaused", { enumerable: true, get: function () { return pause_1.isChannelPaused; } });
+Object.defineProperty(exports, "pauseAllChannels", { enumerable: true, get: function () { return pause_1.pauseAllChannels; } });
+Object.defineProperty(exports, "pauseChannel", { enumerable: true, get: function () { return pause_1.pauseChannel; } });
+Object.defineProperty(exports, "resumeAllChannels", { enumerable: true, get: function () { return pause_1.resumeAllChannels; } });
+Object.defineProperty(exports, "resumeChannel", { enumerable: true, get: function () { return pause_1.resumeChannel; } });
+Object.defineProperty(exports, "togglePauseAllChannels", { enumerable: true, get: function () { return pause_1.togglePauseAllChannels; } });
+Object.defineProperty(exports, "togglePauseChannel", { enumerable: true, get: function () { return pause_1.togglePauseChannel; } });
+// Volume control and ducking functions
+var volume_1 = require("./volume");
+Object.defineProperty(exports, "clearVolumeDucking", { enumerable: true, get: function () { return volume_1.clearVolumeDucking; } });
+Object.defineProperty(exports, "getAllChannelsVolume", { enumerable: true, get: function () { return volume_1.getAllChannelsVolume; } });
+Object.defineProperty(exports, "getChannelVolume", { enumerable: true, get: function () { return volume_1.getChannelVolume; } });
+Object.defineProperty(exports, "setAllChannelsVolume", { enumerable: true, get: function () { return volume_1.setAllChannelsVolume; } });
+Object.defineProperty(exports, "setChannelVolume", { enumerable: true, get: function () { return volume_1.setChannelVolume; } });
+Object.defineProperty(exports, "setVolumeDucking", { enumerable: true, get: function () { return volume_1.setVolumeDucking; } });
+// Audio information and progress tracking functions
 var info_1 = require("./info");
-Object.defineProperty(exports, "audioChannels", { enumerable: true, get: function () { return info_1.audioChannels; } });
 Object.defineProperty(exports, "getAllChannelsInfo", { enumerable: true, get: function () { return info_1.getAllChannelsInfo; } });
 Object.defineProperty(exports, "getCurrentAudioInfo", { enumerable: true, get: function () { return info_1.getCurrentAudioInfo; } });
 Object.defineProperty(exports, "getQueueSnapshot", { enumerable: true, get: function () { return info_1.getQueueSnapshot; } });
+Object.defineProperty(exports, "offAudioPause", { enumerable: true, get: function () { return info_1.offAudioPause; } });
 Object.defineProperty(exports, "offAudioProgress", { enumerable: true, get: function () { return info_1.offAudioProgress; } });
+Object.defineProperty(exports, "offAudioResume", { enumerable: true, get: function () { return info_1.offAudioResume; } });
+Object.defineProperty(exports, "offQueueChange", { enumerable: true, get: function () { return info_1.offQueueChange; } });
 Object.defineProperty(exports, "onAudioComplete", { enumerable: true, get: function () { return info_1.onAudioComplete; } });
+Object.defineProperty(exports, "onAudioPause", { enumerable: true, get: function () { return info_1.onAudioPause; } });
 Object.defineProperty(exports, "onAudioProgress", { enumerable: true, get: function () { return info_1.onAudioProgress; } });
+Object.defineProperty(exports, "onAudioResume", { enumerable: true, get: function () { return info_1.onAudioResume; } });
 Object.defineProperty(exports, "onAudioStart", { enumerable: true, get: function () { return info_1.onAudioStart; } });
 Object.defineProperty(exports, "onQueueChange", { enumerable: true, get: function () { return info_1.onQueueChange; } });
-Object.defineProperty(exports, "offQueueChange", { enumerable: true, get: function () { return info_1.offQueueChange; } });
-// Export utility functions (for advanced usage)
+// Core data access for legacy compatibility
+var info_2 = require("./info");
+Object.defineProperty(exports, "audioChannels", { enumerable: true, get: function () { return info_2.audioChannels; } });
+// Utility helper functions
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "cleanWebpackFilename", { enumerable: true, get: function () { return utils_1.cleanWebpackFilename; } });
 Object.defineProperty(exports, "createQueueSnapshot", { enumerable: true, get: function () { return utils_1.createQueueSnapshot; } });

package/dist/info.d.ts

@@ -1,9 +1,10 @@
 /**
  * @fileoverview Audio information and progress tracking functions for the audio-channel-queue package
  */
-import { AudioInfo, QueueSnapshot, ProgressCallback, QueueChangeCallback, AudioStartCallback, AudioCompleteCallback, ExtendedAudioQueueChannel } from './types';
+import { AudioInfo, QueueSnapshot, ProgressCallback, QueueChangeCallback, AudioStartCallback, AudioCompleteCallback, AudioPauseCallback, AudioResumeCallback, ExtendedAudioQueueChannel } from './types';
 /**
- * Global array of extended audio queue channels
+ * Global array to store audio channels with their queues and callback management
+ * Each channel maintains its own audio queue and event callback sets
  */
 export declare const audioChannels: ExtendedAudioQueueChannel[];
 /**
@@ -120,3 +121,47 @@ export declare const onAudioStart: (channelNumber: number, callback: AudioStartC
  * ```
  */
 export declare const onAudioComplete: (channelNumber: number, callback: AudioCompleteCallback) => void;
+/**
+ * Subscribes to audio pause events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio is paused
+ * @example
+ * ```typescript
+ * onAudioPause(0, (channelNumber, info) => {
+ *   showPauseIndicator();
+ *   logPauseEvent(info.fileName, info.currentTime);
+ * });
+ * ```
+ */
+export declare const onAudioPause: (channelNumber: number, callback: AudioPauseCallback) => void;
+/**
+ * Subscribes to audio resume events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio is resumed
+ * @example
+ * ```typescript
+ * onAudioResume(0, (channelNumber, info) => {
+ *   hidePauseIndicator();
+ *   logResumeEvent(info.fileName, info.currentTime);
+ * });
+ * ```
+ */
+export declare const onAudioResume: (channelNumber: number, callback: AudioResumeCallback) => void;
+/**
+ * Removes pause event listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioPause(0); // Stop receiving pause notifications for channel 0
+ * ```
+ */
+export declare const offAudioPause: (channelNumber: number) => void;
+/**
+ * Removes resume event listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioResume(0); // Stop receiving resume notifications for channel 0
+ * ```
+ */
+export declare const offAudioResume: (channelNumber: number) => void;

package/dist/info.js

@@ -3,11 +3,12 @@
  * @fileoverview Audio information and progress tracking functions for the audio-channel-queue package
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onAudioComplete = exports.onAudioStart = exports.offQueueChange = exports.onQueueChange = exports.offAudioProgress = exports.onAudioProgress = exports.getQueueSnapshot = exports.getAllChannelsInfo = exports.getCurrentAudioInfo = exports.audioChannels = void 0;
+exports.offAudioResume = exports.offAudioPause = exports.onAudioResume = exports.onAudioPause = exports.onAudioComplete = exports.onAudioStart = exports.offQueueChange = exports.onQueueChange = exports.offAudioProgress = exports.onAudioProgress = exports.getQueueSnapshot = exports.getAllChannelsInfo = exports.getCurrentAudioInfo = exports.audioChannels = void 0;
 const utils_1 = require("./utils");
 const events_1 = require("./events");
 /**
- * Global array of extended audio queue channels
+ * Global array to store audio channels with their queues and callback management
+ * Each channel maintains its own audio queue and event callback sets
  */
 exports.audioChannels = [];
 /**
@@ -29,7 +30,7 @@ const getCurrentAudioInfo = (channelNumber = 0) => {
         return null;
     }
     const currentAudio = channel.queue[0];
-    return (0, utils_1.getAudioInfoFromElement)(currentAudio);
+    return (0, utils_1.getAudioInfoFromElement)(currentAudio, channelNumber, exports.audioChannels);
 };
 exports.getCurrentAudioInfo = getCurrentAudioInfo;
 /**
@@ -86,10 +87,15 @@ const onAudioProgress = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -150,10 +156,15 @@ const onQueueChange = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -194,10 +205,15 @@ const onAudioStart = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -225,10 +241,15 @@ const onAudioComplete = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -238,3 +259,101 @@ const onAudioComplete = (channelNumber, callback) => {
     channel.audioCompleteCallbacks.add(callback);
 };
 exports.onAudioComplete = onAudioComplete;
+/**
+ * Subscribes to audio pause events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio is paused
+ * @example
+ * ```typescript
+ * onAudioPause(0, (channelNumber, info) => {
+ *   showPauseIndicator();
+ *   logPauseEvent(info.fileName, info.currentTime);
+ * });
+ * ```
+ */
+const onAudioPause = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            isPaused: false,
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
+        };
+    }
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel.audioPauseCallbacks) {
+        channel.audioPauseCallbacks = new Set();
+    }
+    channel.audioPauseCallbacks.add(callback);
+};
+exports.onAudioPause = onAudioPause;
+/**
+ * Subscribes to audio resume events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio is resumed
+ * @example
+ * ```typescript
+ * onAudioResume(0, (channelNumber, info) => {
+ *   hidePauseIndicator();
+ *   logResumeEvent(info.fileName, info.currentTime);
+ * });
+ * ```
+ */
+const onAudioResume = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            isPaused: false,
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
+        };
+    }
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel.audioResumeCallbacks) {
+        channel.audioResumeCallbacks = new Set();
+    }
+    channel.audioResumeCallbacks.add(callback);
+};
+exports.onAudioResume = onAudioResume;
+/**
+ * Removes pause event listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioPause(0); // Stop receiving pause notifications for channel 0
+ * ```
+ */
+const offAudioPause = (channelNumber) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || !channel.audioPauseCallbacks)
+        return;
+    channel.audioPauseCallbacks.clear();
+};
+exports.offAudioPause = offAudioPause;
+/**
+ * Removes resume event listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioResume(0); // Stop receiving resume notifications for channel 0
+ * ```
+ */
+const offAudioResume = (channelNumber) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || !channel.audioResumeCallbacks)
+        return;
+    channel.audioResumeCallbacks.clear();
+};
+exports.offAudioResume = offAudioResume;

package/dist/pause.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Pause and resume management functions for the audio-channel-queue package
+ */
+/**
+ * Pauses the currently playing audio in a specific channel
+ * @param channelNumber - The channel number to pause (defaults to 0)
+ * @returns Promise that resolves when the audio is paused
+ * @example
+ * ```typescript
+ * await pauseChannel(0); // Pause audio in channel 0
+ * await pauseChannel(); // Pause audio in default channel
+ * ```
+ */
+export declare const pauseChannel: (channelNumber?: number) => Promise<void>;
+/**
+ * Resumes the currently paused audio in a specific channel
+ * @param channelNumber - The channel number to resume (defaults to 0)
+ * @returns Promise that resolves when the audio starts playing
+ * @example
+ * ```typescript
+ * await resumeChannel(0); // Resume audio in channel 0
+ * await resumeChannel(); // Resume audio in default channel
+ * ```
+ */
+export declare const resumeChannel: (channelNumber?: number) => Promise<void>;
+/**
+ * Toggles pause/resume state for a specific channel
+ * @param channelNumber - The channel number to toggle (defaults to 0)
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseChannel(0); // Toggle pause state for channel 0
+ * ```
+ */
+export declare const togglePauseChannel: (channelNumber?: number) => Promise<void>;
+/**
+ * Pauses all currently playing audio across all channels
+ * @returns Promise that resolves when all audio is paused
+ * @example
+ * ```typescript
+ * await pauseAllChannels(); // Pause everything
+ * ```
+ */
+export declare const pauseAllChannels: () => Promise<void>;
+/**
+ * Resumes all currently paused audio across all channels
+ * @returns Promise that resolves when all audio is resumed
+ * @example
+ * ```typescript
+ * await resumeAllChannels(); // Resume everything that was paused
+ * ```
+ */
+export declare const resumeAllChannels: () => Promise<void>;
+/**
+ * Checks if a specific channel is currently paused
+ * @param channelNumber - The channel number to check (defaults to 0)
+ * @returns True if the channel is paused, false otherwise
+ * @example
+ * ```typescript
+ * const isPaused = isChannelPaused(0);
+ * console.log(`Channel 0 is ${isPaused ? 'paused' : 'playing'}`);
+ * ```
+ */
+export declare const isChannelPaused: (channelNumber?: number) => boolean;
+/**
+ * Gets the pause state of all channels
+ * @returns Array of boolean values indicating pause state for each channel
+ * @example
+ * ```typescript
+ * const pauseStates = getAllChannelsPauseState();
+ * pauseStates.forEach((isPaused, index) => {
+ *   console.log(`Channel ${index}: ${isPaused ? 'paused' : 'playing'}`);
+ * });
+ * ```
+ */
+export declare const getAllChannelsPauseState: () => boolean[];
+/**
+ * Toggles pause/resume state for all channels globally
+ * If any channels are currently playing, all channels will be paused
+ * If all channels are paused, all channels will be resumed
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseAllChannels(); // Pause all if any are playing, resume all if all are paused
+ * ```
+ */
+export declare const togglePauseAllChannels: () => Promise<void>;

package/dist/pause.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * @fileoverview Pause and resume management functions for the audio-channel-queue package
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.togglePauseAllChannels = exports.getAllChannelsPauseState = exports.isChannelPaused = exports.resumeAllChannels = exports.pauseAllChannels = exports.togglePauseChannel = exports.resumeChannel = exports.pauseChannel = void 0;
+const info_1 = require("./info");
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+/**
+ * Pauses the currently playing audio in a specific channel
+ * @param channelNumber - The channel number to pause (defaults to 0)
+ * @returns Promise that resolves when the audio is paused
+ * @example
+ * ```typescript
+ * await pauseChannel(0); // Pause audio in channel 0
+ * await pauseChannel(); // Pause audio in default channel
+ * ```
+ */
+const pauseChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        if (!currentAudio.paused && !currentAudio.ended) {
+            currentAudio.pause();
+            channel.isPaused = true;
+            const audioInfo = (0, utils_1.getAudioInfoFromElement)(currentAudio, channelNumber, info_1.audioChannels);
+            if (audioInfo) {
+                (0, events_1.emitAudioPause)(channelNumber, audioInfo, info_1.audioChannels);
+            }
+        }
+    }
+});
+exports.pauseChannel = pauseChannel;
+/**
+ * Resumes the currently paused audio in a specific channel
+ * @param channelNumber - The channel number to resume (defaults to 0)
+ * @returns Promise that resolves when the audio starts playing
+ * @example
+ * ```typescript
+ * await resumeChannel(0); // Resume audio in channel 0
+ * await resumeChannel(); // Resume audio in default channel
+ * ```
+ */
+const resumeChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        // Only resume if both the channel is marked as paused AND the audio element is actually paused AND not ended
+        if (channel.isPaused && currentAudio.paused && !currentAudio.ended) {
+            yield currentAudio.play();
+            channel.isPaused = false;
+            const audioInfo = (0, utils_1.getAudioInfoFromElement)(currentAudio, channelNumber, info_1.audioChannels);
+            if (audioInfo) {
+                (0, events_1.emitAudioResume)(channelNumber, audioInfo, info_1.audioChannels);
+            }
+        }
+    }
+});
+exports.resumeChannel = resumeChannel;
+/**
+ * Toggles pause/resume state for a specific channel
+ * @param channelNumber - The channel number to toggle (defaults to 0)
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseChannel(0); // Toggle pause state for channel 0
+ * ```
+ */
+const togglePauseChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        if (currentAudio.paused) {
+            yield (0, exports.resumeChannel)(channelNumber);
+        }
+        else {
+            yield (0, exports.pauseChannel)(channelNumber);
+        }
+    }
+});
+exports.togglePauseChannel = togglePauseChannel;
+/**
+ * Pauses all currently playing audio across all channels
+ * @returns Promise that resolves when all audio is paused
+ * @example
+ * ```typescript
+ * await pauseAllChannels(); // Pause everything
+ * ```
+ */
+const pauseAllChannels = () => __awaiter(void 0, void 0, void 0, function* () {
+    const pausePromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        pausePromises.push((0, exports.pauseChannel)(index));
+    });
+    yield Promise.all(pausePromises);
+});
+exports.pauseAllChannels = pauseAllChannels;
+/**
+ * Resumes all currently paused audio across all channels
+ * @returns Promise that resolves when all audio is resumed
+ * @example
+ * ```typescript
+ * await resumeAllChannels(); // Resume everything that was paused
+ * ```
+ */
+const resumeAllChannels = () => __awaiter(void 0, void 0, void 0, function* () {
+    const resumePromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        resumePromises.push((0, exports.resumeChannel)(index));
+    });
+    yield Promise.all(resumePromises);
+});
+exports.resumeAllChannels = resumeAllChannels;
+/**
+ * Checks if a specific channel is currently paused
+ * @param channelNumber - The channel number to check (defaults to 0)
+ * @returns True if the channel is paused, false otherwise
+ * @example
+ * ```typescript
+ * const isPaused = isChannelPaused(0);
+ * console.log(`Channel 0 is ${isPaused ? 'paused' : 'playing'}`);
+ * ```
+ */
+const isChannelPaused = (channelNumber = 0) => {
+    const channel = info_1.audioChannels[channelNumber];
+    return (channel === null || channel === void 0 ? void 0 : channel.isPaused) || false;
+};
+exports.isChannelPaused = isChannelPaused;
+/**
+ * Gets the pause state of all channels
+ * @returns Array of boolean values indicating pause state for each channel
+ * @example
+ * ```typescript
+ * const pauseStates = getAllChannelsPauseState();
+ * pauseStates.forEach((isPaused, index) => {
+ *   console.log(`Channel ${index}: ${isPaused ? 'paused' : 'playing'}`);
+ * });
+ * ```
+ */
+const getAllChannelsPauseState = () => {
+    return info_1.audioChannels.map((channel) => (channel === null || channel === void 0 ? void 0 : channel.isPaused) || false);
+};
+exports.getAllChannelsPauseState = getAllChannelsPauseState;
+/**
+ * Toggles pause/resume state for all channels globally
+ * If any channels are currently playing, all channels will be paused
+ * If all channels are paused, all channels will be resumed
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseAllChannels(); // Pause all if any are playing, resume all if all are paused
+ * ```
+ */
+const togglePauseAllChannels = () => __awaiter(void 0, void 0, void 0, function* () {
+    let hasPlayingChannel = false;
+    // Check if any channel is currently playing
+    for (let i = 0; i < info_1.audioChannels.length; i++) {
+        const channel = info_1.audioChannels[i];
+        if (channel && channel.queue.length > 0) {
+            const currentAudio = channel.queue[0];
+            if (!currentAudio.paused && !currentAudio.ended) {
+                hasPlayingChannel = true;
+                break;
+            }
+        }
+    }
+    // If any channel is playing, pause all channels
+    // If no channels are playing, resume all channels
+    if (hasPlayingChannel) {
+        yield (0, exports.pauseAllChannels)();
+    }
+    else {
+        yield (0, exports.resumeAllChannels)();
+    }
+});
+exports.togglePauseAllChannels = togglePauseAllChannels;