@codexo/exojs 0.12.0 → 0.14.0

package/dist/esm/audio/Sound.js

@@ -1,8 +1,8 @@
 import { clamp } from '../math/utils.js';
 import { Vector } from '../math/Vector.js';
-import { AbstractMedia } from './AbstractMedia.js';
-import { onAudioContextReady, isAudioContextReady, getAudioContext } from './audio-context.js';
-import { getAudioManager } from './AudioManager.js';
+import { getAudioContext, isAudioContextReady } from './audio-context.js';
+import { NoopVoice } from './NoopVoice.js';
+import { SoundVoice } from './SoundVoice.js';
 
 /**
  * Eviction strategy used when the pool is full and a new play is requested.
@@ -26,62 +26,54 @@ var SoundPoolStrategy;
     SoundPoolStrategy["LowestPriority"] = "priority";
 })(SoundPoolStrategy || (SoundPoolStrategy = {}));
 /**
- * Pre-decoded short audio clip backed by an `AudioBuffer`. Each
- * {@link Sound.play} call grabs a free `AudioBufferSourceNode` from the
- * pool (default size 8) so the same sound can overlap itself; when the
- * pool is full the configured {@link SoundPoolStrategy} decides which
- * source to evict.
+ * Pre-decoded short audio clip backed by an `AudioBuffer`.
  *
- * Supports audio-sprite playback via {@link Sound.playSprite} — name a
- * sub-region in the {@link AudioSpriteClip} options and trigger by name.
+ * Sound is a **data descriptor** — it holds the decoded audio buffer, sprite
+ * definitions, default playback parameters, and spatial configuration but does
+ * NOT start playback itself. Playback is driven by
+ * `AudioManager.play(sound, options)` which returns a {@link Voice} handle.
  *
- * Routes through any {@link AudioBus}; defaults to the engine's `sound`
- * bus. Calling {@link Sound.makeSpatial} attaches a panner so the sound
- * follows a {@link SceneNode} or world-space target with distance
- * attenuation handled by Web Audio.
+ * Multiple concurrent plays of the same Sound are supported up to `poolSize`.
+ * When the pool is full the configured {@link SoundPoolStrategy} decides which
+ * active voice to evict.
  *
- * Use {@link Music} for long-form streaming audio (single source, decoded
+ * Use {@link AudioStream} for long-form streaming audio (single source, decoded
  * lazily) — `Sound` is best for short, frequently-triggered clips.
  */
-class Sound extends AbstractMedia {
+class Sound {
     _audioBuffer;
-    _pooledSources = [];
-    _queuedPooledPlays = [];
     _sprites = new Map();
-    _audioSetup = null;
-    _paused = true;
-    _poolSize = 8;
-    _poolStrategy = SoundPoolStrategy.FirstInFirstOut;
-    _priority = 0;
+    // Playable buffer window (seconds). Full buffer by default; narrowed by clip().
+    _clipStart = 0;
+    _clipEnd = 0;
+    /** Default volume applied to new voices. */
+    volume;
+    /** Default loop flag applied to new voices. */
+    loop;
+    /** Default playback rate applied to new voices. */
+    playbackRate;
+    /** Default muted flag applied to new voices. */
+    muted;
+    _poolSize;
+    _poolStrategy;
+    _priority;
+    // Spatial descriptor params — read by _createVoice to configure the PannerNode.
     _position = null;
     _velocity = null;
-    _pannerNode = null;
     _distanceModel = 'linear';
     _refDistance = 50;
     _maxDistance = 1000;
     _rolloffFactor = 1;
-    _onAudioContextReady = (ctx) => {
-        onAudioContextReady.remove(this._onAudioContextReady);
-        this.setupWithAudioContext(ctx);
-    };
-    get paused() {
-        return this._paused;
-    }
-    set paused(paused) {
-        if (paused) {
-            this.pause();
-        }
-        else {
-            this.play();
-        }
-    }
-    get analyserTarget() {
-        return this._audioSetup?.gainNode ?? null;
-    }
+    // Active voice pool — tracks concurrent voices for eviction logic.
+    _activeVoices = [];
     /** The underlying decoded audio data. Useful for sharing a single decoded buffer across multiple `Sound` instances. */
     get audioBuffer() {
         return this._audioBuffer;
     }
+    /** Playable duration in seconds — the full buffer, or the clip span for a {@link Sound.clip}. */
+    get duration() {
+        return this._clipEnd - this._clipStart;
+    }
     get poolSize() {
         return this._poolSize;
     }
@@ -117,16 +109,11 @@ class Sound extends AbstractMedia {
             if (this._position !== null) {
                 this._position.destroy();
                 this._position = null;
-                this._teardownSpatial();
-                getAudioManager()._unregisterSpatialSound(this);
             }
             return;
         }
         if (this._position === null) {
-            // Becoming spatial
             this._position = new Vector(value.x, value.y);
-            this._setupSpatial();
-            getAudioManager()._registerSpatialSound(this);
         }
         else {
             this._position.set(value.x, value.y);
@@ -151,15 +138,12 @@ class Sound extends AbstractMedia {
             }
         }
     }
-    /** Distance-attenuation model. Applied immediately if a panner is already attached. */
+    /** Distance-attenuation model. */
     get distanceModel() {
         return this._distanceModel;
     }
     set distanceModel(value) {
         this._distanceModel = value;
-        if (this._pannerNode !== null) {
-            this._pannerNode.distanceModel = value;
-        }
     }
     /** Reference distance — volume is at full strength at and below this distance. */
     get refDistance() {
@@ -167,9 +151,6 @@ class Sound extends AbstractMedia {
     }
     set refDistance(value) {
         this._refDistance = Math.max(0, value);
-        if (this._pannerNode !== null) {
-            this._pannerNode.refDistance = this._refDistance;
-        }
     }
     /** Maximum distance for the `'linear'` model — volume reaches zero here. */
     get maxDistance() {
@@ -177,9 +158,6 @@ class Sound extends AbstractMedia {
     }
     set maxDistance(value) {
         this._maxDistance = Math.max(0, value);
-        if (this._pannerNode !== null) {
-            this._pannerNode.maxDistance = this._maxDistance;
-        }
     }
     /** Falloff steepness. Higher values attenuate faster with distance. */
     get rolloffFactor() {
@@ -187,27 +165,18 @@ class Sound extends AbstractMedia {
     }
     set rolloffFactor(value) {
         this._rolloffFactor = Math.max(0, value);
-        if (this._pannerNode !== null) {
-            this._pannerNode.rolloffFactor = this._rolloffFactor;
-        }
     }
     constructor(audioBuffer, options = {}) {
-        super({
-            duration: audioBuffer.duration,
-            volume: 1,
-            playbackRate: 1,
-            loop: false,
-            muted: false,
-        });
         this._audioBuffer = audioBuffer;
-        const { poolSize, poolStrategy, priority, sprites, distanceModel, refDistance, maxDistance, rolloffFactor, ...playbackOptions } = options;
+        this._clipEnd = audioBuffer.duration;
+        const { poolSize, poolStrategy, priority, sprites, volume, loop, playbackRate, muted, distanceModel, refDistance, maxDistance, rolloffFactor } = options;
+        this.volume = clamp(volume ?? 1, 0, 1);
+        this.loop = loop ?? false;
+        this.playbackRate = clamp(playbackRate ?? 1, 0.1, 20);
+        this.muted = muted ?? false;
         this._poolSize = Math.max(1, Math.floor(poolSize ?? 8));
-        if (poolStrategy !== undefined) {
-            this._poolStrategy = poolStrategy;
-        }
-        if (priority !== undefined) {
-            this._priority = priority;
-        }
+        this._poolStrategy = poolStrategy ?? SoundPoolStrategy.FirstInFirstOut;
+        this._priority = priority ?? 0;
         if (distanceModel !== undefined) {
             this._distanceModel = distanceModel;
         }
@@ -220,52 +189,9 @@ class Sound extends AbstractMedia {
         if (rolloffFactor !== undefined) {
             this._rolloffFactor = Math.max(0, rolloffFactor);
         }
-        if (Object.keys(playbackOptions).length > 0) {
-            this.applyOptions(playbackOptions);
-        }
         if (sprites) {
             this.setSprites(sprites);
         }
-        if (isAudioContextReady()) {
-            this.setupWithAudioContext(getAudioContext());
-        }
-        else {
-            onAudioContextReady.add(this._onAudioContextReady);
-        }
-    }
-    setVolume(value) {
-        const volume = clamp(value, 0, 2);
-        if (this._volume === volume) {
-            return this;
-        }
-        this._volume = volume;
-        if (this._audioSetup) {
-            const { gainNode, audioContext } = this._audioSetup;
-            gainNode.gain.setTargetAtTime(this.muted ? 0 : volume, audioContext.currentTime, 0.01);
-        }
-        return this;
-    }
-    setLoop(loop) {
-        this._loop = loop;
-        return this;
-    }
-    setPlaybackRate(value) {
-        this._playbackRate = clamp(value, 0.1, 20);
-        return this;
-    }
-    getTime() {
-        return 0;
-    }
-    setTime(currentTime) {
-        return this;
-    }
-    setMuted(muted) {
-        this._muted = muted;
-        if (this._audioSetup) {
-            const { gainNode, audioContext } = this._audioSetup;
-            gainNode.gain.setTargetAtTime(muted ? 0 : this.volume, audioContext.currentTime, 0.01);
-        }
-        return this;
     }
     setPoolSize(poolSize) {
         const normalizedPoolSize = Math.max(1, Math.floor(poolSize));
@@ -273,7 +199,7 @@ class Sound extends AbstractMedia {
             return this;
         }
         this._poolSize = normalizedPoolSize;
-        this._trimPooledSources();
+        this._trimActiveVoices();
         return this;
     }
     setSprites(sprites) {
@@ -313,45 +239,57 @@ class Sound extends AbstractMedia {
         return this;
     }
     /**
-     * Play this sound. By default, creates a new pooled instance allowing
-     * multiple concurrent plays up to `poolSize`. Pass `{ replace: true }` to
-     * stop all prior instances of this sound before starting a new one
-     * (singleton-replace mode — useful for non-overlapping playback like UI
-     * confirmation chimes).
+     * Return a new {@link Sound} that plays only the `[offset, offset + duration]`
+     * sub-range (seconds) of this sound's buffer — an audio atlas / sprite-sheet
+     * clip. The clip shares the same decoded {@link AudioBuffer} (no extra memory)
+     * and inherits this sound's default playback + spatial settings, including its
+     * own independent voice pool.
      */
-    play(options) {
-        if (options?.bus !== undefined) {
-            this.bus = options.bus;
-        }
-        const playbackRate = clamp(options?.playbackRate ?? this._playbackRate, 0.1, 20);
-        const offset = Math.max(0, options?.time ?? 0);
-        const loop = options?.loop ?? this._loop;
-        if (options?.volume !== undefined) {
-            this.setVolume(options.volume);
-        }
-        if (options?.muted !== undefined) {
-            this.setMuted(options.muted);
-        }
-        if (options?.replace) {
-            this._stopAllPooled();
-        }
-        if (offset >= this.duration) {
-            return this;
-        }
-        const duration = loop ? undefined : this.duration - offset;
-        this._enqueuePooledPlay({
-            offset,
-            duration,
-            loop,
-            loopStart: 0,
-            loopEnd: this.duration,
-            playbackRate,
+    clip(offset, duration) {
+        const start = clamp(offset, 0, this._audioBuffer.duration);
+        const end = clamp(start + duration, start, this._audioBuffer.duration);
+        const clip = new Sound(this._audioBuffer, {
+            volume: this.volume,
+            loop: this.loop,
+            playbackRate: this.playbackRate,
+            muted: this.muted,
+            poolSize: this._poolSize,
+            poolStrategy: this._poolStrategy,
+            priority: this._priority,
+            distanceModel: this._distanceModel,
+            refDistance: this._refDistance,
+            maxDistance: this._maxDistance,
+            rolloffFactor: this._rolloffFactor,
+        });
+        clip._clipStart = start;
+        clip._clipEnd = end;
+        return clip;
+    }
+    /**
+     * Implements {@link Playable}. Called by {@link AudioManager.play}; do not
+     * call directly — use `manager.play(sound, options)` instead.
+     *
+     * Creates one {@link SoundVoice} backed by a single `AudioBufferSourceNode`.
+     * Pool limits are enforced: if the pool is full the configured eviction
+     * strategy picks a victim to stop before the new voice starts.
+     */
+    _createVoice(manager, options) {
+        const offset = this._clipStart + Math.max(0, options.time ?? 0);
+        if (offset >= this._clipEnd) {
+            return new NoopVoice(options.bus ?? manager.sound);
+        }
+        return this._buildVoice(manager, options, offset, {
+            base: this._clipStart,
+            end: this._clipEnd,
+            loopStart: this._clipStart,
+            loopEnd: this._clipEnd,
         });
-        this._paused = false;
-        this.onStart.dispatch();
-        return this;
     }
-    playSprite(name, options = {}) {
+    /**
+     * Create a voice for a named sprite clip.
+     * @internal Used by managers that want sprite-level playback.
+     */
+    _createSpriteVoice(manager, name, options = {}) {
         const clip = this._sprites.get(name);
         if (!clip) {
             throw new Error(`Sound sprite "${name}" is not defined.`);
@@ -362,196 +300,99 @@ class Sound extends AbstractMedia {
             throw new Error(`Sound sprite "${name}" offset (${clipOffset}s) exceeds clip duration (${clip.end - clip.start}s).`);
         }
         const loop = options.loop ?? clip.loop;
-        const playbackRate = clamp(options.playbackRate ?? this._playbackRate, 0.1, 20);
-        if (options.volume !== undefined) {
-            this.setVolume(options.volume);
-        }
-        if (options.muted !== undefined) {
-            this.setMuted(options.muted);
-        }
-        this._enqueuePooledPlay({
-            offset,
-            duration: loop ? undefined : clip.end - offset,
-            loop,
+        return this._buildVoice(manager, { ...options, loop }, offset, {
+            base: clip.start,
+            end: clip.end,
             loopStart: clip.start,
             loopEnd: clip.end,
-            playbackRate,
         });
-        this.onStart.dispatch();
-        return this;
     }
-    pause(options) {
-        if (options) {
-            this.applyOptions(options);
-        }
-        if (this._paused && this._pooledSources.length === 0) {
-            return this;
-        }
-        const hadPooledSources = this._pooledSources.length > 0;
-        const wasPlaying = !this._paused || hadPooledSources;
-        this._stopAllPooled();
-        this._queuedPooledPlays.length = 0;
-        this._paused = true;
-        if (wasPlaying) {
-            this.onStop.dispatch();
+    /**
+     * Shared voice construction for full-buffer and sprite playback. Enforces the
+     * pool limit, builds the {@link SoundVoice}, seeds spatialization from the
+     * descriptor's position, and tracks the voice for eviction.
+     */
+    _buildVoice(manager, options, offset, window) {
+        const loop = options.loop ?? this.loop;
+        const playbackRate = clamp(options.playbackRate ?? this.playbackRate, 0.1, 20);
+        const detune = options.detune ?? 0;
+        const volume = clamp(options.muted ? 0 : (options.volume ?? (this.muted ? 0 : this.volume)), 0, 1);
+        const bus = options.bus ?? manager.sound;
+        // Pool eviction: stop the victim voice if we're at capacity.
+        this._pruneEndedVoices();
+        if (this._activeVoices.length >= this._poolSize) {
+            const victimIndex = this._pickEvictionVictim();
+            const victim = this._activeVoices[victimIndex];
+            if (victim) {
+                this._activeVoices.splice(victimIndex, 1);
+                victim.voice.stop();
+            }
         }
-        return this;
-    }
-    _getAudioSetup() {
-        return this._audioSetup;
-    }
-    _defaultBus() {
-        return getAudioManager().sound;
-    }
-    _disconnectFromBus() {
-        if (this._audioSetup) {
-            // Disconnect the upstream node (panner if spatial, else gainNode)
-            const upstream = this._pannerNode ?? this._audioSetup.gainNode;
-            upstream.disconnect();
+        const audioContext = getAudioContext();
+        const output = audioContext.createGain();
+        const voice = new SoundVoice({
+            audioContext,
+            output,
+            bus,
+            manager,
+            volume,
+            spatial: {
+                distanceModel: this._distanceModel,
+                refDistance: this._refDistance,
+                maxDistance: this._maxDistance,
+                rolloffFactor: this._rolloffFactor,
+            },
+            buffer: this._audioBuffer,
+            loop,
+            playbackRate,
+            detune,
+            offset,
+            window,
+        });
+        // Seed spatialization from the descriptor's position (initial value only;
+        // move a live voice via `voice.position` or `voice.follow(node)`).
+        if (this._position !== null) {
+            voice.position = this._position;
         }
-    }
-    _connectToBus() {
-        if (this._audioSetup) {
-            const upstream = this._pannerNode ?? this._audioSetup.gainNode;
-            const inputNode = this.bus._getInputNode();
-            if (inputNode) {
-                upstream.connect(inputNode);
-            }
-            else {
-                upstream.connect(this._audioSetup.audioContext.destination);
+        const startedAt = audioContext.currentTime;
+        const effectiveDuration = loop ? Infinity : window.end - offset;
+        const pooledVoice = { voice, startedAt, effectiveDuration };
+        voice.onEnd.add(() => {
+            const index = this._activeVoices.indexOf(pooledVoice);
+            if (index !== -1) {
+                this._activeVoices.splice(index, 1);
             }
+        });
+        this._activeVoices.push(pooledVoice);
+        return voice;
+    }
+    /** Stop all currently active voices (e.g. for replace mode). */
+    _stopAllVoices() {
+        const voices = [...this._activeVoices];
+        this._activeVoices.length = 0;
+        for (const pv of voices) {
+            pv.voice.stop();
         }
     }
     destroy() {
-        if (this._pannerNode !== null) {
-            this._pannerNode.disconnect();
-            this._pannerNode = null;
-        }
+        this._stopAllVoices();
+        this._sprites.clear();
         if (this._position !== null) {
             this._position.destroy();
             this._position = null;
-            getAudioManager()._unregisterSpatialSound(this);
         }
         if (this._velocity !== null) {
             this._velocity.destroy();
             this._velocity = null;
         }
-        super.destroy();
-        onAudioContextReady.remove(this._onAudioContextReady);
-        this._audioSetup?.gainNode.disconnect();
-        this._stopAllPooled();
-        this._queuedPooledPlays.length = 0;
-        this._sprites.clear();
-    }
-    /** Internal: called by AudioManager.update() once per frame for spatial sounds. */
-    _tickSpatial() {
-        if (this._pannerNode === null || this._position === null)
-            return;
-        const ctx = this._pannerNode.context;
-        const t = ctx.currentTime;
-        const panner = this._pannerNode;
-        if (panner.positionX) {
-            panner.positionX.setValueAtTime(this._position.x, t);
-            panner.positionY.setValueAtTime(this._position.y, t);
-            panner.positionZ.setValueAtTime(0, t);
-        }
-        else if (panner.setPosition) {
-            panner.setPosition(this._position.x, this._position.y, 0);
-        }
-    }
-    _setupSpatial() {
-        if (!this._audioSetup || this._pannerNode !== null)
-            return;
-        const ctx = this._audioSetup.audioContext;
-        const panner = ctx.createPanner();
-        panner.panningModel = 'equalpower';
-        panner.distanceModel = this._distanceModel;
-        panner.refDistance = this._refDistance;
-        panner.maxDistance = this._maxDistance;
-        panner.rolloffFactor = this._rolloffFactor;
-        this._pannerNode = panner;
-        // Re-route: gainNode → pannerNode → bus.inputNode
-        this._audioSetup.gainNode.disconnect();
-        this._audioSetup.gainNode.connect(panner);
-        const busInput = this.bus._getInputNode();
-        if (busInput) {
-            panner.connect(busInput);
-        }
-        else {
-            panner.connect(ctx.destination);
-        }
-    }
-    _teardownSpatial() {
-        if (!this._audioSetup || this._pannerNode === null)
-            return;
-        this._audioSetup.gainNode.disconnect();
-        this._pannerNode.disconnect();
-        this._pannerNode = null;
-        // Restore: gainNode → bus.inputNode
-        const busInput = this.bus._getInputNode();
-        if (busInput) {
-            this._audioSetup.gainNode.connect(busInput);
-        }
-        else {
-            this._audioSetup.gainNode.connect(this._audioSetup.audioContext.destination);
-        }
     }
-    setupWithAudioContext(audioContext) {
-        const gainNode = audioContext.createGain();
-        gainNode.gain.setTargetAtTime(this.muted ? 0 : this.volume, audioContext.currentTime, 0.01);
-        const inputNode = this.bus._getInputNode();
-        if (inputNode) {
-            gainNode.connect(inputNode);
-        }
-        else {
-            gainNode.connect(audioContext.destination);
-        }
-        this._audioSetup = { audioContext, gainNode };
-        this._flushQueuedPooledPlays();
-    }
-    _enqueuePooledPlay(play) {
-        if (!this._audioSetup) {
-            this._queuedPooledPlays.push(play);
-            return;
-        }
-        this._playPooledNow(play);
-    }
-    _flushQueuedPooledPlays() {
-        if (!this._audioSetup || this._queuedPooledPlays.length === 0) {
-            return;
-        }
-        const queued = [...this._queuedPooledPlays];
-        this._queuedPooledPlays.length = 0;
-        for (const play of queued) {
-            this._playPooledNow(play);
-        }
-    }
-    _playPooledNow(play) {
-        if (!this._audioSetup) {
-            return;
-        }
-        const { audioContext } = this._audioSetup;
-        const sourceNode = this._createBufferSourceNode(this._audioSetup, play);
-        const startedAt = audioContext.currentTime;
-        const effectiveDuration = play.loop ? Infinity : (play.duration ?? Infinity);
-        const pooledSource = { node: sourceNode, startedAt, effectiveDuration };
-        sourceNode.onended = () => {
-            const index = this._pooledSources.indexOf(pooledSource);
-            if (index !== -1) {
-                this._pooledSources.splice(index, 1);
+    _pruneEndedVoices() {
+        for (let i = this._activeVoices.length - 1; i >= 0; i--) {
+            if (this._activeVoices[i]?.voice.ended === true) {
+                this._activeVoices.splice(i, 1);
             }
-            sourceNode.disconnect();
-            if (this._pooledSources.length === 0 && this._queuedPooledPlays.length === 0) {
-                this._paused = true;
-            }
-        };
-        this._pooledSources.push(pooledSource);
-        this._trimPooledSources();
+        }
     }
-    /**
-     * Pick the index within `_pooledSources` of the source to evict.
-     * The returned index is always valid (0 .. length-1).
-     */
     _pickEvictionVictim() {
         switch (this._poolStrategy) {
             case SoundPoolStrategy.LeastRecentlyUsed: {
@@ -566,18 +407,15 @@ class Sound extends AbstractMedia {
                 return 0; // oldest
         }
     }
-    /**
-     * Returns the index of the source with the smallest remaining playback
-     * time (i.e. closest to its natural end). Used for `LeastRecentlyUsed`.
-     */
     _pickClosestToEnd() {
-        if (!this._audioSetup)
-            return 0;
-        const now = this._audioSetup.audioContext.currentTime;
+        const now = isAudioContextReady() ? getAudioContext().currentTime : 0;
         let minRemaining = Infinity;
         let minIndex = 0;
-        for (let i = 0; i < this._pooledSources.length; i++) {
-            const src = this._pooledSources[i];
+        for (let i = 0; i < this._activeVoices.length; i++) {
+            const src = this._activeVoices[i];
+            if (src === undefined) {
+                continue;
+            }
             const elapsed = now - src.startedAt;
             const remaining = src.effectiveDuration - elapsed;
             if (remaining < minRemaining) {
@@ -587,54 +425,15 @@ class Sound extends AbstractMedia {
         }
         return minIndex;
     }
-    _trimPooledSources() {
-        while (this._pooledSources.length > this._poolSize) {
+    _trimActiveVoices() {
+        while (this._activeVoices.length > this._poolSize) {
             const victimIndex = this._pickEvictionVictim();
-            const victim = this._pooledSources[victimIndex];
-            if (!victim) {
+            const victim = this._activeVoices[victimIndex];
+            if (!victim)
                 break;
-            }
-            this._pooledSources.splice(victimIndex, 1);
-            victim.node.onended = null;
-            this._stopSourceNode(victim.node);
-        }
-    }
-    /** Stop all pooled sources immediately (used by `replace: true` and `pause()`). */
-    _stopAllPooled() {
-        for (const pooledSource of this._pooledSources) {
-            pooledSource.node.onended = null;
-            this._stopSourceNode(pooledSource.node);
-        }
-        this._pooledSources.length = 0;
-    }
-    _stopSourceNode(sourceNode) {
-        try {
-            sourceNode.stop(0);
-        }
-        catch {
-            // source nodes can only be stopped once; ignore invalid state errors
-        }
-        sourceNode.disconnect();
-    }
-    _createBufferSourceNode(setup, play) {
-        const { gainNode } = setup;
-        const sourceNode = setup.audioContext.createBufferSource();
-        sourceNode.buffer = this._audioBuffer;
-        sourceNode.loop = play.loop;
-        sourceNode.playbackRate.value = play.playbackRate;
-        if (play.loop) {
-            sourceNode.loopStart = play.loopStart ?? 0;
-            sourceNode.loopEnd = play.loopEnd ?? this.duration;
-        }
-        sourceNode.connect(gainNode);
-        const duration = play.duration;
-        if (!play.loop && duration !== undefined && duration > 0) {
-            sourceNode.start(0, play.offset, duration);
-        }
-        else {
-            sourceNode.start(0, play.offset);
+            this._activeVoices.splice(victimIndex, 1);
+            victim.voice.stop();
         }
-        return sourceNode;
     }
 }