@goldenratio/wolf 0.0.2

package/target/wolf.js

@@ -0,0 +1,1606 @@
+// src/utils.ts
+function isHtml5Audio(node) {
+  return "play" in node && typeof node.play === "function";
+}
+function loadBuffer(howl, howler) {
+  const url = howl._src.toString();
+  const cache = howler.cache;
+  if (cache[url]) {
+    howl._duration = cache[url].duration;
+    loadSound(howl);
+    return;
+  }
+  if (/^data:[^;]+;base64,/.test(url)) {
+    const data = atob(url.split(",")[1] ?? "");
+    const dataView = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; ++i) {
+      dataView[i] = data.charCodeAt(i);
+    }
+    decodeAudioData(dataView.buffer, howl, howler);
+  } else {
+    const xhr = new XMLHttpRequest();
+    xhr.open(howl._xhr.method, url, true);
+    xhr.withCredentials = howl._xhr.withCredentials;
+    xhr.responseType = "arraybuffer";
+    if (howl._xhr.headers) {
+      Object.keys(howl._xhr.headers).forEach((key) => {
+        xhr.setRequestHeader(key, howl._xhr.headers[key]);
+      });
+    }
+    xhr.onload = () => {
+      const code = String(xhr.status)[0];
+      if (code !== "0" && code !== "2" && code !== "3") {
+        howl._emit("loaderror", void 0, `Failed loading audio file with status: ${xhr.status}.`);
+        return;
+      }
+      decodeAudioData(xhr.response, howl, howler);
+    };
+    xhr.onerror = () => {
+      if (howl._webAudio) {
+        howl._html5 = true;
+        howl._webAudio = false;
+        howl._sounds = [];
+        delete cache[url];
+        howl.load();
+      }
+    };
+    safeXhrSend(xhr);
+  }
+}
+function safeXhrSend(xhr) {
+  try {
+    xhr.send();
+  } catch {
+    xhr.onerror?.(new ProgressEvent("error"));
+  }
+}
+function decodeAudioData(arrayBuffer, howl, howler) {
+  const error = () => howl._emit("loaderror", void 0, "Decoding audio data failed.");
+  const success = (buffer) => {
+    if (buffer && howl._sounds.length > 0) {
+      howler.cache[howl._src.toString()] = buffer;
+      loadSound(howl, buffer);
+    } else {
+      error();
+    }
+  };
+  if (typeof Promise !== "undefined" && howler.ctx?.decodeAudioData.length === 1) {
+    howler.ctx.decodeAudioData(arrayBuffer).then(success).catch(error);
+  } else {
+    howler.ctx?.decodeAudioData(arrayBuffer, success, error);
+  }
+}
+function loadSound(self, buffer) {
+  if (buffer && !self._duration) self._duration = buffer.duration;
+  if (Object.keys(self._sprite).length === 0) {
+    self._sprite = { "__default": [0, self._duration * 1e3] };
+  }
+  if (self._state !== "loaded") {
+    self._state = "loaded";
+    self._emit("load");
+    self._loadQueue();
+  }
+}
+function setupAudioContext(howler) {
+  if (!howler.usingWebAudio) {
+    return;
+  }
+  try {
+    if (typeof AudioContext !== "undefined") {
+      howler.ctx = new AudioContext();
+    } else if (typeof webkitAudioContext !== "undefined") {
+      howler.ctx = new webkitAudioContext();
+    } else {
+      howler.usingWebAudio = false;
+    }
+  } catch {
+    howler.usingWebAudio = false;
+  }
+  if (!howler.ctx) {
+    howler.usingWebAudio = false;
+  }
+  const iOS = /iP(hone|od|ad)/.test(howler._navigator?.platform ?? "");
+  const appVersion = howler._navigator?.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/);
+  const version = appVersion ? parseInt(appVersion[1] ?? "", 10) : void 0;
+  if (iOS && version && version < 9) {
+    const safari = /safari/.test((howler._navigator?.userAgent ?? "").toLowerCase());
+    if (howler._navigator && !safari) {
+      howler.usingWebAudio = false;
+    }
+  }
+  if (howler.usingWebAudio && howler.ctx) {
+    howler.masterGain = typeof howler.ctx.createGain === "undefined" ? howler.ctx["createGainNode"]() : howler.ctx.createGain();
+    howler.masterGain?.gain.setValueAtTime(howler._muted ? 0 : howler._volume, howler.ctx.currentTime);
+    howler.masterGain?.connect(howler.ctx.destination);
+  }
+  howler._setup();
+}
+
+// src/howler.ts
+var HowlerGlobal = class {
+  // Internal
+  _counter;
+  _html5AudioPool;
+  html5PoolSize;
+  _codecs;
+  _howls;
+  _muted;
+  _volume;
+  _canPlayEvent;
+  _navigator;
+  _audioUnlocked;
+  _mobileUnloaded;
+  _scratchBuffer;
+  _suspendTimer;
+  _resumeAfterSuspend;
+  // Public
+  cache = {};
+  masterGain;
+  noAudio = false;
+  usingWebAudio = true;
+  autoSuspend = true;
+  ctx;
+  autoUnlock = true;
+  state = "suspended";
+  constructor() {
+    this._counter = 1e3;
+    this._html5AudioPool = [];
+    this.html5PoolSize = 10;
+    this._codecs = {};
+    this._howls = [];
+    this._muted = false;
+    this._volume = 1;
+    this._canPlayEvent = "canplaythrough";
+    this._navigator = typeof window !== "undefined" && window.navigator ? window.navigator : void 0;
+    this.masterGain = void 0;
+    this.noAudio = false;
+    this.usingWebAudio = true;
+    this.autoSuspend = true;
+    this.ctx = void 0;
+    this.autoUnlock = true;
+    this._setup();
+  }
+  volume(vol) {
+    const self = this;
+    const parsed = typeof vol === "undefined" ? void 0 : parseFloat(String(vol));
+    if (!self.ctx) {
+      setupAudioContext(self);
+    }
+    if (typeof parsed !== "undefined" && parsed >= 0 && parsed <= 1) {
+      self._volume = parsed;
+      if (self._muted) return self._volume;
+      if (self.usingWebAudio && self.masterGain && self.ctx) {
+        self.masterGain.gain.setValueAtTime(parsed, self.ctx.currentTime);
+      }
+      for (let i = 0; i < self._howls.length; i++) {
+        const howl = self._howls[i];
+        if (howl && !howl._webAudio) {
+          const ids = howl._getSoundIds();
+          for (let j = 0; j < ids.length; j++) {
+            const soundId = ids[j];
+            if (typeof soundId !== "number") {
+              continue;
+            }
+            const sound = howl._soundById(soundId);
+            if (sound && sound._node && isHtml5Audio(sound._node)) {
+              sound._node.volume = sound._volume * parsed;
+            }
+          }
+        }
+      }
+      return self;
+    }
+    return self._volume;
+  }
+  mute(muted) {
+    const self = this;
+    if (!self.ctx) {
+      setupAudioContext(self);
+    }
+    self._muted = muted;
+    if (self.usingWebAudio && self.masterGain && self.ctx) {
+      self.masterGain.gain.setValueAtTime(
+        muted ? 0 : self._volume,
+        self.ctx.currentTime
+      );
+    }
+    for (let i = 0; i < self._howls.length; i++) {
+      const howl = self._howls[i];
+      if (howl && !howl._webAudio) {
+        const ids = howl._getSoundIds();
+        for (let j = 0; j < ids.length; j++) {
+          const soundId = ids[j];
+          if (typeof soundId !== "number") {
+            continue;
+          }
+          const sound = howl._soundById(soundId);
+          if (sound && sound._node && isHtml5Audio(sound._node)) {
+            sound._node.muted = muted ? true : sound._muted;
+          }
+        }
+      }
+    }
+    return self;
+  }
+  stop() {
+    const self = this;
+    for (let i = 0; i < self._howls.length; i++) {
+      self._howls[i]?.stop();
+    }
+    return self;
+  }
+  unload() {
+    const self = this;
+    for (let i = self._howls.length - 1; i >= 0; i--) {
+      self._howls[i]?.unload();
+    }
+    if (self.usingWebAudio && self.ctx && typeof self.ctx.close !== "undefined") {
+      self.ctx.close();
+      self.ctx = void 0;
+      setupAudioContext(self);
+    }
+    return self;
+  }
+  codecs(ext) {
+    return this._codecs[ext.replace(/^x-/, "")] ?? false;
+  }
+  _setup() {
+    const self = this;
+    self.state = self.ctx ? self.ctx.state || "suspended" : "suspended";
+    self._autoSuspend();
+    if (!self.usingWebAudio) {
+      if (typeof Audio !== "undefined") {
+        try {
+          const test = new Audio();
+          if (typeof test.oncanplaythrough === "undefined") {
+            self._canPlayEvent = "canplay";
+          }
+        } catch {
+          self.noAudio = true;
+        }
+      } else {
+        self.noAudio = true;
+      }
+    }
+    try {
+      const test = new Audio();
+      if (test.muted) self.noAudio = true;
+    } catch {
+    }
+    if (!self.noAudio) {
+      self._setupCodecs();
+    }
+  }
+  _setupCodecs() {
+    const self = this;
+    let audioTest = void 0;
+    try {
+      audioTest = typeof Audio !== "undefined" ? new Audio() : void 0;
+    } catch {
+      return;
+    }
+    if (!audioTest || typeof audioTest.canPlayType !== "function") {
+      return;
+    }
+    const mpegTest = audioTest.canPlayType("audio/mpeg;").replace(/^no$/, "");
+    const ua = self._navigator ? self._navigator.userAgent : "";
+    const checkOpera = ua.match(/OPR\/(\d+)/g);
+    const isOldOpera = !!(checkOpera && parseInt(checkOpera[0]?.split("/")[1] ?? "", 10) < 33);
+    const checkSafari = ua.indexOf("Safari") !== -1 && ua.indexOf("Chrome") === -1;
+    const safariVersion = ua.match(/Version\/(.*?) /);
+    const isOldSafari = !!(checkSafari && safariVersion && parseInt(safariVersion[1] ?? "", 10) < 15);
+    self._codecs = {
+      "mp3": !!(!isOldOpera && (mpegTest || audioTest.canPlayType("audio/mp3;").replace(/^no$/, ""))),
+      "mpeg": !!mpegTest,
+      "opus": !!audioTest.canPlayType('audio/ogg; codecs="opus"').replace(/^no$/, ""),
+      "ogg": !!audioTest.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, ""),
+      "oga": !!audioTest.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, ""),
+      "wav": !!(audioTest.canPlayType('audio/wav; codecs="1"') || audioTest.canPlayType("audio/wav")).replace(/^no$/, ""),
+      "aac": !!audioTest.canPlayType("audio/aac;").replace(/^no$/, ""),
+      "caf": !!audioTest.canPlayType("audio/x-caf;").replace(/^no$/, ""),
+      "m4a": !!(audioTest.canPlayType("audio/x-m4a;") || audioTest.canPlayType("audio/m4a;") || audioTest.canPlayType("audio/aac;")).replace(/^no$/, ""),
+      "m4b": !!(audioTest.canPlayType("audio/x-m4b;") || audioTest.canPlayType("audio/m4b;") || audioTest.canPlayType("audio/aac;")).replace(/^no$/, ""),
+      "mp4": !!(audioTest.canPlayType("audio/x-mp4;") || audioTest.canPlayType("audio/mp4;") || audioTest.canPlayType("audio/aac;")).replace(/^no$/, ""),
+      "weba": !!(!isOldSafari && audioTest.canPlayType('audio/webm; codecs="vorbis"').replace(/^no$/, "")),
+      "webm": !!(!isOldSafari && audioTest.canPlayType('audio/webm; codecs="vorbis"').replace(/^no$/, "")),
+      "dolby": !!audioTest.canPlayType('audio/mp4; codecs="ec-3"').replace(/^no$/, ""),
+      "flac": !!(audioTest.canPlayType("audio/x-flac;") || audioTest.canPlayType("audio/flac;")).replace(/^no$/, "")
+    };
+  }
+  _unlockAudio() {
+    const self = this;
+    if (self._audioUnlocked || !self.ctx) {
+      return;
+    }
+    self._audioUnlocked = false;
+    self.autoUnlock = false;
+    if (!self._mobileUnloaded && self.ctx.sampleRate !== 44100) {
+      self._mobileUnloaded = true;
+      self.unload();
+    }
+    self._scratchBuffer = self.ctx.createBuffer(1, 1, 22050);
+    const unlock = () => {
+      while (self._html5AudioPool.length < self.html5PoolSize) {
+        try {
+          const audioNode = new Audio();
+          audioNode._unlocked = true;
+          self._releaseHtml5Audio(audioNode);
+        } catch {
+          self.noAudio = true;
+          break;
+        }
+      }
+      for (let i = 0; i < self._howls.length; i++) {
+        const howl = self._howls[i];
+        if (howl && !howl._webAudio) {
+          const ids = howl._getSoundIds();
+          for (let j = 0; j < ids.length; j++) {
+            const soundId = ids[j];
+            if (typeof soundId !== "number") {
+              continue;
+            }
+            const sound = howl._soundById(soundId);
+            if (sound && sound._node && isHtml5Audio(sound._node) && !sound._node._unlocked) {
+              sound._node._unlocked = true;
+              sound._node.load();
+            }
+          }
+        }
+      }
+      self._autoResume();
+      if (self.ctx) {
+        const source = self.ctx.createBufferSource();
+        source.buffer = self._scratchBuffer ?? null;
+        source.connect(self.ctx.destination);
+        if (typeof source.start === "undefined") {
+          if ("noteOn" in source && typeof source.noteOn === "function") {
+            source.noteOn(0);
+          }
+        } else {
+          source.start(0);
+        }
+        if (typeof self.ctx.resume === "function") {
+          self.ctx.resume();
+        }
+        source.onended = () => {
+          source.disconnect();
+          self._audioUnlocked = true;
+          document.removeEventListener("touchstart", unlock, true);
+          document.removeEventListener("touchend", unlock, true);
+          document.removeEventListener("click", unlock, true);
+          document.removeEventListener("keydown", unlock, true);
+          for (let i = 0; i < self._howls.length; i++) {
+            self._howls[i]?._emit("unlock");
+          }
+        };
+      }
+    };
+    document.addEventListener("touchstart", unlock, true);
+    document.addEventListener("touchend", unlock, true);
+    document.addEventListener("click", unlock, true);
+    document.addEventListener("keydown", unlock, true);
+  }
+  _obtainHtml5Audio() {
+    const self = this;
+    if (self._html5AudioPool.length) {
+      return self._html5AudioPool.pop();
+    }
+    const testPlay = new Audio().play();
+    testPlay.catch(() => {
+    });
+    return new Audio();
+  }
+  _releaseHtml5Audio(audio) {
+    const self = this;
+    if (audio._unlocked) {
+      self._html5AudioPool.push(audio);
+    }
+    return self;
+  }
+  _autoSuspend() {
+    const self = this;
+    if (!self.autoSuspend || !self.ctx || typeof self.ctx.suspend === "undefined" || !self.usingWebAudio) {
+      return;
+    }
+    for (let i = 0; i < self._howls.length; i++) {
+      const howl = self._howls[i];
+      if (howl && howl._webAudio) {
+        for (let j = 0; j < howl._sounds.length; j++) {
+          if (!howl._sounds[j]?._paused) {
+            return;
+          }
+        }
+      }
+    }
+    if (self._suspendTimer) {
+      clearTimeout(self._suspendTimer);
+    }
+    self._suspendTimer = setTimeout(() => {
+      if (!self.autoSuspend) {
+        return;
+      }
+      self._suspendTimer = void 0;
+      self.state = "suspending";
+      const handleSuspension = () => {
+        self.state = "suspended";
+        if (self._resumeAfterSuspend) {
+          delete self._resumeAfterSuspend;
+          self._autoResume();
+        }
+      };
+      self.ctx?.suspend().then(handleSuspension, handleSuspension);
+    }, 3e4);
+  }
+  _autoResume() {
+    const self = this;
+    if (!self.ctx || typeof self.ctx.resume === "undefined" || !self.usingWebAudio) {
+      return;
+    }
+    if (self.state === "running" && self.ctx.state !== "interrupted" && self._suspendTimer) {
+      clearTimeout(self._suspendTimer);
+      self._suspendTimer = void 0;
+    } else if (self.state === "suspended" || self.state === "running" && self.ctx.state === "interrupted") {
+      self.ctx.resume().then(() => {
+        self.state = "running";
+        for (let i = 0; i < self._howls.length; i++) {
+          self._howls[i]?._emit("resume");
+        }
+      });
+      if (self._suspendTimer) {
+        clearTimeout(self._suspendTimer);
+        self._suspendTimer = void 0;
+      }
+    } else if (self.state === "suspending") {
+      self._resumeAfterSuspend = true;
+    }
+  }
+};
+var Howler = new HowlerGlobal();
+
+// src/sound.ts
+var Sound = class {
+  howler;
+  parent;
+  _muted;
+  _loop;
+  _volume;
+  _rate;
+  _seek = 0;
+  _rateSeek = 0;
+  _paused = true;
+  _ended = true;
+  _sprite = "__default";
+  _id;
+  _node;
+  _panner;
+  _start = 0;
+  _stop = 0;
+  _playStart = 0;
+  _interval = void 0;
+  _fadeTo = void 0;
+  _errorFn;
+  _loadFn;
+  _endFn;
+  constructor(parent, howler) {
+    this.parent = parent;
+    this.howler = howler;
+    this._muted = parent._muted;
+    this._loop = parent._loop;
+    this._volume = parent._volume;
+    this._rate = parent._rate;
+    this._seek = 0;
+    this._paused = true;
+    this._ended = true;
+    this._sprite = "__default";
+    this._id = ++howler._counter;
+    parent._sounds.push(this);
+    const volume = this.howler._muted || this._muted || parent._muted ? 0 : this._volume;
+    if (parent._webAudio) {
+      const gain = typeof this.howler.ctx?.createGain === "undefined" ? this.howler.ctx["createGainNode"]() : this.howler.ctx.createGain();
+      this._node = gain;
+      this._node.gain.setValueAtTime(volume, this.howler.ctx?.currentTime ?? 0);
+      this._node.paused = true;
+      if (this.howler.masterGain) {
+        this._node.connect(this.howler.masterGain);
+      }
+    } else if (!this.howler.noAudio) {
+      this._node = this.howler._obtainHtml5Audio();
+      this._errorFn = this.errorListener.bind(this);
+      this._node.addEventListener("error", this._errorFn, false);
+      this._loadFn = this.loadListener.bind(this);
+      this._node.addEventListener(this.howler._canPlayEvent, this._loadFn, false);
+      this._endFn = this.endListener.bind(this);
+      this._node.addEventListener("ended", this._endFn, false);
+      this._node.src = parent._src.toString();
+      const preload = parent._preload === true ? "auto" : parent._preload;
+      this._node.preload = preload === false ? "" : preload;
+      this._node.volume = volume * this.howler.volume();
+      this._node.load();
+    }
+  }
+  reset() {
+    const self = this;
+    const parent = self.parent;
+    self._muted = parent._muted;
+    self._loop = parent._loop;
+    self._volume = parent._volume;
+    self._rate = parent._rate;
+    self._seek = 0;
+    self._rateSeek = 0;
+    self._paused = true;
+    self._ended = true;
+    self._sprite = "__default";
+    self._id = ++this.howler._counter;
+    return self;
+  }
+  errorListener() {
+    const self = this;
+    const html = self._node;
+    self.parent._emit("loaderror", self._id, html.error ? html.error.code.toString() : "0");
+    html.removeEventListener("error", self._errorFn, false);
+  }
+  loadListener() {
+    const self = this;
+    const parent = self.parent;
+    const html = self._node;
+    parent._duration = Math.ceil(html.duration * 10) / 10;
+    if (Object.keys(parent._sprite).length === 0) {
+      parent._sprite = { "__default": [0, parent._duration * 1e3] };
+    }
+    if (parent._state !== "loaded") {
+      parent._state = "loaded";
+      parent._emit("load");
+      parent._loadQueue();
+    }
+    html.removeEventListener(this.howler._canPlayEvent, self._loadFn, false);
+  }
+  endListener() {
+    const self = this;
+    const parent = self.parent;
+    const html = self._node;
+    if (parent._duration === Infinity) {
+      parent._duration = Math.ceil(html.duration * 10) / 10;
+      const defaultSprite = parent._sprite["__default"];
+      if (defaultSprite && defaultSprite[1] === Infinity) {
+        defaultSprite[1] = parent._duration * 1e3;
+      }
+      parent._ended(self);
+    }
+    html.removeEventListener("ended", self._endFn, false);
+  }
+};
+
+// src/howl.ts
+var Howl = class {
+  howler;
+  // User-defined
+  _autoplay;
+  _format;
+  _html5;
+  _muted;
+  _loop;
+  _pool;
+  _preload;
+  _rate;
+  _sprite;
+  _src;
+  _volume;
+  _xhr;
+  // Internals
+  _duration = 0;
+  _state = "unloaded";
+  _sounds = [];
+  _endTimers = {};
+  _queue = [];
+  _playLock = false;
+  _webAudio = true;
+  _onend;
+  _onfade;
+  _onload;
+  _onloaderror;
+  _onplayerror;
+  _onpause;
+  _onplay;
+  _onstop;
+  _onmute;
+  _onvolume;
+  _onrate;
+  _onseek;
+  _onunlock;
+  _onresume;
+  constructor(options) {
+    this.howler = Howler;
+    if (!this.howler.ctx) {
+      setupAudioContext(this.howler);
+    }
+    this._autoplay = options["autoplay"] || false;
+    this._format = typeof options["format"] !== "string" ? options["format"] : [options["format"]];
+    this._html5 = options["html5"] || false;
+    this._muted = options["mute"] || false;
+    this._loop = options["loop"] || false;
+    this._pool = options["pool"] || 5;
+    this._preload = typeof options["preload"] === "boolean" || options["preload"] === "metadata" ? options["preload"] : true;
+    this._rate = options["rate"] || 1;
+    this._sprite = options["sprite"] || {};
+    this._src = typeof options["src"] !== "string" ? options["src"] : [options["src"]];
+    this._volume = options["volume"] !== void 0 ? options["volume"] : 1;
+    this._xhr = {
+      method: options["xhr"]?.method ?? "GET",
+      headers: options["xhr"]?.headers ?? void 0,
+      withCredentials: options["xhr"]?.withCredentials ?? false
+    };
+    this._duration = 0;
+    this._state = "unloaded";
+    this._sounds = [];
+    this._endTimers = {};
+    this._queue = [];
+    this._playLock = false;
+    this["_onend"] = options["onend"] ? [{ fn: options["onend"] }] : [];
+    this["_onfade"] = options["onfade"] ? [{ fn: options["onfade"] }] : [];
+    this["_onload"] = options["onload"] ? [{ fn: options["onload"] }] : [];
+    this["_onloaderror"] = options["onloaderror"] ? [{ fn: options["onloaderror"] }] : [];
+    this["_onplayerror"] = options["onplayerror"] ? [{ fn: options["onplayerror"] }] : [];
+    this["_onpause"] = options["onpause"] ? [{ fn: options["onpause"] }] : [];
+    this["_onplay"] = options["onplay"] ? [{ fn: options["onplay"] }] : [];
+    this["_onstop"] = options["onstop"] ? [{ fn: options["onstop"] }] : [];
+    this["_onmute"] = options["onmute"] ? [{ fn: options["onmute"] }] : [];
+    this["_onvolume"] = options["onvolume"] ? [{ fn: options["onvolume"] }] : [];
+    this["_onrate"] = options["onrate"] ? [{ fn: options["onrate"] }] : [];
+    this["_onseek"] = options["onseek"] ? [{ fn: options["onseek"] }] : [];
+    this["_onunlock"] = options["onunlock"] ? [{ fn: options["onunlock"] }] : [];
+    this["_onresume"] = options["onresume"] ? [{ fn: options["onresume"] }] : [];
+    this._webAudio = this.howler.usingWebAudio && !this._html5;
+    if (this.howler.ctx && this.howler.autoUnlock) {
+      this.howler._unlockAudio();
+    }
+    this.howler._howls.push(this);
+    if (this._autoplay) {
+      this._queue.push({ event: "play", action: () => this.play() });
+    }
+    if (this._preload && this._preload !== "none") {
+      this.load();
+    }
+  }
+  load() {
+    const self = this;
+    if (this.howler.noAudio) {
+      self._emit("loaderror", void 0, "No audio support.");
+      return;
+    }
+    let url = void 0;
+    for (let i = 0; i < self._src.length; i++) {
+      let ext;
+      let str;
+      if (self._format && self._format[i]) {
+        ext = self._format[i];
+      } else {
+        str = self._src[i] ?? "";
+        if (typeof str !== "string" || str === "") {
+          self._emit("loaderror", void 0, "Non-string found in selected audio sources - ignoring.");
+          continue;
+        }
+        const dataExt = /^data:audio\/([^;,]+);/i.exec(str);
+        if (dataExt) ext = dataExt[1]?.toLowerCase();
+        else {
+          const m = /\.([^.]+)$/.exec(str.split("?", 1)[0] ?? "");
+          if (m) {
+            ext = m[1]?.toLowerCase();
+          }
+        }
+      }
+      if (!ext) {
+      }
+      if (ext && this.howler.codecs(ext)) {
+        url = self._src[i];
+        break;
+      }
+    }
+    if (!url) {
+      self._emit("loaderror", void 0, "No codec support for selected audio sources.");
+      return;
+    }
+    self._src = [url];
+    self._state = "loading";
+    if (typeof window !== "undefined" && window.location.protocol === "https:" && url.slice(0, 5) === "http:") {
+      self._html5 = true;
+      self._webAudio = false;
+    }
+    new Sound(self, this.howler);
+    if (self._webAudio) {
+      loadBuffer(self, this.howler);
+    }
+  }
+  play(spriteOrId, internal) {
+    const self = this;
+    let id = void 0;
+    if (typeof spriteOrId === "number") {
+      id = spriteOrId;
+      spriteOrId = void 0;
+    } else if (typeof spriteOrId === "string" && self._state === "loaded" && !self._sprite[spriteOrId]) {
+      return void 0;
+    } else if (typeof spriteOrId === "undefined") {
+      spriteOrId = "__default";
+      if (!self._playLock) {
+        let num = 0;
+        for (let i = 0; i < self._sounds.length; i++) {
+          if (self._sounds[i]?._paused && !self._sounds[i]?._ended) {
+            num++;
+            id = self._sounds[i]?._id;
+          }
+        }
+        if (num === 1) {
+          spriteOrId = void 0;
+        } else {
+          id = void 0;
+        }
+      }
+    }
+    const sound = id ? self._soundById(id) : self._inactiveSound();
+    if (!sound) {
+      return void 0;
+    }
+    if (id && !spriteOrId) {
+      spriteOrId = sound._sprite || "__default";
+    }
+    if (self._state !== "loaded") {
+      sound._sprite = spriteOrId?.toString() ?? "__default";
+      sound._ended = false;
+      const soundId = sound._id;
+      self._queue.push({ event: "play", action: () => self.play(soundId) });
+      return soundId;
+    }
+    if (id && !sound._paused) {
+      if (!internal) self._loadQueue("play");
+      return sound._id;
+    }
+    if (self._webAudio) {
+      this.howler._autoResume();
+    }
+    const spriteName = spriteOrId ?? "__default";
+    const seek = Math.max(0, sound._seek > 0 ? sound._seek : (self._sprite[spriteName]?.[0] ?? 0) / 1e3);
+    const spriteDef = self._sprite[spriteName];
+    const duration = spriteDef ? Math.max(
+      0,
+      (spriteDef[0] + spriteDef[1]) / 1e3 - seek
+    ) : 0;
+    const timeout = duration * 1e3 / Math.abs(sound._rate);
+    const start = spriteDef ? spriteDef[0] / 1e3 : 0;
+    const stop = spriteDef ? (spriteDef[0] + spriteDef[1]) / 1e3 : 0;
+    sound._sprite = spriteName;
+    sound._ended = false;
+    const setParams = () => {
+      sound._paused = false;
+      sound._seek = seek;
+      sound._start = start;
+      sound._stop = stop;
+      sound._loop = !!(sound._loop || (self._sprite[spriteName]?.[2] ?? false));
+    };
+    if (seek >= stop) {
+      self._ended(sound);
+      return sound._id;
+    }
+    const node = sound._node;
+    if (self._webAudio) {
+      const playWebAudio = () => {
+        self._playLock = false;
+        setParams();
+        self._refreshBuffer(sound);
+        const vol = sound._muted || self._muted ? 0 : sound._volume;
+        node.gain.setValueAtTime(vol, this.howler.ctx?.currentTime ?? 0);
+        sound._playStart = this.howler.ctx?.currentTime ?? 0;
+        const bs = node.bufferSource;
+        if (typeof bs.start === "undefined") {
+          if ("noteGrainOn" in bs && typeof bs.noteGrainOn === "function")
+            sound._loop ? bs.noteGrainOn(0, seek, 86400) : bs.noteGrainOn(0, seek, duration);
+        } else {
+          sound._loop ? bs.start(0, seek, 86400) : bs.start(0, seek, duration);
+        }
+        if (timeout !== Infinity) {
+          self._endTimers[sound._id] = setTimeout(() => self._ended(sound), timeout);
+        }
+        if (!internal) {
+          setTimeout(() => {
+            self._emit("play", sound._id);
+            self._loadQueue();
+          }, 0);
+        }
+      };
+      if (this.howler.state === "running" && this.howler.ctx?.state !== "interrupted") {
+        playWebAudio();
+      } else {
+        self._playLock = true;
+        self.once("resume", () => {
+          playWebAudio();
+        });
+        self._clearTimer(sound._id);
+      }
+    } else {
+      const html = node;
+      const playHtml5 = () => {
+        html.currentTime = seek;
+        html.muted = sound._muted || self._muted || this.howler._muted || html.muted;
+        html.volume = sound._volume * this.howler.volume();
+        html.playbackRate = sound._rate;
+        try {
+          const p = html.play();
+          if (p && typeof Promise !== "undefined" && (p instanceof Promise || typeof p["then"] === "function")) {
+            self._playLock = true;
+            setParams();
+            p.then(() => {
+              self._playLock = false;
+              html._unlocked = true;
+              if (!internal) self._emit("play", sound._id);
+              else self._loadQueue();
+            }).catch(() => {
+              self._playLock = false;
+              self._emit(
+                "playerror",
+                sound._id,
+                "Playback was unable to start. This is most commonly an issue on mobile devices and Chrome where playback was not within a user interaction."
+              );
+              sound._ended = true;
+              sound._paused = true;
+            });
+          } else if (!internal) {
+            self._playLock = false;
+            setParams();
+            self._emit("play", sound._id);
+          }
+          html.playbackRate = sound._rate;
+          if (html.paused) {
+            self._emit(
+              "playerror",
+              sound._id,
+              "Playback was unable to start. This is most commonly an issue on mobile devices and Chrome where playback was not within a user interaction."
+            );
+            return;
+          }
+          if (spriteName !== "__default" || sound._loop) {
+            self._endTimers[sound._id] = setTimeout(() => self._ended(sound), timeout);
+          } else {
+            self._endTimers[sound._id] = () => {
+              self._ended(sound);
+              html.removeEventListener("ended", self._endTimers[sound._id], false);
+            };
+            html.addEventListener("ended", self._endTimers[sound._id], false);
+          }
+        } catch (err) {
+          self._emit("playerror", sound._id, err);
+        }
+      };
+      if (html.src === "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA") {
+        html.src = self._src.toString();
+        html.load();
+      }
+      if (html.readyState >= 3) {
+        playHtml5();
+      } else {
+        self._playLock = true;
+        self._state = "loading";
+        const listener = () => {
+          self._state = "loaded";
+          playHtml5();
+          html.removeEventListener(this.howler._canPlayEvent, listener, false);
+        };
+        html.addEventListener(this.howler._canPlayEvent, listener, false);
+        self._clearTimer(sound._id);
+      }
+    }
+    return sound._id;
+  }
+  state() {
+    return this._state;
+  }
+  /**
+   * Check if a sound (or any sound) is playing.
+   */
+  playing(id) {
+    const self = this;
+    if (typeof id === "number") {
+      const sound = self._soundById(id);
+      return sound ? !sound._paused : false;
+    }
+    for (let i = 0; i < self._sounds.length; i++) {
+      if (!self._sounds[i]?._paused) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Duration of group, or sprite duration if sound id passed.
+   */
+  duration(id) {
+    const self = this;
+    let duration = self._duration;
+    const sound = typeof id === "number" ? self._soundById(id) : void 0;
+    if (sound) {
+      duration = (self._sprite[sound._sprite]?.[1] ?? 0) / 1e3;
+    }
+    return duration;
+  }
+  /**
+   * Pause playback and save current position.
+   */
+  pause(id, internal) {
+    const self = this;
+    if (self._state !== "loaded" || self._playLock) {
+      self._queue.push({ event: "pause", action: () => self.pause(id) });
+      return self;
+    }
+    const ids = self._getSoundIds(id);
+    for (let i = 0; i < ids.length; i++) {
+      self._clearTimer(ids[i] ?? 0);
+      const sound = self._soundById(ids[i] ?? 0);
+      if (sound && !sound._paused) {
+        sound._seek = self.seek(ids[i] ?? 0);
+        sound._rateSeek = 0;
+        sound._paused = true;
+        self._stopFade(ids[i] ?? 0);
+        if (sound._node) {
+          if (self._webAudio && !isHtml5Audio(sound._node)) {
+            const n = sound._node;
+            if (!n.bufferSource) continue;
+            if (typeof n.bufferSource.stop === "undefined") n.bufferSource.noteOff(0);
+            else n.bufferSource.stop(0);
+            self._cleanBuffer(n);
+          } else if (isHtml5Audio(sound._node) && (!isNaN(sound._node.duration) || sound._node.duration === Infinity)) {
+            sound._node.pause();
+          }
+        }
+      }
+      if (!internal) {
+        self._emit("pause", sound ? sound._id : void 0);
+      }
+    }
+    return self;
+  }
+  rate(rateOrId, idMaybe) {
+    const self = this;
+    const argsLen = arguments.length;
+    let rate;
+    let id;
+    if (argsLen === 0) {
+      id = self._sounds[0]?._id;
+    } else if (argsLen === 1) {
+      const ids = self._getSoundIds();
+      const index = ids.indexOf(rateOrId);
+      if (index >= 0) id = parseInt(String(rateOrId), 10);
+      else rate = parseFloat(String(rateOrId));
+    } else if (argsLen === 2) {
+      rate = parseFloat(String(rateOrId));
+      id = parseInt(String(idMaybe), 10);
+    }
+    if (typeof rate === "number") {
+      if (self._state !== "loaded" || self._playLock) {
+        const capturedArgs = [...arguments];
+        self._queue.push({
+          event: "rate",
+          action: () => self.rate.apply(self, capturedArgs)
+        });
+        return self;
+      }
+      if (typeof id === "undefined") self._rate = rate;
+      const ids = self._getSoundIds(id);
+      for (let i = 0; i < ids.length; i++) {
+        const sound2 = self._soundById(ids[i] ?? 0);
+        if (!sound2) continue;
+        if (self.playing(ids[i])) {
+          sound2._rateSeek = self.seek(ids[i] ?? 0);
+          sound2._playStart = self._webAudio ? Howler.ctx.currentTime : sound2._playStart;
+        }
+        sound2._rate = rate;
+        if (self._webAudio && sound2._node && !isHtml5Audio(sound2._node)) {
+          const n = sound2._node;
+          if (n.bufferSource) n.bufferSource.playbackRate.setValueAtTime(rate, Howler.ctx.currentTime);
+        } else if (sound2._node && isHtml5Audio(sound2._node)) {
+          sound2._node.playbackRate = rate;
+        }
+        const seek = self.seek(ids[i] ?? 0);
+        const sprite = self._sprite[sound2._sprite];
+        const duration = sprite ? (sprite[0] + sprite[1]) / 1e3 - seek : 0;
+        const timeout = duration * 1e3 / Math.abs(sound2._rate);
+        const sId = ids[i];
+        if (typeof sId === "number" && self._endTimers[sId] || !sound2._paused) {
+          if (typeof sId === "number") {
+            self._clearTimer(sId);
+            self._endTimers[sId] = setTimeout(() => self._ended(sound2), timeout);
+          }
+        }
+        self._emit("rate", sound2._id);
+      }
+      return self;
+    }
+    const sound = id ? self._soundById(id) : void 0;
+    return sound ? sound._rate : self._rate;
+  }
+  seek(seekOrId, idMaybe) {
+    const self = this;
+    const argsLen = arguments.length;
+    let seek = void 0;
+    let id = void 0;
+    if (argsLen === 0) {
+      if (self._sounds.length) {
+        id = self._sounds[0]?._id;
+      }
+    } else if (argsLen === 1) {
+      const ids = self._getSoundIds();
+      const index = ids.indexOf(seekOrId);
+      if (index >= 0) {
+        id = parseInt(String(seekOrId), 10);
+      } else if (self._sounds.length) {
+        id = self._sounds[0]?._id;
+        seek = parseFloat(String(seekOrId));
+      }
+    } else if (argsLen === 2) {
+      seek = parseFloat(String(seekOrId));
+      id = parseInt(String(idMaybe), 10);
+    }
+    if (typeof id === "undefined") return 0;
+    if (typeof seek === "number" && (self._state !== "loaded" || self._playLock)) {
+      const capturedArgs = [...arguments];
+      self._queue.push({
+        event: "seek",
+        action: () => self.seek.apply(self, capturedArgs)
+      });
+      return self;
+    }
+    const sound = self._soundById(id);
+    if (!sound) {
+      return self;
+    }
+    if (typeof seek === "number" && seek >= 0) {
+      const wasPlaying = self.playing(id);
+      if (wasPlaying) {
+        self.pause(id, true);
+      }
+      sound._seek = seek;
+      sound._ended = false;
+      self._clearTimer(id);
+      if (!self._webAudio && sound._node && isHtml5Audio(sound._node) && !isNaN(sound._node.duration)) {
+        sound._node.currentTime = seek;
+      }
+      const seekAndEmit = () => {
+        if (wasPlaying) {
+          self.play(id, true);
+        }
+        self._emit("seek", id);
+      };
+      if (wasPlaying && !self._webAudio) {
+        const emitSeek = () => {
+          if (!self._playLock) seekAndEmit();
+          else setTimeout(emitSeek, 0);
+        };
+        setTimeout(emitSeek, 0);
+      } else {
+        seekAndEmit();
+      }
+      return self;
+    }
+    if (self._webAudio) {
+      const realTime = self.playing(id) ? Howler.ctx.currentTime - sound._playStart : 0;
+      const rateSeek = sound._rateSeek ? sound._rateSeek - sound._seek : 0;
+      return sound._seek + (rateSeek + realTime * Math.abs(sound._rate));
+    }
+    if (sound._node && isHtml5Audio(sound._node)) {
+      return sound._node.currentTime;
+    }
+    return 0;
+  }
+  stop(id, internal) {
+    if (typeof id === "undefined") {
+      const ids = this._getSoundIds();
+      for (const sid of ids) {
+        this.stop(sid, internal);
+      }
+      return this;
+    }
+    const sound = this._soundById(id);
+    if (sound) {
+      this._clearTimer(id);
+      sound._seek = sound._start || 0;
+      sound._rateSeek = 0;
+      sound._paused = true;
+      sound._ended = true;
+      if (sound._node) {
+        if (this._webAudio) {
+          const n = sound._node;
+          if (n.bufferSource) {
+            if (typeof n.bufferSource.stop === "undefined") {
+              if ("noteOff" in n.bufferSource && typeof n.bufferSource.noteOff === "function") {
+                n.bufferSource.noteOff(0);
+              }
+            } else {
+              n.bufferSource.stop(0);
+            }
+            this._cleanBuffer(n);
+          }
+        } else if (isHtml5Audio(sound._node)) {
+          const a = sound._node;
+          a.currentTime = sound._start || 0;
+          a.pause();
+          if (a.duration === Infinity) {
+            this._clearSound(a);
+          }
+        }
+      }
+      if (!internal) this._emit("stop", sound._id);
+    }
+    return this;
+  }
+  /**
+   * Mute/unmute a single sound or all sounds in this Howl group.
+   * @param muted Set to true to mute and false to unmute.
+   * @param id The sound ID to update (omit to mute/unmute all).
+   */
+  mute(muted, id) {
+    const self = this;
+    if (typeof id === "undefined" && typeof muted !== "boolean") {
+      return self._muted;
+    }
+    if (self._state !== "loaded" || self._playLock) {
+      self._queue.push({
+        event: "mute",
+        action: () => {
+          self.mute(muted, id);
+        }
+      });
+      return self;
+    }
+    if (typeof id === "undefined" && typeof muted === "boolean") {
+      self._muted = muted;
+    }
+    const ids = self._getSoundIds(id);
+    for (let i = 0; i < ids.length; i++) {
+      const sound = self._soundById(ids[i] ?? 0);
+      if (!sound) continue;
+      sound._muted = muted;
+      if (sound._interval) self._stopFade(sound._id);
+      if (self._webAudio && sound._node && !isHtml5Audio(sound._node)) {
+        sound._node.gain.setValueAtTime(
+          muted ? 0 : sound._volume,
+          Howler.ctx.currentTime
+        );
+      } else if (sound._node && isHtml5Audio(sound._node)) {
+        sound._node.muted = Howler._muted ? true : muted;
+      }
+      self._emit("mute", sound._id);
+    }
+    return self;
+  }
+  volume(volOrId, idMaybe, internal) {
+    const self = this;
+    const argsLen = arguments.length;
+    let vol;
+    let id;
+    if (argsLen === 0) {
+      return self._volume;
+    }
+    if (argsLen === 1 || argsLen === 2 && typeof idMaybe === "undefined") {
+      const ids = self._getSoundIds();
+      const index = ids.indexOf(volOrId);
+      if (index >= 0) {
+        id = parseInt(String(volOrId), 10);
+      } else {
+        vol = parseFloat(String(volOrId));
+      }
+    } else if (argsLen >= 2) {
+      vol = parseFloat(String(volOrId));
+      id = parseInt(String(idMaybe), 10);
+    }
+    if (typeof vol !== "undefined" && vol >= 0 && vol <= 1) {
+      if (self._state !== "loaded" || self._playLock) {
+        const capturedArgs = [...arguments];
+        self._queue.push({
+          event: "volume",
+          action: () => self.volume.apply(self, capturedArgs)
+        });
+        return self;
+      }
+      if (typeof id === "undefined") {
+        self._volume = vol;
+      }
+      const ids = self._getSoundIds(id);
+      for (let i = 0; i < ids.length; i++) {
+        const sound2 = self._soundById(ids[i] ?? 0);
+        if (!sound2) continue;
+        sound2._volume = vol;
+        if (!internal) self._stopFade(ids[i] ?? 0);
+        if (self._webAudio && sound2._node && !sound2._muted && !isHtml5Audio(sound2._node)) {
+          sound2._node.gain.setValueAtTime(vol, Howler.ctx.currentTime);
+        } else if (sound2._node && !sound2._muted && isHtml5Audio(sound2._node)) {
+          sound2._node.volume = vol * Howler.volume();
+        }
+        self._emit("volume", sound2._id);
+      }
+      return self;
+    }
+    const sound = id ? self._soundById(id) : self._sounds[0];
+    return sound ? sound._volume : 0;
+  }
+  /**
+   * Fade a currently playing sound between two volumes (if no id is passed, all sounds will fade).
+   */
+  fade(from, to, len, id) {
+    const self = this;
+    if (self._state !== "loaded" || self._playLock) {
+      self._queue.push({
+        event: "fade",
+        action: () => self.fade(from, to, len, id)
+      });
+      return self;
+    }
+    from = Math.min(Math.max(0, parseFloat(String(from))), 1);
+    to = Math.min(Math.max(0, parseFloat(String(to))), 1);
+    len = parseFloat(String(len));
+    self.volume(from, id);
+    const ids = self._getSoundIds(id);
+    for (let i = 0; i < ids.length; i++) {
+      const sound = self._soundById(ids[i] ?? 0);
+      if (!sound) continue;
+      if (!id) self._stopFade(ids[i] ?? 0);
+      if (self._webAudio && !sound._muted && sound._node && !isHtml5Audio(sound._node)) {
+        const currentTime = Howler.ctx.currentTime;
+        const end = currentTime + len / 1e3;
+        sound._volume = from;
+        sound._node.gain.setValueAtTime(from, currentTime);
+        sound._node.gain.linearRampToValueAtTime(to, end);
+      }
+      self._startFadeInterval(sound, from, to, len, ids[i] ?? 0, typeof id === "undefined");
+    }
+    return self;
+  }
+  loop(loopOrId, idMaybe) {
+    const self = this;
+    const argsLen = arguments.length;
+    let loopVal = false;
+    let id;
+    if (argsLen === 0) return self._loop;
+    if (argsLen === 1) {
+      if (typeof loopOrId === "boolean") {
+        loopVal = loopOrId;
+        self._loop = loopVal;
+      } else {
+        const sound = self._soundById(parseInt(String(loopOrId), 10));
+        return sound ? sound._loop : false;
+      }
+    } else if (argsLen === 2) {
+      loopVal = loopOrId;
+      id = parseInt(String(idMaybe), 10);
+    }
+    const ids = self._getSoundIds(id);
+    for (let i = 0; i < ids.length; i++) {
+      const sound = self._soundById(ids[i] ?? 0);
+      if (!sound) continue;
+      sound._loop = loopVal;
+      if (self._webAudio && sound._node && !isHtml5Audio(sound._node)) {
+        const n = sound._node;
+        if (n.bufferSource) {
+          n.bufferSource.loop = loopVal;
+          if (loopVal) {
+            n.bufferSource.loopStart = sound._start || 0;
+            n.bufferSource.loopEnd = sound._stop;
+            if (self.playing(ids[i])) {
+              self.pause(ids[i], true);
+              self.play(ids[i], true);
+            }
+          }
+        }
+      }
+    }
+    return self;
+  }
+  unload() {
+    const self = this;
+    const sounds = self._sounds;
+    for (let i = 0; i < sounds.length; i++) {
+      if (!sounds[i]?._paused) {
+        self.stop(sounds[i]?._id);
+      }
+      const currentNode = sounds[i]?._node;
+      if (!self._webAudio && currentNode && isHtml5Audio(currentNode)) {
+        self._clearSound(currentNode);
+        if ("_errorFn" in currentNode) {
+          currentNode.removeEventListener("error", currentNode._errorFn, false);
+        }
+        if ("_loadFn" in currentNode) {
+          currentNode.removeEventListener(this.howler._canPlayEvent, currentNode._loadFn, false);
+        }
+        if ("_endFn" in currentNode) {
+          currentNode.removeEventListener("ended", currentNode._endFn, false);
+        }
+        this.howler._releaseHtml5Audio(currentNode);
+      }
+      delete sounds[i]?._node;
+      self._clearTimer(sounds[i]?._id ?? 0);
+    }
+    const index = this.howler._howls.indexOf(self);
+    if (index >= 0) this.howler._howls.splice(index, 1);
+    let remCache = true;
+    for (let i = 0; i < this.howler._howls.length; i++) {
+      const hs = this.howler._howls[i]?._src.toString();
+      if (hs === self._src.toString() || hs && self._src.indexOf(hs) >= 0) {
+        remCache = false;
+        break;
+      }
+    }
+    if (this.howler.cache && remCache) {
+      delete this.howler.cache[self._src.toString()];
+    }
+    this.howler.noAudio = false;
+    self._state = "unloaded";
+    self._sounds = [];
+  }
+  on(event, fn, id, once) {
+    const eventName = "_on" + event;
+    const events = this[eventName];
+    if (typeof fn === "function") {
+      events.push(once ? { id, fn, once } : { id, fn });
+    }
+    return this;
+  }
+  off(event, fn, id) {
+    const self = this;
+    if (typeof fn === "number") {
+      id = fn;
+      fn = void 0;
+    }
+    if (event) {
+      const eventName = "_on" + event;
+      const events = self[eventName];
+      if (fn || id) {
+        for (let i = 0; i < events.length; i++) {
+          const isId = id === events[i]?.id;
+          if (fn === events[i]?.fn && isId || !fn && isId) {
+            events.splice(i, 1);
+            break;
+          }
+        }
+      } else {
+        self[eventName] = [];
+      }
+    } else {
+      const keys = Object.keys(self);
+      for (let i = 0; i < keys.length; i++) {
+        if (keys[i].indexOf("_on") === 0 && Array.isArray(self[keys[i]])) {
+          self[keys[i]] = [];
+        }
+      }
+    }
+    return self;
+  }
+  once(event, fn, id) {
+    return this.on(event, fn, id, true);
+  }
+  /**
+   * Starts the internal interval to fade a sound.
+   */
+  _startFadeInterval(sound, from, to, len, _id, isGroup) {
+    const self = this;
+    let vol = from;
+    const diff = to - from;
+    const steps = Math.abs(diff / 0.01);
+    const stepLen = Math.max(4, steps > 0 ? len / steps : len);
+    let lastTick = Date.now();
+    sound._fadeTo = to;
+    sound._interval = setInterval(() => {
+      const tick = (Date.now() - lastTick) / len;
+      lastTick = Date.now();
+      vol += diff * tick;
+      vol = Math.round(vol * 100) / 100;
+      if (diff < 0) vol = Math.max(to, vol);
+      else vol = Math.min(to, vol);
+      if (self._webAudio) {
+        sound._volume = vol;
+      } else {
+        self.volume(vol, sound._id, true);
+      }
+      if (isGroup) self._volume = vol;
+      if (to < from && vol <= to || to > from && vol >= to) {
+        clearInterval(sound._interval);
+        sound._interval = void 0;
+        sound._fadeTo = void 0;
+        self.volume(to, sound._id);
+        self._emit("fade", sound._id);
+      }
+    }, stepLen);
+  }
+  /**
+   * Stop an active fade.
+   */
+  _stopFade(id) {
+    const self = this;
+    const sound = self._soundById(id);
+    if (sound && sound._interval) {
+      if (self._webAudio && sound._node && !isHtml5Audio(sound._node)) {
+        sound._node.gain.cancelScheduledValues(Howler.ctx?.currentTime ?? 0);
+      }
+      clearInterval(sound._interval);
+      sound._interval = void 0;
+      if (typeof sound._fadeTo === "number") {
+        self.volume(sound._fadeTo, id);
+      }
+      sound._fadeTo = void 0;
+      self._emit("fade", id);
+    }
+    return self;
+  }
+  _emit(event, id, errorMsg) {
+    const self = this;
+    const eventType = "_on" + event;
+    const events = self[eventType];
+    for (let i = events.length - 1; i >= 0; i--) {
+      const currentEvent = events[i];
+      if (currentEvent && (!currentEvent.id || currentEvent.id === id || event === "load")) {
+        setTimeout(() => {
+          currentEvent?.fn.call(self, id, errorMsg);
+        }, 0);
+        if (currentEvent.once) {
+          self.off(event, currentEvent.fn, currentEvent.id);
+        }
+      }
+    }
+    self._loadQueue(event);
+    return self;
+  }
+  _loadQueue(event) {
+    const self = this;
+    if (self._queue.length > 0) {
+      const task = self._queue[0];
+      if (task) {
+        if (event && task.event === event) {
+          self._queue.shift();
+          self._loadQueue();
+        }
+        if (!event) {
+          task.action();
+        }
+      }
+    }
+    return self;
+  }
+  _ended(sound) {
+    const self = this;
+    const sprite = sound._sprite;
+    if (!self._webAudio && sound._node && isHtml5Audio(sound._node) && !sound._node.paused && !sound._node.ended && sound._node.currentTime < sound._stop) {
+      setTimeout(() => self._ended(sound), 100);
+      return self;
+    }
+    const loop = !!(sound._loop || self._sprite[sprite]?.[2]);
+    self._emit("end", sound._id);
+    if (!self._webAudio && loop) {
+      self.stop(sound._id, true).play(sound._id);
+    }
+    if (self._webAudio && loop) {
+      self._emit("play", sound._id);
+      sound._seek = sound._start || 0;
+      sound._rateSeek = 0;
+      sound._playStart = this.howler.ctx?.currentTime ?? 0;
+      const timeout = (sound._stop - sound._start) * 1e3 / Math.abs(sound._rate);
+      self._endTimers[sound._id] = setTimeout(() => self._ended(sound), timeout);
+    }
+    if (self._webAudio && !loop) {
+      sound._paused = true;
+      sound._ended = true;
+      sound._seek = sound._start || 0;
+      sound._rateSeek = 0;
+      self._clearTimer(sound._id);
+      self._cleanBuffer(sound._node);
+      this.howler._autoSuspend();
+    }
+    if (!self._webAudio && !loop) {
+      self.stop(sound._id, true);
+    }
+    return self;
+  }
+  _clearTimer(id) {
+    const self = this;
+    if (self._endTimers[id]) {
+      if (typeof self._endTimers[id] !== "function") {
+        clearTimeout(self._endTimers[id]);
+      } else {
+        const sound = self._soundById(id);
+        if (sound && sound._node && isHtml5Audio(sound._node)) {
+          sound._node.removeEventListener("ended", self._endTimers[id], false);
+        }
+      }
+      delete self._endTimers[id];
+    }
+    return self;
+  }
+  _soundById(id) {
+    for (let i = 0; i < this._sounds.length; i++) {
+      if (id === this._sounds[i]?._id) {
+        return this._sounds[i];
+      }
+    }
+    return void 0;
+  }
+  _inactiveSound() {
+    this._drain();
+    for (let i = 0; i < this._sounds.length; i++) {
+      if (this._sounds[i]?._ended) {
+        const sound = this._sounds[i]?.reset();
+        if (sound) {
+          return sound;
+        }
+      }
+    }
+    return new Sound(this, this.howler);
+  }
+  _drain() {
+    const limit = this._pool;
+    if (this._sounds.length < limit) return;
+    let cnt = 0;
+    for (let i = 0; i < this._sounds.length; i++) {
+      if (this._sounds[i]?._ended) {
+        cnt++;
+      }
+    }
+    for (let i = this._sounds.length - 1; i >= 0; i--) {
+      if (cnt <= limit) {
+        return;
+      }
+      if (this._sounds[i]?._ended) {
+        const currentNode = this._sounds[i]?._node;
+        if (this._webAudio && currentNode && !isHtml5Audio(currentNode)) {
+          currentNode["disconnect"]?.(0);
+        }
+        this._sounds.splice(i, 1);
+        cnt--;
+      }
+    }
+  }
+  _getSoundIds(id) {
+    if (typeof id === "undefined") return this._sounds.map((s) => s._id);
+    return [id];
+  }
+  _refreshBuffer(sound) {
+    sound._node = sound._node;
+    sound._node.bufferSource = this.howler.ctx?.createBufferSource();
+    if (!sound._node?.bufferSource) {
+      return;
+    }
+    const bufferSource = sound._node.bufferSource;
+    bufferSource.buffer = this.howler.cache[this._src.toString()] ?? null;
+    if (sound._panner) {
+      bufferSource.connect(sound._panner);
+    } else {
+      bufferSource.connect(sound._node);
+    }
+    bufferSource.loop = sound._loop;
+    if (sound._loop) {
+      bufferSource.loopStart = sound._start || 0;
+      bufferSource.loopEnd = sound._stop || 0;
+    }
+    bufferSource.playbackRate.setValueAtTime(sound._rate, this.howler.ctx?.currentTime ?? 0);
+  }
+  _cleanBuffer(node) {
+    const isIOS = !!(this.howler._navigator && this.howler._navigator.vendor.indexOf("Apple") >= 0);
+    if (!node.bufferSource) {
+      return;
+    }
+    if (this.howler._scratchBuffer && node.bufferSource) {
+      node.bufferSource.onended = null;
+      node.bufferSource.disconnect(0);
+      if (isIOS) {
+        try {
+          node.bufferSource.buffer = this.howler._scratchBuffer;
+        } catch {
+        }
+      }
+    }
+    node.bufferSource = void 0;
+  }
+  _clearSound(node) {
+    const checkIE = this.howler._navigator && /MSIE |Trident\//.test(this.howler._navigator && this.howler._navigator.userAgent);
+    if (!checkIE) {
+      node.src = "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA";
+    }
+  }
+};
+export {
+  Howl,
+  Howler
+};
+//# sourceMappingURL=wolf.js.map