@eva/plugin-sound 2.0.0-beta.3 → 2.0.0-beta.6

package/dist/EVA.plugin.sound.js

@@ -1,7 +1,12 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 window.EVA = window.EVA || {};
 window.EVA.plugin = window.EVA.plugin || {};
-var _EVA_IIFE_sound = function (exports, eva_js) {
+var _EVA_IIFE_sound = function (exports, eva_js, pixi_js) {
   'use strict';
   function __decorate(decorators, target, key, desc) {
     var c = arguments.length,
@@ -37,69 +42,1618 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
   }
-  let SoundSystem = class SoundSystem extends eva_js.System {
-    constructor(obj) {
+  let instance;
+  function setInstance(sound) {
+    instance = sound;
+    return sound;
+  }
+  function getInstance() {
+    return instance;
+  }
+  class WebAudioUtils {
+    static setParamValue(param, value) {
+      if (param.setValueAtTime) {
+        const context = getInstance().context;
+        param.setValueAtTime(value, context.audioContext.currentTime);
+      } else {
+        param.value = value;
+      }
+      return value;
+    }
+  }
+  class HTMLAudioContext extends pixi_js.EventEmitter {
+    constructor() {
+      super(...arguments);
+      this.speed = 1;
+      this.muted = false;
+      this.volume = 1;
+      this.paused = false;
+    }
+    refresh() {
+      this.emit("refresh");
+    }
+    refreshPaused() {
+      this.emit("refreshPaused");
+    }
+    get filters() {
+      console.warn("HTML Audio does not support filters");
+      return null;
+    }
+    set filters(_filters) {
+      console.warn("HTML Audio does not support filters");
+    }
+    get audioContext() {
+      console.warn("HTML Audio does not support audioContext");
+      return null;
+    }
+    toggleMute() {
+      this.muted = !this.muted;
+      this.refresh();
+      return this.muted;
+    }
+    togglePause() {
+      this.paused = !this.paused;
+      this.refreshPaused();
+      return this.paused;
+    }
+    destroy() {
+      this.removeAllListeners();
+    }
+  }
+  let id$1 = 0;
+  const _HTMLAudioInstance = class extends pixi_js.EventEmitter {
+    constructor(parent) {
       super();
-      this.autoPauseAndStart = true;
-      this.components = [];
-      this.pausedComponents = [];
-      this.audioBufferCache = {};
-      this.decodeAudioPromiseMap = {};
-      _extends(this, obj);
+      this.id = id$1++;
+      this.init(parent);
+    }
+    set(name, value) {
+      if (this[name] === void 0) {
+        throw new Error(`Property with name ${name} does not exist.`);
+      } else {
+        switch (name) {
+          case "speed":
+            this.speed = value;
+            break;
+          case "volume":
+            this.volume = value;
+            break;
+          case "paused":
+            this.paused = value;
+            break;
+          case "loop":
+            this.loop = value;
+            break;
+          case "muted":
+            this.muted = value;
+            break;
+        }
+      }
+      return this;
+    }
+    get progress() {
+      const {
+        currentTime
+      } = this._source;
+      return currentTime / this._duration;
+    }
+    get paused() {
+      return this._paused;
+    }
+    set paused(paused) {
+      this._paused = paused;
+      this.refreshPaused();
+    }
+    _onPlay() {
+      this._playing = true;
+    }
+    _onPause() {
+      this._playing = false;
+    }
+    init(media) {
+      this._playing = false;
+      this._duration = media.source.duration;
+      const source = this._source = media.source.cloneNode(false);
+      source.src = media.parent.url;
+      source.onplay = this._onPlay.bind(this);
+      source.onpause = this._onPause.bind(this);
+      media.context.on("refresh", this.refresh, this);
+      media.context.on("refreshPaused", this.refreshPaused, this);
+      this._media = media;
+    }
+    _internalStop() {
+      if (this._source && this._playing) {
+        this._source.onended = null;
+        this._source.pause();
+      }
+    }
+    stop() {
+      this._internalStop();
+      if (this._source) {
+        this.emit("stop");
+      }
+    }
+    get speed() {
+      return this._speed;
+    }
+    set speed(speed) {
+      this._speed = speed;
+      this.refresh();
+    }
+    get volume() {
+      return this._volume;
+    }
+    set volume(volume) {
+      this._volume = volume;
+      this.refresh();
+    }
+    get loop() {
+      return this._loop;
+    }
+    set loop(loop) {
+      this._loop = loop;
+      this.refresh();
     }
     get muted() {
-      return this.gainNode ? this.gainNode.gain.value === 0 : false;
+      return this._muted;
     }
-    set muted(v) {
-      if (!this.gainNode) {
+    set muted(muted) {
+      this._muted = muted;
+      this.refresh();
+    }
+    get filters() {
+      console.warn("HTML Audio does not support filters");
+      return null;
+    }
+    set filters(_filters) {
+      console.warn("HTML Audio does not support filters");
+    }
+    refresh() {
+      const global = this._media.context;
+      const sound = this._media.parent;
+      this._source.loop = this._loop || sound.loop;
+      const globalVolume = global.volume * (global.muted ? 0 : 1);
+      const soundVolume = sound.volume * (sound.muted ? 0 : 1);
+      const instanceVolume = this._volume * (this._muted ? 0 : 1);
+      this._source.volume = instanceVolume * globalVolume * soundVolume;
+      this._source.playbackRate = this._speed * global.speed * sound.speed;
+    }
+    refreshPaused() {
+      const global = this._media.context;
+      const sound = this._media.parent;
+      const pausedReal = this._paused || sound.paused || global.paused;
+      if (pausedReal !== this._pausedReal) {
+        this._pausedReal = pausedReal;
+        if (pausedReal) {
+          this._internalStop();
+          this.emit("paused");
+        } else {
+          this.emit("resumed");
+          this.play({
+            start: this._source.currentTime,
+            end: this._end,
+            volume: this._volume,
+            speed: this._speed,
+            loop: this._loop
+          });
+        }
+        this.emit("pause", pausedReal);
+      }
+    }
+    play(options) {
+      const {
+        start,
+        end,
+        speed,
+        loop,
+        volume,
+        muted
+      } = options;
+      if (end) {
+        console.assert(end > start, "End time is before start time");
+      }
+      this._speed = speed;
+      this._volume = volume;
+      this._loop = !!loop;
+      this._muted = muted;
+      this.refresh();
+      if (this.loop && end !== null) {
+        console.warn('Looping not support when specifying an "end" time');
+        this.loop = false;
+      }
+      this._start = start;
+      this._end = end || this._duration;
+      this._start = Math.max(0, this._start - _HTMLAudioInstance.PADDING);
+      this._end = Math.min(this._end + _HTMLAudioInstance.PADDING, this._duration);
+      this._source.onloadedmetadata = () => {
+        if (this._source) {
+          this._source.currentTime = start;
+          this._source.onloadedmetadata = null;
+          this.emit("progress", start / this._duration, this._duration);
+          pixi_js.Ticker.shared.add(this._onUpdate, this);
+        }
+      };
+      this._source.onended = this._onComplete.bind(this);
+      this._source.play();
+      this.emit("start");
+    }
+    _onUpdate() {
+      this.emit("progress", this.progress, this._duration);
+      if (this._source.currentTime >= this._end && !this._source.loop) {
+        this._onComplete();
+      }
+    }
+    _onComplete() {
+      pixi_js.Ticker.shared.remove(this._onUpdate, this);
+      this._internalStop();
+      this.emit("progress", 1, this._duration);
+      this.emit("end", this);
+    }
+    destroy() {
+      pixi_js.Ticker.shared.remove(this._onUpdate, this);
+      this.removeAllListeners();
+      const source = this._source;
+      if (source) {
+        source.onended = null;
+        source.onplay = null;
+        source.onpause = null;
+        this._internalStop();
+      }
+      this._source = null;
+      this._speed = 1;
+      this._volume = 1;
+      this._loop = false;
+      this._end = null;
+      this._start = 0;
+      this._duration = 0;
+      this._playing = false;
+      this._pausedReal = false;
+      this._paused = false;
+      this._muted = false;
+      if (this._media) {
+        this._media.context.off("refresh", this.refresh, this);
+        this._media.context.off("refreshPaused", this.refreshPaused, this);
+        this._media = null;
+      }
+    }
+    toString() {
+      return `[HTMLAudioInstance id=${this.id}]`;
+    }
+  };
+  let HTMLAudioInstance = _HTMLAudioInstance;
+  HTMLAudioInstance.PADDING = 0.1;
+  class HTMLAudioMedia extends pixi_js.EventEmitter {
+    init(parent) {
+      this.parent = parent;
+      this._source = parent.options.source || new Audio();
+      if (parent.url) {
+        this._source.src = parent.url;
+      }
+    }
+    create() {
+      return new HTMLAudioInstance(this);
+    }
+    get isPlayable() {
+      return !!this._source && this._source.readyState === 4;
+    }
+    get duration() {
+      return this._source.duration;
+    }
+    get context() {
+      return this.parent.context;
+    }
+    get filters() {
+      return null;
+    }
+    set filters(_filters) {
+      console.warn("HTML Audio does not support filters");
+    }
+    destroy() {
+      this.removeAllListeners();
+      this.parent = null;
+      if (this._source) {
+        this._source.src = "";
+        this._source.load();
+        this._source = null;
+      }
+    }
+    get source() {
+      return this._source;
+    }
+    load(callback) {
+      const source = this._source;
+      const sound = this.parent;
+      if (source.readyState === 4) {
+        sound.isLoaded = true;
+        const instance = sound.autoPlayStart();
+        if (callback) {
+          setTimeout(() => {
+            callback(null, sound, instance);
+          }, 0);
+        }
         return;
       }
-      this.gainNode.gain.setValueAtTime(v ? 0 : 1, 0);
+      if (!sound.url) {
+        callback(new Error("sound.url or sound.source must be set"));
+        return;
+      }
+      source.src = sound.url;
+      const onLoad = () => {
+        removeListeners();
+        sound.isLoaded = true;
+        const instance = sound.autoPlayStart();
+        if (callback) {
+          callback(null, sound, instance);
+        }
+      };
+      const onAbort = () => {
+        removeListeners();
+        if (callback) {
+          callback(new Error("Sound loading has been aborted"));
+        }
+      };
+      const onError = () => {
+        removeListeners();
+        const message = `Failed to load audio element (code: ${source.error.code})`;
+        if (callback) {
+          callback(new Error(message));
+        } else {
+          console.error(message);
+        }
+      };
+      const removeListeners = () => {
+        source.removeEventListener("canplaythrough", onLoad);
+        source.removeEventListener("load", onLoad);
+        source.removeEventListener("abort", onAbort);
+        source.removeEventListener("error", onError);
+      };
+      source.addEventListener("canplaythrough", onLoad, false);
+      source.addEventListener("load", onLoad, false);
+      source.addEventListener("abort", onAbort, false);
+      source.addEventListener("error", onError, false);
+      source.load();
+    }
+  }
+  class SoundSprite {
+    constructor(parent, options) {
+      this.parent = parent;
+      _extends(this, options);
+      this.duration = this.end - this.start;
+      console.assert(this.duration > 0, "End time must be after start time");
+    }
+    play(complete) {
+      return this.parent.play({
+        complete,
+        speed: this.speed || this.parent.speed,
+        end: this.end,
+        start: this.start,
+        loop: this.loop
+      });
+    }
+    destroy() {
+      this.parent = null;
+    }
+  }
+  const extensions = ["ogg", "oga", "opus", "m4a", "mp3", "mpeg", "wav", "aiff", "wma", "mid", "caf"];
+  const mimes = ["audio/mpeg", "audio/ogg"];
+  const supported = {};
+  function validateFormats(typeOverrides) {
+    const overrides = _objectSpread({
+      m4a: "audio/mp4",
+      oga: "audio/ogg",
+      opus: 'audio/ogg; codecs="opus"',
+      caf: 'audio/x-caf; codecs="opus"'
+    }, typeOverrides || {});
+    const audio = document.createElement("audio");
+    const formats = {};
+    const no = /^no$/;
+    extensions.forEach(ext => {
+      const canByExt = audio.canPlayType(`audio/${ext}`).replace(no, "");
+      const canByType = overrides[ext] ? audio.canPlayType(overrides[ext]).replace(no, "") : "";
+      formats[ext] = !!canByExt || !!canByType;
+    });
+    _extends(supported, formats);
+  }
+  validateFormats();
+  let id = 0;
+  class WebAudioInstance extends pixi_js.EventEmitter {
+    constructor(media) {
+      super();
+      this.id = id++;
+      this._media = null;
+      this._paused = false;
+      this._muted = false;
+      this._elapsed = 0;
+      this.init(media);
+    }
+    set(name, value) {
+      if (this[name] === void 0) {
+        throw new Error(`Property with name ${name} does not exist.`);
+      } else {
+        switch (name) {
+          case "speed":
+            this.speed = value;
+            break;
+          case "volume":
+            this.volume = value;
+            break;
+          case "muted":
+            this.muted = value;
+            break;
+          case "loop":
+            this.loop = value;
+            break;
+          case "paused":
+            this.paused = value;
+            break;
+        }
+      }
+      return this;
+    }
+    stop() {
+      if (this._source) {
+        this._internalStop();
+        this.emit("stop");
+      }
+    }
+    get speed() {
+      return this._speed;
+    }
+    set speed(speed) {
+      this._speed = speed;
+      this.refresh();
+      this._update(true);
     }
     get volume() {
-      return this.gainNode ? this.gainNode.gain.value : 1;
+      return this._volume;
     }
-    set volume(v) {
-      if (!this.gainNode || typeof v !== 'number' || v < 0 || v > 1) {
+    set volume(volume) {
+      this._volume = volume;
+      this.refresh();
+    }
+    get muted() {
+      return this._muted;
+    }
+    set muted(muted) {
+      this._muted = muted;
+      this.refresh();
+    }
+    get loop() {
+      return this._loop;
+    }
+    set loop(loop) {
+      this._loop = loop;
+      this.refresh();
+    }
+    get filters() {
+      return this._filters;
+    }
+    set filters(filters) {
+      if (this._filters) {
+        var _this$_filters;
+        (_this$_filters = this._filters) === null || _this$_filters === void 0 ? void 0 : _this$_filters.filter(filter => filter).forEach(filter => filter.disconnect());
+        this._filters = null;
+        this._source.connect(this._gain);
+      }
+      this._filters = filters !== null && filters !== void 0 && filters.length ? filters.slice(0) : null;
+      this.refresh();
+    }
+    refresh() {
+      if (!this._source) {
         return;
       }
-      this.gainNode.gain.setValueAtTime(v, 0);
+      const global = this._media.context;
+      const sound = this._media.parent;
+      this._source.loop = this._loop || sound.loop;
+      const globalVolume = global.volume * (global.muted ? 0 : 1);
+      const soundVolume = sound.volume * (sound.muted ? 0 : 1);
+      const instanceVolume = this._volume * (this._muted ? 0 : 1);
+      WebAudioUtils.setParamValue(this._gain.gain, instanceVolume * soundVolume * globalVolume);
+      WebAudioUtils.setParamValue(this._source.playbackRate, this._speed * sound.speed * global.speed);
+      this.applyFilters();
+    }
+    applyFilters() {
+      var _this$_filters2;
+      if ((_this$_filters2 = this._filters) !== null && _this$_filters2 !== void 0 && _this$_filters2.length) {
+        this._source.disconnect();
+        let source = this._source;
+        this._filters.forEach(filter => {
+          source.connect(filter.destination);
+          source = filter;
+        });
+        source.connect(this._gain);
+      }
     }
-    get audioLocked() {
-      if (!this.ctx) {
-        return true;
+    refreshPaused() {
+      const global = this._media.context;
+      const sound = this._media.parent;
+      const pausedReal = this._paused || sound.paused || global.paused;
+      if (pausedReal !== this._pausedReal) {
+        this._pausedReal = pausedReal;
+        if (pausedReal) {
+          this._internalStop();
+          this.emit("paused");
+        } else {
+          this.emit("resumed");
+          this.play({
+            start: this._elapsed % this._duration,
+            end: this._end,
+            speed: this._speed,
+            loop: this._loop,
+            volume: this._volume
+          });
+        }
+        this.emit("pause", pausedReal);
       }
-      return this.ctx.state !== 'running';
     }
-    resumeAll() {
-      const handleResume = () => {
-        this.pausedComponents.forEach(component => {
-          component.play();
+    play(options) {
+      const {
+        start,
+        end,
+        speed,
+        loop,
+        volume,
+        muted,
+        filters
+      } = options;
+      if (end) {
+        console.assert(end > start, "End time is before start time");
+      }
+      this._paused = false;
+      const {
+        source,
+        gain
+      } = this._media.nodes.cloneBufferSource();
+      this._source = source;
+      this._gain = gain;
+      this._speed = speed;
+      this._volume = volume;
+      this._loop = !!loop;
+      this._muted = muted;
+      this._filters = filters;
+      this.refresh();
+      const duration = this._source.buffer.duration;
+      this._duration = duration;
+      this._end = end;
+      this._lastUpdate = this._now();
+      this._elapsed = start;
+      this._source.onended = this._onComplete.bind(this);
+      if (this._loop) {
+        this._source.loopEnd = end;
+        this._source.loopStart = start;
+        this._source.start(0, start);
+      } else if (end) {
+        this._source.start(0, start, end - start);
+      } else {
+        this._source.start(0, start);
+      }
+      this.emit("start");
+      this._update(true);
+      this.enableTicker(true);
+    }
+    enableTicker(enabled) {
+      pixi_js.Ticker.shared.remove(this._updateListener, this);
+      if (enabled) {
+        pixi_js.Ticker.shared.add(this._updateListener, this);
+      }
+    }
+    get progress() {
+      return this._progress;
+    }
+    get paused() {
+      return this._paused;
+    }
+    set paused(paused) {
+      this._paused = paused;
+      this.refreshPaused();
+    }
+    destroy() {
+      var _this$_filters3;
+      this.removeAllListeners();
+      this._internalStop();
+      if (this._gain) {
+        this._gain.disconnect();
+        this._gain = null;
+      }
+      if (this._media) {
+        this._media.context.events.off("refresh", this.refresh, this);
+        this._media.context.events.off("refreshPaused", this.refreshPaused, this);
+        this._media = null;
+      }
+      (_this$_filters3 = this._filters) === null || _this$_filters3 === void 0 ? void 0 : _this$_filters3.forEach(filter => filter.disconnect());
+      this._filters = null;
+      this._end = null;
+      this._speed = 1;
+      this._volume = 1;
+      this._loop = false;
+      this._elapsed = 0;
+      this._duration = 0;
+      this._paused = false;
+      this._muted = false;
+      this._pausedReal = false;
+    }
+    toString() {
+      return `[WebAudioInstance id=${this.id}]`;
+    }
+    _now() {
+      return this._media.context.audioContext.currentTime;
+    }
+    _updateListener() {
+      this._update();
+    }
+    _update(force = false) {
+      if (this._source) {
+        const now = this._now();
+        const delta = now - this._lastUpdate;
+        if (delta > 0 || force) {
+          const speed = this._source.playbackRate.value;
+          this._elapsed += delta * speed;
+          this._lastUpdate = now;
+          const duration = this._duration;
+          let progress;
+          if (this._source.loopStart) {
+            const soundLength = this._source.loopEnd - this._source.loopStart;
+            progress = (this._source.loopStart + this._elapsed % soundLength) / duration;
+          } else {
+            progress = this._elapsed % duration / duration;
+          }
+          this._progress = progress;
+          this.emit("progress", this._progress, duration);
+        }
+      }
+    }
+    init(media) {
+      this._media = media;
+      media.context.events.on("refresh", this.refresh, this);
+      media.context.events.on("refreshPaused", this.refreshPaused, this);
+    }
+    _internalStop() {
+      if (this._source) {
+        this.enableTicker(false);
+        this._source.onended = null;
+        this._source.stop(0);
+        this._source.disconnect();
+        try {
+          this._source.buffer = null;
+        } catch (err) {
+          console.warn("Failed to set AudioBufferSourceNode.buffer to null:", err);
+        }
+        this._source = null;
+      }
+    }
+    _onComplete() {
+      if (this._source) {
+        this.enableTicker(false);
+        this._source.onended = null;
+        this._source.disconnect();
+        try {
+          this._source.buffer = null;
+        } catch (err) {
+          console.warn("Failed to set AudioBufferSourceNode.buffer to null:", err);
+        }
+      }
+      this._source = null;
+      this._progress = 1;
+      this.emit("progress", 1, this._duration);
+      this.emit("end", this);
+    }
+  }
+  class Filterable {
+    constructor(input, output) {
+      this._output = output;
+      this._input = input;
+    }
+    get destination() {
+      return this._input;
+    }
+    get filters() {
+      return this._filters;
+    }
+    set filters(filters) {
+      if (this._filters) {
+        this._filters.forEach(filter => {
+          if (filter) {
+            filter.disconnect();
+          }
+        });
+        this._filters = null;
+        this._input.connect(this._output);
+      }
+      if (filters && filters.length) {
+        this._filters = filters.slice(0);
+        this._input.disconnect();
+        let prevFilter = null;
+        filters.forEach(filter => {
+          if (prevFilter === null) {
+            this._input.connect(filter.destination);
+          } else {
+            prevFilter.connect(filter.destination);
+          }
+          prevFilter = filter;
         });
-        this.pausedComponents = [];
+        prevFilter.connect(this._output);
+      }
+    }
+    destroy() {
+      this.filters = null;
+      this._input = null;
+      this._output = null;
+    }
+  }
+  const _WebAudioNodes = class extends Filterable {
+    constructor(context) {
+      const audioContext = context.audioContext;
+      const bufferSource = audioContext.createBufferSource();
+      const gain = audioContext.createGain();
+      const analyser = audioContext.createAnalyser();
+      bufferSource.connect(analyser);
+      analyser.connect(gain);
+      gain.connect(context.destination);
+      super(analyser, gain);
+      this.context = context;
+      this.bufferSource = bufferSource;
+      this.gain = gain;
+      this.analyser = analyser;
+    }
+    get script() {
+      if (!this._script) {
+        this._script = this.context.audioContext.createScriptProcessor(_WebAudioNodes.BUFFER_SIZE);
+        this._script.connect(this.context.destination);
+      }
+      return this._script;
+    }
+    destroy() {
+      super.destroy();
+      this.bufferSource.disconnect();
+      if (this._script) {
+        this._script.disconnect();
+      }
+      this.gain.disconnect();
+      this.analyser.disconnect();
+      this.bufferSource = null;
+      this._script = null;
+      this.gain = null;
+      this.analyser = null;
+      this.context = null;
+    }
+    cloneBufferSource() {
+      const orig = this.bufferSource;
+      const source = this.context.audioContext.createBufferSource();
+      source.buffer = orig.buffer;
+      WebAudioUtils.setParamValue(source.playbackRate, orig.playbackRate.value);
+      source.loop = orig.loop;
+      const gain = this.context.audioContext.createGain();
+      source.connect(gain);
+      gain.connect(this.destination);
+      return {
+        source,
+        gain
       };
-      this.ctx.resume().then(handleResume, handleResume);
     }
-    pauseAll() {
-      this.components.forEach(component => {
-        if (component.playing) {
-          this.pausedComponents.push(component);
-          component.pause();
+    get bufferSize() {
+      return this.script.bufferSize;
+    }
+  };
+  let WebAudioNodes = _WebAudioNodes;
+  WebAudioNodes.BUFFER_SIZE = 0;
+  class WebAudioMedia {
+    init(parent) {
+      this.parent = parent;
+      this._nodes = new WebAudioNodes(this.context);
+      this._source = this._nodes.bufferSource;
+      this.source = parent.options.source;
+    }
+    destroy() {
+      this.parent = null;
+      this._nodes.destroy();
+      this._nodes = null;
+      try {
+        this._source.buffer = null;
+      } catch (err) {
+        console.warn("Failed to set AudioBufferSourceNode.buffer to null:", err);
+      }
+      this._source = null;
+      this.source = null;
+    }
+    create() {
+      return new WebAudioInstance(this);
+    }
+    get context() {
+      return this.parent.context;
+    }
+    get isPlayable() {
+      return !!this._source && !!this._source.buffer;
+    }
+    get filters() {
+      return this._nodes.filters;
+    }
+    set filters(filters) {
+      this._nodes.filters = filters;
+    }
+    get duration() {
+      console.assert(this.isPlayable, "Sound not yet playable, no duration");
+      return this._source.buffer.duration;
+    }
+    get buffer() {
+      return this._source.buffer;
+    }
+    set buffer(buffer) {
+      this._source.buffer = buffer;
+    }
+    get nodes() {
+      return this._nodes;
+    }
+    load(callback) {
+      if (this.source) {
+        this._decode(this.source, callback);
+      } else if (this.parent.url) {
+        this._loadUrl(callback);
+      } else if (callback) {
+        callback(new Error("sound.url or sound.source must be set"));
+      } else {
+        console.error("sound.url or sound.source must be set");
+      }
+    }
+    async _loadUrl(callback) {
+      const url = this.parent.url;
+      const response = await pixi_js.DOMAdapter.get().fetch(url);
+      this._decode(await response.arrayBuffer(), callback);
+    }
+    _decode(arrayBuffer, callback) {
+      const audioBufferReadyFn = (err, buffer) => {
+        if (err) {
+          if (callback) {
+            callback(err);
+          }
+        } else {
+          this.parent.isLoaded = true;
+          this.buffer = buffer;
+          const instance = this.parent.autoPlayStart();
+          if (callback) {
+            callback(null, this.parent, instance);
+          }
         }
-      });
-      this.ctx.suspend().then();
+      };
+      if (arrayBuffer instanceof AudioBuffer) {
+        audioBufferReadyFn(null, arrayBuffer);
+      } else {
+        const context = this.parent.context;
+        context.decode(arrayBuffer, audioBufferReadyFn);
+      }
     }
-    stopAll() {
-      this.components.forEach(component => {
-        if (component.playing) {
-          component.stop();
+  }
+  const _Sound = class {
+    static from(source) {
+      let options = {};
+      if (typeof source === "string") {
+        options.url = source;
+      } else if (source instanceof ArrayBuffer || source instanceof AudioBuffer || source instanceof HTMLAudioElement) {
+        options.source = source;
+      } else if (Array.isArray(source)) {
+        options.url = source;
+      } else {
+        options = source;
+      }
+      options = _objectSpread({
+        autoPlay: false,
+        singleInstance: false,
+        url: null,
+        source: null,
+        preload: false,
+        volume: 1,
+        speed: 1,
+        complete: null,
+        loaded: null,
+        loop: false
+      }, options);
+      Object.freeze(options);
+      const media = getInstance().useLegacy ? new HTMLAudioMedia() : new WebAudioMedia();
+      return new _Sound(media, options);
+    }
+    constructor(media, options) {
+      this.media = media;
+      this.options = options;
+      this._instances = [];
+      this._sprites = {};
+      this.media.init(this);
+      const complete = options.complete;
+      this._autoPlayOptions = complete ? {
+        complete
+      } : null;
+      this.isLoaded = false;
+      this._preloadQueue = null;
+      this.isPlaying = false;
+      this.autoPlay = options.autoPlay;
+      this.singleInstance = options.singleInstance;
+      this.preload = options.preload || this.autoPlay;
+      this.url = Array.isArray(options.url) ? this.preferUrl(options.url) : options.url;
+      this.speed = options.speed;
+      this.volume = options.volume;
+      this.loop = options.loop;
+      if (options.sprites) {
+        this.addSprites(options.sprites);
+      }
+      if (this.preload) {
+        this._preload(options.loaded);
+      }
+    }
+    preferUrl(urls) {
+      const [file] = urls.map(url => ({
+        url,
+        ext: pixi_js.path.extname(url).slice(1)
+      })).filter(({
+        ext
+      }) => supported[ext]).sort((a, b) => extensions.indexOf(a.ext) - extensions.indexOf(b.ext));
+      if (!file) {
+        throw new Error("No supported file type found");
+      }
+      return file.url;
+    }
+    get context() {
+      return getInstance().context;
+    }
+    pause() {
+      this.isPlaying = false;
+      this.paused = true;
+      return this;
+    }
+    resume() {
+      this.isPlaying = this._instances.length > 0;
+      this.paused = false;
+      return this;
+    }
+    get paused() {
+      return this._paused;
+    }
+    set paused(paused) {
+      this._paused = paused;
+      this.refreshPaused();
+    }
+    get speed() {
+      return this._speed;
+    }
+    set speed(speed) {
+      this._speed = speed;
+      this.refresh();
+    }
+    get filters() {
+      return this.media.filters;
+    }
+    set filters(filters) {
+      this.media.filters = filters;
+    }
+    addSprites(source, data) {
+      if (typeof source === "object") {
+        const results = {};
+        for (const alias in source) {
+          results[alias] = this.addSprites(alias, source[alias]);
+        }
+        return results;
+      }
+      console.assert(!this._sprites[source], `Alias ${source} is already taken`);
+      const sprite = new SoundSprite(this, data);
+      this._sprites[source] = sprite;
+      return sprite;
+    }
+    destroy() {
+      this._removeInstances();
+      this.removeSprites();
+      this.media.destroy();
+      this.media = null;
+      this._sprites = null;
+      this._instances = null;
+    }
+    removeSprites(alias) {
+      if (!alias) {
+        for (const name in this._sprites) {
+          this.removeSprites(name);
         }
+      } else {
+        const sprite = this._sprites[alias];
+        if (sprite !== void 0) {
+          sprite.destroy();
+          delete this._sprites[alias];
+        }
+      }
+      return this;
+    }
+    get isPlayable() {
+      return this.isLoaded && this.media && this.media.isPlayable;
+    }
+    stop() {
+      if (!this.isPlayable) {
+        this.autoPlay = false;
+        this._autoPlayOptions = null;
+        return this;
+      }
+      this.isPlaying = false;
+      for (let i = this._instances.length - 1; i >= 0; i--) {
+        this._instances[i].stop();
+      }
+      return this;
+    }
+    play(source, complete) {
+      let options;
+      if (typeof source === "string") {
+        const sprite = source;
+        options = {
+          sprite,
+          loop: this.loop,
+          complete
+        };
+      } else if (typeof source === "function") {
+        options = {};
+        options.complete = source;
+      } else {
+        options = source;
+      }
+      options = _objectSpread({
+        complete: null,
+        loaded: null,
+        sprite: null,
+        end: null,
+        start: 0,
+        volume: 1,
+        speed: 1,
+        muted: false,
+        loop: false
+      }, options || {});
+      if (options.sprite) {
+        const alias = options.sprite;
+        console.assert(!!this._sprites[alias], `Alias ${alias} is not available`);
+        const sprite = this._sprites[alias];
+        options.start = sprite.start + (options.start || 0);
+        options.end = sprite.end;
+        options.speed = sprite.speed || 1;
+        options.loop = sprite.loop || options.loop;
+        delete options.sprite;
+      }
+      if (options.offset) {
+        options.start = options.offset;
+      }
+      if (!this.isLoaded) {
+        if (this._preloadQueue) {
+          return new Promise(resolve => {
+            this._preloadQueue.push(() => {
+              resolve(this.play(options));
+            });
+          });
+        }
+        this._preloadQueue = [];
+        this.autoPlay = true;
+        this._autoPlayOptions = options;
+        return new Promise((resolve, reject) => {
+          this._preload((err, sound, media) => {
+            this._preloadQueue.forEach(resolve2 => resolve2());
+            this._preloadQueue = null;
+            if (err) {
+              reject(err);
+            } else {
+              if (options.loaded) {
+                options.loaded(err, sound, media);
+              }
+              resolve(media);
+            }
+          });
+        });
+      }
+      if (this.singleInstance || options.singleInstance) {
+        this._removeInstances();
+      }
+      const instance = this._createInstance();
+      this._instances.push(instance);
+      this.isPlaying = true;
+      instance.once("end", () => {
+        if (options.complete) {
+          options.complete(this);
+        }
+        this._onComplete(instance);
       });
-      this.pausedComponents = [];
-      this.ctx.suspend().then();
+      instance.once("stop", () => {
+        this._onComplete(instance);
+      });
+      instance.play(options);
+      return instance;
+    }
+    refresh() {
+      const len = this._instances.length;
+      for (let i = 0; i < len; i++) {
+        this._instances[i].refresh();
+      }
+    }
+    refreshPaused() {
+      const len = this._instances.length;
+      for (let i = 0; i < len; i++) {
+        this._instances[i].refreshPaused();
+      }
+    }
+    get volume() {
+      return this._volume;
+    }
+    set volume(volume) {
+      this._volume = volume;
+      this.refresh();
+    }
+    get muted() {
+      return this._muted;
+    }
+    set muted(muted) {
+      this._muted = muted;
+      this.refresh();
+    }
+    get loop() {
+      return this._loop;
+    }
+    set loop(loop) {
+      this._loop = loop;
+      this.refresh();
+    }
+    _preload(callback) {
+      this.media.load(callback);
+    }
+    get instances() {
+      return this._instances;
+    }
+    get sprites() {
+      return this._sprites;
+    }
+    get duration() {
+      return this.media.duration;
+    }
+    autoPlayStart() {
+      let instance;
+      if (this.autoPlay) {
+        instance = this.play(this._autoPlayOptions);
+      }
+      return instance;
+    }
+    _removeInstances() {
+      for (let i = this._instances.length - 1; i >= 0; i--) {
+        this._poolInstance(this._instances[i]);
+      }
+      this._instances.length = 0;
+    }
+    _onComplete(instance) {
+      if (this._instances) {
+        const index = this._instances.indexOf(instance);
+        if (index > -1) {
+          this._instances.splice(index, 1);
+        }
+        this.isPlaying = this._instances.length > 0;
+      }
+      this._poolInstance(instance);
+    }
+    _createInstance() {
+      if (_Sound._pool.length > 0) {
+        const instance = _Sound._pool.pop();
+        instance.init(this.media);
+        return instance;
+      }
+      return this.media.create();
+    }
+    _poolInstance(instance) {
+      instance.destroy();
+      if (_Sound._pool.indexOf(instance) < 0) {
+        _Sound._pool.push(instance);
+      }
+    }
+  };
+  let Sound$2 = _Sound;
+  Sound$2._pool = [];
+  class WebAudioContext extends Filterable {
+    constructor() {
+      const win = window;
+      const ctx = new WebAudioContext.AudioContext();
+      const compressor = ctx.createDynamicsCompressor();
+      const analyser = ctx.createAnalyser();
+      analyser.connect(compressor);
+      compressor.connect(ctx.destination);
+      super(analyser, compressor);
+      this.autoPause = true;
+      this._ctx = ctx;
+      this._offlineCtx = new WebAudioContext.OfflineAudioContext(1, 2, win.OfflineAudioContext ? Math.max(8e3, Math.min(96e3, ctx.sampleRate)) : 44100);
+      this.compressor = compressor;
+      this.analyser = analyser;
+      this.events = new pixi_js.EventEmitter();
+      this.volume = 1;
+      this.speed = 1;
+      this.muted = false;
+      this.paused = false;
+      this._locked = ctx.state === "suspended" && ("ontouchstart" in globalThis || "onclick" in globalThis);
+      if (this._locked) {
+        this._unlock();
+        this._unlock = this._unlock.bind(this);
+        document.addEventListener("mousedown", this._unlock, true);
+        document.addEventListener("touchstart", this._unlock, true);
+        document.addEventListener("touchend", this._unlock, true);
+      }
+      this.onFocus = this.onFocus.bind(this);
+      this.onBlur = this.onBlur.bind(this);
+      globalThis.addEventListener("focus", this.onFocus);
+      globalThis.addEventListener("blur", this.onBlur);
+    }
+    onFocus() {
+      if (!this.autoPause) {
+        return;
+      }
+      const state = this._ctx.state;
+      if (state === "suspended" || state === "interrupted" || !this._locked) {
+        this.paused = this._pausedOnBlur;
+        this.refreshPaused();
+      }
+    }
+    onBlur() {
+      if (!this.autoPause) {
+        return;
+      }
+      if (!this._locked) {
+        this._pausedOnBlur = this._paused;
+        this.paused = true;
+        this.refreshPaused();
+      }
+    }
+    _unlock() {
+      if (!this._locked) {
+        return;
+      }
+      this.playEmptySound();
+      if (this._ctx.state === "running") {
+        document.removeEventListener("mousedown", this._unlock, true);
+        document.removeEventListener("touchend", this._unlock, true);
+        document.removeEventListener("touchstart", this._unlock, true);
+        this._locked = false;
+      }
+    }
+    playEmptySound() {
+      const source = this._ctx.createBufferSource();
+      source.buffer = this._ctx.createBuffer(1, 1, 22050);
+      source.connect(this._ctx.destination);
+      source.start(0, 0, 0);
+      if (source.context.state === "suspended") {
+        source.context.resume();
+      }
+    }
+    static get AudioContext() {
+      const win = window;
+      return win.AudioContext || win.webkitAudioContext || null;
+    }
+    static get OfflineAudioContext() {
+      const win = window;
+      return win.OfflineAudioContext || win.webkitOfflineAudioContext || null;
+    }
+    destroy() {
+      super.destroy();
+      const ctx = this._ctx;
+      if (typeof ctx.close !== "undefined") {
+        ctx.close();
+      }
+      globalThis.removeEventListener("focus", this.onFocus);
+      globalThis.removeEventListener("blur", this.onBlur);
+      this.events.removeAllListeners();
+      this.analyser.disconnect();
+      this.compressor.disconnect();
+      this.analyser = null;
+      this.compressor = null;
+      this.events = null;
+      this._offlineCtx = null;
+      this._ctx = null;
+    }
+    get audioContext() {
+      return this._ctx;
+    }
+    get offlineContext() {
+      return this._offlineCtx;
+    }
+    set paused(paused) {
+      if (paused && this._ctx.state === "running") {
+        this._ctx.suspend();
+      } else if (!paused && this._ctx.state === "suspended") {
+        this._ctx.resume();
+      }
+      this._paused = paused;
+    }
+    get paused() {
+      return this._paused;
+    }
+    refresh() {
+      this.events.emit("refresh");
+    }
+    refreshPaused() {
+      this.events.emit("refreshPaused");
+    }
+    toggleMute() {
+      this.muted = !this.muted;
+      this.refresh();
+      return this.muted;
+    }
+    togglePause() {
+      this.paused = !this.paused;
+      this.refreshPaused();
+      return this._paused;
+    }
+    decode(arrayBuffer, callback) {
+      const handleError = err => {
+        callback(new Error((err === null || err === void 0 ? void 0 : err.message) || "Unable to decode file"));
+      };
+      const result = this._offlineCtx.decodeAudioData(arrayBuffer, buffer => {
+        callback(null, buffer);
+      }, handleError);
+      if (result) {
+        result.catch(handleError);
+      }
+    }
+  }
+  class SoundLibrary {
+    constructor() {
+      this.init();
     }
     init() {
-      this.setupAudioContext();
+      if (this.supported) {
+        this._webAudioContext = new WebAudioContext();
+      }
+      this._htmlAudioContext = new HTMLAudioContext();
+      this._sounds = {};
+      this.useLegacy = !this.supported;
+      return this;
+    }
+    get context() {
+      return this._context;
+    }
+    get filtersAll() {
+      if (!this.useLegacy) {
+        return this._context.filters;
+      }
+      return [];
+    }
+    set filtersAll(filtersAll) {
+      if (!this.useLegacy) {
+        this._context.filters = filtersAll;
+      }
+    }
+    get supported() {
+      return WebAudioContext.AudioContext !== null;
+    }
+    add(source, sourceOptions) {
+      if (typeof source === "object") {
+        const results = {};
+        for (const alias in source) {
+          const options2 = this._getOptions(source[alias], sourceOptions);
+          results[alias] = this.add(alias, options2);
+        }
+        return results;
+      }
+      console.assert(!this._sounds[source], `Sound with alias ${source} already exists.`);
+      if (sourceOptions instanceof Sound$2) {
+        this._sounds[source] = sourceOptions;
+        return sourceOptions;
+      }
+      const options = this._getOptions(sourceOptions);
+      const sound = Sound$2.from(options);
+      this._sounds[source] = sound;
+      return sound;
+    }
+    _getOptions(source, overrides) {
+      let options;
+      if (typeof source === "string") {
+        options = {
+          url: source
+        };
+      } else if (Array.isArray(source)) {
+        options = {
+          url: source
+        };
+      } else if (source instanceof ArrayBuffer || source instanceof AudioBuffer || source instanceof HTMLAudioElement) {
+        options = {
+          source
+        };
+      } else {
+        options = source;
+      }
+      options = _objectSpread(_objectSpread({}, options), overrides || {});
+      return options;
+    }
+    get useLegacy() {
+      return this._useLegacy;
+    }
+    set useLegacy(legacy) {
+      this._useLegacy = legacy;
+      this._context = !legacy && this.supported ? this._webAudioContext : this._htmlAudioContext;
+    }
+    get disableAutoPause() {
+      return !this._webAudioContext.autoPause;
+    }
+    set disableAutoPause(autoPause) {
+      this._webAudioContext.autoPause = !autoPause;
+    }
+    remove(alias) {
+      this.exists(alias, true);
+      this._sounds[alias].destroy();
+      delete this._sounds[alias];
+      return this;
+    }
+    get volumeAll() {
+      return this._context.volume;
+    }
+    set volumeAll(volume) {
+      this._context.volume = volume;
+      this._context.refresh();
+    }
+    get speedAll() {
+      return this._context.speed;
+    }
+    set speedAll(speed) {
+      this._context.speed = speed;
+      this._context.refresh();
+    }
+    togglePauseAll() {
+      return this._context.togglePause();
+    }
+    pauseAll() {
+      this._context.paused = true;
+      this._context.refreshPaused();
+      return this;
+    }
+    resumeAll() {
+      this._context.paused = false;
+      this._context.refreshPaused();
+      return this;
+    }
+    toggleMuteAll() {
+      return this._context.toggleMute();
+    }
+    muteAll() {
+      this._context.muted = true;
+      this._context.refresh();
+      return this;
+    }
+    unmuteAll() {
+      this._context.muted = false;
+      this._context.refresh();
+      return this;
+    }
+    removeAll() {
+      for (const alias in this._sounds) {
+        this._sounds[alias].destroy();
+        delete this._sounds[alias];
+      }
+      return this;
+    }
+    stopAll() {
+      for (const alias in this._sounds) {
+        this._sounds[alias].stop();
+      }
+      return this;
+    }
+    exists(alias, assert = false) {
+      const exists = !!this._sounds[alias];
+      if (assert) {
+        console.assert(exists, `No sound matching alias '${alias}'.`);
+      }
+      return exists;
+    }
+    isPlaying() {
+      for (const alias in this._sounds) {
+        if (this._sounds[alias].isPlaying) {
+          return true;
+        }
+      }
+      return false;
+    }
+    find(alias) {
+      this.exists(alias, true);
+      return this._sounds[alias];
+    }
+    play(alias, options) {
+      return this.find(alias).play(options);
+    }
+    stop(alias) {
+      return this.find(alias).stop();
+    }
+    pause(alias) {
+      return this.find(alias).pause();
+    }
+    resume(alias) {
+      return this.find(alias).resume();
+    }
+    volume(alias, volume) {
+      const sound = this.find(alias);
+      if (volume !== void 0) {
+        sound.volume = volume;
+      }
+      return sound.volume;
+    }
+    speed(alias, speed) {
+      const sound = this.find(alias);
+      if (speed !== void 0) {
+        sound.speed = speed;
+      }
+      return sound.speed;
+    }
+    duration(alias) {
+      return this.find(alias).duration;
+    }
+    close() {
+      this.removeAll();
+      this._sounds = null;
+      if (this._webAudioContext) {
+        this._webAudioContext.destroy();
+        this._webAudioContext = null;
+      }
+      if (this._htmlAudioContext) {
+        this._htmlAudioContext.destroy();
+        this._htmlAudioContext = null;
+      }
+      this._context = null;
+      return this;
+    }
+  }
+  const getAlias = asset => {
+    var _asset$alias;
+    const src = asset.src;
+    let alias = asset === null || asset === void 0 ? void 0 : (_asset$alias = asset.alias) === null || _asset$alias === void 0 ? void 0 : _asset$alias[0];
+    if (!alias || asset.src === alias) {
+      alias = pixi_js.path.basename(src, pixi_js.path.extname(src));
+    }
+    return alias;
+  };
+  const soundAsset = {
+    extension: pixi_js.ExtensionType.Asset,
+    detection: {
+      test: async () => true,
+      add: async formats => [...formats, ...extensions.filter(ext => supported[ext])],
+      remove: async formats => formats.filter(ext => formats.includes(ext))
+    },
+    loader: {
+      name: "sound",
+      extension: {
+        type: [pixi_js.ExtensionType.LoadParser],
+        priority: pixi_js.LoaderParserPriority.High
+      },
+      test(url) {
+        const ext = pixi_js.path.extname(url).slice(1);
+        return !!supported[ext] || mimes.some(mime => url.startsWith(`data:${mime}`));
+      },
+      async load(url, asset) {
+        const sound = await new Promise((resolve, reject) => Sound$2.from(_objectSpread(_objectSpread({}, asset.data), {}, {
+          url,
+          preload: true,
+          loaded(err, sound2) {
+            var _asset$data, _asset$data$loaded;
+            if (err) {
+              reject(err);
+            } else {
+              resolve(sound2);
+            }
+            (_asset$data = asset.data) === null || _asset$data === void 0 ? void 0 : (_asset$data$loaded = _asset$data.loaded) === null || _asset$data$loaded === void 0 ? void 0 : _asset$data$loaded.call(_asset$data, err, sound2);
+          }
+        })));
+        getInstance().add(getAlias(asset), sound);
+        return sound;
+      },
+      async unload(_sound, asset) {
+        getInstance().remove(getAlias(asset));
+      }
+    }
+  };
+  pixi_js.extensions.add(soundAsset);
+  const sound = setInstance(new SoundLibrary());
+  pixi_js.extensions.add(soundAsset);
+  let SoundSystem = class SoundSystem extends eva_js.System {
+    constructor(obj) {
+      super();
+      this.autoPauseAndStart = true;
+      this.components = [];
+      this.audioBufferCache = {};
+      _extends(this, obj);
+    }
+    resumeAll() {
+      sound.resumeAll();
+    }
+    pauseAll() {
+      sound.pauseAll();
+    }
+    stopAll() {
+      sound.stopAll();
     }
     update() {
       const changes = this.componentObserver.clear();
@@ -124,12 +1678,7 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
         component.onDestroy();
       });
       this.components = [];
-      if (this.ctx) {
-        this.gainNode.disconnect();
-        this.gainNode = null;
-        this.ctx.close();
-        this.ctx = null;
-      }
+      sound.removeAll();
     }
     componentChanged(changed) {
       return __awaiter(this, void 0, void 0, function* () {
@@ -139,44 +1688,8 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
         }
       });
     }
-    setupAudioContext() {
-      try {
-        const AudioContext = window.AudioContext || window.webkitAudioContext;
-        this.ctx = new AudioContext();
-      } catch (error) {
-        console.error(error);
-        if (this.onError) {
-          this.onError(error);
-        }
-      }
-      if (!this.ctx) {
-        return;
-      }
-      this.gainNode = typeof this.ctx.createGain === 'undefined' ? this.ctx.createGainNode() : this.ctx.createGain();
-      this.gainNode.gain.setValueAtTime(this.muted ? 0 : this.volume, this.ctx.currentTime);
-      this.gainNode.connect(this.ctx.destination);
-      this.unlockAudio();
-    }
-    unlockAudio() {
-      if (!this.ctx || !this.audioLocked) {
-        return;
-      }
-      const unlock = () => {
-        if (this.ctx) {
-          const removeListenerFn = () => {
-            document.body.removeEventListener('touchstart', unlock);
-            document.body.removeEventListener('touchend', unlock);
-            document.body.removeEventListener('click', unlock);
-          };
-          this.ctx.resume().then(removeListenerFn, removeListenerFn);
-        }
-      };
-      document.body.addEventListener('touchstart', unlock);
-      document.body.addEventListener('touchend', unlock);
-      document.body.addEventListener('click', unlock);
-    }
     add(changed) {
-      var _a;
+      var _a, _b;
       return __awaiter(this, void 0, void 0, function* () {
         const component = changed.component;
         this.components.push(component);
@@ -187,11 +1700,9 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
           component.state = 'loading';
           const audio = yield eva_js.resource.getResource(config.resource);
           if (!this.audioBufferCache[audio.name] && ((_a = audio === null || audio === void 0 ? void 0 : audio.data) === null || _a === void 0 ? void 0 : _a.audio)) {
-            this.audioBufferCache[audio.name] = yield this.decodeAudioData(audio.data.audio, audio.name);
+            this.audioBufferCache[audio.name] = (_b = audio === null || audio === void 0 ? void 0 : audio.data) === null || _b === void 0 ? void 0 : _b.audio;
           }
           if (this.audioBufferCache[audio.name]) {
-            component.systemContext = this.ctx;
-            component.systemDestination = this.gainNode;
             component.onload(this.audioBufferCache[audio.name]);
           }
         } catch (error) {
@@ -201,40 +1712,6 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
         }
       });
     }
-    decodeAudioData(arraybuffer, name) {
-      if (this.decodeAudioPromiseMap[name]) {
-        return this.decodeAudioPromiseMap[name];
-      }
-      const promise = new Promise((resolve, reject) => {
-        if (!this.ctx) {
-          reject(new Error('No audio support'));
-        }
-        const success = decodedData => {
-          if (this.decodeAudioPromiseMap[name]) {
-            delete this.decodeAudioPromiseMap[name];
-          }
-          if (decodedData) {
-            resolve(decodedData);
-          } else {
-            reject(new Error(`Error decoding audio ${name}`));
-          }
-        };
-        const error = err => {
-          if (this.decodeAudioPromiseMap[name]) {
-            delete this.decodeAudioPromiseMap[name];
-          }
-          reject(new Error(`${err}. arrayBuffer byteLength: ${arraybuffer ? arraybuffer.byteLength : 0}`));
-        };
-        const promise = this.ctx.decodeAudioData(arraybuffer, success, error);
-        if (promise instanceof Promise) {
-          promise.catch(err => {
-            reject(new Error(`catch ${err}, arrayBuffer byteLength: ${arraybuffer ? arraybuffer.byteLength : 0}`));
-          });
-        }
-      });
-      this.decodeAudioPromiseMap[name] = promise;
-      return promise;
-    }
   };
   SoundSystem.systemName = 'SoundSystem';
   SoundSystem = __decorate([eva_js.decorators.componentObserver({
@@ -251,34 +1728,25 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
         muted: false,
         volume: 1,
         loop: false,
-        seek: 0
+        seek: 0,
+        speed: 1
       };
-      this.playTime = 0;
-      this.startTime = 0;
-      this.duration = 0;
       this.actionQueue = [];
     }
+    get playing() {
+      return this.buffer.isPlaying;
+    }
     get muted() {
-      return this.gainNode ? this.gainNode.gain.value === 0 : false;
+      return this.buffer.muted;
     }
     set muted(v) {
-      if (!this.gainNode) {
-        return;
-      }
-      this.gainNode.gain.setValueAtTime(v ? 0 : this.config.volume, 0);
+      this.buffer.muted = v;
     }
     get volume() {
-      return this.gainNode ? this.gainNode.gain.value : 1;
+      return this.buffer.volume;
     }
     set volume(v) {
-      if (typeof v !== 'number' || v < 0 || v > 1) {
-        return;
-      }
-      this.config.volume = v;
-      if (!this.gainNode) {
-        return;
-      }
-      this.gainNode.gain.setValueAtTime(v, 0);
+      this.buffer.volume = v;
     }
     init(obj) {
       if (!obj) {
@@ -293,100 +1761,31 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
       if (this.state !== 'loaded') {
         this.actionQueue.push(this.play.bind(this));
       }
-      this.destroySource();
-      this.createSource();
-      if (!this.sourceNode) {
-        return;
-      }
-      const when = this.systemContext.currentTime;
-      const offset = this.config.seek;
-      const duration = this.config.duration;
-      this.sourceNode.start(0, offset, duration);
-      this.startTime = when;
-      this.playTime = when - offset;
-      this.paused = false;
-      this.playing = true;
-      this.resetConfig();
-      this.endedListener = () => {
-        if (!this.sourceNode) {
-          return;
-        }
-        if (this.config.onEnd) {
-          this.config.onEnd();
-        }
-        if (this.playing) {
-          this.destroySource();
-        }
-      };
-      this.sourceNode.addEventListener('ended', this.endedListener);
+      this.buffer.play();
+    }
+    resume() {
+      this.buffer.resume();
     }
     pause() {
-      if (this.state !== 'loaded') {
-        this.actionQueue.push(this.pause.bind(this));
-      }
-      if (this.paused || !this.playing) {
-        return;
-      }
-      this.paused = true;
-      this.playing = false;
-      this.config.seek = this.getCurrentTime();
-      this.destroySource();
+      this.buffer.pause();
     }
     stop() {
-      if (this.state !== 'loaded') {
-        this.actionQueue.push(this.stop.bind(this));
-      }
-      if (!this.paused && !this.playing) {
-        return;
-      }
-      this.playing = false;
-      this.paused = false;
-      this.destroySource();
-      this.resetConfig();
+      this.buffer.stop();
     }
     onload(buffer) {
       this.state = 'loaded';
       this.buffer = buffer;
-      this.duration = this.buffer.duration;
+      this.buffer.muted = this.config.muted;
+      this.buffer.volume = this.config.volume;
+      this.buffer.loop = this.config.loop;
+      this.buffer.speed = this.config.speed;
       this.actionQueue.forEach(action => action());
       this.actionQueue.length = 0;
     }
     onDestroy() {
       this.actionQueue.length = 0;
-      this.destroySource();
-    }
-    resetConfig() {
-      this.config.seek = 0;
-    }
-    getCurrentTime() {
-      if (this.config.loop && this.duration > 0) {
-        return (this.systemContext.currentTime - this.playTime) % this.duration;
-      }
-      return this.systemContext.currentTime - this.playTime;
-    }
-    createSource() {
-      if (!this.systemContext || this.state !== 'loaded') {
-        return;
-      }
-      this.sourceNode = this.systemContext.createBufferSource();
-      this.sourceNode.buffer = this.buffer;
-      this.sourceNode.loop = this.config.loop;
-      if (!this.gainNode) {
-        this.gainNode = this.systemContext.createGain();
-        this.gainNode.connect(this.systemDestination);
-        _extends(this, this.config);
-      }
-      this.sourceNode.connect(this.gainNode);
-    }
-    destroySource() {
-      if (!this.sourceNode) return;
-      this.sourceNode.removeEventListener('ended', this.endedListener);
-      this.sourceNode.stop();
-      this.sourceNode.disconnect();
-      this.sourceNode = null;
-      this.startTime = 0;
-      this.playTime = 0;
-      this.playing = false;
+      this.buffer.destroy();
+      this.buffer = null;
     }
   }
   Sound.componentName = 'Sound';
@@ -397,5 +1796,5 @@ var _EVA_IIFE_sound = function (exports, eva_js) {
     value: true
   });
   return exports;
-}({}, EVA);
+}({}, EVA, PIXI);
 window.EVA.plugin.sound = window.EVA.plugin.sound || _EVA_IIFE_sound;