@mingxy/ocosay 1.0.20 → 1.0.22

package/dist/plugin.js

@@ -1,128 +1,3111 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/howler/dist/howler.js
+var require_howler = __commonJS({
+  "node_modules/howler/dist/howler.js"(exports) {
+    (function() {
+      "use strict";
+      var HowlerGlobal2 = function() {
+        this.init();
+      };
+      HowlerGlobal2.prototype = {
+        /**
+         * Initialize the global Howler object.
+         * @return {Howler}
+         */
+        init: function() {
+          var self = this || Howler2;
+          self._counter = 1e3;
+          self._html5AudioPool = [];
+          self.html5PoolSize = 10;
+          self._codecs = {};
+          self._howls = [];
+          self._muted = false;
+          self._volume = 1;
+          self._canPlayEvent = "canplaythrough";
+          self._navigator = typeof window !== "undefined" && window.navigator ? window.navigator : null;
+          self.masterGain = null;
+          self.noAudio = false;
+          self.usingWebAudio = true;
+          self.autoSuspend = true;
+          self.ctx = null;
+          self.autoUnlock = true;
+          self._setup();
+          return self;
+        },
+        /**
+         * Get/set the global volume for all sounds.
+         * @param  {Float} vol Volume from 0.0 to 1.0.
+         * @return {Howler/Float}     Returns self or current volume.
+         */
+        volume: function(vol) {
+          var self = this || Howler2;
+          vol = parseFloat(vol);
+          if (!self.ctx) {
+            setupAudioContext();
+          }
+          if (typeof vol !== "undefined" && vol >= 0 && vol <= 1) {
+            self._volume = vol;
+            if (self._muted) {
+              return self;
+            }
+            if (self.usingWebAudio) {
+              self.masterGain.gain.setValueAtTime(vol, Howler2.ctx.currentTime);
+            }
+            for (var i = 0; i < self._howls.length; i++) {
+              if (!self._howls[i]._webAudio) {
+                var ids = self._howls[i]._getSoundIds();
+                for (var j = 0; j < ids.length; j++) {
+                  var sound = self._howls[i]._soundById(ids[j]);
+                  if (sound && sound._node) {
+                    sound._node.volume = sound._volume * vol;
+                  }
+                }
+              }
+            }
+            return self;
+          }
+          return self._volume;
+        },
+        /**
+         * Handle muting and unmuting globally.
+         * @param  {Boolean} muted Is muted or not.
+         */
+        mute: function(muted) {
+          var self = this || Howler2;
+          if (!self.ctx) {
+            setupAudioContext();
+          }
+          self._muted = muted;
+          if (self.usingWebAudio) {
+            self.masterGain.gain.setValueAtTime(muted ? 0 : self._volume, Howler2.ctx.currentTime);
+          }
+          for (var i = 0; i < self._howls.length; i++) {
+            if (!self._howls[i]._webAudio) {
+              var ids = self._howls[i]._getSoundIds();
+              for (var j = 0; j < ids.length; j++) {
+                var sound = self._howls[i]._soundById(ids[j]);
+                if (sound && sound._node) {
+                  sound._node.muted = muted ? true : sound._muted;
+                }
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Handle stopping all sounds globally.
+         */
+        stop: function() {
+          var self = this || Howler2;
+          for (var i = 0; i < self._howls.length; i++) {
+            self._howls[i].stop();
+          }
+          return self;
+        },
+        /**
+         * Unload and destroy all currently loaded Howl objects.
+         * @return {Howler}
+         */
+        unload: function() {
+          var self = this || Howler2;
+          for (var 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 = null;
+            setupAudioContext();
+          }
+          return self;
+        },
+        /**
+         * Check for codec support of specific extension.
+         * @param  {String} ext Audio file extention.
+         * @return {Boolean}
+         */
+        codecs: function(ext) {
+          return (this || Howler2)._codecs[ext.replace(/^x-/, "")];
+        },
+        /**
+         * Setup various state values for global tracking.
+         * @return {Howler}
+         */
+        _setup: function() {
+          var self = this || Howler2;
+          self.state = self.ctx ? self.ctx.state || "suspended" : "suspended";
+          self._autoSuspend();
+          if (!self.usingWebAudio) {
+            if (typeof Audio !== "undefined") {
+              try {
+                var test = new Audio();
+                if (typeof test.oncanplaythrough === "undefined") {
+                  self._canPlayEvent = "canplay";
+                }
+              } catch (e) {
+                self.noAudio = true;
+              }
+            } else {
+              self.noAudio = true;
+            }
+          }
+          try {
+            var test = new Audio();
+            if (test.muted) {
+              self.noAudio = true;
+            }
+          } catch (e) {
+          }
+          if (!self.noAudio) {
+            self._setupCodecs();
+          }
+          return self;
+        },
+        /**
+         * Check for browser support for various codecs and cache the results.
+         * @return {Howler}
+         */
+        _setupCodecs: function() {
+          var self = this || Howler2;
+          var audioTest = null;
+          try {
+            audioTest = typeof Audio !== "undefined" ? new Audio() : null;
+          } catch (err) {
+            return self;
+          }
+          if (!audioTest || typeof audioTest.canPlayType !== "function") {
+            return self;
+          }
+          var mpegTest = audioTest.canPlayType("audio/mpeg;").replace(/^no$/, "");
+          var ua = self._navigator ? self._navigator.userAgent : "";
+          var checkOpera = ua.match(/OPR\/(\d+)/g);
+          var isOldOpera = checkOpera && parseInt(checkOpera[0].split("/")[1], 10) < 33;
+          var checkSafari = ua.indexOf("Safari") !== -1 && ua.indexOf("Chrome") === -1;
+          var safariVersion = ua.match(/Version\/(.*?) /);
+          var 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$/, "")
+          };
+          return self;
+        },
+        /**
+         * Some browsers/devices will only allow audio to be played after a user interaction.
+         * Attempt to automatically unlock audio on the first user interaction.
+         * Concept from: http://paulbakaus.com/tutorials/html5/web-audio-on-ios/
+         * @return {Howler}
+         */
+        _unlockAudio: function() {
+          var self = this || Howler2;
+          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);
+          var unlock = function(e) {
+            while (self._html5AudioPool.length < self.html5PoolSize) {
+              try {
+                var audioNode = new Audio();
+                audioNode._unlocked = true;
+                self._releaseHtml5Audio(audioNode);
+              } catch (e2) {
+                self.noAudio = true;
+                break;
+              }
+            }
+            for (var i = 0; i < self._howls.length; i++) {
+              if (!self._howls[i]._webAudio) {
+                var ids = self._howls[i]._getSoundIds();
+                for (var j = 0; j < ids.length; j++) {
+                  var sound = self._howls[i]._soundById(ids[j]);
+                  if (sound && sound._node && !sound._node._unlocked) {
+                    sound._node._unlocked = true;
+                    sound._node.load();
+                  }
+                }
+              }
+            }
+            self._autoResume();
+            var source = self.ctx.createBufferSource();
+            source.buffer = self._scratchBuffer;
+            source.connect(self.ctx.destination);
+            if (typeof source.start === "undefined") {
+              source.noteOn(0);
+            } else {
+              source.start(0);
+            }
+            if (typeof self.ctx.resume === "function") {
+              self.ctx.resume();
+            }
+            source.onended = function() {
+              source.disconnect(0);
+              self._audioUnlocked = true;
+              document.removeEventListener("touchstart", unlock, true);
+              document.removeEventListener("touchend", unlock, true);
+              document.removeEventListener("click", unlock, true);
+              document.removeEventListener("keydown", unlock, true);
+              for (var i2 = 0; i2 < self._howls.length; i2++) {
+                self._howls[i2]._emit("unlock");
+              }
+            };
+          };
+          document.addEventListener("touchstart", unlock, true);
+          document.addEventListener("touchend", unlock, true);
+          document.addEventListener("click", unlock, true);
+          document.addEventListener("keydown", unlock, true);
+          return self;
+        },
+        /**
+         * Get an unlocked HTML5 Audio object from the pool. If none are left,
+         * return a new Audio object and throw a warning.
+         * @return {Audio} HTML5 Audio object.
+         */
+        _obtainHtml5Audio: function() {
+          var self = this || Howler2;
+          if (self._html5AudioPool.length) {
+            return self._html5AudioPool.pop();
+          }
+          var testPlay = new Audio().play();
+          if (testPlay && typeof Promise !== "undefined" && (testPlay instanceof Promise || typeof testPlay.then === "function")) {
+            testPlay.catch(function() {
+              console.warn("HTML5 Audio pool exhausted, returning potentially locked audio object.");
+            });
+          }
+          return new Audio();
+        },
+        /**
+         * Return an activated HTML5 Audio object to the pool.
+         * @return {Howler}
+         */
+        _releaseHtml5Audio: function(audio) {
+          var self = this || Howler2;
+          if (audio._unlocked) {
+            self._html5AudioPool.push(audio);
+          }
+          return self;
+        },
+        /**
+         * Automatically suspend the Web Audio AudioContext after no sound has played for 30 seconds.
+         * This saves processing/energy and fixes various browser-specific bugs with audio getting stuck.
+         * @return {Howler}
+         */
+        _autoSuspend: function() {
+          var self = this;
+          if (!self.autoSuspend || !self.ctx || typeof self.ctx.suspend === "undefined" || !Howler2.usingWebAudio) {
+            return;
+          }
+          for (var i = 0; i < self._howls.length; i++) {
+            if (self._howls[i]._webAudio) {
+              for (var j = 0; j < self._howls[i]._sounds.length; j++) {
+                if (!self._howls[i]._sounds[j]._paused) {
+                  return self;
+                }
+              }
+            }
+          }
+          if (self._suspendTimer) {
+            clearTimeout(self._suspendTimer);
+          }
+          self._suspendTimer = setTimeout(function() {
+            if (!self.autoSuspend) {
+              return;
+            }
+            self._suspendTimer = null;
+            self.state = "suspending";
+            var handleSuspension = function() {
+              self.state = "suspended";
+              if (self._resumeAfterSuspend) {
+                delete self._resumeAfterSuspend;
+                self._autoResume();
+              }
+            };
+            self.ctx.suspend().then(handleSuspension, handleSuspension);
+          }, 3e4);
+          return self;
+        },
+        /**
+         * Automatically resume the Web Audio AudioContext when a new sound is played.
+         * @return {Howler}
+         */
+        _autoResume: function() {
+          var self = this;
+          if (!self.ctx || typeof self.ctx.resume === "undefined" || !Howler2.usingWebAudio) {
+            return;
+          }
+          if (self.state === "running" && self.ctx.state !== "interrupted" && self._suspendTimer) {
+            clearTimeout(self._suspendTimer);
+            self._suspendTimer = null;
+          } else if (self.state === "suspended" || self.state === "running" && self.ctx.state === "interrupted") {
+            self.ctx.resume().then(function() {
+              self.state = "running";
+              for (var i = 0; i < self._howls.length; i++) {
+                self._howls[i]._emit("resume");
+              }
+            });
+            if (self._suspendTimer) {
+              clearTimeout(self._suspendTimer);
+              self._suspendTimer = null;
+            }
+          } else if (self.state === "suspending") {
+            self._resumeAfterSuspend = true;
+          }
+          return self;
+        }
+      };
+      var Howler2 = new HowlerGlobal2();
+      var Howl3 = function(o) {
+        var self = this;
+        if (!o.src || o.src.length === 0) {
+          console.error("An array of source files must be passed with any new Howl.");
+          return;
+        }
+        self.init(o);
+      };
+      Howl3.prototype = {
+        /**
+         * Initialize a new Howl group object.
+         * @param  {Object} o Passed in properties for this group.
+         * @return {Howl}
+         */
+        init: function(o) {
+          var self = this;
+          if (!Howler2.ctx) {
+            setupAudioContext();
+          }
+          self._autoplay = o.autoplay || false;
+          self._format = typeof o.format !== "string" ? o.format : [o.format];
+          self._html5 = o.html5 || false;
+          self._muted = o.mute || false;
+          self._loop = o.loop || false;
+          self._pool = o.pool || 5;
+          self._preload = typeof o.preload === "boolean" || o.preload === "metadata" ? o.preload : true;
+          self._rate = o.rate || 1;
+          self._sprite = o.sprite || {};
+          self._src = typeof o.src !== "string" ? o.src : [o.src];
+          self._volume = o.volume !== void 0 ? o.volume : 1;
+          self._xhr = {
+            method: o.xhr && o.xhr.method ? o.xhr.method : "GET",
+            headers: o.xhr && o.xhr.headers ? o.xhr.headers : null,
+            withCredentials: o.xhr && o.xhr.withCredentials ? o.xhr.withCredentials : false
+          };
+          self._duration = 0;
+          self._state = "unloaded";
+          self._sounds = [];
+          self._endTimers = {};
+          self._queue = [];
+          self._playLock = false;
+          self._onend = o.onend ? [{ fn: o.onend }] : [];
+          self._onfade = o.onfade ? [{ fn: o.onfade }] : [];
+          self._onload = o.onload ? [{ fn: o.onload }] : [];
+          self._onloaderror = o.onloaderror ? [{ fn: o.onloaderror }] : [];
+          self._onplayerror = o.onplayerror ? [{ fn: o.onplayerror }] : [];
+          self._onpause = o.onpause ? [{ fn: o.onpause }] : [];
+          self._onplay = o.onplay ? [{ fn: o.onplay }] : [];
+          self._onstop = o.onstop ? [{ fn: o.onstop }] : [];
+          self._onmute = o.onmute ? [{ fn: o.onmute }] : [];
+          self._onvolume = o.onvolume ? [{ fn: o.onvolume }] : [];
+          self._onrate = o.onrate ? [{ fn: o.onrate }] : [];
+          self._onseek = o.onseek ? [{ fn: o.onseek }] : [];
+          self._onunlock = o.onunlock ? [{ fn: o.onunlock }] : [];
+          self._onresume = [];
+          self._webAudio = Howler2.usingWebAudio && !self._html5;
+          if (typeof Howler2.ctx !== "undefined" && Howler2.ctx && Howler2.autoUnlock) {
+            Howler2._unlockAudio();
+          }
+          Howler2._howls.push(self);
+          if (self._autoplay) {
+            self._queue.push({
+              event: "play",
+              action: function() {
+                self.play();
+              }
+            });
+          }
+          if (self._preload && self._preload !== "none") {
+            self.load();
+          }
+          return self;
+        },
+        /**
+         * Load the audio file.
+         * @return {Howler}
+         */
+        load: function() {
+          var self = this;
+          var url = null;
+          if (Howler2.noAudio) {
+            self._emit("loaderror", null, "No audio support.");
+            return;
+          }
+          if (typeof self._src === "string") {
+            self._src = [self._src];
+          }
+          for (var i = 0; i < self._src.length; i++) {
+            var ext, str;
+            if (self._format && self._format[i]) {
+              ext = self._format[i];
+            } else {
+              str = self._src[i];
+              if (typeof str !== "string") {
+                self._emit("loaderror", null, "Non-string found in selected audio sources - ignoring.");
+                continue;
+              }
+              ext = /^data:audio\/([^;,]+);/i.exec(str);
+              if (!ext) {
+                ext = /\.([^.]+)$/.exec(str.split("?", 1)[0]);
+              }
+              if (ext) {
+                ext = ext[1].toLowerCase();
+              }
+            }
+            if (!ext) {
+              console.warn('No file extension was found. Consider using the "format" property or specify an extension.');
+            }
+            if (ext && Howler2.codecs(ext)) {
+              url = self._src[i];
+              break;
+            }
+          }
+          if (!url) {
+            self._emit("loaderror", null, "No codec support for selected audio sources.");
+            return;
+          }
+          self._src = url;
+          self._state = "loading";
+          if (window.location.protocol === "https:" && url.slice(0, 5) === "http:") {
+            self._html5 = true;
+            self._webAudio = false;
+          }
+          new Sound2(self);
+          if (self._webAudio) {
+            loadBuffer(self);
+          }
+          return self;
+        },
+        /**
+         * Play a sound or resume previous playback.
+         * @param  {String/Number} sprite   Sprite name for sprite playback or sound id to continue previous.
+         * @param  {Boolean} internal Internal Use: true prevents event firing.
+         * @return {Number}          Sound ID.
+         */
+        play: function(sprite, internal) {
+          var self = this;
+          var id = null;
+          if (typeof sprite === "number") {
+            id = sprite;
+            sprite = null;
+          } else if (typeof sprite === "string" && self._state === "loaded" && !self._sprite[sprite]) {
+            return null;
+          } else if (typeof sprite === "undefined") {
+            sprite = "__default";
+            if (!self._playLock) {
+              var num = 0;
+              for (var 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) {
+                sprite = null;
+              } else {
+                id = null;
+              }
+            }
+          }
+          var sound = id ? self._soundById(id) : self._inactiveSound();
+          if (!sound) {
+            return null;
+          }
+          if (id && !sprite) {
+            sprite = sound._sprite || "__default";
+          }
+          if (self._state !== "loaded") {
+            sound._sprite = sprite;
+            sound._ended = false;
+            var soundId = sound._id;
+            self._queue.push({
+              event: "play",
+              action: function() {
+                self.play(soundId);
+              }
+            });
+            return soundId;
+          }
+          if (id && !sound._paused) {
+            if (!internal) {
+              self._loadQueue("play");
+            }
+            return sound._id;
+          }
+          if (self._webAudio) {
+            Howler2._autoResume();
+          }
+          var seek = Math.max(0, sound._seek > 0 ? sound._seek : self._sprite[sprite][0] / 1e3);
+          var duration = Math.max(0, (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3 - seek);
+          var timeout = duration * 1e3 / Math.abs(sound._rate);
+          var start = self._sprite[sprite][0] / 1e3;
+          var stop2 = (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3;
+          sound._sprite = sprite;
+          sound._ended = false;
+          var setParams = function() {
+            sound._paused = false;
+            sound._seek = seek;
+            sound._start = start;
+            sound._stop = stop2;
+            sound._loop = !!(sound._loop || self._sprite[sprite][2]);
+          };
+          if (seek >= stop2) {
+            self._ended(sound);
+            return;
+          }
+          var node = sound._node;
+          if (self._webAudio) {
+            var playWebAudio = function() {
+              self._playLock = false;
+              setParams();
+              self._refreshBuffer(sound);
+              var vol = sound._muted || self._muted ? 0 : sound._volume;
+              node.gain.setValueAtTime(vol, Howler2.ctx.currentTime);
+              sound._playStart = Howler2.ctx.currentTime;
+              if (typeof node.bufferSource.start === "undefined") {
+                sound._loop ? node.bufferSource.noteGrainOn(0, seek, 86400) : node.bufferSource.noteGrainOn(0, seek, duration);
+              } else {
+                sound._loop ? node.bufferSource.start(0, seek, 86400) : node.bufferSource.start(0, seek, duration);
+              }
+              if (timeout !== Infinity) {
+                self._endTimers[sound._id] = setTimeout(self._ended.bind(self, sound), timeout);
+              }
+              if (!internal) {
+                setTimeout(function() {
+                  self._emit("play", sound._id);
+                  self._loadQueue();
+                }, 0);
+              }
+            };
+            if (Howler2.state === "running" && Howler2.ctx.state !== "interrupted") {
+              playWebAudio();
+            } else {
+              self._playLock = true;
+              self.once("resume", playWebAudio);
+              self._clearTimer(sound._id);
+            }
+          } else {
+            var playHtml5 = function() {
+              node.currentTime = seek;
+              node.muted = sound._muted || self._muted || Howler2._muted || node.muted;
+              node.volume = sound._volume * Howler2.volume();
+              node.playbackRate = sound._rate;
+              try {
+                var play = node.play();
+                if (play && typeof Promise !== "undefined" && (play instanceof Promise || typeof play.then === "function")) {
+                  self._playLock = true;
+                  setParams();
+                  play.then(function() {
+                    self._playLock = false;
+                    node._unlocked = true;
+                    if (!internal) {
+                      self._emit("play", sound._id);
+                    } else {
+                      self._loadQueue();
+                    }
+                  }).catch(function() {
+                    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);
+                }
+                node.playbackRate = sound._rate;
+                if (node.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 (sprite !== "__default" || sound._loop) {
+                  self._endTimers[sound._id] = setTimeout(self._ended.bind(self, sound), timeout);
+                } else {
+                  self._endTimers[sound._id] = function() {
+                    self._ended(sound);
+                    node.removeEventListener("ended", self._endTimers[sound._id], false);
+                  };
+                  node.addEventListener("ended", self._endTimers[sound._id], false);
+                }
+              } catch (err) {
+                self._emit("playerror", sound._id, err);
+              }
+            };
+            if (node.src === "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA") {
+              node.src = self._src;
+              node.load();
+            }
+            var loadedNoReadyState = window && window.ejecta || !node.readyState && Howler2._navigator.isCocoonJS;
+            if (node.readyState >= 3 || loadedNoReadyState) {
+              playHtml5();
+            } else {
+              self._playLock = true;
+              self._state = "loading";
+              var listener = function() {
+                self._state = "loaded";
+                playHtml5();
+                node.removeEventListener(Howler2._canPlayEvent, listener, false);
+              };
+              node.addEventListener(Howler2._canPlayEvent, listener, false);
+              self._clearTimer(sound._id);
+            }
+          }
+          return sound._id;
+        },
+        /**
+         * Pause playback and save current position.
+         * @param  {Number} id The sound ID (empty to pause all in group).
+         * @return {Howl}
+         */
+        pause: function(id) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "pause",
+              action: function() {
+                self.pause(id);
+              }
+            });
+            return self;
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            self._clearTimer(ids[i]);
+            var sound = self._soundById(ids[i]);
+            if (sound && !sound._paused) {
+              sound._seek = self.seek(ids[i]);
+              sound._rateSeek = 0;
+              sound._paused = true;
+              self._stopFade(ids[i]);
+              if (sound._node) {
+                if (self._webAudio) {
+                  if (!sound._node.bufferSource) {
+                    continue;
+                  }
+                  if (typeof sound._node.bufferSource.stop === "undefined") {
+                    sound._node.bufferSource.noteOff(0);
+                  } else {
+                    sound._node.bufferSource.stop(0);
+                  }
+                  self._cleanBuffer(sound._node);
+                } else if (!isNaN(sound._node.duration) || sound._node.duration === Infinity) {
+                  sound._node.pause();
+                }
+              }
+            }
+            if (!arguments[1]) {
+              self._emit("pause", sound ? sound._id : null);
+            }
+          }
+          return self;
+        },
+        /**
+         * Stop playback and reset to start.
+         * @param  {Number} id The sound ID (empty to stop all in group).
+         * @param  {Boolean} internal Internal Use: true prevents event firing.
+         * @return {Howl}
+         */
+        stop: function(id, internal) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "stop",
+              action: function() {
+                self.stop(id);
+              }
+            });
+            return self;
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            self._clearTimer(ids[i]);
+            var sound = self._soundById(ids[i]);
+            if (sound) {
+              sound._seek = sound._start || 0;
+              sound._rateSeek = 0;
+              sound._paused = true;
+              sound._ended = true;
+              self._stopFade(ids[i]);
+              if (sound._node) {
+                if (self._webAudio) {
+                  if (sound._node.bufferSource) {
+                    if (typeof sound._node.bufferSource.stop === "undefined") {
+                      sound._node.bufferSource.noteOff(0);
+                    } else {
+                      sound._node.bufferSource.stop(0);
+                    }
+                    self._cleanBuffer(sound._node);
+                  }
+                } else if (!isNaN(sound._node.duration) || sound._node.duration === Infinity) {
+                  sound._node.currentTime = sound._start || 0;
+                  sound._node.pause();
+                  if (sound._node.duration === Infinity) {
+                    self._clearSound(sound._node);
+                  }
+                }
+              }
+              if (!internal) {
+                self._emit("stop", sound._id);
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Mute/unmute a single sound or all sounds in this Howl group.
+         * @param  {Boolean} muted Set to true to mute and false to unmute.
+         * @param  {Number} id    The sound ID to update (omit to mute/unmute all).
+         * @return {Howl}
+         */
+        mute: function(muted, id) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "mute",
+              action: function() {
+                self.mute(muted, id);
+              }
+            });
+            return self;
+          }
+          if (typeof id === "undefined") {
+            if (typeof muted === "boolean") {
+              self._muted = muted;
+            } else {
+              return self._muted;
+            }
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            var sound = self._soundById(ids[i]);
+            if (sound) {
+              sound._muted = muted;
+              if (sound._interval) {
+                self._stopFade(sound._id);
+              }
+              if (self._webAudio && sound._node) {
+                sound._node.gain.setValueAtTime(muted ? 0 : sound._volume, Howler2.ctx.currentTime);
+              } else if (sound._node) {
+                sound._node.muted = Howler2._muted ? true : muted;
+              }
+              self._emit("mute", sound._id);
+            }
+          }
+          return self;
+        },
+        /**
+         * Get/set the volume of this sound or of the Howl group. This method can optionally take 0, 1 or 2 arguments.
+         *   volume() -> Returns the group's volume value.
+         *   volume(id) -> Returns the sound id's current volume.
+         *   volume(vol) -> Sets the volume of all sounds in this Howl group.
+         *   volume(vol, id) -> Sets the volume of passed sound id.
+         * @return {Howl/Number} Returns self or current volume.
+         */
+        volume: function() {
+          var self = this;
+          var args = arguments;
+          var vol, id;
+          if (args.length === 0) {
+            return self._volume;
+          } else if (args.length === 1 || args.length === 2 && typeof args[1] === "undefined") {
+            var ids = self._getSoundIds();
+            var index = ids.indexOf(args[0]);
+            if (index >= 0) {
+              id = parseInt(args[0], 10);
+            } else {
+              vol = parseFloat(args[0]);
+            }
+          } else if (args.length >= 2) {
+            vol = parseFloat(args[0]);
+            id = parseInt(args[1], 10);
+          }
+          var sound;
+          if (typeof vol !== "undefined" && vol >= 0 && vol <= 1) {
+            if (self._state !== "loaded" || self._playLock) {
+              self._queue.push({
+                event: "volume",
+                action: function() {
+                  self.volume.apply(self, args);
+                }
+              });
+              return self;
+            }
+            if (typeof id === "undefined") {
+              self._volume = vol;
+            }
+            id = self._getSoundIds(id);
+            for (var i = 0; i < id.length; i++) {
+              sound = self._soundById(id[i]);
+              if (sound) {
+                sound._volume = vol;
+                if (!args[2]) {
+                  self._stopFade(id[i]);
+                }
+                if (self._webAudio && sound._node && !sound._muted) {
+                  sound._node.gain.setValueAtTime(vol, Howler2.ctx.currentTime);
+                } else if (sound._node && !sound._muted) {
+                  sound._node.volume = vol * Howler2.volume();
+                }
+                self._emit("volume", sound._id);
+              }
+            }
+          } else {
+            sound = id ? self._soundById(id) : self._sounds[0];
+            return sound ? sound._volume : 0;
+          }
+          return self;
+        },
+        /**
+         * Fade a currently playing sound between two volumes (if no id is passed, all sounds will fade).
+         * @param  {Number} from The value to fade from (0.0 to 1.0).
+         * @param  {Number} to   The volume to fade to (0.0 to 1.0).
+         * @param  {Number} len  Time in milliseconds to fade.
+         * @param  {Number} id   The sound id (omit to fade all sounds).
+         * @return {Howl}
+         */
+        fade: function(from, to, len, id) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "fade",
+              action: function() {
+                self.fade(from, to, len, id);
+              }
+            });
+            return self;
+          }
+          from = Math.min(Math.max(0, parseFloat(from)), 1);
+          to = Math.min(Math.max(0, parseFloat(to)), 1);
+          len = parseFloat(len);
+          self.volume(from, id);
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            var sound = self._soundById(ids[i]);
+            if (sound) {
+              if (!id) {
+                self._stopFade(ids[i]);
+              }
+              if (self._webAudio && !sound._muted) {
+                var currentTime = Howler2.ctx.currentTime;
+                var 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], typeof id === "undefined");
+            }
+          }
+          return self;
+        },
+        /**
+         * Starts the internal interval to fade a sound.
+         * @param  {Object} sound Reference to sound to fade.
+         * @param  {Number} from The value to fade from (0.0 to 1.0).
+         * @param  {Number} to   The volume to fade to (0.0 to 1.0).
+         * @param  {Number} len  Time in milliseconds to fade.
+         * @param  {Number} id   The sound id to fade.
+         * @param  {Boolean} isGroup   If true, set the volume on the group.
+         */
+        _startFadeInterval: function(sound, from, to, len, id, isGroup) {
+          var self = this;
+          var vol = from;
+          var diff = to - from;
+          var steps = Math.abs(diff / 0.01);
+          var stepLen = Math.max(4, steps > 0 ? len / steps : len);
+          var lastTick = Date.now();
+          sound._fadeTo = to;
+          sound._interval = setInterval(function() {
+            var 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 = null;
+              sound._fadeTo = null;
+              self.volume(to, sound._id);
+              self._emit("fade", sound._id);
+            }
+          }, stepLen);
+        },
+        /**
+         * Internal method that stops the currently playing fade when
+         * a new fade starts, volume is changed or the sound is stopped.
+         * @param  {Number} id The sound id.
+         * @return {Howl}
+         */
+        _stopFade: function(id) {
+          var self = this;
+          var sound = self._soundById(id);
+          if (sound && sound._interval) {
+            if (self._webAudio) {
+              sound._node.gain.cancelScheduledValues(Howler2.ctx.currentTime);
+            }
+            clearInterval(sound._interval);
+            sound._interval = null;
+            self.volume(sound._fadeTo, id);
+            sound._fadeTo = null;
+            self._emit("fade", id);
+          }
+          return self;
+        },
+        /**
+         * Get/set the loop parameter on a sound. This method can optionally take 0, 1 or 2 arguments.
+         *   loop() -> Returns the group's loop value.
+         *   loop(id) -> Returns the sound id's loop value.
+         *   loop(loop) -> Sets the loop value for all sounds in this Howl group.
+         *   loop(loop, id) -> Sets the loop value of passed sound id.
+         * @return {Howl/Boolean} Returns self or current loop value.
+         */
+        loop: function() {
+          var self = this;
+          var args = arguments;
+          var loop, id, sound;
+          if (args.length === 0) {
+            return self._loop;
+          } else if (args.length === 1) {
+            if (typeof args[0] === "boolean") {
+              loop = args[0];
+              self._loop = loop;
+            } else {
+              sound = self._soundById(parseInt(args[0], 10));
+              return sound ? sound._loop : false;
+            }
+          } else if (args.length === 2) {
+            loop = args[0];
+            id = parseInt(args[1], 10);
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            sound = self._soundById(ids[i]);
+            if (sound) {
+              sound._loop = loop;
+              if (self._webAudio && sound._node && sound._node.bufferSource) {
+                sound._node.bufferSource.loop = loop;
+                if (loop) {
+                  sound._node.bufferSource.loopStart = sound._start || 0;
+                  sound._node.bufferSource.loopEnd = sound._stop;
+                  if (self.playing(ids[i])) {
+                    self.pause(ids[i], true);
+                    self.play(ids[i], true);
+                  }
+                }
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Get/set the playback rate of a sound. This method can optionally take 0, 1 or 2 arguments.
+         *   rate() -> Returns the first sound node's current playback rate.
+         *   rate(id) -> Returns the sound id's current playback rate.
+         *   rate(rate) -> Sets the playback rate of all sounds in this Howl group.
+         *   rate(rate, id) -> Sets the playback rate of passed sound id.
+         * @return {Howl/Number} Returns self or the current playback rate.
+         */
+        rate: function() {
+          var self = this;
+          var args = arguments;
+          var rate, id;
+          if (args.length === 0) {
+            id = self._sounds[0]._id;
+          } else if (args.length === 1) {
+            var ids = self._getSoundIds();
+            var index = ids.indexOf(args[0]);
+            if (index >= 0) {
+              id = parseInt(args[0], 10);
+            } else {
+              rate = parseFloat(args[0]);
+            }
+          } else if (args.length === 2) {
+            rate = parseFloat(args[0]);
+            id = parseInt(args[1], 10);
+          }
+          var sound;
+          if (typeof rate === "number") {
+            if (self._state !== "loaded" || self._playLock) {
+              self._queue.push({
+                event: "rate",
+                action: function() {
+                  self.rate.apply(self, args);
+                }
+              });
+              return self;
+            }
+            if (typeof id === "undefined") {
+              self._rate = rate;
+            }
+            id = self._getSoundIds(id);
+            for (var i = 0; i < id.length; i++) {
+              sound = self._soundById(id[i]);
+              if (sound) {
+                if (self.playing(id[i])) {
+                  sound._rateSeek = self.seek(id[i]);
+                  sound._playStart = self._webAudio ? Howler2.ctx.currentTime : sound._playStart;
+                }
+                sound._rate = rate;
+                if (self._webAudio && sound._node && sound._node.bufferSource) {
+                  sound._node.bufferSource.playbackRate.setValueAtTime(rate, Howler2.ctx.currentTime);
+                } else if (sound._node) {
+                  sound._node.playbackRate = rate;
+                }
+                var seek = self.seek(id[i]);
+                var duration = (self._sprite[sound._sprite][0] + self._sprite[sound._sprite][1]) / 1e3 - seek;
+                var timeout = duration * 1e3 / Math.abs(sound._rate);
+                if (self._endTimers[id[i]] || !sound._paused) {
+                  self._clearTimer(id[i]);
+                  self._endTimers[id[i]] = setTimeout(self._ended.bind(self, sound), timeout);
+                }
+                self._emit("rate", sound._id);
+              }
+            }
+          } else {
+            sound = self._soundById(id);
+            return sound ? sound._rate : self._rate;
+          }
+          return self;
+        },
+        /**
+         * Get/set the seek position of a sound. This method can optionally take 0, 1 or 2 arguments.
+         *   seek() -> Returns the first sound node's current seek position.
+         *   seek(id) -> Returns the sound id's current seek position.
+         *   seek(seek) -> Sets the seek position of the first sound node.
+         *   seek(seek, id) -> Sets the seek position of passed sound id.
+         * @return {Howl/Number} Returns self or the current seek position.
+         */
+        seek: function() {
+          var self = this;
+          var args = arguments;
+          var seek, id;
+          if (args.length === 0) {
+            if (self._sounds.length) {
+              id = self._sounds[0]._id;
+            }
+          } else if (args.length === 1) {
+            var ids = self._getSoundIds();
+            var index = ids.indexOf(args[0]);
+            if (index >= 0) {
+              id = parseInt(args[0], 10);
+            } else if (self._sounds.length) {
+              id = self._sounds[0]._id;
+              seek = parseFloat(args[0]);
+            }
+          } else if (args.length === 2) {
+            seek = parseFloat(args[0]);
+            id = parseInt(args[1], 10);
+          }
+          if (typeof id === "undefined") {
+            return 0;
+          }
+          if (typeof seek === "number" && (self._state !== "loaded" || self._playLock)) {
+            self._queue.push({
+              event: "seek",
+              action: function() {
+                self.seek.apply(self, args);
+              }
+            });
+            return self;
+          }
+          var sound = self._soundById(id);
+          if (sound) {
+            if (typeof seek === "number" && seek >= 0) {
+              var playing = self.playing(id);
+              if (playing) {
+                self.pause(id, true);
+              }
+              sound._seek = seek;
+              sound._ended = false;
+              self._clearTimer(id);
+              if (!self._webAudio && sound._node && !isNaN(sound._node.duration)) {
+                sound._node.currentTime = seek;
+              }
+              var seekAndEmit = function() {
+                if (playing) {
+                  self.play(id, true);
+                }
+                self._emit("seek", id);
+              };
+              if (playing && !self._webAudio) {
+                var emitSeek = function() {
+                  if (!self._playLock) {
+                    seekAndEmit();
+                  } else {
+                    setTimeout(emitSeek, 0);
+                  }
+                };
+                setTimeout(emitSeek, 0);
+              } else {
+                seekAndEmit();
+              }
+            } else {
+              if (self._webAudio) {
+                var realTime = self.playing(id) ? Howler2.ctx.currentTime - sound._playStart : 0;
+                var rateSeek = sound._rateSeek ? sound._rateSeek - sound._seek : 0;
+                return sound._seek + (rateSeek + realTime * Math.abs(sound._rate));
+              } else {
+                return sound._node.currentTime;
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Check if a specific sound is currently playing or not (if id is provided), or check if at least one of the sounds in the group is playing or not.
+         * @param  {Number}  id The sound id to check. If none is passed, the whole sound group is checked.
+         * @return {Boolean} True if playing and false if not.
+         */
+        playing: function(id) {
+          var self = this;
+          if (typeof id === "number") {
+            var sound = self._soundById(id);
+            return sound ? !sound._paused : false;
+          }
+          for (var i = 0; i < self._sounds.length; i++) {
+            if (!self._sounds[i]._paused) {
+              return true;
+            }
+          }
+          return false;
+        },
+        /**
+         * Get the duration of this sound. Passing a sound id will return the sprite duration.
+         * @param  {Number} id The sound id to check. If none is passed, return full source duration.
+         * @return {Number} Audio duration in seconds.
+         */
+        duration: function(id) {
+          var self = this;
+          var duration = self._duration;
+          var sound = self._soundById(id);
+          if (sound) {
+            duration = self._sprite[sound._sprite][1] / 1e3;
+          }
+          return duration;
+        },
+        /**
+         * Returns the current loaded state of this Howl.
+         * @return {String} 'unloaded', 'loading', 'loaded'
+         */
+        state: function() {
+          return this._state;
+        },
+        /**
+         * Unload and destroy the current Howl object.
+         * This will immediately stop all sound instances attached to this group.
+         */
+        unload: function() {
+          var self = this;
+          var sounds = self._sounds;
+          for (var i = 0; i < sounds.length; i++) {
+            if (!sounds[i]._paused) {
+              self.stop(sounds[i]._id);
+            }
+            if (!self._webAudio) {
+              self._clearSound(sounds[i]._node);
+              sounds[i]._node.removeEventListener("error", sounds[i]._errorFn, false);
+              sounds[i]._node.removeEventListener(Howler2._canPlayEvent, sounds[i]._loadFn, false);
+              sounds[i]._node.removeEventListener("ended", sounds[i]._endFn, false);
+              Howler2._releaseHtml5Audio(sounds[i]._node);
+            }
+            delete sounds[i]._node;
+            self._clearTimer(sounds[i]._id);
+          }
+          var index = Howler2._howls.indexOf(self);
+          if (index >= 0) {
+            Howler2._howls.splice(index, 1);
+          }
+          var remCache = true;
+          for (i = 0; i < Howler2._howls.length; i++) {
+            if (Howler2._howls[i]._src === self._src || self._src.indexOf(Howler2._howls[i]._src) >= 0) {
+              remCache = false;
+              break;
+            }
+          }
+          if (cache && remCache) {
+            delete cache[self._src];
+          }
+          Howler2.noAudio = false;
+          self._state = "unloaded";
+          self._sounds = [];
+          self = null;
+          return null;
+        },
+        /**
+         * Listen to a custom event.
+         * @param  {String}   event Event name.
+         * @param  {Function} fn    Listener to call.
+         * @param  {Number}   id    (optional) Only listen to events for this sound.
+         * @param  {Number}   once  (INTERNAL) Marks event to fire only once.
+         * @return {Howl}
+         */
+        on: function(event, fn, id, once) {
+          var self = this;
+          var events = self["_on" + event];
+          if (typeof fn === "function") {
+            events.push(once ? { id, fn, once } : { id, fn });
+          }
+          return self;
+        },
+        /**
+         * Remove a custom event. Call without parameters to remove all events.
+         * @param  {String}   event Event name.
+         * @param  {Function} fn    Listener to remove. Leave empty to remove all.
+         * @param  {Number}   id    (optional) Only remove events for this sound.
+         * @return {Howl}
+         */
+        off: function(event, fn, id) {
+          var self = this;
+          var events = self["_on" + event];
+          var i = 0;
+          if (typeof fn === "number") {
+            id = fn;
+            fn = null;
+          }
+          if (fn || id) {
+            for (i = 0; i < events.length; i++) {
+              var isId = id === events[i].id;
+              if (fn === events[i].fn && isId || !fn && isId) {
+                events.splice(i, 1);
+                break;
+              }
+            }
+          } else if (event) {
+            self["_on" + event] = [];
+          } else {
+            var keys = Object.keys(self);
+            for (i = 0; i < keys.length; i++) {
+              if (keys[i].indexOf("_on") === 0 && Array.isArray(self[keys[i]])) {
+                self[keys[i]] = [];
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Listen to a custom event and remove it once fired.
+         * @param  {String}   event Event name.
+         * @param  {Function} fn    Listener to call.
+         * @param  {Number}   id    (optional) Only listen to events for this sound.
+         * @return {Howl}
+         */
+        once: function(event, fn, id) {
+          var self = this;
+          self.on(event, fn, id, 1);
+          return self;
+        },
+        /**
+         * Emit all events of a specific type and pass the sound id.
+         * @param  {String} event Event name.
+         * @param  {Number} id    Sound ID.
+         * @param  {Number} msg   Message to go with event.
+         * @return {Howl}
+         */
+        _emit: function(event, id, msg) {
+          var self = this;
+          var events = self["_on" + event];
+          for (var i = events.length - 1; i >= 0; i--) {
+            if (!events[i].id || events[i].id === id || event === "load") {
+              setTimeout(function(fn) {
+                fn.call(this, id, msg);
+              }.bind(self, events[i].fn), 0);
+              if (events[i].once) {
+                self.off(event, events[i].fn, events[i].id);
+              }
+            }
+          }
+          self._loadQueue(event);
+          return self;
+        },
+        /**
+         * Queue of actions initiated before the sound has loaded.
+         * These will be called in sequence, with the next only firing
+         * after the previous has finished executing (even if async like play).
+         * @return {Howl}
+         */
+        _loadQueue: function(event) {
+          var self = this;
+          if (self._queue.length > 0) {
+            var task = self._queue[0];
+            if (task.event === event) {
+              self._queue.shift();
+              self._loadQueue();
+            }
+            if (!event) {
+              task.action();
+            }
+          }
+          return self;
+        },
+        /**
+         * Fired when playback ends at the end of the duration.
+         * @param  {Sound} sound The sound object to work with.
+         * @return {Howl}
+         */
+        _ended: function(sound) {
+          var self = this;
+          var sprite = sound._sprite;
+          if (!self._webAudio && sound._node && !sound._node.paused && !sound._node.ended && sound._node.currentTime < sound._stop) {
+            setTimeout(self._ended.bind(self, sound), 100);
+            return self;
+          }
+          var 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 = Howler2.ctx.currentTime;
+            var timeout = (sound._stop - sound._start) * 1e3 / Math.abs(sound._rate);
+            self._endTimers[sound._id] = setTimeout(self._ended.bind(self, 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);
+            Howler2._autoSuspend();
+          }
+          if (!self._webAudio && !loop) {
+            self.stop(sound._id, true);
+          }
+          return self;
+        },
+        /**
+         * Clear the end timer for a sound playback.
+         * @param  {Number} id The sound ID.
+         * @return {Howl}
+         */
+        _clearTimer: function(id) {
+          var self = this;
+          if (self._endTimers[id]) {
+            if (typeof self._endTimers[id] !== "function") {
+              clearTimeout(self._endTimers[id]);
+            } else {
+              var sound = self._soundById(id);
+              if (sound && sound._node) {
+                sound._node.removeEventListener("ended", self._endTimers[id], false);
+              }
+            }
+            delete self._endTimers[id];
+          }
+          return self;
+        },
+        /**
+         * Return the sound identified by this ID, or return null.
+         * @param  {Number} id Sound ID
+         * @return {Object}    Sound object or null.
+         */
+        _soundById: function(id) {
+          var self = this;
+          for (var i = 0; i < self._sounds.length; i++) {
+            if (id === self._sounds[i]._id) {
+              return self._sounds[i];
+            }
+          }
+          return null;
+        },
+        /**
+         * Return an inactive sound from the pool or create a new one.
+         * @return {Sound} Sound playback object.
+         */
+        _inactiveSound: function() {
+          var self = this;
+          self._drain();
+          for (var i = 0; i < self._sounds.length; i++) {
+            if (self._sounds[i]._ended) {
+              return self._sounds[i].reset();
+            }
+          }
+          return new Sound2(self);
+        },
+        /**
+         * Drain excess inactive sounds from the pool.
+         */
+        _drain: function() {
+          var self = this;
+          var limit = self._pool;
+          var cnt = 0;
+          var i = 0;
+          if (self._sounds.length < limit) {
+            return;
+          }
+          for (i = 0; i < self._sounds.length; i++) {
+            if (self._sounds[i]._ended) {
+              cnt++;
+            }
+          }
+          for (i = self._sounds.length - 1; i >= 0; i--) {
+            if (cnt <= limit) {
+              return;
+            }
+            if (self._sounds[i]._ended) {
+              if (self._webAudio && self._sounds[i]._node) {
+                self._sounds[i]._node.disconnect(0);
+              }
+              self._sounds.splice(i, 1);
+              cnt--;
+            }
+          }
+        },
+        /**
+         * Get all ID's from the sounds pool.
+         * @param  {Number} id Only return one ID if one is passed.
+         * @return {Array}    Array of IDs.
+         */
+        _getSoundIds: function(id) {
+          var self = this;
+          if (typeof id === "undefined") {
+            var ids = [];
+            for (var i = 0; i < self._sounds.length; i++) {
+              ids.push(self._sounds[i]._id);
+            }
+            return ids;
+          } else {
+            return [id];
+          }
+        },
+        /**
+         * Load the sound back into the buffer source.
+         * @param  {Sound} sound The sound object to work with.
+         * @return {Howl}
+         */
+        _refreshBuffer: function(sound) {
+          var self = this;
+          sound._node.bufferSource = Howler2.ctx.createBufferSource();
+          sound._node.bufferSource.buffer = cache[self._src];
+          if (sound._panner) {
+            sound._node.bufferSource.connect(sound._panner);
+          } else {
+            sound._node.bufferSource.connect(sound._node);
+          }
+          sound._node.bufferSource.loop = sound._loop;
+          if (sound._loop) {
+            sound._node.bufferSource.loopStart = sound._start || 0;
+            sound._node.bufferSource.loopEnd = sound._stop || 0;
+          }
+          sound._node.bufferSource.playbackRate.setValueAtTime(sound._rate, Howler2.ctx.currentTime);
+          return self;
+        },
+        /**
+         * Prevent memory leaks by cleaning up the buffer source after playback.
+         * @param  {Object} node Sound's audio node containing the buffer source.
+         * @return {Howl}
+         */
+        _cleanBuffer: function(node) {
+          var self = this;
+          var isIOS = Howler2._navigator && Howler2._navigator.vendor.indexOf("Apple") >= 0;
+          if (!node.bufferSource) {
+            return self;
+          }
+          if (Howler2._scratchBuffer && node.bufferSource) {
+            node.bufferSource.onended = null;
+            node.bufferSource.disconnect(0);
+            if (isIOS) {
+              try {
+                node.bufferSource.buffer = Howler2._scratchBuffer;
+              } catch (e) {
+              }
+            }
+          }
+          node.bufferSource = null;
+          return self;
+        },
+        /**
+         * Set the source to a 0-second silence to stop any downloading (except in IE).
+         * @param  {Object} node Audio node to clear.
+         */
+        _clearSound: function(node) {
+          var checkIE = /MSIE |Trident\//.test(Howler2._navigator && Howler2._navigator.userAgent);
+          if (!checkIE) {
+            node.src = "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA";
+          }
+        }
+      };
+      var Sound2 = function(howl) {
+        this._parent = howl;
+        this.init();
+      };
+      Sound2.prototype = {
+        /**
+         * Initialize a new Sound object.
+         * @return {Sound}
+         */
+        init: function() {
+          var self = this;
+          var parent = self._parent;
+          self._muted = parent._muted;
+          self._loop = parent._loop;
+          self._volume = parent._volume;
+          self._rate = parent._rate;
+          self._seek = 0;
+          self._paused = true;
+          self._ended = true;
+          self._sprite = "__default";
+          self._id = ++Howler2._counter;
+          parent._sounds.push(self);
+          self.create();
+          return self;
+        },
+        /**
+         * Create and setup a new sound object, whether HTML5 Audio or Web Audio.
+         * @return {Sound}
+         */
+        create: function() {
+          var self = this;
+          var parent = self._parent;
+          var volume = Howler2._muted || self._muted || self._parent._muted ? 0 : self._volume;
+          if (parent._webAudio) {
+            self._node = typeof Howler2.ctx.createGain === "undefined" ? Howler2.ctx.createGainNode() : Howler2.ctx.createGain();
+            self._node.gain.setValueAtTime(volume, Howler2.ctx.currentTime);
+            self._node.paused = true;
+            self._node.connect(Howler2.masterGain);
+          } else if (!Howler2.noAudio) {
+            self._node = Howler2._obtainHtml5Audio();
+            self._errorFn = self._errorListener.bind(self);
+            self._node.addEventListener("error", self._errorFn, false);
+            self._loadFn = self._loadListener.bind(self);
+            self._node.addEventListener(Howler2._canPlayEvent, self._loadFn, false);
+            self._endFn = self._endListener.bind(self);
+            self._node.addEventListener("ended", self._endFn, false);
+            self._node.src = parent._src;
+            self._node.preload = parent._preload === true ? "auto" : parent._preload;
+            self._node.volume = volume * Howler2.volume();
+            self._node.load();
+          }
+          return self;
+        },
+        /**
+         * Reset the parameters of this sound to the original state (for recycle).
+         * @return {Sound}
+         */
+        reset: function() {
+          var self = this;
+          var 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 = ++Howler2._counter;
+          return self;
+        },
+        /**
+         * HTML5 Audio error listener callback.
+         */
+        _errorListener: function() {
+          var self = this;
+          self._parent._emit("loaderror", self._id, self._node.error ? self._node.error.code : 0);
+          self._node.removeEventListener("error", self._errorFn, false);
+        },
+        /**
+         * HTML5 Audio canplaythrough listener callback.
+         */
+        _loadListener: function() {
+          var self = this;
+          var parent = self._parent;
+          parent._duration = Math.ceil(self._node.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();
+          }
+          self._node.removeEventListener(Howler2._canPlayEvent, self._loadFn, false);
+        },
+        /**
+         * HTML5 Audio ended listener callback.
+         */
+        _endListener: function() {
+          var self = this;
+          var parent = self._parent;
+          if (parent._duration === Infinity) {
+            parent._duration = Math.ceil(self._node.duration * 10) / 10;
+            if (parent._sprite.__default[1] === Infinity) {
+              parent._sprite.__default[1] = parent._duration * 1e3;
+            }
+            parent._ended(self);
+          }
+          self._node.removeEventListener("ended", self._endFn, false);
+        }
+      };
+      var cache = {};
+      var loadBuffer = function(self) {
+        var url = self._src;
+        if (cache[url]) {
+          self._duration = cache[url].duration;
+          loadSound(self);
+          return;
+        }
+        if (/^data:[^;]+;base64,/.test(url)) {
+          var data = atob(url.split(",")[1]);
+          var dataView = new Uint8Array(data.length);
+          for (var i = 0; i < data.length; ++i) {
+            dataView[i] = data.charCodeAt(i);
+          }
+          decodeAudioData(dataView.buffer, self);
+        } else {
+          var xhr = new XMLHttpRequest();
+          xhr.open(self._xhr.method, url, true);
+          xhr.withCredentials = self._xhr.withCredentials;
+          xhr.responseType = "arraybuffer";
+          if (self._xhr.headers) {
+            Object.keys(self._xhr.headers).forEach(function(key) {
+              xhr.setRequestHeader(key, self._xhr.headers[key]);
+            });
+          }
+          xhr.onload = function() {
+            var code = (xhr.status + "")[0];
+            if (code !== "0" && code !== "2" && code !== "3") {
+              self._emit("loaderror", null, "Failed loading audio file with status: " + xhr.status + ".");
+              return;
+            }
+            decodeAudioData(xhr.response, self);
+          };
+          xhr.onerror = function() {
+            if (self._webAudio) {
+              self._html5 = true;
+              self._webAudio = false;
+              self._sounds = [];
+              delete cache[url];
+              self.load();
+            }
+          };
+          safeXhrSend(xhr);
+        }
+      };
+      var safeXhrSend = function(xhr) {
+        try {
+          xhr.send();
+        } catch (e) {
+          xhr.onerror();
+        }
+      };
+      var decodeAudioData = function(arraybuffer, self) {
+        var error = function() {
+          self._emit("loaderror", null, "Decoding audio data failed.");
+        };
+        var success = function(buffer) {
+          if (buffer && self._sounds.length > 0) {
+            cache[self._src] = buffer;
+            loadSound(self, buffer);
+          } else {
+            error();
+          }
+        };
+        if (typeof Promise !== "undefined" && Howler2.ctx.decodeAudioData.length === 1) {
+          Howler2.ctx.decodeAudioData(arraybuffer).then(success).catch(error);
+        } else {
+          Howler2.ctx.decodeAudioData(arraybuffer, success, error);
+        }
+      };
+      var loadSound = function(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();
+        }
+      };
+      var setupAudioContext = function() {
+        if (!Howler2.usingWebAudio) {
+          return;
+        }
+        try {
+          if (typeof AudioContext !== "undefined") {
+            Howler2.ctx = new AudioContext();
+          } else if (typeof webkitAudioContext !== "undefined") {
+            Howler2.ctx = new webkitAudioContext();
+          } else {
+            Howler2.usingWebAudio = false;
+          }
+        } catch (e) {
+          Howler2.usingWebAudio = false;
+        }
+        if (!Howler2.ctx) {
+          Howler2.usingWebAudio = false;
+        }
+        var iOS = /iP(hone|od|ad)/.test(Howler2._navigator && Howler2._navigator.platform);
+        var appVersion = Howler2._navigator && Howler2._navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/);
+        var version = appVersion ? parseInt(appVersion[1], 10) : null;
+        if (iOS && version && version < 9) {
+          var safari = /safari/.test(Howler2._navigator && Howler2._navigator.userAgent.toLowerCase());
+          if (Howler2._navigator && !safari) {
+            Howler2.usingWebAudio = false;
+          }
+        }
+        if (Howler2.usingWebAudio) {
+          Howler2.masterGain = typeof Howler2.ctx.createGain === "undefined" ? Howler2.ctx.createGainNode() : Howler2.ctx.createGain();
+          Howler2.masterGain.gain.setValueAtTime(Howler2._muted ? 0 : Howler2._volume, Howler2.ctx.currentTime);
+          Howler2.masterGain.connect(Howler2.ctx.destination);
+        }
+        Howler2._setup();
+      };
+      if (typeof define === "function" && define.amd) {
+        define([], function() {
+          return {
+            Howler: Howler2,
+            Howl: Howl3
+          };
+        });
+      }
+      if (typeof exports !== "undefined") {
+        exports.Howler = Howler2;
+        exports.Howl = Howl3;
+      }
+      if (typeof global !== "undefined") {
+        global.HowlerGlobal = HowlerGlobal2;
+        global.Howler = Howler2;
+        global.Howl = Howl3;
+        global.Sound = Sound2;
+      } else if (typeof window !== "undefined") {
+        window.HowlerGlobal = HowlerGlobal2;
+        window.Howler = Howler2;
+        window.Howl = Howl3;
+        window.Sound = Sound2;
+      }
+    })();
+    (function() {
+      "use strict";
+      HowlerGlobal.prototype._pos = [0, 0, 0];
+      HowlerGlobal.prototype._orientation = [0, 0, -1, 0, 1, 0];
+      HowlerGlobal.prototype.stereo = function(pan) {
+        var self = this;
+        if (!self.ctx || !self.ctx.listener) {
+          return self;
+        }
+        for (var i = self._howls.length - 1; i >= 0; i--) {
+          self._howls[i].stereo(pan);
+        }
+        return self;
+      };
+      HowlerGlobal.prototype.pos = function(x, y, z) {
+        var self = this;
+        if (!self.ctx || !self.ctx.listener) {
+          return self;
+        }
+        y = typeof y !== "number" ? self._pos[1] : y;
+        z = typeof z !== "number" ? self._pos[2] : z;
+        if (typeof x === "number") {
+          self._pos = [x, y, z];
+          if (typeof self.ctx.listener.positionX !== "undefined") {
+            self.ctx.listener.positionX.setTargetAtTime(self._pos[0], Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.positionY.setTargetAtTime(self._pos[1], Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.positionZ.setTargetAtTime(self._pos[2], Howler.ctx.currentTime, 0.1);
+          } else {
+            self.ctx.listener.setPosition(self._pos[0], self._pos[1], self._pos[2]);
+          }
+        } else {
+          return self._pos;
+        }
+        return self;
+      };
+      HowlerGlobal.prototype.orientation = function(x, y, z, xUp, yUp, zUp) {
+        var self = this;
+        if (!self.ctx || !self.ctx.listener) {
+          return self;
+        }
+        var or = self._orientation;
+        y = typeof y !== "number" ? or[1] : y;
+        z = typeof z !== "number" ? or[2] : z;
+        xUp = typeof xUp !== "number" ? or[3] : xUp;
+        yUp = typeof yUp !== "number" ? or[4] : yUp;
+        zUp = typeof zUp !== "number" ? or[5] : zUp;
+        if (typeof x === "number") {
+          self._orientation = [x, y, z, xUp, yUp, zUp];
+          if (typeof self.ctx.listener.forwardX !== "undefined") {
+            self.ctx.listener.forwardX.setTargetAtTime(x, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.forwardY.setTargetAtTime(y, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.forwardZ.setTargetAtTime(z, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.upX.setTargetAtTime(xUp, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.upY.setTargetAtTime(yUp, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.upZ.setTargetAtTime(zUp, Howler.ctx.currentTime, 0.1);
+          } else {
+            self.ctx.listener.setOrientation(x, y, z, xUp, yUp, zUp);
+          }
+        } else {
+          return or;
+        }
+        return self;
+      };
+      Howl.prototype.init = /* @__PURE__ */ (function(_super) {
+        return function(o) {
+          var self = this;
+          self._orientation = o.orientation || [1, 0, 0];
+          self._stereo = o.stereo || null;
+          self._pos = o.pos || null;
+          self._pannerAttr = {
+            coneInnerAngle: typeof o.coneInnerAngle !== "undefined" ? o.coneInnerAngle : 360,
+            coneOuterAngle: typeof o.coneOuterAngle !== "undefined" ? o.coneOuterAngle : 360,
+            coneOuterGain: typeof o.coneOuterGain !== "undefined" ? o.coneOuterGain : 0,
+            distanceModel: typeof o.distanceModel !== "undefined" ? o.distanceModel : "inverse",
+            maxDistance: typeof o.maxDistance !== "undefined" ? o.maxDistance : 1e4,
+            panningModel: typeof o.panningModel !== "undefined" ? o.panningModel : "HRTF",
+            refDistance: typeof o.refDistance !== "undefined" ? o.refDistance : 1,
+            rolloffFactor: typeof o.rolloffFactor !== "undefined" ? o.rolloffFactor : 1
+          };
+          self._onstereo = o.onstereo ? [{ fn: o.onstereo }] : [];
+          self._onpos = o.onpos ? [{ fn: o.onpos }] : [];
+          self._onorientation = o.onorientation ? [{ fn: o.onorientation }] : [];
+          return _super.call(this, o);
+        };
+      })(Howl.prototype.init);
+      Howl.prototype.stereo = function(pan, id) {
+        var self = this;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (self._state !== "loaded") {
+          self._queue.push({
+            event: "stereo",
+            action: function() {
+              self.stereo(pan, id);
+            }
+          });
+          return self;
+        }
+        var pannerType = typeof Howler.ctx.createStereoPanner === "undefined" ? "spatial" : "stereo";
+        if (typeof id === "undefined") {
+          if (typeof pan === "number") {
+            self._stereo = pan;
+            self._pos = [pan, 0, 0];
+          } else {
+            return self._stereo;
+          }
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          var sound = self._soundById(ids[i]);
+          if (sound) {
+            if (typeof pan === "number") {
+              sound._stereo = pan;
+              sound._pos = [pan, 0, 0];
+              if (sound._node) {
+                sound._pannerAttr.panningModel = "equalpower";
+                if (!sound._panner || !sound._panner.pan) {
+                  setupPanner(sound, pannerType);
+                }
+                if (pannerType === "spatial") {
+                  if (typeof sound._panner.positionX !== "undefined") {
+                    sound._panner.positionX.setValueAtTime(pan, Howler.ctx.currentTime);
+                    sound._panner.positionY.setValueAtTime(0, Howler.ctx.currentTime);
+                    sound._panner.positionZ.setValueAtTime(0, Howler.ctx.currentTime);
+                  } else {
+                    sound._panner.setPosition(pan, 0, 0);
+                  }
+                } else {
+                  sound._panner.pan.setValueAtTime(pan, Howler.ctx.currentTime);
+                }
+              }
+              self._emit("stereo", sound._id);
+            } else {
+              return sound._stereo;
+            }
+          }
+        }
+        return self;
+      };
+      Howl.prototype.pos = function(x, y, z, id) {
+        var self = this;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (self._state !== "loaded") {
+          self._queue.push({
+            event: "pos",
+            action: function() {
+              self.pos(x, y, z, id);
+            }
+          });
+          return self;
+        }
+        y = typeof y !== "number" ? 0 : y;
+        z = typeof z !== "number" ? -0.5 : z;
+        if (typeof id === "undefined") {
+          if (typeof x === "number") {
+            self._pos = [x, y, z];
+          } else {
+            return self._pos;
+          }
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          var sound = self._soundById(ids[i]);
+          if (sound) {
+            if (typeof x === "number") {
+              sound._pos = [x, y, z];
+              if (sound._node) {
+                if (!sound._panner || sound._panner.pan) {
+                  setupPanner(sound, "spatial");
+                }
+                if (typeof sound._panner.positionX !== "undefined") {
+                  sound._panner.positionX.setValueAtTime(x, Howler.ctx.currentTime);
+                  sound._panner.positionY.setValueAtTime(y, Howler.ctx.currentTime);
+                  sound._panner.positionZ.setValueAtTime(z, Howler.ctx.currentTime);
+                } else {
+                  sound._panner.setPosition(x, y, z);
+                }
+              }
+              self._emit("pos", sound._id);
+            } else {
+              return sound._pos;
+            }
+          }
+        }
+        return self;
+      };
+      Howl.prototype.orientation = function(x, y, z, id) {
+        var self = this;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (self._state !== "loaded") {
+          self._queue.push({
+            event: "orientation",
+            action: function() {
+              self.orientation(x, y, z, id);
+            }
+          });
+          return self;
+        }
+        y = typeof y !== "number" ? self._orientation[1] : y;
+        z = typeof z !== "number" ? self._orientation[2] : z;
+        if (typeof id === "undefined") {
+          if (typeof x === "number") {
+            self._orientation = [x, y, z];
+          } else {
+            return self._orientation;
+          }
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          var sound = self._soundById(ids[i]);
+          if (sound) {
+            if (typeof x === "number") {
+              sound._orientation = [x, y, z];
+              if (sound._node) {
+                if (!sound._panner) {
+                  if (!sound._pos) {
+                    sound._pos = self._pos || [0, 0, -0.5];
+                  }
+                  setupPanner(sound, "spatial");
+                }
+                if (typeof sound._panner.orientationX !== "undefined") {
+                  sound._panner.orientationX.setValueAtTime(x, Howler.ctx.currentTime);
+                  sound._panner.orientationY.setValueAtTime(y, Howler.ctx.currentTime);
+                  sound._panner.orientationZ.setValueAtTime(z, Howler.ctx.currentTime);
+                } else {
+                  sound._panner.setOrientation(x, y, z);
+                }
+              }
+              self._emit("orientation", sound._id);
+            } else {
+              return sound._orientation;
+            }
+          }
+        }
+        return self;
+      };
+      Howl.prototype.pannerAttr = function() {
+        var self = this;
+        var args = arguments;
+        var o, id, sound;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (args.length === 0) {
+          return self._pannerAttr;
+        } else if (args.length === 1) {
+          if (typeof args[0] === "object") {
+            o = args[0];
+            if (typeof id === "undefined") {
+              if (!o.pannerAttr) {
+                o.pannerAttr = {
+                  coneInnerAngle: o.coneInnerAngle,
+                  coneOuterAngle: o.coneOuterAngle,
+                  coneOuterGain: o.coneOuterGain,
+                  distanceModel: o.distanceModel,
+                  maxDistance: o.maxDistance,
+                  refDistance: o.refDistance,
+                  rolloffFactor: o.rolloffFactor,
+                  panningModel: o.panningModel
+                };
+              }
+              self._pannerAttr = {
+                coneInnerAngle: typeof o.pannerAttr.coneInnerAngle !== "undefined" ? o.pannerAttr.coneInnerAngle : self._coneInnerAngle,
+                coneOuterAngle: typeof o.pannerAttr.coneOuterAngle !== "undefined" ? o.pannerAttr.coneOuterAngle : self._coneOuterAngle,
+                coneOuterGain: typeof o.pannerAttr.coneOuterGain !== "undefined" ? o.pannerAttr.coneOuterGain : self._coneOuterGain,
+                distanceModel: typeof o.pannerAttr.distanceModel !== "undefined" ? o.pannerAttr.distanceModel : self._distanceModel,
+                maxDistance: typeof o.pannerAttr.maxDistance !== "undefined" ? o.pannerAttr.maxDistance : self._maxDistance,
+                refDistance: typeof o.pannerAttr.refDistance !== "undefined" ? o.pannerAttr.refDistance : self._refDistance,
+                rolloffFactor: typeof o.pannerAttr.rolloffFactor !== "undefined" ? o.pannerAttr.rolloffFactor : self._rolloffFactor,
+                panningModel: typeof o.pannerAttr.panningModel !== "undefined" ? o.pannerAttr.panningModel : self._panningModel
+              };
+            }
+          } else {
+            sound = self._soundById(parseInt(args[0], 10));
+            return sound ? sound._pannerAttr : self._pannerAttr;
+          }
+        } else if (args.length === 2) {
+          o = args[0];
+          id = parseInt(args[1], 10);
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          sound = self._soundById(ids[i]);
+          if (sound) {
+            var pa = sound._pannerAttr;
+            pa = {
+              coneInnerAngle: typeof o.coneInnerAngle !== "undefined" ? o.coneInnerAngle : pa.coneInnerAngle,
+              coneOuterAngle: typeof o.coneOuterAngle !== "undefined" ? o.coneOuterAngle : pa.coneOuterAngle,
+              coneOuterGain: typeof o.coneOuterGain !== "undefined" ? o.coneOuterGain : pa.coneOuterGain,
+              distanceModel: typeof o.distanceModel !== "undefined" ? o.distanceModel : pa.distanceModel,
+              maxDistance: typeof o.maxDistance !== "undefined" ? o.maxDistance : pa.maxDistance,
+              refDistance: typeof o.refDistance !== "undefined" ? o.refDistance : pa.refDistance,
+              rolloffFactor: typeof o.rolloffFactor !== "undefined" ? o.rolloffFactor : pa.rolloffFactor,
+              panningModel: typeof o.panningModel !== "undefined" ? o.panningModel : pa.panningModel
+            };
+            var panner = sound._panner;
+            if (!panner) {
+              if (!sound._pos) {
+                sound._pos = self._pos || [0, 0, -0.5];
+              }
+              setupPanner(sound, "spatial");
+              panner = sound._panner;
+            }
+            panner.coneInnerAngle = pa.coneInnerAngle;
+            panner.coneOuterAngle = pa.coneOuterAngle;
+            panner.coneOuterGain = pa.coneOuterGain;
+            panner.distanceModel = pa.distanceModel;
+            panner.maxDistance = pa.maxDistance;
+            panner.refDistance = pa.refDistance;
+            panner.rolloffFactor = pa.rolloffFactor;
+            panner.panningModel = pa.panningModel;
+          }
+        }
+        return self;
+      };
+      Sound.prototype.init = /* @__PURE__ */ (function(_super) {
+        return function() {
+          var self = this;
+          var parent = self._parent;
+          self._orientation = parent._orientation;
+          self._stereo = parent._stereo;
+          self._pos = parent._pos;
+          self._pannerAttr = parent._pannerAttr;
+          _super.call(this);
+          if (self._stereo) {
+            parent.stereo(self._stereo);
+          } else if (self._pos) {
+            parent.pos(self._pos[0], self._pos[1], self._pos[2], self._id);
+          }
+        };
+      })(Sound.prototype.init);
+      Sound.prototype.reset = /* @__PURE__ */ (function(_super) {
+        return function() {
+          var self = this;
+          var parent = self._parent;
+          self._orientation = parent._orientation;
+          self._stereo = parent._stereo;
+          self._pos = parent._pos;
+          self._pannerAttr = parent._pannerAttr;
+          if (self._stereo) {
+            parent.stereo(self._stereo);
+          } else if (self._pos) {
+            parent.pos(self._pos[0], self._pos[1], self._pos[2], self._id);
+          } else if (self._panner) {
+            self._panner.disconnect(0);
+            self._panner = void 0;
+            parent._refreshBuffer(self);
+          }
+          return _super.call(this);
+        };
+      })(Sound.prototype.reset);
+      var setupPanner = function(sound, type) {
+        type = type || "spatial";
+        if (type === "spatial") {
+          sound._panner = Howler.ctx.createPanner();
+          sound._panner.coneInnerAngle = sound._pannerAttr.coneInnerAngle;
+          sound._panner.coneOuterAngle = sound._pannerAttr.coneOuterAngle;
+          sound._panner.coneOuterGain = sound._pannerAttr.coneOuterGain;
+          sound._panner.distanceModel = sound._pannerAttr.distanceModel;
+          sound._panner.maxDistance = sound._pannerAttr.maxDistance;
+          sound._panner.refDistance = sound._pannerAttr.refDistance;
+          sound._panner.rolloffFactor = sound._pannerAttr.rolloffFactor;
+          sound._panner.panningModel = sound._pannerAttr.panningModel;
+          if (typeof sound._panner.positionX !== "undefined") {
+            sound._panner.positionX.setValueAtTime(sound._pos[0], Howler.ctx.currentTime);
+            sound._panner.positionY.setValueAtTime(sound._pos[1], Howler.ctx.currentTime);
+            sound._panner.positionZ.setValueAtTime(sound._pos[2], Howler.ctx.currentTime);
+          } else {
+            sound._panner.setPosition(sound._pos[0], sound._pos[1], sound._pos[2]);
+          }
+          if (typeof sound._panner.orientationX !== "undefined") {
+            sound._panner.orientationX.setValueAtTime(sound._orientation[0], Howler.ctx.currentTime);
+            sound._panner.orientationY.setValueAtTime(sound._orientation[1], Howler.ctx.currentTime);
+            sound._panner.orientationZ.setValueAtTime(sound._orientation[2], Howler.ctx.currentTime);
+          } else {
+            sound._panner.setOrientation(sound._orientation[0], sound._orientation[1], sound._orientation[2]);
+          }
+        } else {
+          sound._panner = Howler.ctx.createStereoPanner();
+          sound._panner.pan.setValueAtTime(sound._stereo, Howler.ctx.currentTime);
+        }
+        sound._panner.connect(sound._node);
+        if (!sound._paused) {
+          sound._parent.pause(sound._id, true).play(sound._id, true);
+        }
+      };
+    })();
+  }
+});
+
 // src/plugin.ts
 import { tool } from "@opencode-ai/plugin";
 
 // src/core/speaker.ts
 import { EventEmitter as EventEmitter2 } from "events";
 
-// src/core/types.ts
-var TTSError = class extends Error {
-  constructor(message, code, provider, details) {
-    super(message);
-    this.name = "TTSError";
-    this.code = code;
-    this.provider = provider;
-    this.details = details;
+// src/core/types.ts
+var TTSError = class extends Error {
+  constructor(message, code, provider, details) {
+    super(message);
+    this.name = "TTSError";
+    this.code = code;
+    this.provider = provider;
+    this.details = details;
+  }
+  code;
+  provider;
+  details;
+};
+
+// src/providers/base.ts
+var providers = /* @__PURE__ */ new Map();
+function registerProvider(name, provider) {
+  if (providers.has(name)) {
+    throw new TTSError(
+      `Provider "${name}" is already registered`,
+      "UNKNOWN" /* UNKNOWN */,
+      "system"
+    );
+  }
+  providers.set(name, provider);
+}
+function getProvider(name) {
+  const provider = providers.get(name);
+  if (!provider) {
+    throw new TTSError(
+      `TTS Provider "${name}" not found`,
+      "UNKNOWN" /* UNKNOWN */,
+      "system"
+    );
+  }
+  return provider;
+}
+function listProviders() {
+  return Array.from(providers.keys());
+}
+function hasProvider(name) {
+  return providers.has(name);
+}
+var BaseTTSProvider = class {
+  apiKey;
+  defaultVoice;
+  defaultModel = "stream";
+  async initialize() {
+  }
+  async destroy() {
+  }
+  /**
+   * 通用 speak 实现，处理通用逻辑
+   */
+  async speak(text, options) {
+    if (!text || text.trim().length === 0) {
+      throw new TTSError(
+        "Text cannot be empty",
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        this.name
+      );
+    }
+    const voice = options?.voice || this.defaultVoice;
+    const model = options?.model || this.defaultModel;
+    return this.doSpeak(text, voice, model, options);
+  }
+  pause() {
+    throw new TTSError(
+      "Pause is not supported by this provider",
+      "UNKNOWN" /* UNKNOWN */,
+      this.name
+    );
+  }
+  resume() {
+    throw new TTSError(
+      "Resume is not supported by this provider",
+      "UNKNOWN" /* UNKNOWN */,
+      this.name
+    );
+  }
+  stop() {
+    return Promise.resolve();
+  }
+  async listVoices() {
+    return [];
+  }
+  getCapabilities() {
+    return this.capabilities;
+  }
+  /**
+   * 验证 API Key
+   */
+  validateApiKey() {
+    if (!this.apiKey) {
+      throw new TTSError(
+        `API key is required for provider "${this.name}"`,
+        "AUTH" /* AUTH */,
+        this.name
+      );
+    }
+  }
+};
+
+// src/core/player.ts
+import { EventEmitter } from "events";
+import fs from "fs";
+import { createWriteStream } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join4 } from "path";
+
+// src/core/backends/naudiodon-backend.ts
+var UnsupportedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedError";
+  }
+};
+var NaudiodonBackend = class {
+  name = "naudiodon";
+  supportsStreaming = true;
+  audioOutput;
+  events;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  sampleRate;
+  channels;
+  volume = 1;
+  bytesWritten = 0;
+  constructor(options = {}) {
+    this.sampleRate = options.sampleRate || 16e3;
+    this.channels = options.channels || 1;
+    this.events = options.events;
+    this.volume = options.volume ?? 1;
+  }
+  start(_filePath) {
+    if (this._started) return;
+    try {
+      const naudiodon = __require("naudiodon");
+      const AudioOutput = naudiodon;
+      this.audioOutput = new AudioOutput({
+        sampleRate: this.sampleRate,
+        channels: this.channels,
+        bitDepth: 16
+      });
+      this.audioOutput.on("error", (error) => {
+        this.handleError(error);
+      });
+      this.audioOutput.start();
+      this._started = true;
+      this._stopped = false;
+      this.events?.onStart?.();
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("naudiodon is not installed. Run: npm install naudiodon");
+      }
+      throw error;
+    }
+  }
+  write(chunk) {
+    if (!this._started || this._stopped) return;
+    if (this.audioOutput) {
+      const adjustedChunk = this.adjustVolume(chunk);
+      this.audioOutput.write(adjustedChunk);
+      this.bytesWritten += chunk.length;
+      this.events?.onProgress?.(this.bytesWritten);
+    }
+  }
+  end() {
+    if (this.audioOutput) {
+      this.audioOutput.end();
+    }
+  }
+  pause() {
+    if (!this._started || this._paused || this._stopped) return;
+    throw new UnsupportedError("naudiodon backend does not support pause");
+  }
+  resume() {
+    if (!this._paused || this._stopped) return;
+    this._paused = false;
+    this.events?.onResume?.();
+  }
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.audioOutput) {
+      try {
+        this.audioOutput.quit();
+      } catch (e) {
+      }
+      this.audioOutput = void 0;
+    }
+    this.bytesWritten = 0;
+    this.events?.onStop?.();
+  }
+  getCurrentTime() {
+    return this.bytesWritten / (this.sampleRate * this.channels * 2);
+  }
+  getDuration() {
+    return void 0;
+  }
+  setVolume(volume) {
+    this.volume = Math.max(0, Math.min(1, volume));
+  }
+  destroy() {
+    this.stop();
+  }
+  adjustVolume(chunk) {
+    if (this.volume === 1) return chunk;
+    const adjusted = Buffer.alloc(chunk.length);
+    for (let i = 0; i < chunk.length; i += 2) {
+      const sample = chunk.readInt16LE(i) * this.volume;
+      adjusted.writeInt16LE(Math.round(sample), i);
+    }
+    return adjusted;
+  }
+  handleError(error) {
+    this.events?.onError?.(error);
+  }
+};
+
+// src/core/backends/afplay-backend.ts
+import { execFile } from "child_process";
+import { tmpdir } from "os";
+import { join } from "path";
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+var SAFE_PATH_REGEX = /^[\w\/\.]+$/;
+var AfplayBackend = class {
+  name = "afplay";
+  supportsStreaming = false;
+  process;
+  tempFile;
+  events;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  // P0-4: 缓冲所有chunk，等end()时一次性写入文件
+  chunks = [];
+  hasEnded = false;
+  constructor(options = {}) {
+    this.events = options.events;
+  }
+  start(filePath) {
+    if (this._started) return;
+    if (!SAFE_PATH_REGEX.test(filePath)) {
+      throw new Error(`Invalid file path: ${filePath}`);
+    }
+    this.tempFile = filePath;
+    this._started = true;
+    this._stopped = false;
+    this.events?.onStart?.();
+    this.process = execFile("afplay", [filePath], (error) => {
+      if (this._stopped) return;
+      if (error) {
+        this.handleError(error);
+        return;
+      }
+      this._started = false;
+      this.events?.onEnd?.();
+    });
+    this.process.on("error", (error) => {
+      this.handleError(error);
+    });
+  }
+  write(chunk) {
+    if (this._stopped) return;
+    this.chunks.push(chunk);
+  }
+  end() {
+    if (this._stopped || this.hasEnded) return;
+    this.hasEnded = true;
+    if (this.chunks.length === 0) return;
+    this.tempFile = join(tmpdir(), `ocosay-${Date.now()}.wav`);
+    writeFileSync(this.tempFile, Buffer.concat(this.chunks));
+    this.chunks = [];
+    this.start(this.tempFile);
+  }
+  pause() {
+    if (!this._started || this._paused || this._stopped) return;
+    if (this.process) {
+      try {
+        this.process.kill("SIGSTOP");
+        this._paused = true;
+        this.events?.onPause?.();
+      } catch (e) {
+      }
+    }
+  }
+  resume() {
+    if (!this._paused || this._stopped) return;
+    if (this.process) {
+      try {
+        this.process.kill("SIGCONT");
+        this._paused = false;
+        this.events?.onResume?.();
+      } catch (e) {
+      }
+    }
+  }
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch (e) {
+      }
+      this.process = void 0;
+    }
+    this.cleanup();
+    this.chunks = [];
+    this.hasEnded = false;
+    this.events?.onStop?.();
+  }
+  setVolume(_volume) {
+  }
+  destroy() {
+    this.stop();
+  }
+  cleanup() {
+    if (this.tempFile && this.tempFile.startsWith(tmpdir())) {
+      try {
+        if (existsSync(this.tempFile)) {
+          unlinkSync(this.tempFile);
+        }
+      } catch (e) {
+      }
+      this.tempFile = void 0;
+    }
+  }
+  handleError(error) {
+    this.events?.onError?.(error);
   }
-  code;
-  provider;
-  details;
 };
 
-// src/providers/base.ts
-var providers = /* @__PURE__ */ new Map();
-function registerProvider(name, provider) {
-  if (providers.has(name)) {
-    throw new TTSError(
-      `Provider "${name}" is already registered`,
-      "UNKNOWN" /* UNKNOWN */,
-      "system"
-    );
+// src/core/backends/aplay-backend.ts
+import { execFile as execFile2 } from "child_process";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+import { writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync2 } from "fs";
+var SAFE_PATH_REGEX2 = /^[\w\/\.]+$/;
+var AplayBackend = class {
+  name = "aplay";
+  supportsStreaming = false;
+  process;
+  tempFile;
+  events;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  // P0-4: 缓冲所有chunk，等end()时一次性写入文件
+  chunks = [];
+  hasEnded = false;
+  constructor(options = {}) {
+    this.events = options.events;
   }
-  providers.set(name, provider);
-}
-function getProvider(name) {
-  const provider = providers.get(name);
-  if (!provider) {
-    throw new TTSError(
-      `TTS Provider "${name}" not found`,
-      "UNKNOWN" /* UNKNOWN */,
-      "system"
-    );
+  start(filePath) {
+    if (this._started) return;
+    if (!SAFE_PATH_REGEX2.test(filePath)) {
+      throw new Error(`Invalid file path: ${filePath}`);
+    }
+    this.tempFile = filePath;
+    this._started = true;
+    this._stopped = false;
+    this.events?.onStart?.();
+    this.process = execFile2("aplay", [filePath], (error) => {
+      if (this._stopped) return;
+      if (error) {
+        this.handleError(error);
+        return;
+      }
+      this._started = false;
+      this.events?.onEnd?.();
+    });
+    this.process.on("error", (error) => {
+      this.handleError(error);
+    });
   }
-  return provider;
-}
-function listProviders() {
-  return Array.from(providers.keys());
-}
-function hasProvider(name) {
-  return providers.has(name);
+  write(chunk) {
+    if (this._stopped) return;
+    this.chunks.push(chunk);
+  }
+  end() {
+    if (this._stopped || this.hasEnded) return;
+    this.hasEnded = true;
+    if (this.chunks.length === 0) return;
+    this.tempFile = join2(tmpdir2(), `ocosay-${Date.now()}.wav`);
+    writeFileSync2(this.tempFile, Buffer.concat(this.chunks));
+    this.chunks = [];
+    this.start(this.tempFile);
+  }
+  pause() {
+    if (!this._started || this._paused || this._stopped) return;
+    if (this.process) {
+      try {
+        this.process.kill("SIGSTOP");
+        this._paused = true;
+        this.events?.onPause?.();
+      } catch (e) {
+      }
+    }
+  }
+  resume() {
+    if (!this._paused || this._stopped) return;
+    if (this.process) {
+      try {
+        this.process.kill("SIGCONT");
+        this._paused = false;
+        this.events?.onResume?.();
+      } catch (e) {
+      }
+    }
+  }
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch (e) {
+      }
+      this.process = void 0;
+    }
+    this.cleanup();
+    this.chunks = [];
+    this.hasEnded = false;
+    this.events?.onStop?.();
+  }
+  setVolume(_volume) {
+  }
+  destroy() {
+    this.stop();
+  }
+  cleanup() {
+    if (this.tempFile && this.tempFile.startsWith(tmpdir2())) {
+      try {
+        if (existsSync2(this.tempFile)) {
+          unlinkSync2(this.tempFile);
+        }
+      } catch (e) {
+      }
+      this.tempFile = void 0;
+    }
+  }
+  handleError(error) {
+    this.events?.onError?.(error);
+  }
+};
+
+// src/core/backends/powershell-backend.ts
+import { spawn } from "child_process";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join3 } from "path";
+import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, existsSync as existsSync3 } from "fs";
+var SAFE_PATH_REGEX3 = /^[\w\:\\_.]+$/i;
+function wslPathToWindows(wslPath) {
+  return wslPath.replace(/^\/mnt\/([a-z])\//, "$1:/").replace(/\//g, "\\");
 }
-var BaseTTSProvider = class {
-  apiKey;
-  defaultVoice;
-  defaultModel = "stream";
-  async initialize() {
+var UnsupportedError2 = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedError";
+  }
+};
+var PowerShellBackend = class {
+  name = "powershell";
+  supportsStreaming = false;
+  process;
+  tempFile;
+  events;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  // P0-4: 缓冲所有chunk，等end()时一次性写入文件
+  chunks = [];
+  hasEnded = false;
+  constructor(options = {}) {
+    this.events = options.events;
+  }
+  start(filePath) {
+    if (this._started) return;
+    if (isWsl()) {
+      filePath = wslPathToWindows(filePath);
+    }
+    if (!SAFE_PATH_REGEX3.test(filePath)) {
+      throw new Error(`Invalid file path: ${filePath}`);
+    }
+    this.tempFile = filePath;
+    this._started = true;
+    this._stopped = false;
+    this.events?.onStart?.();
+    const escapedPath = filePath.replace(/'/g, "''");
+    const psScript = `$sound = New-Object System.Media.SoundPlayer('${escapedPath}'); $sound.PlayAsync()`;
+    const scriptFile = join3(tmpdir3(), `ocosay-${Date.now()}.ps1`);
+    writeFileSync3(scriptFile, psScript, { encoding: "utf8" });
+    this.process = spawn("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptFile], {
+      stdio: "ignore",
+      detached: false
+    });
+    this.process.on("exit", () => {
+      try {
+        if (existsSync3(scriptFile)) {
+          unlinkSync3(scriptFile);
+        }
+      } catch (e) {
+      }
+    });
+    this.process.on("exit", (code) => {
+      if (this._stopped) return;
+      if (code === 0 || code === null) {
+        this._started = false;
+        this.events?.onEnd?.();
+      } else {
+        this.handleError(new Error(`PowerShell playback exited with code ${code}`));
+      }
+    });
+    this.process.on("error", (error) => {
+      this.handleError(error);
+    });
+  }
+  write(chunk) {
+    if (this._stopped) return;
+    this.chunks.push(chunk);
+  }
+  end() {
+    if (this._stopped || this.hasEnded) return;
+    this.hasEnded = true;
+    if (this.chunks.length === 0) return;
+    this.tempFile = join3(tmpdir3(), `ocosay-${Date.now()}.wav`);
+    writeFileSync3(this.tempFile, Buffer.concat(this.chunks));
+    this.chunks = [];
+    this.start(this.tempFile);
+  }
+  pause() {
+    if (!this._started || this._paused || this._stopped) return;
+    throw new UnsupportedError2("pause is not supported by PowerShell SoundPlayer");
+  }
+  resume() {
+    if (!this._paused || this._stopped) return;
+    throw new UnsupportedError2("resume is not supported by PowerShell SoundPlayer");
+  }
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch (e) {
+      }
+      this.process = void 0;
+    }
+    this.cleanup();
+    this.chunks = [];
+    this.hasEnded = false;
+    this.events?.onStop?.();
+  }
+  setVolume(_volume) {
+  }
+  destroy() {
+    this.stop();
+  }
+  cleanup() {
+    if (this.tempFile && this.tempFile.startsWith(tmpdir3())) {
+      try {
+        if (existsSync3(this.tempFile)) {
+          unlinkSync3(this.tempFile);
+        }
+      } catch (e) {
+      }
+      this.tempFile = void 0;
+    }
   }
-  async destroy() {
+  handleError(error) {
+    this.events?.onError?.(error);
   }
-  /**
-   * 通用 speak 实现，处理通用逻辑
-   */
-  async speak(text, options) {
-    if (!text || text.trim().length === 0) {
-      throw new TTSError(
-        "Text cannot be empty",
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        this.name
-      );
+};
+
+// src/core/backends/howler-backend.ts
+var import_howler = __toESM(require_howler(), 1);
+var HowlerBackend = class {
+  name = "howler";
+  supportsStreaming = false;
+  // Howler.js 不支持真正的流式播放
+  howl = null;
+  events;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  volume = 1;
+  bytesWritten = 0;
+  blobUrl = null;
+  format;
+  constructor(options = {}) {
+    this.events = options.events;
+    this.volume = options.volume ?? 1;
+    this.format = options.format || "mp3";
+  }
+  start(_filePath) {
+    if (this._started) {
+      this.stop();
+    }
+    this._started = true;
+    this._stopped = false;
+    this._paused = false;
+    this.bytesWritten = 0;
+    this.howl = new import_howler.Howl({
+      src: [""],
+      // 初始为空
+      html5: true,
+      // 启用 HTML5 Audio 模式支持流式
+      volume: this.volume,
+      format: [this.format],
+      onplay: () => {
+        this.events?.onStart?.();
+      },
+      onpause: () => {
+        if (!this._stopped) {
+          this.events?.onPause?.();
+        }
+      },
+      onstop: () => {
+        if (!this._stopped) {
+          this.events?.onStop?.();
+        }
+      },
+      onend: () => {
+        this.events?.onEnd?.();
+      },
+      onloaderror: (_id, error) => {
+        this.handleError(new Error(`Howler load error: ${error}`));
+      },
+      onplayerror: (_id, error) => {
+        this.handleError(new Error(`Howler play error: ${error}`));
+      }
+    });
+  }
+  write(chunk) {
+    if (!this._started || this._stopped) return;
+    if (!this.howl) return;
+    this.bytesWritten += chunk.length;
+    this.events?.onProgress?.(this.bytesWritten);
+    const blob = new Blob([chunk], { type: `audio/${this.format}` });
+    if (this.blobUrl) {
+      URL.revokeObjectURL(this.blobUrl);
+    }
+    this.blobUrl = URL.createObjectURL(blob);
+    const wasPlaying = this.howl.playing();
+    this.howl.stop();
+    this.howl.unload();
+    this.howl = new import_howler.Howl({
+      src: [this.blobUrl],
+      html5: true,
+      volume: this.volume,
+      format: [this.format],
+      onplay: () => {
+        if (!wasPlaying) {
+          this.events?.onStart?.();
+        }
+      },
+      onpause: () => {
+        if (!this._stopped) {
+          this.events?.onPause?.();
+        }
+      },
+      onstop: () => {
+        if (!this._stopped) {
+          this.events?.onStop?.();
+        }
+      },
+      onend: () => {
+        this.events?.onEnd?.();
+      },
+      onloaderror: (_id, error) => {
+        this.handleError(new Error(`Howler load error: ${error}`));
+      },
+      onplayerror: (_id, error) => {
+        this.handleError(new Error(`Howler play error: ${error}`));
+      }
+    });
+    if (wasPlaying || this._started) {
+      this.howl.play();
     }
-    const voice = options?.voice || this.defaultVoice;
-    const model = options?.model || this.defaultModel;
-    return this.doSpeak(text, voice, model, options);
+  }
+  end() {
   }
   pause() {
-    throw new TTSError(
-      "Pause is not supported by this provider",
-      "UNKNOWN" /* UNKNOWN */,
-      this.name
-    );
+    if (!this._started || this._paused || this._stopped) return;
+    if (this.howl && this.howl.playing()) {
+      this.howl.pause();
+      this._paused = true;
+      this.events?.onPause?.();
+    }
   }
   resume() {
-    throw new TTSError(
-      "Resume is not supported by this provider",
-      "UNKNOWN" /* UNKNOWN */,
-      this.name
-    );
+    if (!this._paused || this._stopped) return;
+    if (this.howl) {
+      this.howl.play();
+      this._paused = false;
+      this.events?.onResume?.();
+    }
   }
   stop() {
-    return Promise.resolve();
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.howl) {
+      try {
+        this.howl.stop();
+        this.howl.unload();
+      } catch (e) {
+      }
+      this.howl = null;
+    }
+    if (this.blobUrl) {
+      URL.revokeObjectURL(this.blobUrl);
+      this.blobUrl = null;
+    }
+    this.bytesWritten = 0;
+    this.events?.onStop?.();
   }
-  async listVoices() {
-    return [];
+  getCurrentTime() {
+    if (this.howl) {
+      return this.howl.seek();
+    }
+    return void 0;
   }
-  getCapabilities() {
-    return this.capabilities;
+  getDuration() {
+    if (this.howl) {
+      return this.howl.duration();
+    }
+    return void 0;
   }
-  /**
-   * 验证 API Key
-   */
-  validateApiKey() {
-    if (!this.apiKey) {
-      throw new TTSError(
-        `API key is required for provider "${this.name}"`,
-        "AUTH" /* AUTH */,
-        this.name
-      );
+  setVolume(volume) {
+    this.volume = Math.max(0, Math.min(1, volume));
+    if (this.howl) {
+      this.howl.volume(this.volume);
     }
   }
+  destroy() {
+    this.stop();
+  }
+  handleError(error) {
+    this.events?.onError?.(error);
+  }
 };
 
+// src/core/backends/index.ts
+function isNaudiodonAvailable() {
+  try {
+    __require.resolve("naudiodon");
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isWsl() {
+  if (process.platform !== "linux") return false;
+  try {
+    return __require("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+  } catch {
+    return false;
+  }
+}
+function createBackend(type = "auto" /* AUTO */, options = {}) {
+  const platform = process.platform;
+  if (type !== "auto" /* AUTO */) {
+    return createBackendByType(type, options);
+  }
+  if (isNaudiodonAvailable()) {
+    try {
+      const naudiodon = __require("naudiodon");
+      if (naudiodon) {
+        return new NaudiodonBackend(options);
+      }
+    } catch (e) {
+    }
+  }
+  switch (platform) {
+    case "darwin":
+      return new AfplayBackend(options);
+    case "linux":
+      if (isWsl()) {
+        return new PowerShellBackend(options);
+      }
+      return new AplayBackend(options);
+    case "win32":
+      return new PowerShellBackend(options);
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+function createBackendByType(type, options) {
+  switch (type) {
+    case "naudiodon" /* NAUDIODON */:
+      return new NaudiodonBackend(options);
+    case "afplay" /* AFPLAY */:
+      return new AfplayBackend(options);
+    case "aplay" /* APLAY */:
+      return new AplayBackend(options);
+    case "powershell" /* POWERSHELL */:
+      return new PowerShellBackend(options);
+    case "howler" /* HOWLER */:
+      return new HowlerBackend(options);
+    default:
+      throw new Error(`Unknown backend type: ${type}`);
+  }
+}
+
 // src/core/player.ts
-import { EventEmitter } from "events";
-import { spawn } from "child_process";
-import fs from "fs";
-import { createWriteStream } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
 var AudioPlayer = class extends EventEmitter {
   constructor(events) {
     super();
     this.events = events;
+    this.backend = createBackend("auto" /* AUTO */, {
+      events: {
+        onStart: () => {
+          this.events?.onStart?.();
+          this.emit("start");
+        },
+        onEnd: () => {
+          this._playing = false;
+          this.events?.onEnd?.();
+          this.emit("end");
+          this.cleanup();
+        },
+        onError: (error) => {
+          this._playing = false;
+          const ttsError = new TTSError(
+            error.message || "Playback failed",
+            "PLAYER_ERROR" /* PLAYER_ERROR */,
+            "player"
+          );
+          this.events?.onError?.(ttsError);
+          this.emit("error", ttsError);
+        },
+        onPause: () => {
+          this.events?.onPause?.();
+          this.emit("pause");
+        },
+        onResume: () => {
+          this.events?.onResume?.();
+          this.emit("resume");
+        },
+        onStop: () => {
+          this.events?.onStop?.();
+          this.emit("stop");
+        }
+      }
+    });
   }
   events;
   _playing = false;
   _paused = false;
-  currentProcess;
+  backend;
   currentFile;
   /**
    * 播放音频
@@ -136,7 +3119,7 @@ var AudioPlayer = class extends EventEmitter {
     this._playing = true;
     this._paused = false;
     try {
-      const tempFile = join(tmpdir(), `ocosay-${Date.now()}.${format}`);
+      const tempFile = join4(tmpdir4(), `ocosay-${Date.now()}.${format}`);
       this.currentFile = tempFile;
       if (Buffer.isBuffer(audioData)) {
         fs.writeFileSync(tempFile, audioData);
@@ -181,88 +3164,29 @@ var AudioPlayer = class extends EventEmitter {
   }
   /**
    * 播放音频文件
-   * 优先使用 afplay (macOS), aplay (Linux), 否则用 PowerShell (Windows)
+   * 使用 AudioBackend 统一后端播放
    */
-  playFile(filePath, format) {
-    const platform = process.platform;
-    return new Promise((resolve, reject) => {
-      let command;
-      let args;
-      if (platform === "darwin") {
-        command = "afplay";
-        args = [filePath];
-      } else if (platform === "linux") {
-        command = "aplay";
-        args = [filePath];
-      } else {
-        command = "powershell";
-        args = ["-c", `(New-Object System.Media.SoundPlayer('${filePath.replace(/\\/g, "\\\\")}')).PlaySync()`];
-      }
-      this.currentProcess = spawn(command, args, {
-        stdio: "ignore",
-        detached: false
-      });
-      this.currentProcess.on("exit", (code, signal) => {
-        if (signal === "SIGTERM" || signal === "SIGINT") {
-          resolve();
-        } else if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`Player exited with code ${code}`));
-        }
-      });
-      this.currentProcess.on("error", (error) => {
-        reject(error);
-      });
+  playFile(filePath, _format) {
+    return new Promise((resolve) => {
+      this.backend.start(filePath);
+      resolve();
     });
   }
-  /**
-   * 暂停播放
-   * 注意: 目前通过 SIGSTOP 实现，真正的 pause 需要支持暂停的音频库
-   */
   pause() {
     if (!this._playing || this._paused) return;
-    if (this.currentProcess) {
-      try {
-        this.currentProcess.kill("SIGSTOP");
-        this._paused = true;
-        this.events?.onPause?.();
-        this.emit("pause");
-      } catch (e) {
-      }
-    }
+    this.backend.pause();
+    this._paused = true;
   }
-  /**
-   * 恢复播放
-   */
   resume() {
     if (!this._playing || !this._paused) return;
-    if (this.currentProcess) {
-      try {
-        this.currentProcess.kill("SIGCONT");
-        this._paused = false;
-        this.events?.onResume?.();
-        this.emit("resume");
-      } catch (e) {
-      }
-    }
+    this.backend.resume();
+    this._paused = false;
   }
-  /**
-   * 停止播放
-   */
   async stop() {
     this._playing = false;
     this._paused = false;
-    if (this.currentProcess) {
-      try {
-        this.currentProcess.kill("SIGTERM");
-      } catch (e) {
-      }
-      this.currentProcess = void 0;
-    }
+    this.backend.stop();
     this.cleanup();
-    this.events?.onStop?.();
-    this.emit("stop");
   }
   /**
    * 是否正在播放
@@ -523,6 +3447,20 @@ async function listVoices(providerName) {
 }
 
 // src/tools/tts.ts
+function extractTextArg(args) {
+  if (!args || typeof args !== "object") {
+    return void 0;
+  }
+  const argObj = args;
+  const text = argObj.text;
+  if (typeof text === "string" && text.trim().length > 0) {
+    return text;
+  }
+  if (text !== void 0) {
+    console.warn("[tts] text arg is not a valid string, type:", typeof text, "value:", String(text).substring(0, 100));
+  }
+  return void 0;
+}
 async function handleToolCall(toolName, args) {
   try {
     switch (toolName) {
@@ -545,21 +3483,24 @@ async function handleToolCall(toolName, args) {
       case "tts_resume":
         resume();
         return { success: true, message: "Resumed" };
-      case "tts_list_voices":
+      case "tts_list_voices": {
         const voices = await listVoices(args?.provider);
         return { success: true, voices };
-      case "tts_list_providers":
+      }
+      case "tts_list_providers": {
         const speaker2 = getDefaultSpeaker();
         const providers2 = speaker2.getProviders();
         return { success: true, providers: providers2 };
-      case "tts_status":
+      }
+      case "tts_status": {
         const s = getDefaultSpeaker();
         return {
           success: true,
           isPlaying: s.isPlaying(),
           isPaused: s.isPausedState()
         };
-      case "tts_stream_speak":
+      }
+      case "tts_stream_speak": {
         if (!isAutoReadEnabled()) {
           throw new TTSError(
             "Stream mode is not enabled. autoRead must be enabled in configuration to use tts_stream_speak.",
@@ -578,11 +3519,10 @@ async function handleToolCall(toolName, args) {
         const synthesizer = getStreamingSynthesizer();
         if (streamReader2 && synthesizer) {
           streamReader2.start();
-          if (args?.text !== void 0 && typeof args.text === "string") {
-            console.log("[tts_stream_speak] synthesizing text:", args.text.substring(0, 50) + "...");
-            synthesizer.synthesize(args.text);
-          } else if (args?.text !== void 0) {
-            console.log("[tts_stream_speak] args.text is not a string, type:", typeof args.text, "value:", args.text);
+          const textArg = extractTextArg(args);
+          if (textArg && typeof textArg === "string" && textArg.trim().length > 0) {
+            console.log("[tts_stream_speak] synthesizing text:", textArg.substring(0, 50) + "...");
+            synthesizer.synthesize(textArg);
           }
           return { success: true, message: "Stream speak started" };
         }
@@ -591,7 +3531,8 @@ async function handleToolCall(toolName, args) {
           "UNKNOWN" /* UNKNOWN */,
           "tts_stream"
         );
-      case "tts_stream_stop":
+      }
+      case "tts_stream_stop": {
         if (!isStreamEnabled()) {
           throw new TTSError(
             "Stream mode is not enabled. Please enable autoRead in configuration.",
@@ -609,6 +3550,7 @@ async function handleToolCall(toolName, args) {
           "UNKNOWN" /* UNKNOWN */,
           "tts_stream"
         );
+      }
       case "tts_stream_status":
         if (!isStreamEnabled()) {
           return {
@@ -1310,15 +4252,8 @@ var StreamingSynthesizer = class extends EventEmitter4 {
 
 // src/core/stream-player.ts
 import { EventEmitter as EventEmitter5 } from "events";
-import { spawn as spawn2 } from "child_process";
-import fs2 from "fs";
-import { createWriteStream as createWriteStream2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join2 } from "path";
 var StreamPlayer = class extends EventEmitter5 {
-  tempFile = "";
-  writeStream;
-  playerProcess;
+  backend = null;
   _bytesWritten = 0;
   _started = false;
   _paused = false;
@@ -1329,69 +4264,62 @@ var StreamPlayer = class extends EventEmitter5 {
     super();
     this.format = options.format || "mp3";
     this.events = options.events;
+    const backendType = options.backendType || "naudiodon" /* NAUDIODON */;
+    this.backend = createBackend(backendType, {
+      format: this.format,
+      events: {
+        onStart: () => {
+          this.events?.onStart?.();
+          this.emit("start");
+        },
+        onEnd: () => {
+          this.events?.onEnd?.();
+          this.emit("end");
+        },
+        onError: (error) => {
+          this.handleError(error);
+        },
+        onPause: () => {
+          this._paused = true;
+          this.events?.onPause?.();
+          this.emit("pause");
+        },
+        onResume: () => {
+          this._paused = false;
+          this.events?.onResume?.();
+          this.emit("resume");
+        },
+        onStop: () => {
+          this.events?.onStop?.();
+          this.emit("stop");
+        },
+        onProgress: (bytes) => {
+          this.events?.onProgress?.(bytes);
+          this.emit("progress", bytes);
+        }
+      }
+    });
   }
   /**
    * 开始播放
-   * 创建临时文件，创建写入流，启动播放器进程
+   * 初始化后端，准备接收音频数据
    */
   start() {
     if (this._started) {
       return;
     }
-    this.tempFile = join2(tmpdir2(), `ocosay-stream-${Date.now()}.${this.format}`);
-    this.writeStream = createWriteStream2(this.tempFile, { highWaterMark: 64 * 1024 });
-    this.writeStream.on("error", (error) => {
-      this.handleError(error);
-    });
-    this.writeStream.on("finish", () => {
-    });
-    this.startPlayer();
-    this._started = true;
-    this._stopped = false;
-    this.events?.onStart?.();
-    this.emit("start");
-  }
-  /**
-   * 启动播放器进程
-   */
-  startPlayer() {
-    const platform = process.platform;
-    let command;
-    let args;
-    if (platform === "darwin") {
-      command = "afplay";
-      args = [this.tempFile];
-    } else if (platform === "linux") {
-      command = "aplay";
-      args = [this.tempFile];
-    } else {
-      this.handleError(new Error("Windows platform is not supported for stream playback. PlaySync() blocks the Node.js event loop."));
+    if (!this.backend) {
+      this.handleError(new Error("Audio backend not initialized"));
       return;
     }
-    this.playerProcess = spawn2(command, args, {
-      stdio: "ignore",
-      detached: false
-    });
-    this.playerProcess.on("exit", (code, signal) => {
-      if (this._stopped) {
-        return;
-      }
-      if (signal === "SIGTERM" || signal === "SIGINT") {
-        return;
-      }
-      if (code === 0 || code === null) {
-        this.events?.onEnd?.();
-        this.emit("end");
-      } else {
-        this.handleError(new Error(`Player exited with code ${code}`));
-      }
-    });
-    this.playerProcess.on("error", (error) => {
-      this.handleError(error);
-    });
+    this.backend.start("");
+    this._started = true;
+    this._stopped = false;
+    this._paused = false;
+    this._bytesWritten = 0;
   }
   /**
-   * 写入音频数据块（边收边写）
+   * 写入音频数据块（边收边播）
    * 如果尚未 start()，会自动调用
    */
   write(chunk) {
@@ -1401,12 +4329,8 @@ var StreamPlayer = class extends EventEmitter5 {
     if (!this._started) {
       this.start();
     }
-    if (this.writeStream) {
-      const canContinue = this.writeStream.write(chunk);
-      if (!canContinue) {
-        this.writeStream.once("drain", () => {
-        });
-      }
+    if (this.backend) {
+      this.backend.write(chunk);
       this._bytesWritten += chunk.length;
       this.events?.onProgress?.(this._bytesWritten);
       this.emit("progress", this._bytesWritten);
@@ -1414,56 +4338,37 @@ var StreamPlayer = class extends EventEmitter5 {
   }
   /**
    * 结束写入
-   * 关闭写入流，但不杀播放器进程，让它播完
+   * 通知后端写入完成，但保持播放直到结束
    */
   end() {
-    if (this.writeStream) {
-      this.writeStream.end();
-      this.writeStream = void 0;
+    if (this.backend) {
+      this.backend.end();
     }
   }
   /**
    * 停止播放
-   * 杀死播放器进程，删除临时文件
+   * 立即停止播放并释放资源
    */
   stop() {
     this._stopped = true;
     this._started = false;
     this._paused = false;
-    if (this.playerProcess) {
-      try {
-        this.playerProcess.kill("SIGTERM");
-      } catch (e) {
-      }
-      this.playerProcess = void 0;
-    }
-    if (this.writeStream) {
-      try {
-        this.writeStream.destroy();
-      } catch (e) {
-      }
-      this.writeStream = void 0;
+    if (this.backend) {
+      this.backend.stop();
     }
-    this.deleteTempFile();
+    this._bytesWritten = 0;
     this.events?.onStop?.();
     this.emit("stop");
   }
   /**
    * 暂停播放
-   * 使用 SIGSTOP 暂停播放器进程
    */
   pause() {
     if (!this._started || this._paused || this._stopped) {
       return;
     }
-    if (this.playerProcess) {
-      try {
-        this.playerProcess.kill("SIGSTOP");
-        this._paused = true;
-        this.events?.onPause?.();
-        this.emit("pause");
-      } catch (e) {
-      }
+    if (this.backend) {
+      this.backend.pause();
     }
   }
   /**
@@ -1473,14 +4378,8 @@ var StreamPlayer = class extends EventEmitter5 {
     if (!this._paused || this._stopped) {
       return;
     }
-    if (this.playerProcess) {
-      try {
-        this.playerProcess.kill("SIGCONT");
-        this._paused = false;
-        this.events?.onResume?.();
-        this.emit("resume");
-      } catch (e) {
-      }
+    if (this.backend) {
+      this.backend.resume();
     }
   }
   /**
@@ -1507,12 +4406,6 @@ var StreamPlayer = class extends EventEmitter5 {
   getBytesWritten() {
     return this._bytesWritten;
   }
-  /**
-   * 获取临时文件路径
-   */
-  getTempFile() {
-    return this.tempFile;
-  }
   /**
    * 处理错误
    */
@@ -1520,20 +4413,6 @@ var StreamPlayer = class extends EventEmitter5 {
     this.events?.onError?.(error);
     this.emit("error", error);
   }
-  /**
-   * 删除临时文件
-   */
-  deleteTempFile() {
-    if (this.tempFile) {
-      try {
-        if (fs2.existsSync(this.tempFile)) {
-          fs2.unlinkSync(this.tempFile);
-        }
-      } catch (e) {
-      }
-      this.tempFile = "";
-    }
-  }
 };
 
 // src/index.ts
@@ -1671,7 +4550,7 @@ function getStreamPlayer() {
 }
 
 // src/config.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 import * as os from "os";
 var DEFAULT_CONFIG = {
@@ -1768,21 +4647,21 @@ function resolveEnvValue(value) {
 }
 function loadOrCreateConfig() {
   const configDir = path.dirname(CONFIG_PATH);
-  if (!fs3.existsSync(configDir)) {
+  if (!fs2.existsSync(configDir)) {
     try {
-      fs3.mkdirSync(configDir, { recursive: true });
+      fs2.mkdirSync(configDir, { recursive: true });
     } catch (err) {
       throw new Error(`[ocosay] \u65E0\u6CD5\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55 ${configDir}: ${err}`);
     }
   }
-  if (!fs3.existsSync(CONFIG_PATH)) {
+  if (!fs2.existsSync(CONFIG_PATH)) {
     console.info("[ocosay] \u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u6B63\u5728\u521B\u5EFA\u9ED8\u8BA4\u914D\u7F6E...");
     const defaultConfig = generateDefaultConfig();
     const configContent = JSON.stringify(defaultConfig, null, 2);
     try {
-      fs3.writeFileSync(CONFIG_PATH, configContent, "utf-8");
+      fs2.writeFileSync(CONFIG_PATH, configContent, "utf-8");
       try {
-        fs3.chmodSync(CONFIG_PATH, 384);
+        fs2.chmodSync(CONFIG_PATH, 384);
       } catch (err) {
         console.warn(`[ocosay] \u65E0\u6CD5\u8BBE\u7F6E\u914D\u7F6E\u6587\u4EF6\u6743\u9650: ${err}`);
       }
@@ -1794,7 +4673,7 @@ function loadOrCreateConfig() {
     return defaultConfig;
   }
   try {
-    const content = fs3.readFileSync(CONFIG_PATH, "utf-8");
+    const content = fs2.readFileSync(CONFIG_PATH, "utf-8");
     const stripped = stripComments(content);
     const loaded = JSON.parse(stripped);
     const merged = mergeWithDefaults(loaded, DEFAULT_CONFIG);
@@ -1819,11 +4698,14 @@ function loadOrCreateConfig() {
 
 // src/plugin.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join6 } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
 var pluginName = "ocosay";
 var pluginVersion = "0.0.0";
 try {
-  const pkg = JSON.parse(readFileSync2(join4(process.cwd(), "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync2(join6(__dirname, "package.json"), "utf-8"));
   pluginVersion = pkg.version || "0.0.0";
 } catch {
 }
@@ -1974,11 +4856,11 @@ var OcosayPlugin = async (input, _options) => {
   if (opencodeShowToast) {
     global.__opencode_tui_showToast__ = opencodeShowToast;
   }
-  setTimeout(() => {
+  setTimeout(async () => {
     if (!opencodeShowToast) return;
     if (initError) {
       console.info(`[Ocosay] Ocosay v${pluginVersion} Initialization Failed: Initialization failed, please check config`);
-      opencodeShowToast({
+      await opencodeShowToast({
         body: {
           title: `Ocosay v${pluginVersion} Initialization Failed`,
           message: "Initialization failed, please check config",
@@ -1987,7 +4869,7 @@ var OcosayPlugin = async (input, _options) => {
       });
     } else {
       console.info(`[Ocosay] Ocosay v${pluginVersion} Plugin Loaded: Auto-read: ${config.autoRead ? "ON" : "OFF"}`);
-      opencodeShowToast({
+      await opencodeShowToast({
         body: {
           title: `Ocosay v${pluginVersion} Plugin Loaded`,
           message: `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
@@ -2045,7 +4927,7 @@ var OcosayPlugin = async (input, _options) => {
       if (input.client?.tui?.showToast) {
         global.__opencode_tui_showToast__ = input.client.tui.showToast;
       }
-      setTimeout(() => {
+      setTimeout(async () => {
         const showToastFn = input.client?.tui?.showToast;
         if (!showToastFn) {
           console.warn("[Ocosay] showToast not available");
@@ -2053,7 +4935,7 @@ var OcosayPlugin = async (input, _options) => {
         }
         if (initError) {
           console.info(`[Ocosay] Ocosay v${pluginVersion} Initialization Failed: Initialization failed, please check config`);
-          showToastFn({
+          await showToastFn({
             body: {
               title: `Ocosay v${pluginVersion} Initialization Failed`,
               message: "Initialization failed, please check config",
@@ -2062,7 +4944,7 @@ var OcosayPlugin = async (input, _options) => {
           });
         } else {
           console.info(`[Ocosay] Ocosay v${pluginVersion} Plugin Loaded: Auto-read: ${config.autoRead ? "ON" : "OFF"}`);
-          showToastFn({
+          await showToastFn({
             body: {
               title: `Ocosay v${pluginVersion} Plugin Loaded`,
               message: `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
@@ -2083,4 +4965,28 @@ export {
   plugin_default as default,
   server
 };
+/*! Bundled license information:
+
+howler/dist/howler.js:
+  (*!
+   *  howler.js v2.2.4
+   *  howlerjs.com
+   *
+   *  (c) 2013-2020, James Simpson of GoldFire Studios
+   *  goldfirestudios.com
+   *
+   *  MIT License
+   *)
+  (*!
+   *  Spatial Plugin - Adds support for stereo and 3D audio where Web Audio is supported.
+   *  
+   *  howler.js v2.2.4
+   *  howlerjs.com
+   *
+   *  (c) 2013-2020, James Simpson of GoldFire Studios
+   *  goldfirestudios.com
+   *
+   *  MIT License
+   *)
+*/
 //# sourceMappingURL=plugin.js.map