react-modern-audio-player 1.4.0-rc.2 → 2.0.0-beta.1

package/dist/wavesurfer-_j5aw4gZ.mjs

@@ -0,0 +1,4471 @@
+function oe(q, Z) {
+  for (var X = 0; X < Z.length; X++) {
+    const Q = Z[X];
+    if (typeof Q != "string" && !Array.isArray(Q)) {
+      for (const G in Q)
+        if (G !== "default" && !(G in q)) {
+          const K = Object.getOwnPropertyDescriptor(Q, G);
+          K && Object.defineProperty(q, G, K.get ? K : {
+            enumerable: !0,
+            get: () => Q[G]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(q, Symbol.toStringTag, { value: "Module" }));
+}
+function ue(q) {
+  return q && q.__esModule && Object.prototype.hasOwnProperty.call(q, "default") ? q.default : q;
+}
+var re = { exports: {} };
+/*!
+ * wavesurfer.js 6.6.4 (2023-06-10)
+ * https://wavesurfer-js.org
+ * @license BSD-3-Clause
+ */
+(function(q, Z) {
+  (function(Q, G) {
+    q.exports = G();
+  })(self, () => (
+    /******/
+    (() => {
+      var X = {
+        /***/
+        "./src/drawer.canvasentry.js": (
+          /*!***********************************!*\
+            !*** ./src/drawer.canvasentry.js ***!
+            \***********************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var g = E(C(
+              /*! ./util/style */
+              "./src/util/style.js"
+            )), W = E(C(
+              /*! ./util/get-id */
+              "./src/util/get-id.js"
+            ));
+            function E(p) {
+              return p && p.__esModule ? p : { default: p };
+            }
+            function M(p) {
+              "@babel/helpers - typeof";
+              return M = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(c) {
+                return typeof c;
+              } : function(c) {
+                return c && typeof Symbol == "function" && c.constructor === Symbol && c !== Symbol.prototype ? "symbol" : typeof c;
+              }, M(p);
+            }
+            function x(p, c) {
+              if (!(p instanceof c))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function I(p, c) {
+              for (var v = 0; v < c.length; v++) {
+                var d = c[v];
+                d.enumerable = d.enumerable || !1, d.configurable = !0, "value" in d && (d.writable = !0), Object.defineProperty(p, O(d.key), d);
+              }
+            }
+            function b(p, c, v) {
+              return c && I(p.prototype, c), Object.defineProperty(p, "prototype", { writable: !1 }), p;
+            }
+            function O(p) {
+              var c = R(p, "string");
+              return M(c) === "symbol" ? c : String(c);
+            }
+            function R(p, c) {
+              if (M(p) !== "object" || p === null) return p;
+              var v = p[Symbol.toPrimitive];
+              if (v !== void 0) {
+                var d = v.call(p, c);
+                if (M(d) !== "object") return d;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(p);
+            }
+            var _ = /* @__PURE__ */ function() {
+              function p() {
+                x(this, p), this.wave = null, this.waveCtx = null, this.progress = null, this.progressCtx = null, this.start = 0, this.end = 1, this.id = (0, W.default)(typeof this.constructor.name < "u" ? this.constructor.name.toLowerCase() + "_" : "canvasentry_"), this.canvasContextAttributes = {};
+              }
+              return b(p, [{
+                key: "initWave",
+                value: function(v) {
+                  this.wave = v, this.waveCtx = this.wave.getContext("2d", this.canvasContextAttributes);
+                }
+                /**
+                 * Store the progress wave canvas element and create the 2D rendering
+                 * context
+                 *
+                 * @param {HTMLCanvasElement} element The progress wave `canvas` element.
+                 */
+              }, {
+                key: "initProgress",
+                value: function(v) {
+                  this.progress = v, this.progressCtx = this.progress.getContext("2d", this.canvasContextAttributes);
+                }
+                /**
+                 * Update the dimensions
+                 *
+                 * @param {number} elementWidth Width of the entry
+                 * @param {number} totalWidth Total width of the multi canvas renderer
+                 * @param {number} width The new width of the element
+                 * @param {number} height The new height of the element
+                 */
+              }, {
+                key: "updateDimensions",
+                value: function(v, d, P, w) {
+                  this.start = this.wave.offsetLeft / d || 0, this.end = this.start + v / d, this.wave.width = P, this.wave.height = w;
+                  var k = {
+                    width: v + "px"
+                  };
+                  (0, g.default)(this.wave, k), this.hasProgressCanvas && (this.progress.width = P, this.progress.height = w, (0, g.default)(this.progress, k));
+                }
+                /**
+                 * Clear the wave and progress rendering contexts
+                 */
+              }, {
+                key: "clearWave",
+                value: function() {
+                  this.waveCtx.clearRect(0, 0, this.waveCtx.canvas.width, this.waveCtx.canvas.height), this.hasProgressCanvas && this.progressCtx.clearRect(0, 0, this.progressCtx.canvas.width, this.progressCtx.canvas.height);
+                }
+                /**
+                 * Set the fill styles for wave and progress
+                 * @param {string|string[]} waveColor Fill color for the wave canvas,
+                 * or an array of colors to apply as a gradient
+                 * @param {?string|string[]} progressColor Fill color for the progress canvas,
+                 * or an array of colors to apply as a gradient
+                 */
+              }, {
+                key: "setFillStyles",
+                value: function(v, d) {
+                  this.waveCtx.fillStyle = this.getFillStyle(this.waveCtx, v), this.hasProgressCanvas && (this.progressCtx.fillStyle = this.getFillStyle(this.progressCtx, d));
+                }
+                /**
+                 * Utility function to handle wave color arguments
+                 *
+                 * When the color argument type is a string or CanvasGradient instance,
+                 * it will be returned as is. Otherwise, it will be treated as an array,
+                 * and a new CanvasGradient will be returned
+                 *
+                 * @since 6.0.0
+                 * @param {CanvasRenderingContext2D} ctx Rendering context of target canvas
+                 * @param {string|string[]|CanvasGradient} color Either a single fill color
+                 *     for the wave canvas, an existing CanvasGradient instance, or an array
+                 *     of colors to apply as a gradient
+                 * @returns {string|CanvasGradient} Returns a string fillstyle value, or a
+                 *     canvas gradient
+                 */
+              }, {
+                key: "getFillStyle",
+                value: function(v, d) {
+                  if (typeof d == "string" || d instanceof CanvasGradient)
+                    return d;
+                  var P = v.createLinearGradient(0, 0, 0, v.canvas.height);
+                  return d.forEach(function(w, k) {
+                    return P.addColorStop(k / d.length, w);
+                  }), P;
+                }
+                /**
+                 * Set the canvas transforms for wave and progress
+                 *
+                 * @param {boolean} vertical Whether to render vertically
+                 */
+              }, {
+                key: "applyCanvasTransforms",
+                value: function(v) {
+                  v && (this.waveCtx.setTransform(0, 1, 1, 0, 0, 0), this.hasProgressCanvas && this.progressCtx.setTransform(0, 1, 1, 0, 0, 0));
+                }
+                /**
+                 * Draw a rectangle for wave and progress
+                 *
+                 * @param {number} x X start position
+                 * @param {number} y Y start position
+                 * @param {number} width Width of the rectangle
+                 * @param {number} height Height of the rectangle
+                 * @param {number} radius Radius of the rectangle
+                 */
+              }, {
+                key: "fillRects",
+                value: function(v, d, P, w, k) {
+                  this.fillRectToContext(this.waveCtx, v, d, P, w, k), this.hasProgressCanvas && this.fillRectToContext(this.progressCtx, v, d, P, w, k);
+                }
+                /**
+                 * Draw the actual rectangle on a `canvas` element
+                 *
+                 * @param {CanvasRenderingContext2D} ctx Rendering context of target canvas
+                 * @param {number} x X start position
+                 * @param {number} y Y start position
+                 * @param {number} width Width of the rectangle
+                 * @param {number} height Height of the rectangle
+                 * @param {number} radius Radius of the rectangle
+                 */
+              }, {
+                key: "fillRectToContext",
+                value: function(v, d, P, w, k, y) {
+                  v && (y ? this.drawRoundedRect(v, d, P, w, k, y) : v.fillRect(d, P, w, k));
+                }
+                /**
+                 * Draw a rounded rectangle on Canvas
+                 *
+                 * @param {CanvasRenderingContext2D} ctx Canvas context
+                 * @param {number} x X-position of the rectangle
+                 * @param {number} y Y-position of the rectangle
+                 * @param {number} width Width of the rectangle
+                 * @param {number} height Height of the rectangle
+                 * @param {number} radius Radius of the rectangle
+                 *
+                 * @return {void}
+                 * @example drawRoundedRect(ctx, 50, 50, 5, 10, 3)
+                 */
+              }, {
+                key: "drawRoundedRect",
+                value: function(v, d, P, w, k, y) {
+                  k !== 0 && (k < 0 && (k *= -1, P -= k), v.beginPath(), v.moveTo(d + y, P), v.lineTo(d + w - y, P), v.quadraticCurveTo(d + w, P, d + w, P + y), v.lineTo(d + w, P + k - y), v.quadraticCurveTo(d + w, P + k, d + w - y, P + k), v.lineTo(d + y, P + k), v.quadraticCurveTo(d, P + k, d, P + k - y), v.lineTo(d, P + y), v.quadraticCurveTo(d, P, d + y, P), v.closePath(), v.fill());
+                }
+                /**
+                 * Render the actual wave and progress lines
+                 *
+                 * @param {number[]} peaks Array with peaks data
+                 * @param {number} absmax Maximum peak value (absolute)
+                 * @param {number} halfH Half the height of the waveform
+                 * @param {number} offsetY Offset to the top
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that
+                 * should be rendered
+                 */
+              }, {
+                key: "drawLines",
+                value: function(v, d, P, w, k, y) {
+                  this.drawLineToContext(this.waveCtx, v, d, P, w, k, y), this.hasProgressCanvas && this.drawLineToContext(this.progressCtx, v, d, P, w, k, y);
+                }
+                /**
+                 * Render the actual waveform line on a `canvas` element
+                 *
+                 * @param {CanvasRenderingContext2D} ctx Rendering context of target canvas
+                 * @param {number[]} peaks Array with peaks data
+                 * @param {number} absmax Maximum peak value (absolute)
+                 * @param {number} halfH Half the height of the waveform
+                 * @param {number} offsetY Offset to the top
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that
+                 * should be rendered
+                 */
+              }, {
+                key: "drawLineToContext",
+                value: function(v, d, P, w, k, y, f) {
+                  if (v) {
+                    var m = d.length / 2, u = Math.round(m * this.start), n = Math.round(m * this.end) + 1, a = u, o = n, r = this.wave.width / (o - a - 1), t = w + k, s = P / w;
+                    v.beginPath(), v.moveTo((a - u) * r, t), v.lineTo((a - u) * r, t - Math.round((d[2 * a] || 0) / s));
+                    var i, e, l;
+                    for (i = a; i < o; i++)
+                      e = d[2 * i] || 0, l = Math.round(e / s), v.lineTo((i - u) * r + this.halfPixel, t - l);
+                    var A = o - 1;
+                    for (A; A >= a; A--)
+                      e = d[2 * A + 1] || 0, l = Math.round(e / s), v.lineTo((A - u) * r + this.halfPixel, t - l);
+                    v.lineTo((a - u) * r, t - Math.round((d[2 * a + 1] || 0) / s)), v.closePath(), v.fill();
+                  }
+                }
+                /**
+                 * Destroys this entry
+                 */
+              }, {
+                key: "destroy",
+                value: function() {
+                  this.waveCtx = null, this.wave = null, this.progressCtx = null, this.progress = null;
+                }
+                /**
+                 * Return image data of the wave `canvas` element
+                 *
+                 * When using a `type` of `'blob'`, this will return a `Promise` that
+                 * resolves with a `Blob` instance.
+                 *
+                 * @param {string} format='image/png' An optional value of a format type.
+                 * @param {number} quality=0.92 An optional value between 0 and 1.
+                 * @param {string} type='dataURL' Either 'dataURL' or 'blob'.
+                 * @return {string|Promise} When using the default `'dataURL'` `type` this
+                 * returns a data URL. When using the `'blob'` `type` this returns a
+                 * `Promise` that resolves with a `Blob` instance.
+                 */
+              }, {
+                key: "getImage",
+                value: function(v, d, P) {
+                  var w = this;
+                  if (P === "blob")
+                    return new Promise(function(k) {
+                      w.wave.toBlob(k, v, d);
+                    });
+                  if (P === "dataURL")
+                    return this.wave.toDataURL(v, d);
+                }
+              }]), p;
+            }();
+            h.default = _, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/drawer.js": (
+          /*!***********************!*\
+            !*** ./src/drawer.js ***!
+            \***********************/
+          /***/
+          (j, h, C) => {
+            function g(y) {
+              "@babel/helpers - typeof";
+              return g = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(f) {
+                return typeof f;
+              } : function(f) {
+                return f && typeof Symbol == "function" && f.constructor === Symbol && f !== Symbol.prototype ? "symbol" : typeof f;
+              }, g(y);
+            }
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var W = M(C(
+              /*! ./util */
+              "./src/util/index.js"
+            ));
+            function E(y) {
+              if (typeof WeakMap != "function") return null;
+              var f = /* @__PURE__ */ new WeakMap(), m = /* @__PURE__ */ new WeakMap();
+              return (E = function(n) {
+                return n ? m : f;
+              })(y);
+            }
+            function M(y, f) {
+              if (y && y.__esModule)
+                return y;
+              if (y === null || g(y) !== "object" && typeof y != "function")
+                return { default: y };
+              var m = E(f);
+              if (m && m.has(y))
+                return m.get(y);
+              var u = {}, n = Object.defineProperty && Object.getOwnPropertyDescriptor;
+              for (var a in y)
+                if (a !== "default" && Object.prototype.hasOwnProperty.call(y, a)) {
+                  var o = n ? Object.getOwnPropertyDescriptor(y, a) : null;
+                  o && (o.get || o.set) ? Object.defineProperty(u, a, o) : u[a] = y[a];
+                }
+              return u.default = y, m && m.set(y, u), u;
+            }
+            function x(y, f) {
+              if (!(y instanceof f))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function I(y, f) {
+              for (var m = 0; m < f.length; m++) {
+                var u = f[m];
+                u.enumerable = u.enumerable || !1, u.configurable = !0, "value" in u && (u.writable = !0), Object.defineProperty(y, O(u.key), u);
+              }
+            }
+            function b(y, f, m) {
+              return f && I(y.prototype, f), Object.defineProperty(y, "prototype", { writable: !1 }), y;
+            }
+            function O(y) {
+              var f = R(y, "string");
+              return g(f) === "symbol" ? f : String(f);
+            }
+            function R(y, f) {
+              if (g(y) !== "object" || y === null) return y;
+              var m = y[Symbol.toPrimitive];
+              if (m !== void 0) {
+                var u = m.call(y, f);
+                if (g(u) !== "object") return u;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(y);
+            }
+            function _(y, f) {
+              if (typeof f != "function" && f !== null)
+                throw new TypeError("Super expression must either be null or a function");
+              y.prototype = Object.create(f && f.prototype, { constructor: { value: y, writable: !0, configurable: !0 } }), Object.defineProperty(y, "prototype", { writable: !1 }), f && p(y, f);
+            }
+            function p(y, f) {
+              return p = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(u, n) {
+                return u.__proto__ = n, u;
+              }, p(y, f);
+            }
+            function c(y) {
+              var f = P();
+              return function() {
+                var u = w(y), n;
+                if (f) {
+                  var a = w(this).constructor;
+                  n = Reflect.construct(u, arguments, a);
+                } else
+                  n = u.apply(this, arguments);
+                return v(this, n);
+              };
+            }
+            function v(y, f) {
+              if (f && (g(f) === "object" || typeof f == "function"))
+                return f;
+              if (f !== void 0)
+                throw new TypeError("Derived constructors may only return object or undefined");
+              return d(y);
+            }
+            function d(y) {
+              if (y === void 0)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return y;
+            }
+            function P() {
+              if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) return !1;
+              if (typeof Proxy == "function") return !0;
+              try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+              } catch {
+                return !1;
+              }
+            }
+            function w(y) {
+              return w = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(m) {
+                return m.__proto__ || Object.getPrototypeOf(m);
+              }, w(y);
+            }
+            var k = /* @__PURE__ */ function(y) {
+              _(m, y);
+              var f = c(m);
+              function m(u, n) {
+                var a;
+                return x(this, m), a = f.call(this), a.container = W.withOrientation(u, n.vertical), a.params = n, a.width = 0, a.height = n.height * a.params.pixelRatio, a.lastPos = 0, a.wrapper = null, a;
+              }
+              return b(m, [{
+                key: "style",
+                value: function(n, a) {
+                  return W.style(n, a);
+                }
+                /**
+                 * Create the wrapper `<wave>` element, style it and set up the events for
+                 * interaction
+                 */
+              }, {
+                key: "createWrapper",
+                value: function() {
+                  this.wrapper = W.withOrientation(this.container.appendChild(document.createElement("wave")), this.params.vertical), this.style(this.wrapper, {
+                    display: "block",
+                    position: "relative",
+                    userSelect: "none",
+                    webkitUserSelect: "none",
+                    height: this.params.height + "px"
+                  }), (this.params.fillParent || this.params.scrollParent) && this.style(this.wrapper, {
+                    width: "100%",
+                    cursor: this.params.hideCursor ? "none" : "auto",
+                    overflowX: this.params.hideScrollbar ? "hidden" : "auto",
+                    overflowY: "hidden"
+                  }), this.setupWrapperEvents();
+                }
+                /**
+                 * Handle click event
+                 *
+                 * @param {Event} e Click event
+                 * @param {?boolean} noPrevent Set to true to not call `e.preventDefault()`
+                 * @return {number} Playback position from 0 to 1
+                 */
+              }, {
+                key: "handleEvent",
+                value: function(n, a) {
+                  !a && n.preventDefault();
+                  var o = W.withOrientation(n.targetTouches ? n.targetTouches[0] : n, this.params.vertical).clientX, r = this.wrapper.getBoundingClientRect(), t = this.width, s = this.getWidth(), i = this.getProgressPixels(r, o), e;
+                  return !this.params.fillParent && t < s ? e = i * (this.params.pixelRatio / t) || 0 : e = (i + this.wrapper.scrollLeft) / this.wrapper.scrollWidth || 0, W.clamp(e, 0, 1);
+                }
+              }, {
+                key: "getProgressPixels",
+                value: function(n, a) {
+                  return this.params.rtl ? n.right - a : a - n.left;
+                }
+              }, {
+                key: "setupWrapperEvents",
+                value: function() {
+                  var n = this;
+                  this.wrapper.addEventListener("click", function(a) {
+                    var o = W.withOrientation(a, n.params.vertical), r = n.wrapper.offsetHeight - n.wrapper.clientHeight;
+                    if (r !== 0) {
+                      var t = n.wrapper.getBoundingClientRect();
+                      if (o.clientY >= t.bottom - r)
+                        return;
+                    }
+                    n.params.interact && n.fireEvent("click", a, n.handleEvent(a));
+                  }), this.wrapper.addEventListener("dblclick", function(a) {
+                    n.params.interact && n.fireEvent("dblclick", a, n.handleEvent(a));
+                  }), this.wrapper.addEventListener("scroll", function(a) {
+                    return n.fireEvent("scroll", a);
+                  });
+                }
+                /**
+                 * Draw peaks on the canvas
+                 *
+                 * @param {number[]|Number.<Array[]>} peaks Can also be an array of arrays
+                 * for split channel rendering
+                 * @param {number} length The width of the area that should be drawn
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that should be
+                 * rendered
+                 */
+              }, {
+                key: "drawPeaks",
+                value: function(n, a, o, r) {
+                  this.setWidth(a) || this.clearWave(), this.params.barWidth ? this.drawBars(n, 0, o, r) : this.drawWave(n, 0, o, r);
+                }
+                /**
+                 * Scroll to the beginning
+                 */
+              }, {
+                key: "resetScroll",
+                value: function() {
+                  this.wrapper !== null && (this.wrapper.scrollLeft = 0);
+                }
+                /**
+                 * Recenter the view-port at a certain percent of the waveform
+                 *
+                 * @param {number} percent Value from 0 to 1 on the waveform
+                 */
+              }, {
+                key: "recenter",
+                value: function(n) {
+                  var a = this.wrapper.scrollWidth * n;
+                  this.recenterOnPosition(a, !0);
+                }
+                /**
+                 * Recenter the view-port on a position, either scroll there immediately or
+                 * in steps of 5 pixels
+                 *
+                 * @param {number} position X-offset in pixels
+                 * @param {boolean} immediate Set to true to immediately scroll somewhere
+                 */
+              }, {
+                key: "recenterOnPosition",
+                value: function(n, a) {
+                  var o = this.wrapper.scrollLeft, r = ~~(this.wrapper.clientWidth / 2), t = this.wrapper.scrollWidth - this.wrapper.clientWidth, s = n - r, i = s - o;
+                  if (t != 0) {
+                    if (!a && -r <= i && i < r) {
+                      var e = this.params.autoCenterRate;
+                      e /= r, e *= t, i = Math.max(-e, Math.min(e, i)), s = o + i;
+                    }
+                    s = Math.max(0, Math.min(t, s)), s != o && (this.wrapper.scrollLeft = s);
+                  }
+                }
+                /**
+                 * Get the current scroll position in pixels
+                 *
+                 * @return {number} Horizontal scroll position in pixels
+                 */
+              }, {
+                key: "getScrollX",
+                value: function() {
+                  var n = 0;
+                  if (this.wrapper) {
+                    var a = this.params.pixelRatio;
+                    if (n = Math.round(this.wrapper.scrollLeft * a), this.params.scrollParent) {
+                      var o = ~~(this.wrapper.scrollWidth * a - this.getWidth());
+                      n = Math.min(o, Math.max(0, n));
+                    }
+                  }
+                  return n;
+                }
+                /**
+                 * Get the width of the container
+                 *
+                 * @return {number} The width of the container
+                 */
+              }, {
+                key: "getWidth",
+                value: function() {
+                  return Math.round(this.container.clientWidth * this.params.pixelRatio);
+                }
+                /**
+                 * Set the width of the container
+                 *
+                 * @param {number} width The new width of the container
+                 * @return {boolean} Whether the width of the container was updated or not
+                 */
+              }, {
+                key: "setWidth",
+                value: function(n) {
+                  if (this.width == n)
+                    return !1;
+                  if (this.width = n, this.params.fillParent || this.params.scrollParent)
+                    this.style(this.wrapper, {
+                      width: ""
+                    });
+                  else {
+                    var a = ~~(this.width / this.params.pixelRatio) + "px";
+                    this.style(this.wrapper, {
+                      width: a
+                    });
+                  }
+                  return this.updateSize(), !0;
+                }
+                /**
+                 * Set the height of the container
+                 *
+                 * @param {number} height The new height of the container.
+                 * @return {boolean} Whether the height of the container was updated or not
+                 */
+              }, {
+                key: "setHeight",
+                value: function(n) {
+                  return n == this.height ? !1 : (this.height = n, this.style(this.wrapper, {
+                    height: ~~(this.height / this.params.pixelRatio) + "px"
+                  }), this.updateSize(), !0);
+                }
+                /**
+                 * Called by wavesurfer when progress should be rendered
+                 *
+                 * @param {number} progress From 0 to 1
+                 */
+              }, {
+                key: "progress",
+                value: function(n) {
+                  var a = 1 / this.params.pixelRatio, o = Math.round(n * this.width) * a;
+                  if (o < this.lastPos || o - this.lastPos >= a) {
+                    if (this.lastPos = o, this.params.scrollParent && this.params.autoCenter) {
+                      var r = ~~(this.wrapper.scrollWidth * n);
+                      this.recenterOnPosition(r, this.params.autoCenterImmediately);
+                    }
+                    this.updateProgress(o);
+                  }
+                }
+                /**
+                 * This is called when wavesurfer is destroyed
+                 */
+              }, {
+                key: "destroy",
+                value: function() {
+                  this.unAll(), this.wrapper && (this.wrapper.parentNode == this.container.domElement && this.container.removeChild(this.wrapper.domElement), this.wrapper = null);
+                }
+                /* Renderer-specific methods */
+                /**
+                 * Called after cursor related params have changed.
+                 *
+                 * @abstract
+                 */
+              }, {
+                key: "updateCursor",
+                value: function() {
+                }
+                /**
+                 * Called when the size of the container changes so the renderer can adjust
+                 *
+                 * @abstract
+                 */
+              }, {
+                key: "updateSize",
+                value: function() {
+                }
+                /**
+                 * Draw a waveform with bars
+                 *
+                 * @abstract
+                 * @param {number[]|Number.<Array[]>} peaks Can also be an array of arrays for split channel
+                 * rendering
+                 * @param {number} channelIndex The index of the current channel. Normally
+                 * should be 0
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that should be
+                 * rendered
+                 */
+              }, {
+                key: "drawBars",
+                value: function(n, a, o, r) {
+                }
+                /**
+                 * Draw a waveform
+                 *
+                 * @abstract
+                 * @param {number[]|Number.<Array[]>} peaks Can also be an array of arrays for split channel
+                 * rendering
+                 * @param {number} channelIndex The index of the current channel. Normally
+                 * should be 0
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that should be
+                 * rendered
+                 */
+              }, {
+                key: "drawWave",
+                value: function(n, a, o, r) {
+                }
+                /**
+                 * Clear the waveform
+                 *
+                 * @abstract
+                 */
+              }, {
+                key: "clearWave",
+                value: function() {
+                }
+                /**
+                 * Render the new progress
+                 *
+                 * @abstract
+                 * @param {number} position X-Offset of progress position in pixels
+                 */
+              }, {
+                key: "updateProgress",
+                value: function(n) {
+                }
+              }]), m;
+            }(W.Observer);
+            h.default = k, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/drawer.multicanvas.js": (
+          /*!***********************************!*\
+            !*** ./src/drawer.multicanvas.js ***!
+            \***********************************/
+          /***/
+          (j, h, C) => {
+            function g(u) {
+              "@babel/helpers - typeof";
+              return g = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(n) {
+                return typeof n;
+              } : function(n) {
+                return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+              }, g(u);
+            }
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var W = b(C(
+              /*! ./drawer */
+              "./src/drawer.js"
+            )), E = I(C(
+              /*! ./util */
+              "./src/util/index.js"
+            )), M = b(C(
+              /*! ./drawer.canvasentry */
+              "./src/drawer.canvasentry.js"
+            ));
+            function x(u) {
+              if (typeof WeakMap != "function") return null;
+              var n = /* @__PURE__ */ new WeakMap(), a = /* @__PURE__ */ new WeakMap();
+              return (x = function(r) {
+                return r ? a : n;
+              })(u);
+            }
+            function I(u, n) {
+              if (u && u.__esModule)
+                return u;
+              if (u === null || g(u) !== "object" && typeof u != "function")
+                return { default: u };
+              var a = x(n);
+              if (a && a.has(u))
+                return a.get(u);
+              var o = {}, r = Object.defineProperty && Object.getOwnPropertyDescriptor;
+              for (var t in u)
+                if (t !== "default" && Object.prototype.hasOwnProperty.call(u, t)) {
+                  var s = r ? Object.getOwnPropertyDescriptor(u, t) : null;
+                  s && (s.get || s.set) ? Object.defineProperty(o, t, s) : o[t] = u[t];
+                }
+              return o.default = u, a && a.set(u, o), o;
+            }
+            function b(u) {
+              return u && u.__esModule ? u : { default: u };
+            }
+            function O(u, n) {
+              if (!(u instanceof n))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function R(u, n) {
+              for (var a = 0; a < n.length; a++) {
+                var o = n[a];
+                o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(u, p(o.key), o);
+              }
+            }
+            function _(u, n, a) {
+              return n && R(u.prototype, n), Object.defineProperty(u, "prototype", { writable: !1 }), u;
+            }
+            function p(u) {
+              var n = c(u, "string");
+              return g(n) === "symbol" ? n : String(n);
+            }
+            function c(u, n) {
+              if (g(u) !== "object" || u === null) return u;
+              var a = u[Symbol.toPrimitive];
+              if (a !== void 0) {
+                var o = a.call(u, n);
+                if (g(o) !== "object") return o;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(u);
+            }
+            function v(u, n) {
+              if (typeof n != "function" && n !== null)
+                throw new TypeError("Super expression must either be null or a function");
+              u.prototype = Object.create(n && n.prototype, { constructor: { value: u, writable: !0, configurable: !0 } }), Object.defineProperty(u, "prototype", { writable: !1 }), n && d(u, n);
+            }
+            function d(u, n) {
+              return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, r) {
+                return o.__proto__ = r, o;
+              }, d(u, n);
+            }
+            function P(u) {
+              var n = y();
+              return function() {
+                var o = f(u), r;
+                if (n) {
+                  var t = f(this).constructor;
+                  r = Reflect.construct(o, arguments, t);
+                } else
+                  r = o.apply(this, arguments);
+                return w(this, r);
+              };
+            }
+            function w(u, n) {
+              if (n && (g(n) === "object" || typeof n == "function"))
+                return n;
+              if (n !== void 0)
+                throw new TypeError("Derived constructors may only return object or undefined");
+              return k(u);
+            }
+            function k(u) {
+              if (u === void 0)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return u;
+            }
+            function y() {
+              if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) return !1;
+              if (typeof Proxy == "function") return !0;
+              try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+              } catch {
+                return !1;
+              }
+            }
+            function f(u) {
+              return f = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(a) {
+                return a.__proto__ || Object.getPrototypeOf(a);
+              }, f(u);
+            }
+            var m = /* @__PURE__ */ function(u) {
+              v(a, u);
+              var n = P(a);
+              function a(o, r) {
+                var t;
+                return O(this, a), t = n.call(this, o, r), t.maxCanvasWidth = r.maxCanvasWidth, t.maxCanvasElementWidth = Math.round(r.maxCanvasWidth / r.pixelRatio), t.hasProgressCanvas = r.waveColor != r.progressColor, t.halfPixel = 0.5 / r.pixelRatio, t.canvases = [], t.progressWave = null, t.EntryClass = M.default, t.canvasContextAttributes = r.drawingContextAttributes, t.overlap = 2 * Math.ceil(r.pixelRatio / 2), t.barRadius = r.barRadius || 0, t.vertical = r.vertical, t;
+              }
+              return _(a, [{
+                key: "init",
+                value: function() {
+                  this.createWrapper(), this.createElements();
+                }
+                /**
+                 * Create the canvas elements and style them
+                 *
+                 */
+              }, {
+                key: "createElements",
+                value: function() {
+                  this.progressWave = E.withOrientation(this.wrapper.appendChild(document.createElement("wave")), this.params.vertical), this.style(this.progressWave, {
+                    position: "absolute",
+                    zIndex: 3,
+                    left: 0,
+                    top: 0,
+                    bottom: 0,
+                    overflow: "hidden",
+                    width: "0",
+                    display: "none",
+                    boxSizing: "border-box",
+                    borderRightStyle: "solid",
+                    pointerEvents: "none"
+                  }), this.addCanvas(), this.updateCursor();
+                }
+                /**
+                 * Update cursor style
+                 */
+              }, {
+                key: "updateCursor",
+                value: function() {
+                  this.style(this.progressWave, {
+                    borderRightWidth: this.params.cursorWidth + "px",
+                    borderRightColor: this.params.cursorColor
+                  });
+                }
+                /**
+                 * Adjust to the updated size by adding or removing canvases
+                 */
+              }, {
+                key: "updateSize",
+                value: function() {
+                  for (var r = this, t = Math.round(this.width / this.params.pixelRatio), s = Math.ceil(t / (this.maxCanvasElementWidth + this.overlap)); this.canvases.length < s; )
+                    this.addCanvas();
+                  for (; this.canvases.length > s; )
+                    this.removeCanvas();
+                  var i = this.maxCanvasWidth + this.overlap, e = this.canvases.length - 1;
+                  this.canvases.forEach(function(l, A) {
+                    A == e && (i = r.width - r.maxCanvasWidth * e), r.updateDimensions(l, i, r.height), l.clearWave();
+                  });
+                }
+                /**
+                 * Add a canvas to the canvas list
+                 *
+                 */
+              }, {
+                key: "addCanvas",
+                value: function() {
+                  var r = new this.EntryClass();
+                  r.canvasContextAttributes = this.canvasContextAttributes, r.hasProgressCanvas = this.hasProgressCanvas, r.halfPixel = this.halfPixel;
+                  var t = this.maxCanvasElementWidth * this.canvases.length, s = E.withOrientation(this.wrapper.appendChild(document.createElement("canvas")), this.params.vertical);
+                  if (this.style(s, {
+                    position: "absolute",
+                    zIndex: 2,
+                    left: t + "px",
+                    top: 0,
+                    bottom: 0,
+                    height: "100%",
+                    pointerEvents: "none"
+                  }), r.initWave(s), this.hasProgressCanvas) {
+                    var i = E.withOrientation(this.progressWave.appendChild(document.createElement("canvas")), this.params.vertical);
+                    this.style(i, {
+                      position: "absolute",
+                      left: t + "px",
+                      top: 0,
+                      bottom: 0,
+                      height: "100%"
+                    }), r.initProgress(i);
+                  }
+                  this.canvases.push(r);
+                }
+                /**
+                 * Pop single canvas from the list
+                 *
+                 */
+              }, {
+                key: "removeCanvas",
+                value: function() {
+                  var r = this.canvases[this.canvases.length - 1];
+                  r.wave.parentElement.removeChild(r.wave.domElement), this.hasProgressCanvas && r.progress.parentElement.removeChild(r.progress.domElement), r && (r.destroy(), r = null), this.canvases.pop();
+                }
+                /**
+                 * Update the dimensions of a canvas element
+                 *
+                 * @param {CanvasEntry} entry Target entry
+                 * @param {number} width The new width of the element
+                 * @param {number} height The new height of the element
+                 */
+              }, {
+                key: "updateDimensions",
+                value: function(r, t, s) {
+                  var i = Math.round(t / this.params.pixelRatio), e = Math.round(this.width / this.params.pixelRatio);
+                  r.updateDimensions(i, e, t, s), this.style(this.progressWave, {
+                    display: "block"
+                  });
+                }
+                /**
+                 * Clear the whole multi-canvas
+                 */
+              }, {
+                key: "clearWave",
+                value: function() {
+                  var r = this;
+                  E.frame(function() {
+                    r.canvases.forEach(function(t) {
+                      return t.clearWave();
+                    });
+                  })();
+                }
+                /**
+                 * Draw a waveform with bars
+                 *
+                 * @param {number[]|Number.<Array[]>} peaks Can also be an array of arrays
+                 * for split channel rendering
+                 * @param {number} channelIndex The index of the current channel. Normally
+                 * should be 0. Must be an integer.
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that should be
+                 * rendered
+                 * @returns {void}
+                 */
+              }, {
+                key: "drawBars",
+                value: function(r, t, s, i) {
+                  var e = this;
+                  return this.prepareDraw(r, t, s, i, function(l) {
+                    var A = l.absmax, T = l.hasMinVals;
+                    l.height;
+                    var S = l.offsetY, D = l.halfH, B = l.peaks, V = l.channelIndex;
+                    if (s !== void 0) {
+                      var N = T ? 2 : 1, H = B.length / N, L = e.params.barWidth * e.params.pixelRatio, U = e.params.barGap === null ? Math.max(e.params.pixelRatio, ~~(L / 2)) : Math.max(e.params.pixelRatio, e.params.barGap * e.params.pixelRatio), F = L + U, z = H / e.width, ie = s, ae = i, Y = ie;
+                      for (Y; Y < ae; Y += F) {
+                        var $ = 0, ee = Math.floor(Y * z) * N, se = Math.floor((Y + F) * z) * N;
+                        do {
+                          var te = Math.abs(B[ee]);
+                          te > $ && ($ = te), ee += N;
+                        } while (ee < se);
+                        var J = Math.round($ / A * D);
+                        e.params.barMinHeight && (J = Math.max(J, e.params.barMinHeight)), e.fillRect(Y + e.halfPixel, D - J + S, L + e.halfPixel, J * 2, e.barRadius, V);
+                      }
+                    }
+                  });
+                }
+                /**
+                 * Draw a waveform
+                 *
+                 * @param {number[]|Number.<Array[]>} peaks Can also be an array of arrays
+                 * for split channel rendering
+                 * @param {number} channelIndex The index of the current channel. Normally
+                 * should be 0
+                 * @param {number?} start The x-offset of the beginning of the area that
+                 * should be rendered (If this isn't set only a flat line is rendered)
+                 * @param {number?} end The x-offset of the end of the area that should be
+                 * rendered
+                 * @returns {void}
+                 */
+              }, {
+                key: "drawWave",
+                value: function(r, t, s, i) {
+                  var e = this;
+                  return this.prepareDraw(r, t, s, i, function(l) {
+                    var A = l.absmax, T = l.hasMinVals;
+                    l.height;
+                    var S = l.offsetY, D = l.halfH, B = l.peaks, V = l.channelIndex;
+                    if (!T) {
+                      var N = [], H = B.length, L = 0;
+                      for (L; L < H; L++)
+                        N[2 * L] = B[L], N[2 * L + 1] = -B[L];
+                      B = N;
+                    }
+                    s !== void 0 && e.drawLine(B, A, D, S, s, i, V), e.fillRect(0, D + S - e.halfPixel, e.width, e.halfPixel, e.barRadius, V);
+                  });
+                }
+                /**
+                 * Tell the canvas entries to render their portion of the waveform
+                 *
+                 * @param {number[]} peaks Peaks data
+                 * @param {number} absmax Maximum peak value (absolute)
+                 * @param {number} halfH Half the height of the waveform
+                 * @param {number} offsetY Offset to the top
+                 * @param {number} start The x-offset of the beginning of the area that
+                 * should be rendered
+                 * @param {number} end The x-offset of the end of the area that
+                 * should be rendered
+                 * @param {channelIndex} channelIndex The channel index of the line drawn
+                 */
+              }, {
+                key: "drawLine",
+                value: function(r, t, s, i, e, l, A) {
+                  var T = this, S = this.params.splitChannelsOptions.channelColors[A] || {}, D = S.waveColor, B = S.progressColor;
+                  this.canvases.forEach(function(V, N) {
+                    T.setFillStyles(V, D, B), T.applyCanvasTransforms(V, T.params.vertical), V.drawLines(r, t, s, i, e, l);
+                  });
+                }
+                /**
+                 * Draw a rectangle on the multi-canvas
+                 *
+                 * @param {number} x X-position of the rectangle
+                 * @param {number} y Y-position of the rectangle
+                 * @param {number} width Width of the rectangle
+                 * @param {number} height Height of the rectangle
+                 * @param {number} radius Radius of the rectangle
+                 * @param {channelIndex} channelIndex The channel index of the bar drawn
+                 */
+              }, {
+                key: "fillRect",
+                value: function(r, t, s, i, e, l) {
+                  var A = Math.floor(r / this.maxCanvasWidth), T = Math.min(Math.ceil((r + s) / this.maxCanvasWidth) + 1, this.canvases.length), S = A;
+                  for (S; S < T; S++) {
+                    var D = this.canvases[S], B = S * this.maxCanvasWidth, V = {
+                      x1: Math.max(r, S * this.maxCanvasWidth),
+                      y1: t,
+                      x2: Math.min(r + s, S * this.maxCanvasWidth + D.wave.width),
+                      y2: t + i
+                    };
+                    if (V.x1 < V.x2) {
+                      var N = this.params.splitChannelsOptions.channelColors[l] || {}, H = N.waveColor, L = N.progressColor;
+                      this.setFillStyles(D, H, L), this.applyCanvasTransforms(D, this.params.vertical), D.fillRects(V.x1 - B, V.y1, V.x2 - V.x1, V.y2 - V.y1, e);
+                    }
+                  }
+                }
+                /**
+                 * Returns whether to hide the channel from being drawn based on params.
+                 *
+                 * @param {number} channelIndex The index of the current channel.
+                 * @returns {bool} True to hide the channel, false to draw.
+                 */
+              }, {
+                key: "hideChannel",
+                value: function(r) {
+                  return this.params.splitChannels && this.params.splitChannelsOptions.filterChannels.includes(r);
+                }
+                /**
+                 * Performs preparation tasks and calculations which are shared by `drawBars`
+                 * and `drawWave`
+                 *
+                 * @param {number[]|Number.<Array[]>} peaks Can also be an array of arrays for
+                 * split channel rendering
+                 * @param {number} channelIndex The index of the current channel. Normally
+                 * should be 0
+                 * @param {number?} start The x-offset of the beginning of the area that
+                 * should be rendered. If this isn't set only a flat line is rendered
+                 * @param {number?} end The x-offset of the end of the area that should be
+                 * rendered
+                 * @param {function} fn The render function to call, e.g. `drawWave`
+                 * @param {number} drawIndex The index of the current channel after filtering.
+                 * @param {number?} normalizedMax Maximum modulation value across channels for use with relativeNormalization. Ignored when undefined
+                 * @returns {void}
+                 */
+              }, {
+                key: "prepareDraw",
+                value: function(r, t, s, i, e, l, A) {
+                  var T = this;
+                  return E.frame(function() {
+                    if (r[0] instanceof Array) {
+                      var S = r;
+                      if (T.params.splitChannels) {
+                        var D = S.filter(function(F, z) {
+                          return !T.hideChannel(z);
+                        });
+                        T.params.splitChannelsOptions.overlay || T.setHeight(Math.max(D.length, 1) * T.params.height * T.params.pixelRatio);
+                        var B;
+                        return T.params.splitChannelsOptions && T.params.splitChannelsOptions.relativeNormalization && (B = E.max(S.map(function(F) {
+                          return E.absMax(F);
+                        }))), S.forEach(function(F, z) {
+                          return T.prepareDraw(F, z, s, i, e, D.indexOf(F), B);
+                        });
+                      }
+                      r = S[0];
+                    }
+                    if (!T.hideChannel(t)) {
+                      var V = 1 / T.params.barHeight;
+                      T.params.normalize && (V = A === void 0 ? E.absMax(r) : A);
+                      var N = [].some.call(r, function(F) {
+                        return F < 0;
+                      }), H = T.params.height * T.params.pixelRatio, L = H / 2, U = H * l || 0;
+                      return T.params.splitChannelsOptions && T.params.splitChannelsOptions.overlay && (U = 0), e({
+                        absmax: V,
+                        hasMinVals: N,
+                        height: H,
+                        offsetY: U,
+                        halfH: L,
+                        peaks: r,
+                        channelIndex: t
+                      });
+                    }
+                  })();
+                }
+                /**
+                 * Set the fill styles for a certain entry (wave and progress)
+                 *
+                 * @param {CanvasEntry} entry Target entry
+                 * @param {string} waveColor Wave color to draw this entry
+                 * @param {string} progressColor Progress color to draw this entry
+                 */
+              }, {
+                key: "setFillStyles",
+                value: function(r) {
+                  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.params.waveColor, s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : this.params.progressColor;
+                  r.setFillStyles(t, s);
+                }
+                /**
+                 * Set the canvas transforms for a certain entry (wave and progress)
+                 *
+                 * @param {CanvasEntry} entry Target entry
+                 * @param {boolean} vertical Whether to render the waveform vertically
+                 */
+              }, {
+                key: "applyCanvasTransforms",
+                value: function(r) {
+                  var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+                  r.applyCanvasTransforms(t);
+                }
+                /**
+                 * Return image data of the multi-canvas
+                 *
+                 * When using a `type` of `'blob'`, this will return a `Promise`.
+                 *
+                 * @param {string} format='image/png' An optional value of a format type.
+                 * @param {number} quality=0.92 An optional value between 0 and 1.
+                 * @param {string} type='dataURL' Either 'dataURL' or 'blob'.
+                 * @return {string|string[]|Promise} When using the default `'dataURL'`
+                 * `type` this returns a single data URL or an array of data URLs,
+                 * one for each canvas. When using the `'blob'` `type` this returns a
+                 * `Promise` that resolves with an array of `Blob` instances, one for each
+                 * canvas.
+                 */
+              }, {
+                key: "getImage",
+                value: function(r, t, s) {
+                  if (s === "blob")
+                    return Promise.all(this.canvases.map(function(e) {
+                      return e.getImage(r, t, s);
+                    }));
+                  if (s === "dataURL") {
+                    var i = this.canvases.map(function(e) {
+                      return e.getImage(r, t, s);
+                    });
+                    return i.length > 1 ? i : i[0];
+                  }
+                }
+                /**
+                 * Render the new progress
+                 *
+                 * @param {number} position X-offset of progress position in pixels
+                 */
+              }, {
+                key: "updateProgress",
+                value: function(r) {
+                  this.style(this.progressWave, {
+                    width: r + "px"
+                  });
+                }
+              }]), a;
+            }(W.default);
+            h.default = m, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/mediaelement-webaudio.js": (
+          /*!**************************************!*\
+            !*** ./src/mediaelement-webaudio.js ***!
+            \**************************************/
+          /***/
+          (j, h, C) => {
+            function g(f) {
+              "@babel/helpers - typeof";
+              return g = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(m) {
+                return typeof m;
+              } : function(m) {
+                return m && typeof Symbol == "function" && m.constructor === Symbol && m !== Symbol.prototype ? "symbol" : typeof m;
+              }, g(f);
+            }
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var W = E(C(
+              /*! ./mediaelement */
+              "./src/mediaelement.js"
+            ));
+            function E(f) {
+              return f && f.__esModule ? f : { default: f };
+            }
+            function M(f, m) {
+              if (!(f instanceof m))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function x(f, m) {
+              for (var u = 0; u < m.length; u++) {
+                var n = m[u];
+                n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(f, b(n.key), n);
+              }
+            }
+            function I(f, m, u) {
+              return m && x(f.prototype, m), Object.defineProperty(f, "prototype", { writable: !1 }), f;
+            }
+            function b(f) {
+              var m = O(f, "string");
+              return g(m) === "symbol" ? m : String(m);
+            }
+            function O(f, m) {
+              if (g(f) !== "object" || f === null) return f;
+              var u = f[Symbol.toPrimitive];
+              if (u !== void 0) {
+                var n = u.call(f, m);
+                if (g(n) !== "object") return n;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(f);
+            }
+            function R() {
+              return typeof Reflect < "u" && Reflect.get ? R = Reflect.get.bind() : R = function(m, u, n) {
+                var a = _(m, u);
+                if (a) {
+                  var o = Object.getOwnPropertyDescriptor(a, u);
+                  return o.get ? o.get.call(arguments.length < 3 ? m : n) : o.value;
+                }
+              }, R.apply(this, arguments);
+            }
+            function _(f, m) {
+              for (; !Object.prototype.hasOwnProperty.call(f, m) && (f = k(f), f !== null); )
+                ;
+              return f;
+            }
+            function p(f, m) {
+              if (typeof m != "function" && m !== null)
+                throw new TypeError("Super expression must either be null or a function");
+              f.prototype = Object.create(m && m.prototype, { constructor: { value: f, writable: !0, configurable: !0 } }), Object.defineProperty(f, "prototype", { writable: !1 }), m && c(f, m);
+            }
+            function c(f, m) {
+              return c = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, a) {
+                return n.__proto__ = a, n;
+              }, c(f, m);
+            }
+            function v(f) {
+              var m = w();
+              return function() {
+                var n = k(f), a;
+                if (m) {
+                  var o = k(this).constructor;
+                  a = Reflect.construct(n, arguments, o);
+                } else
+                  a = n.apply(this, arguments);
+                return d(this, a);
+              };
+            }
+            function d(f, m) {
+              if (m && (g(m) === "object" || typeof m == "function"))
+                return m;
+              if (m !== void 0)
+                throw new TypeError("Derived constructors may only return object or undefined");
+              return P(f);
+            }
+            function P(f) {
+              if (f === void 0)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return f;
+            }
+            function w() {
+              if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) return !1;
+              if (typeof Proxy == "function") return !0;
+              try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+              } catch {
+                return !1;
+              }
+            }
+            function k(f) {
+              return k = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(u) {
+                return u.__proto__ || Object.getPrototypeOf(u);
+              }, k(f);
+            }
+            var y = /* @__PURE__ */ function(f) {
+              p(u, f);
+              var m = v(u);
+              function u(n) {
+                var a;
+                return M(this, u), a = m.call(this, n), a.params = n, a.sourceMediaElement = null, a;
+              }
+              return I(u, [{
+                key: "init",
+                value: function() {
+                  this.setPlaybackRate(this.params.audioRate), this.createTimer(), this.createVolumeNode(), this.createScriptNode(), this.createAnalyserNode();
+                }
+                /**
+                 * Private method called by both `load` (from url)
+                 * and `loadElt` (existing media element) methods.
+                 *
+                 * @param {HTMLMediaElement} media HTML5 Audio or Video element
+                 * @param {number[]|Number.<Array[]>} peaks Array of peak data
+                 * @param {string} preload HTML 5 preload attribute value
+                 * @private
+                 */
+              }, {
+                key: "_load",
+                value: function(a, o, r) {
+                  R(k(u.prototype), "_load", this).call(this, a, o, r), this.createMediaElementSource(a);
+                }
+                /**
+                 * Create MediaElementSource node
+                 *
+                 * @since 3.2.0
+                 * @param {HTMLMediaElement} mediaElement HTML5 Audio to load
+                 */
+              }, {
+                key: "createMediaElementSource",
+                value: function(a) {
+                  this.sourceMediaElement = this.ac.createMediaElementSource(a), this.sourceMediaElement.connect(this.analyser);
+                }
+              }, {
+                key: "play",
+                value: function(a, o) {
+                  return this.resumeAudioContext(), R(k(u.prototype), "play", this).call(this, a, o);
+                }
+                /**
+                 * This is called when wavesurfer is destroyed
+                 *
+                 */
+              }, {
+                key: "destroy",
+                value: function() {
+                  R(k(u.prototype), "destroy", this).call(this), this.destroyWebAudio();
+                }
+              }]), u;
+            }(W.default);
+            h.default = y, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/mediaelement.js": (
+          /*!*****************************!*\
+            !*** ./src/mediaelement.js ***!
+            \*****************************/
+          /***/
+          (j, h, C) => {
+            function g(n) {
+              "@babel/helpers - typeof";
+              return g = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(a) {
+                return typeof a;
+              } : function(a) {
+                return a && typeof Symbol == "function" && a.constructor === Symbol && a !== Symbol.prototype ? "symbol" : typeof a;
+              }, g(n);
+            }
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var W = I(C(
+              /*! ./webaudio */
+              "./src/webaudio.js"
+            )), E = x(C(
+              /*! ./util */
+              "./src/util/index.js"
+            ));
+            function M(n) {
+              if (typeof WeakMap != "function") return null;
+              var a = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap();
+              return (M = function(t) {
+                return t ? o : a;
+              })(n);
+            }
+            function x(n, a) {
+              if (n && n.__esModule)
+                return n;
+              if (n === null || g(n) !== "object" && typeof n != "function")
+                return { default: n };
+              var o = M(a);
+              if (o && o.has(n))
+                return o.get(n);
+              var r = {}, t = Object.defineProperty && Object.getOwnPropertyDescriptor;
+              for (var s in n)
+                if (s !== "default" && Object.prototype.hasOwnProperty.call(n, s)) {
+                  var i = t ? Object.getOwnPropertyDescriptor(n, s) : null;
+                  i && (i.get || i.set) ? Object.defineProperty(r, s, i) : r[s] = n[s];
+                }
+              return r.default = n, o && o.set(n, r), r;
+            }
+            function I(n) {
+              return n && n.__esModule ? n : { default: n };
+            }
+            function b(n, a) {
+              if (!(n instanceof a))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function O(n, a) {
+              for (var o = 0; o < a.length; o++) {
+                var r = a[o];
+                r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(n, _(r.key), r);
+              }
+            }
+            function R(n, a, o) {
+              return a && O(n.prototype, a), Object.defineProperty(n, "prototype", { writable: !1 }), n;
+            }
+            function _(n) {
+              var a = p(n, "string");
+              return g(a) === "symbol" ? a : String(a);
+            }
+            function p(n, a) {
+              if (g(n) !== "object" || n === null) return n;
+              var o = n[Symbol.toPrimitive];
+              if (o !== void 0) {
+                var r = o.call(n, a);
+                if (g(r) !== "object") return r;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(n);
+            }
+            function c() {
+              return typeof Reflect < "u" && Reflect.get ? c = Reflect.get.bind() : c = function(a, o, r) {
+                var t = v(a, o);
+                if (t) {
+                  var s = Object.getOwnPropertyDescriptor(t, o);
+                  return s.get ? s.get.call(arguments.length < 3 ? a : r) : s.value;
+                }
+              }, c.apply(this, arguments);
+            }
+            function v(n, a) {
+              for (; !Object.prototype.hasOwnProperty.call(n, a) && (n = m(n), n !== null); )
+                ;
+              return n;
+            }
+            function d(n, a) {
+              if (typeof a != "function" && a !== null)
+                throw new TypeError("Super expression must either be null or a function");
+              n.prototype = Object.create(a && a.prototype, { constructor: { value: n, writable: !0, configurable: !0 } }), Object.defineProperty(n, "prototype", { writable: !1 }), a && P(n, a);
+            }
+            function P(n, a) {
+              return P = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, t) {
+                return r.__proto__ = t, r;
+              }, P(n, a);
+            }
+            function w(n) {
+              var a = f();
+              return function() {
+                var r = m(n), t;
+                if (a) {
+                  var s = m(this).constructor;
+                  t = Reflect.construct(r, arguments, s);
+                } else
+                  t = r.apply(this, arguments);
+                return k(this, t);
+              };
+            }
+            function k(n, a) {
+              if (a && (g(a) === "object" || typeof a == "function"))
+                return a;
+              if (a !== void 0)
+                throw new TypeError("Derived constructors may only return object or undefined");
+              return y(n);
+            }
+            function y(n) {
+              if (n === void 0)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return n;
+            }
+            function f() {
+              if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) return !1;
+              if (typeof Proxy == "function") return !0;
+              try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+              } catch {
+                return !1;
+              }
+            }
+            function m(n) {
+              return m = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+                return o.__proto__ || Object.getPrototypeOf(o);
+              }, m(n);
+            }
+            var u = /* @__PURE__ */ function(n) {
+              d(o, n);
+              var a = w(o);
+              function o(r) {
+                var t;
+                return b(this, o), t = a.call(this, r), t.params = r, t.media = {
+                  currentTime: 0,
+                  duration: 0,
+                  paused: !0,
+                  playbackRate: 1,
+                  play: function() {
+                  },
+                  pause: function() {
+                  },
+                  volume: 0
+                }, t.mediaType = r.mediaType.toLowerCase(), t.elementPosition = r.elementPosition, t.peaks = null, t.playbackRate = 1, t.volume = 1, t.isMuted = !1, t.buffer = null, t.onPlayEnd = null, t.mediaListeners = {}, t;
+              }
+              return R(o, [{
+                key: "init",
+                value: function() {
+                  this.setPlaybackRate(this.params.audioRate), this.createTimer();
+                }
+                /**
+                 * Attach event listeners to media element.
+                 */
+              }, {
+                key: "_setupMediaListeners",
+                value: function() {
+                  var t = this;
+                  this.mediaListeners.error = function() {
+                    t.fireEvent("error", "Error loading media element");
+                  }, this.mediaListeners.waiting = function() {
+                    t.fireEvent("waiting");
+                  }, this.mediaListeners.canplay = function() {
+                    t.fireEvent("canplay");
+                  }, this.mediaListeners.ended = function() {
+                    t.fireEvent("finish");
+                  }, this.mediaListeners.play = function() {
+                    t.fireEvent("play");
+                  }, this.mediaListeners.pause = function() {
+                    t.fireEvent("pause");
+                  }, this.mediaListeners.seeked = function(s) {
+                    t.fireEvent("seek");
+                  }, this.mediaListeners.volumechange = function(s) {
+                    t.isMuted = t.media.muted, t.isMuted ? t.volume = 0 : t.volume = t.media.volume, t.fireEvent("volume");
+                  }, Object.keys(this.mediaListeners).forEach(function(s) {
+                    t.media.removeEventListener(s, t.mediaListeners[s]), t.media.addEventListener(s, t.mediaListeners[s]);
+                  });
+                }
+                /**
+                 * Create a timer to provide a more precise `audioprocess` event.
+                 */
+              }, {
+                key: "createTimer",
+                value: function() {
+                  var t = this, s = function i() {
+                    t.isPaused() || (t.fireEvent("audioprocess", t.getCurrentTime()), E.frame(i)());
+                  };
+                  this.on("play", s), this.on("pause", function() {
+                    t.fireEvent("audioprocess", t.getCurrentTime());
+                  });
+                }
+                /**
+                 * Create media element with url as its source,
+                 * and append to container element.
+                 *
+                 * @param {string} url Path to media file
+                 * @param {HTMLElement} container HTML element
+                 * @param {number[]|Number.<Array[]>} peaks Array of peak data
+                 * @param {string} preload HTML 5 preload attribute value
+                 * @throws Will throw an error if the `url` argument is not a valid media
+                 * element.
+                 */
+              }, {
+                key: "load",
+                value: function(t, s, i, e) {
+                  var l = document.createElement(this.mediaType);
+                  l.controls = this.params.mediaControls, l.autoplay = this.params.autoplay || !1, l.preload = e ?? "auto", l.src = t, l.style.width = "100%";
+                  var A = s.querySelector(this.mediaType);
+                  A && s.removeChild(A), s.appendChild(l), this._load(l, i, e);
+                }
+                /**
+                 * Load existing media element.
+                 *
+                 * @param {HTMLMediaElement} elt HTML5 Audio or Video element
+                 * @param {number[]|Number.<Array[]>} peaks Array of peak data
+                 */
+              }, {
+                key: "loadElt",
+                value: function(t, s) {
+                  t.controls = this.params.mediaControls, t.autoplay = this.params.autoplay || !1, this._load(t, s, t.preload);
+                }
+                /**
+                 * Method called by both `load` (from url)
+                 * and `loadElt` (existing media element) methods.
+                 *
+                 * @param {HTMLMediaElement} media HTML5 Audio or Video element
+                 * @param {number[]|Number.<Array[]>} peaks Array of peak data
+                 * @param {string} preload HTML 5 preload attribute value
+                 * @throws Will throw an error if the `media` argument is not a valid media
+                 * element.
+                 * @private
+                 */
+              }, {
+                key: "_load",
+                value: function(t, s, i) {
+                  if (!(t instanceof HTMLMediaElement) || typeof t.addEventListener > "u")
+                    throw new Error("media parameter is not a valid media element");
+                  typeof t.load == "function" && !(s && i == "none") && t.load(), this.media = t, this._setupMediaListeners(), this.peaks = s, this.onPlayEnd = null, this.buffer = null, this.isMuted = t.muted, this.setPlaybackRate(this.playbackRate), this.setVolume(this.volume);
+                }
+                /**
+                 * Used by `wavesurfer.isPlaying()` and `wavesurfer.playPause()`
+                 *
+                 * @return {boolean} Media paused or not
+                 */
+              }, {
+                key: "isPaused",
+                value: function() {
+                  return !this.media || this.media.paused;
+                }
+                /**
+                 * Used by `wavesurfer.getDuration()`
+                 *
+                 * @return {number} Duration
+                 */
+              }, {
+                key: "getDuration",
+                value: function() {
+                  if (this.explicitDuration)
+                    return this.explicitDuration;
+                  var t = (this.buffer || this.media).duration;
+                  return t >= 1 / 0 && (t = this.media.seekable.end(0)), t;
+                }
+                /**
+                 * Returns the current time in seconds relative to the audio-clip's
+                 * duration.
+                 *
+                 * @return {number} Current time
+                 */
+              }, {
+                key: "getCurrentTime",
+                value: function() {
+                  return this.media && this.media.currentTime;
+                }
+                /**
+                 * Get the position from 0 to 1
+                 *
+                 * @return {number} Current position
+                 */
+              }, {
+                key: "getPlayedPercents",
+                value: function() {
+                  return this.getCurrentTime() / this.getDuration() || 0;
+                }
+                /**
+                 * Get the audio source playback rate.
+                 *
+                 * @return {number} Playback rate
+                 */
+              }, {
+                key: "getPlaybackRate",
+                value: function() {
+                  return this.playbackRate || this.media.playbackRate;
+                }
+                /**
+                 * Set the audio source playback rate.
+                 *
+                 * @param {number} value Playback rate
+                 */
+              }, {
+                key: "setPlaybackRate",
+                value: function(t) {
+                  this.playbackRate = t || 1, this.media.playbackRate = this.playbackRate;
+                }
+                /**
+                 * Used by `wavesurfer.seekTo()`
+                 *
+                 * @param {number} start Position to start at in seconds
+                 */
+              }, {
+                key: "seekTo",
+                value: function(t) {
+                  t != null && !isNaN(t) && (this.media.currentTime = t), this.clearPlayEnd();
+                }
+                /**
+                 * Plays the loaded audio region.
+                 *
+                 * @param {number} start Start offset in seconds, relative to the beginning
+                 * of a clip.
+                 * @param {number} end When to stop, relative to the beginning of a clip.
+                 * @emits MediaElement#play
+                 * @return {Promise} Result
+                 */
+              }, {
+                key: "play",
+                value: function(t, s) {
+                  this.seekTo(t);
+                  var i = this.media.play();
+                  return s && this.setPlayEnd(s), i;
+                }
+                /**
+                 * Pauses the loaded audio.
+                 *
+                 * @emits MediaElement#pause
+                 * @return {Promise} Result
+                 */
+              }, {
+                key: "pause",
+                value: function() {
+                  var t;
+                  return this.media && (t = this.media.pause()), this.clearPlayEnd(), t;
+                }
+                /**
+                 * Set the play end
+                 *
+                 * @param {number} end Where to end
+                 */
+              }, {
+                key: "setPlayEnd",
+                value: function(t) {
+                  var s = this;
+                  this.clearPlayEnd(), this._onPlayEnd = function(i) {
+                    i >= t && (s.pause(), s.seekTo(t));
+                  }, this.on("audioprocess", this._onPlayEnd);
+                }
+                /** @private */
+              }, {
+                key: "clearPlayEnd",
+                value: function() {
+                  this._onPlayEnd && (this.un("audioprocess", this._onPlayEnd), this._onPlayEnd = null);
+                }
+                /**
+                 * Compute the max and min value of the waveform when broken into
+                 * <length> subranges.
+                 *
+                 * @param {number} length How many subranges to break the waveform into.
+                 * @param {number} first First sample in the required range.
+                 * @param {number} last Last sample in the required range.
+                 * @return {number[]|Number.<Array[]>} Array of 2*<length> peaks or array of
+                 * arrays of peaks consisting of (max, min) values for each subrange.
+                 */
+              }, {
+                key: "getPeaks",
+                value: function(t, s, i) {
+                  return this.buffer ? c(m(o.prototype), "getPeaks", this).call(this, t, s, i) : this.peaks || [];
+                }
+                /**
+                 * Set the sink id for the media player
+                 *
+                 * @param {string} deviceId String value representing audio device id.
+                 * @returns {Promise} A Promise that resolves to `undefined` when there
+                 * are no errors.
+                 */
+              }, {
+                key: "setSinkId",
+                value: function(t) {
+                  return t ? this.media.setSinkId ? this.media.setSinkId(t) : Promise.reject(new Error("setSinkId is not supported in your browser")) : Promise.reject(new Error("Invalid deviceId: " + t));
+                }
+                /**
+                 * Get the current volume
+                 *
+                 * @return {number} value A floating point value between 0 and 1.
+                 */
+              }, {
+                key: "getVolume",
+                value: function() {
+                  return this.volume;
+                }
+                /**
+                 * Set the audio volume
+                 *
+                 * @param {number} value A floating point value between 0 and 1.
+                 */
+              }, {
+                key: "setVolume",
+                value: function(t) {
+                  this.volume = t, this.media.volume !== this.volume && (this.media.volume = this.volume);
+                }
+                /**
+                 * Enable or disable muted audio
+                 *
+                 * @since 4.0.0
+                 * @param {boolean} muted Specify `true` to mute audio.
+                 */
+              }, {
+                key: "setMute",
+                value: function(t) {
+                  this.isMuted = this.media.muted = t;
+                }
+                /**
+                 * This is called when wavesurfer is destroyed
+                 *
+                 */
+              }, {
+                key: "destroy",
+                value: function() {
+                  var t = this;
+                  this.pause(), this.unAll(), this.destroyed = !0, Object.keys(this.mediaListeners).forEach(function(s) {
+                    t.media && t.media.removeEventListener(s, t.mediaListeners[s]);
+                  }), this.params.removeMediaElementOnDestroy && this.media && this.media.parentNode && this.media.parentNode.removeChild(this.media), this.media = null;
+                }
+              }]), o;
+            }(W.default);
+            h.default = u, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/peakcache.js": (
+          /*!**************************!*\
+            !*** ./src/peakcache.js ***!
+            \**************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            function C(b) {
+              "@babel/helpers - typeof";
+              return C = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(O) {
+                return typeof O;
+              } : function(O) {
+                return O && typeof Symbol == "function" && O.constructor === Symbol && O !== Symbol.prototype ? "symbol" : typeof O;
+              }, C(b);
+            }
+            function g(b, O) {
+              if (!(b instanceof O))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function W(b, O) {
+              for (var R = 0; R < O.length; R++) {
+                var _ = O[R];
+                _.enumerable = _.enumerable || !1, _.configurable = !0, "value" in _ && (_.writable = !0), Object.defineProperty(b, M(_.key), _);
+              }
+            }
+            function E(b, O, R) {
+              return O && W(b.prototype, O), Object.defineProperty(b, "prototype", { writable: !1 }), b;
+            }
+            function M(b) {
+              var O = x(b, "string");
+              return C(O) === "symbol" ? O : String(O);
+            }
+            function x(b, O) {
+              if (C(b) !== "object" || b === null) return b;
+              var R = b[Symbol.toPrimitive];
+              if (R !== void 0) {
+                var _ = R.call(b, O);
+                if (C(_) !== "object") return _;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(b);
+            }
+            var I = /* @__PURE__ */ function() {
+              function b() {
+                g(this, b), this.clearPeakCache();
+              }
+              return E(b, [{
+                key: "clearPeakCache",
+                value: function() {
+                  this.peakCacheRanges = [], this.peakCacheLength = -1;
+                }
+                /**
+                 * Add a range of peaks to the cache
+                 *
+                 * @param {number} length The length of the range
+                 * @param {number} start The x offset of the start of the range
+                 * @param {number} end The x offset of the end of the range
+                 * @return {Number.<Array[]>} Array with arrays of numbers
+                 */
+              }, {
+                key: "addRangeToPeakCache",
+                value: function(R, _, p) {
+                  R != this.peakCacheLength && (this.clearPeakCache(), this.peakCacheLength = R);
+                  for (var c = [], v = 0; v < this.peakCacheRanges.length && this.peakCacheRanges[v] < _; )
+                    v++;
+                  for (v % 2 == 0 && c.push(_); v < this.peakCacheRanges.length && this.peakCacheRanges[v] <= p; )
+                    c.push(this.peakCacheRanges[v]), v++;
+                  v % 2 == 0 && c.push(p), c = c.filter(function(P, w, k) {
+                    return w == 0 ? P != k[w + 1] : w == k.length - 1 ? P != k[w - 1] : P != k[w - 1] && P != k[w + 1];
+                  }), this.peakCacheRanges = this.peakCacheRanges.concat(c), this.peakCacheRanges = this.peakCacheRanges.sort(function(P, w) {
+                    return P - w;
+                  }).filter(function(P, w, k) {
+                    return w == 0 ? P != k[w + 1] : w == k.length - 1 ? P != k[w - 1] : P != k[w - 1] && P != k[w + 1];
+                  });
+                  var d = [];
+                  for (v = 0; v < c.length; v += 2)
+                    d.push([c[v], c[v + 1]]);
+                  return d;
+                }
+                /**
+                 * For testing
+                 *
+                 * @return {Number.<Array[]>} Array with arrays of numbers
+                 */
+              }, {
+                key: "getCacheRanges",
+                value: function() {
+                  var R = [], _;
+                  for (_ = 0; _ < this.peakCacheRanges.length; _ += 2)
+                    R.push([this.peakCacheRanges[_], this.peakCacheRanges[_ + 1]]);
+                  return R;
+                }
+              }]), b;
+            }();
+            h.default = I, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/absMax.js": (
+          /*!****************************!*\
+            !*** ./src/util/absMax.js ***!
+            \****************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = M;
+            var g = E(C(
+              /*! ./max */
+              "./src/util/max.js"
+            )), W = E(C(
+              /*! ./min */
+              "./src/util/min.js"
+            ));
+            function E(x) {
+              return x && x.__esModule ? x : { default: x };
+            }
+            function M(x) {
+              var I = (0, g.default)(x), b = (0, W.default)(x);
+              return -b > I ? -b : I;
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/clamp.js": (
+          /*!***************************!*\
+            !*** ./src/util/clamp.js ***!
+            \***************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = C;
+            function C(g, W, E) {
+              return Math.min(Math.max(W, g), E);
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/fetch.js": (
+          /*!***************************!*\
+            !*** ./src/util/fetch.js ***!
+            \***************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = _;
+            var g = W(C(
+              /*! ./observer */
+              "./src/util/observer.js"
+            ));
+            function W(p) {
+              return p && p.__esModule ? p : { default: p };
+            }
+            function E(p) {
+              "@babel/helpers - typeof";
+              return E = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(c) {
+                return typeof c;
+              } : function(c) {
+                return c && typeof Symbol == "function" && c.constructor === Symbol && c !== Symbol.prototype ? "symbol" : typeof c;
+              }, E(p);
+            }
+            function M(p, c) {
+              if (!(p instanceof c))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function x(p, c) {
+              for (var v = 0; v < c.length; v++) {
+                var d = c[v];
+                d.enumerable = d.enumerable || !1, d.configurable = !0, "value" in d && (d.writable = !0), Object.defineProperty(p, b(d.key), d);
+              }
+            }
+            function I(p, c, v) {
+              return c && x(p.prototype, c), Object.defineProperty(p, "prototype", { writable: !1 }), p;
+            }
+            function b(p) {
+              var c = O(p, "string");
+              return E(c) === "symbol" ? c : String(c);
+            }
+            function O(p, c) {
+              if (E(p) !== "object" || p === null) return p;
+              var v = p[Symbol.toPrimitive];
+              if (v !== void 0) {
+                var d = v.call(p, c);
+                if (E(d) !== "object") return d;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(p);
+            }
+            var R = /* @__PURE__ */ function() {
+              function p(c, v, d) {
+                M(this, p), this.instance = c, this.instance._reader = d.body.getReader(), this.total = parseInt(v, 10), this.loaded = 0;
+              }
+              return I(p, [{
+                key: "start",
+                value: function(v) {
+                  var d = this, P = function w() {
+                    d.instance._reader.read().then(function(k) {
+                      var y = k.done, f = k.value;
+                      if (y) {
+                        d.total === 0 && d.instance.onProgress.call(d.instance, {
+                          loaded: d.loaded,
+                          total: d.total,
+                          lengthComputable: !1
+                        }), v.close();
+                        return;
+                      }
+                      d.loaded += f.byteLength, d.instance.onProgress.call(d.instance, {
+                        loaded: d.loaded,
+                        total: d.total,
+                        lengthComputable: d.total !== 0
+                      }), v.enqueue(f), w();
+                    }).catch(function(k) {
+                      v.error(k);
+                    });
+                  };
+                  P();
+                }
+              }]), p;
+            }();
+            function _(p) {
+              if (p) {
+                if (!p.url)
+                  throw new Error("fetch url missing");
+              } else throw new Error("fetch options missing");
+              var c = new g.default(), v = new Headers(), d = new Request(p.url);
+              c.controller = new AbortController(), p && p.requestHeaders && p.requestHeaders.forEach(function(k) {
+                v.append(k.key, k.value);
+              });
+              var P = p.responseType || "json", w = {
+                method: p.method || "GET",
+                headers: v,
+                mode: p.mode || "cors",
+                credentials: p.credentials || "same-origin",
+                cache: p.cache || "default",
+                redirect: p.redirect || "follow",
+                referrer: p.referrer || "client",
+                signal: c.controller.signal
+              };
+              return fetch(d, w).then(function(k) {
+                c.response = k;
+                var y = !0;
+                k.body || (y = !1);
+                var f = k.headers.get("content-length");
+                return f === null && (y = !1), y ? (c.onProgress = function(m) {
+                  c.fireEvent("progress", m);
+                }, new Response(new ReadableStream(new R(c, f, k)), w)) : k;
+              }).then(function(k) {
+                var y;
+                if (k.ok)
+                  switch (P) {
+                    case "arraybuffer":
+                      return k.arrayBuffer();
+                    case "json":
+                      return k.json();
+                    case "blob":
+                      return k.blob();
+                    case "text":
+                      return k.text();
+                    default:
+                      y = "Unknown responseType: " + P;
+                      break;
+                  }
+                throw y || (y = "HTTP error status: " + k.status), new Error(y);
+              }).then(function(k) {
+                c.fireEvent("success", k);
+              }).catch(function(k) {
+                c.fireEvent("error", k);
+              }), c.fetchRequest = d, c;
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/frame.js": (
+          /*!***************************!*\
+            !*** ./src/util/frame.js ***!
+            \***************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = E;
+            var g = W(C(
+              /*! ./request-animation-frame */
+              "./src/util/request-animation-frame.js"
+            ));
+            function W(M) {
+              return M && M.__esModule ? M : { default: M };
+            }
+            function E(M) {
+              return function() {
+                for (var x = arguments.length, I = new Array(x), b = 0; b < x; b++)
+                  I[b] = arguments[b];
+                return (0, g.default)(function() {
+                  return M.apply(void 0, I);
+                });
+              };
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/get-id.js": (
+          /*!****************************!*\
+            !*** ./src/util/get-id.js ***!
+            \****************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = C;
+            function C(g) {
+              return g === void 0 && (g = "wavesurfer_"), g + Math.random().toString(32).substring(2);
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/index.js": (
+          /*!***************************!*\
+            !*** ./src/util/index.js ***!
+            \***************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), Object.defineProperty(h, "Observer", {
+              enumerable: !0,
+              get: function() {
+                return x.default;
+              }
+            }), Object.defineProperty(h, "absMax", {
+              enumerable: !0,
+              get: function() {
+                return M.default;
+              }
+            }), Object.defineProperty(h, "clamp", {
+              enumerable: !0,
+              get: function() {
+                return c.default;
+              }
+            }), Object.defineProperty(h, "debounce", {
+              enumerable: !0,
+              get: function() {
+                return R.default;
+              }
+            }), Object.defineProperty(h, "fetchFile", {
+              enumerable: !0,
+              get: function() {
+                return p.default;
+              }
+            }), Object.defineProperty(h, "frame", {
+              enumerable: !0,
+              get: function() {
+                return O.default;
+              }
+            }), Object.defineProperty(h, "getId", {
+              enumerable: !0,
+              get: function() {
+                return g.default;
+              }
+            }), Object.defineProperty(h, "ignoreSilenceMode", {
+              enumerable: !0,
+              get: function() {
+                return d.default;
+              }
+            }), Object.defineProperty(h, "max", {
+              enumerable: !0,
+              get: function() {
+                return W.default;
+              }
+            }), Object.defineProperty(h, "min", {
+              enumerable: !0,
+              get: function() {
+                return E.default;
+              }
+            }), Object.defineProperty(h, "preventClick", {
+              enumerable: !0,
+              get: function() {
+                return _.default;
+              }
+            }), Object.defineProperty(h, "requestAnimationFrame", {
+              enumerable: !0,
+              get: function() {
+                return b.default;
+              }
+            }), Object.defineProperty(h, "style", {
+              enumerable: !0,
+              get: function() {
+                return I.default;
+              }
+            }), Object.defineProperty(h, "withOrientation", {
+              enumerable: !0,
+              get: function() {
+                return v.default;
+              }
+            });
+            var g = P(C(
+              /*! ./get-id */
+              "./src/util/get-id.js"
+            )), W = P(C(
+              /*! ./max */
+              "./src/util/max.js"
+            )), E = P(C(
+              /*! ./min */
+              "./src/util/min.js"
+            )), M = P(C(
+              /*! ./absMax */
+              "./src/util/absMax.js"
+            )), x = P(C(
+              /*! ./observer */
+              "./src/util/observer.js"
+            )), I = P(C(
+              /*! ./style */
+              "./src/util/style.js"
+            )), b = P(C(
+              /*! ./request-animation-frame */
+              "./src/util/request-animation-frame.js"
+            )), O = P(C(
+              /*! ./frame */
+              "./src/util/frame.js"
+            )), R = P(C(
+              /*! debounce */
+              "./node_modules/debounce/index.js"
+            )), _ = P(C(
+              /*! ./prevent-click */
+              "./src/util/prevent-click.js"
+            )), p = P(C(
+              /*! ./fetch */
+              "./src/util/fetch.js"
+            )), c = P(C(
+              /*! ./clamp */
+              "./src/util/clamp.js"
+            )), v = P(C(
+              /*! ./orientation */
+              "./src/util/orientation.js"
+            )), d = P(C(
+              /*! ./silence-mode */
+              "./src/util/silence-mode.js"
+            ));
+            function P(w) {
+              return w && w.__esModule ? w : { default: w };
+            }
+          }
+        ),
+        /***/
+        "./src/util/max.js": (
+          /*!*************************!*\
+            !*** ./src/util/max.js ***!
+            \*************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = C;
+            function C(g) {
+              var W = -1 / 0;
+              return Object.keys(g).forEach(function(E) {
+                g[E] > W && (W = g[E]);
+              }), W;
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/min.js": (
+          /*!*************************!*\
+            !*** ./src/util/min.js ***!
+            \*************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = C;
+            function C(g) {
+              var W = 1 / 0;
+              return Object.keys(g).forEach(function(E) {
+                g[E] < W && (W = g[E]);
+              }), W;
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/observer.js": (
+          /*!******************************!*\
+            !*** ./src/util/observer.js ***!
+            \******************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            function C(b) {
+              "@babel/helpers - typeof";
+              return C = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(O) {
+                return typeof O;
+              } : function(O) {
+                return O && typeof Symbol == "function" && O.constructor === Symbol && O !== Symbol.prototype ? "symbol" : typeof O;
+              }, C(b);
+            }
+            function g(b, O) {
+              if (!(b instanceof O))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function W(b, O) {
+              for (var R = 0; R < O.length; R++) {
+                var _ = O[R];
+                _.enumerable = _.enumerable || !1, _.configurable = !0, "value" in _ && (_.writable = !0), Object.defineProperty(b, M(_.key), _);
+              }
+            }
+            function E(b, O, R) {
+              return O && W(b.prototype, O), Object.defineProperty(b, "prototype", { writable: !1 }), b;
+            }
+            function M(b) {
+              var O = x(b, "string");
+              return C(O) === "symbol" ? O : String(O);
+            }
+            function x(b, O) {
+              if (C(b) !== "object" || b === null) return b;
+              var R = b[Symbol.toPrimitive];
+              if (R !== void 0) {
+                var _ = R.call(b, O);
+                if (C(_) !== "object") return _;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return String(b);
+            }
+            var I = /* @__PURE__ */ function() {
+              function b() {
+                g(this, b), this._disabledEventEmissions = [], this.handlers = null;
+              }
+              return E(b, [{
+                key: "on",
+                value: function(R, _) {
+                  var p = this;
+                  this.handlers || (this.handlers = {});
+                  var c = this.handlers[R];
+                  return c || (c = this.handlers[R] = []), c.push(_), {
+                    name: R,
+                    callback: _,
+                    un: function(d, P) {
+                      return p.un(d, P);
+                    }
+                  };
+                }
+                /**
+                 * Remove an event handler.
+                 *
+                 * @param {string} event Name of the event the listener that should be
+                 * removed listens to
+                 * @param {function} fn The callback that should be removed
+                 */
+              }, {
+                key: "un",
+                value: function(R, _) {
+                  if (this.handlers) {
+                    var p = this.handlers[R], c;
+                    if (p)
+                      if (_)
+                        for (c = p.length - 1; c >= 0; c--)
+                          p[c] == _ && p.splice(c, 1);
+                      else
+                        p.length = 0;
+                  }
+                }
+                /**
+                 * Remove all event handlers.
+                 */
+              }, {
+                key: "unAll",
+                value: function() {
+                  this.handlers = null;
+                }
+                /**
+                 * Attach a handler to an event. The handler is executed at most once per
+                 * event type.
+                 *
+                 * @param {string} event The event to listen to
+                 * @param {function} handler The callback that is only to be called once
+                 * @return {ListenerDescriptor} The event descriptor
+                 */
+              }, {
+                key: "once",
+                value: function(R, _) {
+                  var p = this, c = function v() {
+                    for (var d = arguments.length, P = new Array(d), w = 0; w < d; w++)
+                      P[w] = arguments[w];
+                    _.apply(p, P), setTimeout(function() {
+                      p.un(R, v);
+                    }, 0);
+                  };
+                  return this.on(R, c);
+                }
+                /**
+                 * Disable firing a list of events by name. When specified, event handlers for any event type
+                 * passed in here will not be called.
+                 *
+                 * @since 4.0.0
+                 * @param {string[]} eventNames an array of event names to disable emissions for
+                 * @example
+                 * // disable seek and interaction events
+                 * wavesurfer.setDisabledEventEmissions(['seek', 'interaction']);
+                 */
+              }, {
+                key: "setDisabledEventEmissions",
+                value: function(R) {
+                  this._disabledEventEmissions = R;
+                }
+                /**
+                 * plugins borrow part of this class without calling the constructor,
+                 * so we have to be careful about _disabledEventEmissions
+                 */
+              }, {
+                key: "_isDisabledEventEmission",
+                value: function(R) {
+                  return this._disabledEventEmissions && this._disabledEventEmissions.includes(R);
+                }
+                /**
+                 * Manually fire an event
+                 *
+                 * @param {string} event The event to fire manually
+                 * @param {...any} args The arguments with which to call the listeners
+                 */
+              }, {
+                key: "fireEvent",
+                value: function(R) {
+                  for (var _ = arguments.length, p = new Array(_ > 1 ? _ - 1 : 0), c = 1; c < _; c++)
+                    p[c - 1] = arguments[c];
+                  if (!(!this.handlers || this._isDisabledEventEmission(R))) {
+                    var v = this.handlers[R];
+                    v && v.forEach(function(d) {
+                      d.apply(void 0, p);
+                    });
+                  }
+                }
+              }]), b;
+            }();
+            h.default = I, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/orientation.js": (
+          /*!*********************************!*\
+            !*** ./src/util/orientation.js ***!
+            \*********************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = E;
+            var C = {
+              width: "height",
+              height: "width",
+              overflowX: "overflowY",
+              overflowY: "overflowX",
+              clientWidth: "clientHeight",
+              clientHeight: "clientWidth",
+              clientX: "clientY",
+              clientY: "clientX",
+              scrollWidth: "scrollHeight",
+              scrollLeft: "scrollTop",
+              offsetLeft: "offsetTop",
+              offsetTop: "offsetLeft",
+              offsetHeight: "offsetWidth",
+              offsetWidth: "offsetHeight",
+              left: "top",
+              right: "bottom",
+              top: "left",
+              bottom: "right",
+              borderRightStyle: "borderBottomStyle",
+              borderRightWidth: "borderBottomWidth",
+              borderRightColor: "borderBottomColor"
+            };
+            function g(M, x) {
+              return Object.prototype.hasOwnProperty.call(C, M) && x ? C[M] : M;
+            }
+            var W = Symbol("isProxy");
+            function E(M, x) {
+              return M[W] ? M : new Proxy(M, {
+                get: function(b, O, R) {
+                  if (O === W)
+                    return !0;
+                  if (O === "domElement")
+                    return b;
+                  if (O === "style")
+                    return E(b.style, x);
+                  if (O === "canvas")
+                    return E(b.canvas, x);
+                  if (O === "getBoundingClientRect")
+                    return function() {
+                      return E(b.getBoundingClientRect.apply(b, arguments), x);
+                    };
+                  if (O === "getContext")
+                    return function() {
+                      return E(b.getContext.apply(b, arguments), x);
+                    };
+                  var _ = b[g(O, x)];
+                  return typeof _ == "function" ? _.bind(b) : _;
+                },
+                set: function(b, O, R) {
+                  return b[g(O, x)] = R, !0;
+                }
+              });
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/prevent-click.js": (
+          /*!***********************************!*\
+            !*** ./src/util/prevent-click.js ***!
+            \***********************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = g;
+            function C(W) {
+              W.stopPropagation(), document.body.removeEventListener("click", C, !0);
+            }
+            function g(W) {
+              document.body.addEventListener("click", C, !0);
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/request-animation-frame.js": (
+          /*!*********************************************!*\
+            !*** ./src/util/request-animation-frame.js ***!
+            \*********************************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var C = (window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function(g, W) {
+              return setTimeout(g, 1e3 / 60);
+            }).bind(window);
+            h.default = C, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/silence-mode.js": (
+          /*!**********************************!*\
+            !*** ./src/util/silence-mode.js ***!
+            \**********************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = C;
+            function C() {
+              var g = new AudioContext(), W = g.createBufferSource();
+              W.buffer = g.createBuffer(1, 1, 44100), W.connect(g.destination), W.start();
+              var E = "data:audio/mpeg;base64,//uQxAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAACcQCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA//////////////////////////////////////////////////////////////////8AAABhTEFNRTMuMTAwA8MAAAAAAAAAABQgJAUHQQAB9AAAAnGMHkkIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//sQxAADgnABGiAAQBCqgCRMAAgEAH///////////////7+n/9FTuQsQH//////2NG0jWUGlio5gLQTOtIoeR2WX////X4s9Atb/JRVCbBUpeRUq//////////////////9RUi0f2jn/+xDECgPCjAEQAABN4AAANIAAAAQVTEFNRTMuMTAwVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVQ==", M = document.createElement("div");
+              M.innerHTML = '<audio x-webkit-airplay="deny"></audio>';
+              var x = M.children.item(0);
+              x.src = E, x.preload = "auto", x.type = "audio/mpeg", x.disableRemotePlayback = !0, x.play(), x.remove(), M.remove();
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/util/style.js": (
+          /*!***************************!*\
+            !*** ./src/util/style.js ***!
+            \***************************/
+          /***/
+          (j, h) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = C;
+            function C(g, W) {
+              return Object.keys(W).forEach(function(E) {
+                g.style[E] !== W[E] && (g.style[E] = W[E]);
+              }), g;
+            }
+            j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/wavesurfer.js": (
+          /*!***************************!*\
+            !*** ./src/wavesurfer.js ***!
+            \***************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var g = R(C(
+              /*! ./util */
+              "./src/util/index.js"
+            )), W = b(C(
+              /*! ./drawer.multicanvas */
+              "./src/drawer.multicanvas.js"
+            )), E = b(C(
+              /*! ./webaudio */
+              "./src/webaudio.js"
+            )), M = b(C(
+              /*! ./mediaelement */
+              "./src/mediaelement.js"
+            )), x = b(C(
+              /*! ./peakcache */
+              "./src/peakcache.js"
+            )), I = b(C(
+              /*! ./mediaelement-webaudio */
+              "./src/mediaelement-webaudio.js"
+            ));
+            function b(r) {
+              return r && r.__esModule ? r : { default: r };
+            }
+            function O(r) {
+              if (typeof WeakMap != "function") return null;
+              var t = /* @__PURE__ */ new WeakMap(), s = /* @__PURE__ */ new WeakMap();
+              return (O = function(e) {
+                return e ? s : t;
+              })(r);
+            }
+            function R(r, t) {
+              if (r && r.__esModule)
+                return r;
+              if (r === null || y(r) !== "object" && typeof r != "function")
+                return { default: r };
+              var s = O(t);
+              if (s && s.has(r))
+                return s.get(r);
+              var i = {}, e = Object.defineProperty && Object.getOwnPropertyDescriptor;
+              for (var l in r)
+                if (l !== "default" && Object.prototype.hasOwnProperty.call(r, l)) {
+                  var A = e ? Object.getOwnPropertyDescriptor(r, l) : null;
+                  A && (A.get || A.set) ? Object.defineProperty(i, l, A) : i[l] = r[l];
+                }
+              return i.default = r, s && s.set(r, i), i;
+            }
+            function _(r, t) {
+              if (typeof t != "function" && t !== null)
+                throw new TypeError("Super expression must either be null or a function");
+              r.prototype = Object.create(t && t.prototype, { constructor: { value: r, writable: !0, configurable: !0 } }), Object.defineProperty(r, "prototype", { writable: !1 }), t && p(r, t);
+            }
+            function p(r, t) {
+              return p = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(i, e) {
+                return i.__proto__ = e, i;
+              }, p(r, t);
+            }
+            function c(r) {
+              var t = P();
+              return function() {
+                var i = w(r), e;
+                if (t) {
+                  var l = w(this).constructor;
+                  e = Reflect.construct(i, arguments, l);
+                } else
+                  e = i.apply(this, arguments);
+                return v(this, e);
+              };
+            }
+            function v(r, t) {
+              if (t && (y(t) === "object" || typeof t == "function"))
+                return t;
+              if (t !== void 0)
+                throw new TypeError("Derived constructors may only return object or undefined");
+              return d(r);
+            }
+            function d(r) {
+              if (r === void 0)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return r;
+            }
+            function P() {
+              if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) return !1;
+              if (typeof Proxy == "function") return !0;
+              try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+              } catch {
+                return !1;
+              }
+            }
+            function w(r) {
+              return w = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(s) {
+                return s.__proto__ || Object.getPrototypeOf(s);
+              }, w(r);
+            }
+            function k(r, t, s) {
+              return t = n(t), t in r ? Object.defineProperty(r, t, { value: s, enumerable: !0, configurable: !0, writable: !0 }) : r[t] = s, r;
+            }
+            function y(r) {
+              "@babel/helpers - typeof";
+              return y = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+                return typeof t;
+              } : function(t) {
+                return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+              }, y(r);
+            }
+            function f(r, t) {
+              if (!(r instanceof t))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function m(r, t) {
+              for (var s = 0; s < t.length; s++) {
+                var i = t[s];
+                i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(r, n(i.key), i);
+              }
+            }
+            function u(r, t, s) {
+              return t && m(r.prototype, t), s && m(r, s), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+            }
+            function n(r) {
+              var t = a(r, "string");
+              return y(t) === "symbol" ? t : String(t);
+            }
+            function a(r, t) {
+              if (y(r) !== "object" || r === null) return r;
+              var s = r[Symbol.toPrimitive];
+              if (s !== void 0) {
+                var i = s.call(r, t);
+                if (y(i) !== "object") return i;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return (t === "string" ? String : Number)(r);
+            }
+            var o = /* @__PURE__ */ function(r) {
+              _(s, r);
+              var t = c(s);
+              function s(i) {
+                var e;
+                if (f(this, s), e = t.call(this), k(d(e), "defaultParams", {
+                  audioContext: null,
+                  audioScriptProcessor: null,
+                  audioRate: 1,
+                  autoCenter: !0,
+                  autoCenterRate: 5,
+                  autoCenterImmediately: !1,
+                  backend: "WebAudio",
+                  backgroundColor: null,
+                  barHeight: 1,
+                  barRadius: 0,
+                  barGap: null,
+                  barMinHeight: null,
+                  container: null,
+                  cursorColor: "#333",
+                  cursorWidth: 1,
+                  dragSelection: !0,
+                  drawingContextAttributes: {
+                    // Boolean that hints the user agent to reduce the latency
+                    // by desynchronizing the canvas paint cycle from the event
+                    // loop
+                    desynchronized: !1
+                  },
+                  duration: null,
+                  fillParent: !0,
+                  forceDecode: !1,
+                  height: 128,
+                  hideScrollbar: !1,
+                  hideCursor: !1,
+                  ignoreSilenceMode: !1,
+                  interact: !0,
+                  loopSelection: !0,
+                  maxCanvasWidth: 4e3,
+                  mediaContainer: null,
+                  mediaControls: !1,
+                  mediaType: "audio",
+                  minPxPerSec: 20,
+                  normalize: !1,
+                  partialRender: !1,
+                  pixelRatio: window.devicePixelRatio || screen.deviceXDPI / screen.logicalXDPI,
+                  plugins: [],
+                  progressColor: "#555",
+                  removeMediaElementOnDestroy: !0,
+                  renderer: W.default,
+                  responsive: !1,
+                  rtl: !1,
+                  scrollParent: !1,
+                  skipLength: 2,
+                  splitChannels: !1,
+                  splitChannelsOptions: {
+                    overlay: !1,
+                    channelColors: {},
+                    filterChannels: [],
+                    relativeNormalization: !1,
+                    splitDragSelection: !1
+                  },
+                  vertical: !1,
+                  waveColor: "#999",
+                  xhr: {}
+                }), k(d(e), "backends", {
+                  MediaElement: M.default,
+                  WebAudio: E.default,
+                  MediaElementWebAudio: I.default
+                }), k(d(e), "util", g), e.params = Object.assign({}, e.defaultParams, i), e.params.splitChannelsOptions = Object.assign({}, e.defaultParams.splitChannelsOptions, i.splitChannelsOptions), e.container = typeof i.container == "string" ? document.querySelector(e.params.container) : e.params.container, !e.container)
+                  throw new Error("Container element not found");
+                if (e.params.mediaContainer == null ? e.mediaContainer = e.container : typeof e.params.mediaContainer == "string" ? e.mediaContainer = document.querySelector(e.params.mediaContainer) : e.mediaContainer = e.params.mediaContainer, !e.mediaContainer)
+                  throw new Error("Media Container element not found");
+                if (e.params.maxCanvasWidth <= 1)
+                  throw new Error("maxCanvasWidth must be greater than 1");
+                if (e.params.maxCanvasWidth % 2 == 1)
+                  throw new Error("maxCanvasWidth must be an even number");
+                if (e.params.rtl === !0 && (e.params.vertical === !0 ? g.style(e.container, {
+                  transform: "rotateX(180deg)"
+                }) : g.style(e.container, {
+                  transform: "rotateY(180deg)"
+                })), e.params.backgroundColor && e.setBackgroundColor(e.params.backgroundColor), e.savedVolume = 0, e.isMuted = !1, e.tmpEvents = [], e.currentRequest = null, e.arraybuffer = null, e.drawer = null, e.backend = null, e.peakCache = null, typeof e.params.renderer != "function")
+                  throw new Error("Renderer parameter is invalid");
+                e.Drawer = e.params.renderer, e.params.backend == "AudioElement" && (e.params.backend = "MediaElement"), (e.params.backend == "WebAudio" || e.params.backend === "MediaElementWebAudio") && !E.default.prototype.supportsWebAudio.call(null) && (e.params.backend = "MediaElement"), e.Backend = e.backends[e.params.backend], e.initialisedPluginList = {}, e.isDestroyed = !1, e.isReady = !1;
+                var l = 0;
+                return e._onResize = g.debounce(function() {
+                  e.drawer.wrapper && l != e.drawer.wrapper.clientWidth && !e.params.scrollParent && (l = e.drawer.wrapper.clientWidth, l && e.drawer.fireEvent("redraw"));
+                }, typeof e.params.responsive == "number" ? e.params.responsive : 100), v(e, d(e));
+              }
+              return u(s, [{
+                key: "init",
+                value: function() {
+                  return this.registerPlugins(this.params.plugins), this.createDrawer(), this.createBackend(), this.createPeakCache(), this;
+                }
+                /**
+                 * Add and initialise array of plugins (if `plugin.deferInit` is falsey),
+                 * this function is called in the init function of wavesurfer
+                 *
+                 * @param {PluginDefinition[]} plugins An array of plugin definitions
+                 * @emits {WaveSurfer#plugins-registered} Called with the array of plugin definitions
+                 * @return {this} The wavesurfer instance
+                 */
+              }, {
+                key: "registerPlugins",
+                value: function(e) {
+                  var l = this;
+                  return e.forEach(function(A) {
+                    return l.addPlugin(A);
+                  }), e.forEach(function(A) {
+                    A.deferInit || l.initPlugin(A.name);
+                  }), this.fireEvent("plugins-registered", e), this;
+                }
+                /**
+                 * Get a map of plugin names that are currently initialised
+                 *
+                 * @example wavesurfer.getPlugins();
+                 * @return {Object} Object with plugin names
+                 */
+              }, {
+                key: "getActivePlugins",
+                value: function() {
+                  return this.initialisedPluginList;
+                }
+                /**
+                 * Add a plugin object to wavesurfer
+                 *
+                 * @param {PluginDefinition} plugin A plugin definition
+                 * @emits {WaveSurfer#plugin-added} Called with the name of the plugin that was added
+                 * @example wavesurfer.addPlugin(WaveSurfer.minimap());
+                 * @return {this} The wavesurfer instance
+                 */
+              }, {
+                key: "addPlugin",
+                value: function(e) {
+                  var l = this;
+                  if (!e.name)
+                    throw new Error("Plugin does not have a name!");
+                  if (!e.instance)
+                    throw new Error("Plugin ".concat(e.name, " does not have an instance property!"));
+                  e.staticProps && Object.keys(e.staticProps).forEach(function(S) {
+                    l[S] = e.staticProps[S];
+                  });
+                  var A = e.instance, T = Object.getOwnPropertyNames(g.Observer.prototype);
+                  return T.forEach(function(S) {
+                    A.prototype[S] = g.Observer.prototype[S];
+                  }), this[e.name] = new A(e.params || {}, this), this.fireEvent("plugin-added", e.name), this;
+                }
+                /**
+                 * Initialise a plugin
+                 *
+                 * @param {string} name A plugin name
+                 * @emits WaveSurfer#plugin-initialised
+                 * @example wavesurfer.initPlugin('minimap');
+                 * @return {this} The wavesurfer instance
+                 */
+              }, {
+                key: "initPlugin",
+                value: function(e) {
+                  if (!this[e])
+                    throw new Error("Plugin ".concat(e, " has not been added yet!"));
+                  return this.initialisedPluginList[e] && this.destroyPlugin(e), this[e].init(), this.initialisedPluginList[e] = !0, this.fireEvent("plugin-initialised", e), this;
+                }
+                /**
+                 * Destroy a plugin
+                 *
+                 * @param {string} name A plugin name
+                 * @emits WaveSurfer#plugin-destroyed
+                 * @example wavesurfer.destroyPlugin('minimap');
+                 * @returns {this} The wavesurfer instance
+                 */
+              }, {
+                key: "destroyPlugin",
+                value: function(e) {
+                  if (!this[e])
+                    throw new Error("Plugin ".concat(e, " has not been added yet and cannot be destroyed!"));
+                  if (!this.initialisedPluginList[e])
+                    throw new Error("Plugin ".concat(e, " is not active and cannot be destroyed!"));
+                  if (typeof this[e].destroy != "function")
+                    throw new Error("Plugin ".concat(e, " does not have a destroy function!"));
+                  return this[e].destroy(), delete this.initialisedPluginList[e], this.fireEvent("plugin-destroyed", e), this;
+                }
+                /**
+                 * Destroy all initialised plugins. Convenience function to use when
+                 * wavesurfer is removed
+                 *
+                 * @private
+                 */
+              }, {
+                key: "destroyAllPlugins",
+                value: function() {
+                  var e = this;
+                  Object.keys(this.initialisedPluginList).forEach(function(l) {
+                    return e.destroyPlugin(l);
+                  });
+                }
+                /**
+                 * Create the drawer and draw the waveform
+                 *
+                 * @private
+                 * @emits WaveSurfer#drawer-created
+                 */
+              }, {
+                key: "createDrawer",
+                value: function() {
+                  var e = this;
+                  this.drawer = new this.Drawer(this.container, this.params), this.drawer.init(), this.fireEvent("drawer-created", this.drawer), this.params.responsive !== !1 && (window.addEventListener("resize", this._onResize, !0), window.addEventListener("orientationchange", this._onResize, !0)), this.drawer.on("redraw", function() {
+                    e.drawBuffer(), e.drawer.progress(e.backend.getPlayedPercents());
+                  }), this.drawer.on("click", function(l, A) {
+                    setTimeout(function() {
+                      return e.seekTo(A);
+                    }, 0);
+                  }), this.drawer.on("scroll", function(l) {
+                    e.params.partialRender && e.drawBuffer(), e.fireEvent("scroll", l);
+                  }), this.drawer.on("dblclick", function(l, A) {
+                    e.fireEvent("dblclick", l, A);
+                  });
+                }
+                /**
+                 * Create the backend
+                 *
+                 * @private
+                 * @emits WaveSurfer#backend-created
+                 */
+              }, {
+                key: "createBackend",
+                value: function() {
+                  var e = this;
+                  this.backend && this.backend.destroy(), this.backend = new this.Backend(this.params), this.backend.init(), this.fireEvent("backend-created", this.backend), this.backend.on("finish", function() {
+                    e.drawer.progress(e.backend.getPlayedPercents()), e.fireEvent("finish");
+                  }), this.backend.on("play", function() {
+                    return e.fireEvent("play");
+                  }), this.backend.on("pause", function() {
+                    return e.fireEvent("pause");
+                  }), this.backend.on("audioprocess", function(l) {
+                    e.drawer.progress(e.backend.getPlayedPercents()), e.fireEvent("audioprocess", l);
+                  }), (this.params.backend === "MediaElement" || this.params.backend === "MediaElementWebAudio") && (this.backend.on("seek", function() {
+                    e.drawer.progress(e.backend.getPlayedPercents());
+                  }), this.backend.on("volume", function() {
+                    var l = e.getVolume();
+                    e.fireEvent("volume", l), e.backend.isMuted !== e.isMuted && (e.isMuted = e.backend.isMuted, e.fireEvent("mute", e.isMuted));
+                  }));
+                }
+                /**
+                 * Create the peak cache
+                 *
+                 * @private
+                 */
+              }, {
+                key: "createPeakCache",
+                value: function() {
+                  this.params.partialRender && (this.peakCache = new x.default());
+                }
+                /**
+                 * Get the duration of the audio clip
+                 *
+                 * @example const duration = wavesurfer.getDuration();
+                 * @return {number} Duration in seconds
+                 */
+              }, {
+                key: "getDuration",
+                value: function() {
+                  return this.backend.getDuration();
+                }
+                /**
+                 * Get the current playback position
+                 *
+                 * @example const currentTime = wavesurfer.getCurrentTime();
+                 * @return {number} Playback position in seconds
+                 */
+              }, {
+                key: "getCurrentTime",
+                value: function() {
+                  return this.backend.getCurrentTime();
+                }
+                /**
+                 * Set the current play time in seconds.
+                 *
+                 * @param {number} seconds A positive number in seconds. E.g. 10 means 10
+                 * seconds, 60 means 1 minute
+                 */
+              }, {
+                key: "setCurrentTime",
+                value: function(e) {
+                  e >= this.getDuration() ? this.seekTo(1) : this.seekTo(e / this.getDuration());
+                }
+                /**
+                 * Starts playback from the current position. Optional start and end
+                 * measured in seconds can be used to set the range of audio to play.
+                 *
+                 * @param {?number} start Position to start at
+                 * @param {?number} end Position to end at
+                 * @emits WaveSurfer#interaction
+                 * @return {Promise} Result of the backend play method
+                 * @example
+                 * // play from second 1 to 5
+                 * wavesurfer.play(1, 5);
+                 */
+              }, {
+                key: "play",
+                value: function(e, l) {
+                  var A = this;
+                  return this.params.ignoreSilenceMode && g.ignoreSilenceMode(), this.fireEvent("interaction", function() {
+                    return A.play(e, l);
+                  }), this.backend.play(e, l);
+                }
+                /**
+                 * Set a point in seconds for playback to stop at.
+                 *
+                 * @param {number} position Position (in seconds) to stop at
+                 * @version 3.3.0
+                 */
+              }, {
+                key: "setPlayEnd",
+                value: function(e) {
+                  this.backend.setPlayEnd(e);
+                }
+                /**
+                 * Stops and pauses playback
+                 *
+                 * @example wavesurfer.pause();
+                 * @return {Promise} Result of the backend pause method
+                 */
+              }, {
+                key: "pause",
+                value: function() {
+                  if (!this.backend.isPaused())
+                    return this.backend.pause();
+                }
+                /**
+                 * Toggle playback
+                 *
+                 * @example wavesurfer.playPause();
+                 * @return {Promise} Result of the backend play or pause method
+                 */
+              }, {
+                key: "playPause",
+                value: function() {
+                  return this.backend.isPaused() ? this.play() : this.pause();
+                }
+                /**
+                 * Get the current playback state
+                 *
+                 * @example const isPlaying = wavesurfer.isPlaying();
+                 * @return {boolean} False if paused, true if playing
+                 */
+              }, {
+                key: "isPlaying",
+                value: function() {
+                  return !this.backend.isPaused();
+                }
+                /**
+                 * Skip backward
+                 *
+                 * @param {?number} seconds Amount to skip back, if not specified `skipLength`
+                 * is used
+                 * @example wavesurfer.skipBackward();
+                 */
+              }, {
+                key: "skipBackward",
+                value: function(e) {
+                  this.skip(-e || -this.params.skipLength);
+                }
+                /**
+                 * Skip forward
+                 *
+                 * @param {?number} seconds Amount to skip back, if not specified `skipLength`
+                 * is used
+                 * @example wavesurfer.skipForward();
+                 */
+              }, {
+                key: "skipForward",
+                value: function(e) {
+                  this.skip(e || this.params.skipLength);
+                }
+                /**
+                 * Skip a number of seconds from the current position (use a negative value
+                 * to go backwards).
+                 *
+                 * @param {number} offset Amount to skip back or forwards
+                 * @example
+                 * // go back 2 seconds
+                 * wavesurfer.skip(-2);
+                 */
+              }, {
+                key: "skip",
+                value: function(e) {
+                  var l = this.getDuration() || 1, A = this.getCurrentTime() || 0;
+                  A = Math.max(0, Math.min(l, A + (e || 0))), this.seekAndCenter(A / l);
+                }
+                /**
+                 * Seeks to a position and centers the view
+                 *
+                 * @param {number} progress Between 0 (=beginning) and 1 (=end)
+                 * @example
+                 * // seek and go to the middle of the audio
+                 * wavesurfer.seekTo(0.5);
+                 */
+              }, {
+                key: "seekAndCenter",
+                value: function(e) {
+                  this.seekTo(e), this.drawer.recenter(e);
+                }
+                /**
+                 * Seeks to a position
+                 *
+                 * @param {number} progress Between 0 (=beginning) and 1 (=end)
+                 * @emits WaveSurfer#interaction
+                 * @emits WaveSurfer#seek
+                 * @example
+                 * // seek to the middle of the audio
+                 * wavesurfer.seekTo(0.5);
+                 */
+              }, {
+                key: "seekTo",
+                value: function(e) {
+                  var l = this;
+                  if (typeof e != "number" || !isFinite(e) || e < 0 || e > 1)
+                    throw new Error("Error calling wavesurfer.seekTo, parameter must be a number between 0 and 1!");
+                  this.fireEvent("interaction", function() {
+                    return l.seekTo(e);
+                  });
+                  var A = this.params.backend === "WebAudio", T = this.backend.isPaused();
+                  A && !T && this.backend.pause();
+                  var S = this.params.scrollParent;
+                  this.params.scrollParent = !1, this.backend.seekTo(e * this.getDuration()), this.drawer.progress(e), A && !T && this.backend.play(), this.params.scrollParent = S, this.fireEvent("seek", e);
+                }
+                /**
+                 * Stops and goes to the beginning.
+                 *
+                 * @example wavesurfer.stop();
+                 */
+              }, {
+                key: "stop",
+                value: function() {
+                  this.pause(), this.seekTo(0), this.drawer.progress(0);
+                }
+                /**
+                 * Sets the ID of the audio device to use for output and returns a Promise.
+                 *
+                 * @param {string} deviceId String value representing underlying output
+                 * device
+                 * @returns {Promise} `Promise` that resolves to `undefined` when there are
+                 * no errors detected.
+                 */
+              }, {
+                key: "setSinkId",
+                value: function(e) {
+                  return this.backend.setSinkId(e);
+                }
+                /**
+                 * Set the playback volume.
+                 *
+                 * @param {number} newVolume A value between 0 and 1, 0 being no
+                 * volume and 1 being full volume.
+                 * @emits WaveSurfer#volume
+                 */
+              }, {
+                key: "setVolume",
+                value: function(e) {
+                  if (this.isMuted === !0) {
+                    this.savedVolume = e;
+                    return;
+                  }
+                  this.backend.setVolume(e), this.fireEvent("volume", e);
+                }
+                /**
+                 * Get the playback volume.
+                 *
+                 * @return {number} A value between 0 and 1, 0 being no
+                 * volume and 1 being full volume.
+                 */
+              }, {
+                key: "getVolume",
+                value: function() {
+                  return this.backend.getVolume();
+                }
+                /**
+                 * Set the playback rate.
+                 *
+                 * @param {number} rate A positive number. E.g. 0.5 means half the normal
+                 * speed, 2 means double speed and so on.
+                 * @example wavesurfer.setPlaybackRate(2);
+                 */
+              }, {
+                key: "setPlaybackRate",
+                value: function(e) {
+                  this.backend.setPlaybackRate(e);
+                }
+                /**
+                 * Get the playback rate.
+                 *
+                 * @return {number} The current playback rate.
+                 */
+              }, {
+                key: "getPlaybackRate",
+                value: function() {
+                  return this.backend.getPlaybackRate();
+                }
+                /**
+                 * Toggle the volume on and off. If not currently muted it will save the
+                 * current volume value and turn the volume off. If currently muted then it
+                 * will restore the volume to the saved value, and then rest the saved
+                 * value.
+                 *
+                 * @example wavesurfer.toggleMute();
+                 */
+              }, {
+                key: "toggleMute",
+                value: function() {
+                  this.setMute(!this.isMuted);
+                }
+                /**
+                 * Enable or disable muted audio
+                 *
+                 * @param {boolean} mute Specify `true` to mute audio.
+                 * @emits WaveSurfer#volume
+                 * @emits WaveSurfer#mute
+                 * @example
+                 * // unmute
+                 * wavesurfer.setMute(false);
+                 * console.log(wavesurfer.getMute()) // logs false
+                 */
+              }, {
+                key: "setMute",
+                value: function(e) {
+                  if (e === this.isMuted) {
+                    this.fireEvent("mute", this.isMuted);
+                    return;
+                  }
+                  this.backend.setMute ? (this.backend.setMute(e), this.isMuted = e) : e ? (this.savedVolume = this.backend.getVolume(), this.backend.setVolume(0), this.isMuted = !0, this.fireEvent("volume", 0)) : (this.backend.setVolume(this.savedVolume), this.isMuted = !1, this.fireEvent("volume", this.savedVolume)), this.fireEvent("mute", this.isMuted);
+                }
+                /**
+                 * Get the current mute status.
+                 *
+                 * @example const isMuted = wavesurfer.getMute();
+                 * @return {boolean} Current mute status
+                 */
+              }, {
+                key: "getMute",
+                value: function() {
+                  return this.isMuted;
+                }
+                /**
+                 * Get the list of current set filters as an array.
+                 *
+                 * Filters must be set with setFilters method first
+                 *
+                 * @return {array} List of enabled filters
+                 */
+              }, {
+                key: "getFilters",
+                value: function() {
+                  return this.backend.filters || [];
+                }
+                /**
+                 * Toggles `scrollParent` and redraws
+                 *
+                 * @example wavesurfer.toggleScroll();
+                 */
+              }, {
+                key: "toggleScroll",
+                value: function() {
+                  this.params.scrollParent = !this.params.scrollParent, this.drawBuffer();
+                }
+                /**
+                 * Toggle mouse interaction
+                 *
+                 * @example wavesurfer.toggleInteraction();
+                 */
+              }, {
+                key: "toggleInteraction",
+                value: function() {
+                  this.params.interact = !this.params.interact;
+                }
+                /**
+                 * Get the fill color of the waveform after the cursor.
+                 *
+                 * @param {?number} channelIdx Optional index of the channel to get its wave color if splitChannels is true
+                 * @return {string|object} A CSS color string, or an array of CSS color strings.
+                 */
+              }, {
+                key: "getWaveColor",
+                value: function() {
+                  var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+                  return this.params.splitChannelsOptions.channelColors[e] ? this.params.splitChannelsOptions.channelColors[e].waveColor : this.params.waveColor;
+                }
+                /**
+                 * Set the fill color of the waveform after the cursor.
+                 *
+                 * @param {string|object} color A CSS color string, or an array of CSS color strings.
+                 * @param {?number} channelIdx Optional index of the channel to set its wave color if splitChannels is true
+                 * @example wavesurfer.setWaveColor('#ddd');
+                 */
+              }, {
+                key: "setWaveColor",
+                value: function(e) {
+                  var l = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                  this.params.splitChannelsOptions.channelColors[l] ? this.params.splitChannelsOptions.channelColors[l].waveColor = e : this.params.waveColor = e, this.drawBuffer();
+                }
+                /**
+                 * Get the fill color of the waveform behind the cursor.
+                 *
+                 * @param {?number} channelIdx Optional index of the channel to get its progress color if splitChannels is true
+                 * @return {string|object} A CSS color string, or an array of CSS color strings.
+                 */
+              }, {
+                key: "getProgressColor",
+                value: function() {
+                  var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+                  return this.params.splitChannelsOptions.channelColors[e] ? this.params.splitChannelsOptions.channelColors[e].progressColor : this.params.progressColor;
+                }
+                /**
+                 * Set the fill color of the waveform behind the cursor.
+                 *
+                 * @param {string|object} color A CSS color string, or an array of CSS color strings.
+                 * @param {?number} channelIdx Optional index of the channel to set its progress color if splitChannels is true
+                 * @example wavesurfer.setProgressColor('#400');
+                 */
+              }, {
+                key: "setProgressColor",
+                value: function(e, l) {
+                  this.params.splitChannelsOptions.channelColors[l] ? this.params.splitChannelsOptions.channelColors[l].progressColor = e : this.params.progressColor = e, this.drawBuffer();
+                }
+                /**
+                 * Get the background color of the waveform container.
+                 *
+                 * @return {string} A CSS color string.
+                 */
+              }, {
+                key: "getBackgroundColor",
+                value: function() {
+                  return this.params.backgroundColor;
+                }
+                /**
+                 * Set the background color of the waveform container.
+                 *
+                 * @param {string} color A CSS color string.
+                 * @example wavesurfer.setBackgroundColor('#FF00FF');
+                 */
+              }, {
+                key: "setBackgroundColor",
+                value: function(e) {
+                  this.params.backgroundColor = e, g.style(this.container, {
+                    background: this.params.backgroundColor
+                  });
+                }
+                /**
+                 * Get the fill color of the cursor indicating the playhead
+                 * position.
+                 *
+                 * @return {string} A CSS color string.
+                 */
+              }, {
+                key: "getCursorColor",
+                value: function() {
+                  return this.params.cursorColor;
+                }
+                /**
+                 * Set the fill color of the cursor indicating the playhead
+                 * position.
+                 *
+                 * @param {string} color A CSS color string.
+                 * @example wavesurfer.setCursorColor('#222');
+                 */
+              }, {
+                key: "setCursorColor",
+                value: function(e) {
+                  this.params.cursorColor = e, this.drawer.updateCursor();
+                }
+                /**
+                 * Get the height of the waveform.
+                 *
+                 * @return {number} Height measured in pixels.
+                 */
+              }, {
+                key: "getHeight",
+                value: function() {
+                  return this.params.height;
+                }
+                /**
+                 * Set the height of the waveform.
+                 *
+                 * @param {number} height Height measured in pixels.
+                 * @example wavesurfer.setHeight(200);
+                 */
+              }, {
+                key: "setHeight",
+                value: function(e) {
+                  this.params.height = e, this.drawer.setHeight(e * this.params.pixelRatio), this.drawBuffer();
+                }
+                /**
+                 * Hide channels from being drawn on the waveform if splitting channels.
+                 *
+                 * For example, if we want to draw only the peaks for the right stereo channel:
+                 *
+                 * const wavesurfer = new WaveSurfer.create({...splitChannels: true});
+                 * wavesurfer.load('stereo_audio.mp3');
+                 *
+                 * wavesurfer.setFilteredChannel([0]); <-- hide left channel peaks.
+                 *
+                 * @param {array} channelIndices Channels to be filtered out from drawing.
+                 * @version 4.0.0
+                 */
+              }, {
+                key: "setFilteredChannels",
+                value: function(e) {
+                  this.params.splitChannelsOptions.filterChannels = e, this.drawBuffer();
+                }
+                /**
+                 * Get the correct peaks for current wave view-port and render wave
+                 *
+                 * @private
+                 * @emits WaveSurfer#redraw
+                 */
+              }, {
+                key: "drawBuffer",
+                value: function() {
+                  var e = Math.round(this.getDuration() * this.params.minPxPerSec * this.params.pixelRatio), l = this.drawer.getWidth(), A = e, T = 0, S = Math.max(T + l, A);
+                  this.params.fillParent && (!this.params.scrollParent || e < l) && (A = l, T = 0, S = A);
+                  var D;
+                  if (this.params.partialRender) {
+                    var B = this.peakCache.addRangeToPeakCache(A, T, S), V;
+                    for (V = 0; V < B.length; V++)
+                      D = this.backend.getPeaks(A, B[V][0], B[V][1]), this.drawer.drawPeaks(D, A, B[V][0], B[V][1]);
+                  } else
+                    D = this.backend.getPeaks(A, T, S), this.drawer.drawPeaks(D, A, T, S);
+                  this.fireEvent("redraw", D, A);
+                }
+                /**
+                 * Horizontally zooms the waveform in and out. It also changes the parameter
+                 * `minPxPerSec` and enables the `scrollParent` option. Calling the function
+                 * with a falsey parameter will reset the zoom state.
+                 *
+                 * @param {?number} pxPerSec Number of horizontal pixels per second of
+                 * audio, if none is set the waveform returns to unzoomed state
+                 * @emits WaveSurfer#zoom
+                 * @example wavesurfer.zoom(20);
+                 */
+              }, {
+                key: "zoom",
+                value: function(e) {
+                  e ? (this.params.minPxPerSec = e, this.params.scrollParent = !0) : (this.params.minPxPerSec = this.defaultParams.minPxPerSec, this.params.scrollParent = !1), this.drawBuffer(), this.drawer.progress(this.backend.getPlayedPercents()), this.drawer.recenter(this.getCurrentTime() / this.getDuration()), this.fireEvent("zoom", e);
+                }
+                /**
+                 * Decode buffer and load
+                 *
+                 * @private
+                 * @param {ArrayBuffer} arraybuffer Buffer to process
+                 */
+              }, {
+                key: "loadArrayBuffer",
+                value: function(e) {
+                  var l = this;
+                  this.decodeArrayBuffer(e, function(A) {
+                    l.isDestroyed || l.loadDecodedBuffer(A);
+                  });
+                }
+                /**
+                 * Directly load an externally decoded AudioBuffer
+                 *
+                 * @private
+                 * @param {AudioBuffer} buffer Buffer to process
+                 * @emits WaveSurfer#ready
+                 */
+              }, {
+                key: "loadDecodedBuffer",
+                value: function(e) {
+                  this.backend.load(e), this.drawBuffer(), this.isReady = !0, this.fireEvent("ready");
+                }
+                /**
+                 * Loads audio data from a Blob or File object
+                 *
+                 * @param {Blob|File} blob Audio data
+                 * @example
+                 */
+              }, {
+                key: "loadBlob",
+                value: function(e) {
+                  var l = this, A = new FileReader();
+                  A.addEventListener("progress", function(T) {
+                    return l.onProgress(T);
+                  }), A.addEventListener("load", function(T) {
+                    return l.loadArrayBuffer(T.target.result);
+                  }), A.addEventListener("error", function() {
+                    return l.fireEvent("error", "Error reading file");
+                  }), A.readAsArrayBuffer(e), this.empty();
+                }
+                /**
+                 * Loads audio and re-renders the waveform.
+                 *
+                 * @param {string|HTMLMediaElement} url The url of the audio file or the
+                 * audio element with the audio
+                 * @param {number[]|Number.<Array[]>} peaks Wavesurfer does not have to decode
+                 * the audio to render the waveform if this is specified
+                 * @param {?string} preload (Use with backend `MediaElement` and `MediaElementWebAudio`)
+                 * `'none'|'metadata'|'auto'` Preload attribute for the media element
+                 * @param {?number} duration The duration of the audio. This is used to
+                 * render the peaks data in the correct size for the audio duration (as
+                 * befits the current `minPxPerSec` and zoom value) without having to decode
+                 * the audio.
+                 * @returns {void}
+                 * @throws Will throw an error if the `url` argument is empty.
+                 * @example
+                 * // uses fetch or media element to load file (depending on backend)
+                 * wavesurfer.load('http://example.com/demo.wav');
+                 *
+                 * // setting preload attribute with media element backend and supplying
+                 * // peaks
+                 * wavesurfer.load(
+                 *   'http://example.com/demo.wav',
+                 *   [0.0218, 0.0183, 0.0165, 0.0198, 0.2137, 0.2888],
+                 *   true
+                 * );
+                 */
+              }, {
+                key: "load",
+                value: function(e, l, A, T) {
+                  if (!e)
+                    throw new Error("url parameter cannot be empty");
+                  if (this.empty(), A) {
+                    var S = {
+                      "Preload is not 'auto', 'none' or 'metadata'": ["auto", "metadata", "none"].indexOf(A) === -1,
+                      "Peaks are not provided": !l,
+                      "Backend is not of type 'MediaElement' or 'MediaElementWebAudio'": ["MediaElement", "MediaElementWebAudio"].indexOf(this.params.backend) === -1,
+                      "Url is not of type string": typeof e != "string"
+                    }, D = Object.keys(S).filter(function(B) {
+                      return S[B];
+                    });
+                    D.length && (console.warn(`Preload parameter of wavesurfer.load will be ignored because:
+	- ` + D.join(`
+	- `)), A = null);
+                  }
+                  switch (this.params.backend === "WebAudio" && e instanceof HTMLMediaElement && (e = e.src), this.params.backend) {
+                    case "WebAudio":
+                      return this.loadBuffer(e, l, T);
+                    case "MediaElement":
+                    case "MediaElementWebAudio":
+                      return this.loadMediaElement(e, l, A, T);
+                  }
+                }
+                /**
+                 * Loads audio using Web Audio buffer backend.
+                 *
+                 * @private
+                 * @emits WaveSurfer#waveform-ready
+                 * @param {string} url URL of audio file
+                 * @param {number[]|Number.<Array[]>} peaks Peaks data
+                 * @param {?number} duration Optional duration of audio file
+                 * @returns {void}
+                 */
+              }, {
+                key: "loadBuffer",
+                value: function(e, l, A) {
+                  var T = this, S = function(B) {
+                    return B && T.tmpEvents.push(T.once("ready", B)), T.getArrayBuffer(e, function(V) {
+                      return T.loadArrayBuffer(V);
+                    });
+                  };
+                  if (l)
+                    this.backend.setPeaks(l, A), this.drawBuffer(), this.fireEvent("waveform-ready"), this.tmpEvents.push(this.once("interaction", S));
+                  else
+                    return S();
+                }
+                /**
+                 * Either create a media element, or load an existing media element.
+                 *
+                 * @private
+                 * @emits WaveSurfer#waveform-ready
+                 * @param {string|HTMLMediaElement} urlOrElt Either a path to a media file, or an
+                 * existing HTML5 Audio/Video Element
+                 * @param {number[]|Number.<Array[]>} peaks Array of peaks. Required to bypass web audio
+                 * dependency
+                 * @param {?boolean} preload Set to true if the preload attribute of the
+                 * audio element should be enabled
+                 * @param {?number} duration Optional duration of audio file
+                 */
+              }, {
+                key: "loadMediaElement",
+                value: function(e, l, A, T) {
+                  var S = this, D = e;
+                  if (typeof e == "string")
+                    this.backend.load(D, this.mediaContainer, l, A);
+                  else {
+                    var B = e;
+                    this.backend.loadElt(B, l), D = B.src;
+                  }
+                  this.tmpEvents.push(this.backend.once("canplay", function() {
+                    S.backend.destroyed || (S.drawBuffer(), S.isReady = !0, S.fireEvent("ready"));
+                  }), this.backend.once("error", function(V) {
+                    return S.fireEvent("error", V);
+                  })), l && (this.backend.setPeaks(l, T), this.drawBuffer(), this.fireEvent("waveform-ready")), (!l || this.params.forceDecode) && this.backend.supportsWebAudio() && this.getArrayBuffer(D, function(V) {
+                    S.decodeArrayBuffer(V, function(N) {
+                      S.backend.buffer = N, S.backend.setPeaks(null), S.drawBuffer(), S.fireEvent("waveform-ready");
+                    });
+                  });
+                }
+                /**
+                 * Decode an array buffer and pass data to a callback
+                 *
+                 * @private
+                 * @param {Object} arraybuffer The array buffer to decode
+                 * @param {function} callback The function to call on complete
+                 */
+              }, {
+                key: "decodeArrayBuffer",
+                value: function(e, l) {
+                  var A = this;
+                  this.isDestroyed || (this.arraybuffer = e, this.backend.decodeArrayBuffer(e, function(T) {
+                    !A.isDestroyed && A.arraybuffer == e && (l(T), A.arraybuffer = null);
+                  }, function() {
+                    return A.fireEvent("error", "Error decoding audiobuffer");
+                  }));
+                }
+                /**
+                 * Load an array buffer using fetch and pass the result to a callback
+                 *
+                 * @param {string} url The URL of the file object
+                 * @param {function} callback The function to call on complete
+                 * @returns {util.fetchFile} fetch call
+                 * @private
+                 */
+              }, {
+                key: "getArrayBuffer",
+                value: function(e, l) {
+                  var A = this, T = Object.assign({
+                    url: e,
+                    responseType: "arraybuffer"
+                  }, this.params.xhr), S = g.fetchFile(T);
+                  return this.currentRequest = S, this.tmpEvents.push(S.on("progress", function(D) {
+                    A.onProgress(D);
+                  }), S.on("success", function(D) {
+                    l(D), A.currentRequest = null;
+                  }), S.on("error", function(D) {
+                    A.fireEvent("error", D), A.currentRequest = null;
+                  })), S;
+                }
+                /**
+                 * Called while the audio file is loading
+                 *
+                 * @private
+                 * @param {Event} e Progress event
+                 * @emits WaveSurfer#loading
+                 */
+              }, {
+                key: "onProgress",
+                value: function(e) {
+                  var l;
+                  e.lengthComputable ? l = e.loaded / e.total : l = e.loaded / (e.loaded + 1e6), this.fireEvent("loading", Math.round(l * 100), e.target);
+                }
+                /**
+                 * Exports PCM data into a JSON array and optionally opens in a new window
+                 * as valid JSON Blob instance.
+                 *
+                 * @param {number} length=1024 The scale in which to export the peaks
+                 * @param {number} accuracy=10000
+                 * @param {?boolean} noWindow Set to true to disable opening a new
+                 * window with the JSON
+                 * @param {number} start Start index
+                 * @param {number} end End index
+                 * @return {Promise} Promise that resolves with array of peaks
+                 */
+              }, {
+                key: "exportPCM",
+                value: function(e, l, A, T, S) {
+                  e = e || 1024, T = T || 0, l = l || 1e4, A = A || !1;
+                  var D = this.backend.getPeaks(e, T, S), B = [].map.call(D, function(V) {
+                    return Math.round(V * l) / l;
+                  });
+                  return new Promise(function(V, N) {
+                    if (!A) {
+                      var H = new Blob([JSON.stringify(B)], {
+                        type: "application/json;charset=utf-8"
+                      }), L = URL.createObjectURL(H);
+                      window.open(L), URL.revokeObjectURL(L);
+                    }
+                    V(B);
+                  });
+                }
+                /**
+                 * Save waveform image as data URI.
+                 *
+                 * The default format is `image/png`. Other supported types are
+                 * `image/jpeg` and `image/webp`.
+                 *
+                 * @param {string} format='image/png' A string indicating the image format.
+                 * The default format type is `image/png`.
+                 * @param {number} quality=1 A number between 0 and 1 indicating the image
+                 * quality to use for image formats that use lossy compression such as
+                 * `image/jpeg` and `image/webp`.
+                 * @param {string} type Image data type to return. Either `dataURL` (default)
+                 * or `blob`.
+                 * @return {string|string[]|Promise} When using `dataURL` type this returns
+                 * a single data URL or an array of data URLs, one for each canvas. When using
+                 * `blob` type this returns a `Promise` resolving with an array of `Blob`
+                 * instances, one for each canvas.
+                 */
+              }, {
+                key: "exportImage",
+                value: function(e, l, A) {
+                  return e || (e = "image/png"), l || (l = 1), A || (A = "dataURL"), this.drawer.getImage(e, l, A);
+                }
+                /**
+                 * Cancel any fetch request currently in progress
+                 */
+              }, {
+                key: "cancelAjax",
+                value: function() {
+                  this.currentRequest && this.currentRequest.controller && (this.currentRequest._reader && this.currentRequest._reader.cancel().catch(function(e) {
+                  }), this.currentRequest.controller.abort(), this.currentRequest = null);
+                }
+                /**
+                 * @private
+                 */
+              }, {
+                key: "clearTmpEvents",
+                value: function() {
+                  this.tmpEvents.forEach(function(e) {
+                    return e.un();
+                  });
+                }
+                /**
+                 * Display empty waveform.
+                 */
+              }, {
+                key: "empty",
+                value: function() {
+                  this.backend.isPaused() || (this.stop(), this.backend.disconnectSource()), this.isReady = !1, this.cancelAjax(), this.clearTmpEvents(), this.drawer.progress(0), this.drawer.setWidth(0), this.drawer.drawPeaks({
+                    length: this.drawer.getWidth()
+                  }, 0);
+                }
+                /**
+                 * Remove events, elements and disconnect WebAudio nodes.
+                 *
+                 * @emits WaveSurfer#destroy
+                 */
+              }, {
+                key: "destroy",
+                value: function() {
+                  this.destroyAllPlugins(), this.fireEvent("destroy"), this.cancelAjax(), this.clearTmpEvents(), this.unAll(), this.params.responsive !== !1 && (window.removeEventListener("resize", this._onResize, !0), window.removeEventListener("orientationchange", this._onResize, !0)), this.backend && (this.backend.destroy(), this.backend = null), this.drawer && this.drawer.destroy(), this.isDestroyed = !0, this.isReady = !1, this.arraybuffer = null;
+                }
+              }], [{
+                key: "create",
+                value: (
+                  /**
+                   * Instantiate this class, call its `init` function and returns it
+                   *
+                   * @param {WavesurferParams} params The wavesurfer parameters
+                   * @return {Object} WaveSurfer instance
+                   * @example const wavesurfer = WaveSurfer.create(params);
+                   */
+                  function(e) {
+                    var l = new s(e);
+                    return l.init();
+                  }
+                )
+                /**
+                 * The library version number is available as a static property of the
+                 * WaveSurfer class
+                 *
+                 * @type {String}
+                 * @example
+                 * console.log('Using wavesurfer.js ' + WaveSurfer.VERSION);
+                 */
+              }]), s;
+            }(g.Observer);
+            h.default = o, k(o, "VERSION", "6.6.4"), k(o, "util", g), j.exports = h.default;
+          }
+        ),
+        /***/
+        "./src/webaudio.js": (
+          /*!*************************!*\
+            !*** ./src/webaudio.js ***!
+            \*************************/
+          /***/
+          (j, h, C) => {
+            Object.defineProperty(h, "__esModule", {
+              value: !0
+            }), h.default = void 0;
+            var g = E(C(
+              /*! ./util */
+              "./src/util/index.js"
+            ));
+            function W(n) {
+              if (typeof WeakMap != "function") return null;
+              var a = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap();
+              return (W = function(t) {
+                return t ? o : a;
+              })(n);
+            }
+            function E(n, a) {
+              if (n && n.__esModule)
+                return n;
+              if (n === null || M(n) !== "object" && typeof n != "function")
+                return { default: n };
+              var o = W(a);
+              if (o && o.has(n))
+                return o.get(n);
+              var r = {}, t = Object.defineProperty && Object.getOwnPropertyDescriptor;
+              for (var s in n)
+                if (s !== "default" && Object.prototype.hasOwnProperty.call(n, s)) {
+                  var i = t ? Object.getOwnPropertyDescriptor(n, s) : null;
+                  i && (i.get || i.set) ? Object.defineProperty(r, s, i) : r[s] = n[s];
+                }
+              return r.default = n, o && o.set(n, r), r;
+            }
+            function M(n) {
+              "@babel/helpers - typeof";
+              return M = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(a) {
+                return typeof a;
+              } : function(a) {
+                return a && typeof Symbol == "function" && a.constructor === Symbol && a !== Symbol.prototype ? "symbol" : typeof a;
+              }, M(n);
+            }
+            function x(n, a) {
+              if (!(n instanceof a))
+                throw new TypeError("Cannot call a class as a function");
+            }
+            function I(n, a) {
+              for (var o = 0; o < a.length; o++) {
+                var r = a[o];
+                r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(n, w(r.key), r);
+              }
+            }
+            function b(n, a, o) {
+              return a && I(n.prototype, a), Object.defineProperty(n, "prototype", { writable: !1 }), n;
+            }
+            function O(n, a) {
+              if (typeof a != "function" && a !== null)
+                throw new TypeError("Super expression must either be null or a function");
+              n.prototype = Object.create(a && a.prototype, { constructor: { value: n, writable: !0, configurable: !0 } }), Object.defineProperty(n, "prototype", { writable: !1 }), a && R(n, a);
+            }
+            function R(n, a) {
+              return R = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, t) {
+                return r.__proto__ = t, r;
+              }, R(n, a);
+            }
+            function _(n) {
+              var a = v();
+              return function() {
+                var r = d(n), t;
+                if (a) {
+                  var s = d(this).constructor;
+                  t = Reflect.construct(r, arguments, s);
+                } else
+                  t = r.apply(this, arguments);
+                return p(this, t);
+              };
+            }
+            function p(n, a) {
+              if (a && (M(a) === "object" || typeof a == "function"))
+                return a;
+              if (a !== void 0)
+                throw new TypeError("Derived constructors may only return object or undefined");
+              return c(n);
+            }
+            function c(n) {
+              if (n === void 0)
+                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+              return n;
+            }
+            function v() {
+              if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) return !1;
+              if (typeof Proxy == "function") return !0;
+              try {
+                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+                })), !0;
+              } catch {
+                return !1;
+              }
+            }
+            function d(n) {
+              return d = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+                return o.__proto__ || Object.getPrototypeOf(o);
+              }, d(n);
+            }
+            function P(n, a, o) {
+              return a = w(a), a in n ? Object.defineProperty(n, a, { value: o, enumerable: !0, configurable: !0, writable: !0 }) : n[a] = o, n;
+            }
+            function w(n) {
+              var a = k(n, "string");
+              return M(a) === "symbol" ? a : String(a);
+            }
+            function k(n, a) {
+              if (M(n) !== "object" || n === null) return n;
+              var o = n[Symbol.toPrimitive];
+              if (o !== void 0) {
+                var r = o.call(n, a);
+                if (M(r) !== "object") return r;
+                throw new TypeError("@@toPrimitive must return a primitive value.");
+              }
+              return (a === "string" ? String : Number)(n);
+            }
+            var y = "playing", f = "paused", m = "finished", u = /* @__PURE__ */ function(n) {
+              O(o, n);
+              var a = _(o);
+              function o(r) {
+                var t, s, i;
+                return x(this, o), i = a.call(this), P(c(i), "audioContext", null), P(c(i), "stateBehaviors", (t = {}, P(t, y, {
+                  init: function() {
+                    this.addOnAudioProcess();
+                  },
+                  getPlayedPercents: function() {
+                    var l = this.getDuration();
+                    return this.getCurrentTime() / l || 0;
+                  },
+                  getCurrentTime: function() {
+                    return this.startPosition + this.getPlayedTime();
+                  }
+                }), P(t, f, {
+                  init: function() {
+                  },
+                  getPlayedPercents: function() {
+                    var l = this.getDuration();
+                    return this.getCurrentTime() / l || 0;
+                  },
+                  getCurrentTime: function() {
+                    return this.startPosition;
+                  }
+                }), P(t, m, {
+                  init: function() {
+                    this.fireEvent("finish");
+                  },
+                  getPlayedPercents: function() {
+                    return 1;
+                  },
+                  getCurrentTime: function() {
+                    return this.getDuration();
+                  }
+                }), t)), i.params = r, i.ac = r.audioContext || (i.supportsWebAudio() ? i.getAudioContext() : {}), i.lastPlay = i.ac.currentTime, i.startPosition = 0, i.scheduledPause = null, i.states = (s = {}, P(s, y, Object.create(i.stateBehaviors[y])), P(s, f, Object.create(i.stateBehaviors[f])), P(s, m, Object.create(i.stateBehaviors[m])), s), i.buffer = null, i.filters = [], i.gainNode = null, i.mergedPeaks = null, i.offlineAc = null, i.peaks = null, i.playbackRate = 1, i.analyser = null, i.scriptNode = null, i.source = null, i.splitPeaks = [], i.state = null, i.explicitDuration = r.duration, i.sinkStreamDestination = null, i.sinkAudioElement = null, i.destroyed = !1, i;
+              }
+              return b(o, [{
+                key: "supportsWebAudio",
+                value: (
+                  /**
+                   * Does the browser support this backend
+                   *
+                   * @return {boolean} Whether or not this browser supports this backend
+                   */
+                  function() {
+                    return !!(window.AudioContext || window.webkitAudioContext);
+                  }
+                )
+                /**
+                 * Get the audio context used by this backend or create one
+                 *
+                 * @return {AudioContext} Existing audio context, or creates a new one
+                 */
+              }, {
+                key: "getAudioContext",
+                value: function() {
+                  return window.WaveSurferAudioContext || (window.WaveSurferAudioContext = new (window.AudioContext || window.webkitAudioContext)()), window.WaveSurferAudioContext;
+                }
+                /**
+                 * Get the offline audio context used by this backend or create one
+                 *
+                 * @param {number} sampleRate The sample rate to use
+                 * @return {OfflineAudioContext} Existing offline audio context, or creates
+                 * a new one
+                 */
+              }, {
+                key: "getOfflineAudioContext",
+                value: function(t) {
+                  return window.WaveSurferOfflineAudioContext || (window.WaveSurferOfflineAudioContext = new (window.OfflineAudioContext || window.webkitOfflineAudioContext)(1, 2, t)), window.WaveSurferOfflineAudioContext;
+                }
+              }, {
+                key: "init",
+                value: function() {
+                  this.createVolumeNode(), this.createScriptNode(), this.createAnalyserNode(), this.setState(f), this.setPlaybackRate(this.params.audioRate), this.setLength(0);
+                }
+                /** @private */
+              }, {
+                key: "disconnectFilters",
+                value: function() {
+                  this.filters && (this.filters.forEach(function(t) {
+                    t && t.disconnect();
+                  }), this.filters = null, this.analyser.connect(this.gainNode));
+                }
+                /**
+                 * @private
+                 *
+                 * @param {string} state The new state
+                 */
+              }, {
+                key: "setState",
+                value: function(t) {
+                  this.state !== this.states[t] && (this.state = this.states[t], this.state.init.call(this));
+                }
+                /**
+                 * Unpacked `setFilters()`
+                 *
+                 * @param {...AudioNode} filters One or more filters to set
+                 */
+              }, {
+                key: "setFilter",
+                value: function() {
+                  for (var t = arguments.length, s = new Array(t), i = 0; i < t; i++)
+                    s[i] = arguments[i];
+                  this.setFilters(s);
+                }
+                /**
+                 * Insert custom Web Audio nodes into the graph
+                 *
+                 * @param {AudioNode[]} filters Packed filters array
+                 * @example
+                 * const lowpass = wavesurfer.backend.ac.createBiquadFilter();
+                 * wavesurfer.backend.setFilter(lowpass);
+                 */
+              }, {
+                key: "setFilters",
+                value: function(t) {
+                  this.disconnectFilters(), t && t.length && (this.filters = t, this.analyser.disconnect(), t.reduce(function(s, i) {
+                    return s.connect(i), i;
+                  }, this.analyser).connect(this.gainNode));
+                }
+                /** Create ScriptProcessorNode to process audio */
+              }, {
+                key: "createScriptNode",
+                value: function() {
+                  this.params.audioScriptProcessor && (this.scriptNode = this.params.audioScriptProcessor, this.scriptNode.connect(this.ac.destination));
+                }
+                /** @private */
+              }, {
+                key: "addOnAudioProcess",
+                value: function() {
+                  var t = this, s = function i() {
+                    var e = t.getCurrentTime();
+                    e >= t.getDuration() && t.state !== t.states[m] ? (t.setState(m), t.fireEvent("pause")) : e >= t.scheduledPause && t.state !== t.states[f] ? t.pause() : t.state === t.states[y] && (t.fireEvent("audioprocess", e), g.frame(i)());
+                  };
+                  s();
+                }
+                /** Create analyser node to perform audio analysis */
+              }, {
+                key: "createAnalyserNode",
+                value: function() {
+                  this.analyser = this.ac.createAnalyser(), this.analyser.connect(this.gainNode);
+                }
+                /**
+                 * Create the gain node needed to control the playback volume.
+                 *
+                 */
+              }, {
+                key: "createVolumeNode",
+                value: function() {
+                  this.ac.createGain ? this.gainNode = this.ac.createGain() : this.gainNode = this.ac.createGainNode(), this.gainNode.connect(this.ac.destination);
+                }
+                /**
+                 * Set the sink id for the media player
+                 *
+                 * @param {string} deviceId String value representing audio device id.
+                 * @returns {Promise} A Promise that resolves to `undefined` when there
+                 * are no errors.
+                 */
+              }, {
+                key: "setSinkId",
+                value: function(t) {
+                  return t ? (this.sinkAudioElement || (this.sinkAudioElement = new window.Audio(), this.sinkAudioElement.autoplay = !0), this.sinkAudioElement.setSinkId ? (this.sinkStreamDestination || (this.sinkStreamDestination = this.ac.createMediaStreamDestination()), this.gainNode.disconnect(), this.gainNode.connect(this.sinkStreamDestination), this.sinkAudioElement.srcObject = this.sinkStreamDestination.stream, this.sinkAudioElement.setSinkId(t)) : Promise.reject(new Error("setSinkId is not supported in your browser"))) : Promise.reject(new Error("Invalid deviceId: " + t));
+                }
+                /**
+                 * Set the audio volume
+                 *
+                 * @param {number} value A floating point value between 0 and 1.
+                 */
+              }, {
+                key: "setVolume",
+                value: function(t) {
+                  this.gainNode.gain.setValueAtTime(t, this.ac.currentTime);
+                }
+                /**
+                 * Get the current volume
+                 *
+                 * @return {number} value A floating point value between 0 and 1.
+                 */
+              }, {
+                key: "getVolume",
+                value: function() {
+                  return this.gainNode.gain.value;
+                }
+                /**
+                 * Decode an array buffer and pass data to a callback
+                 *
+                 * @private
+                 * @param {ArrayBuffer} arraybuffer The array buffer to decode
+                 * @param {function} callback The function to call on complete.
+                 * @param {function} errback The function to call on error.
+                 */
+              }, {
+                key: "decodeArrayBuffer",
+                value: function(t, s, i) {
+                  this.offlineAc || (this.offlineAc = this.getOfflineAudioContext(this.ac && this.ac.sampleRate ? this.ac.sampleRate : 44100)), "webkitAudioContext" in window ? this.offlineAc.decodeAudioData(t, function(e) {
+                    return s(e);
+                  }, i) : this.offlineAc.decodeAudioData(t).then(function(e) {
+                    return s(e);
+                  }).catch(function(e) {
+                    return i(e);
+                  });
+                }
+                /**
+                 * Set pre-decoded peaks
+                 *
+                 * @param {number[]|Number.<Array[]>} peaks Peaks data
+                 * @param {?number} duration Explicit duration
+                 */
+              }, {
+                key: "setPeaks",
+                value: function(t, s) {
+                  s != null && (this.explicitDuration = s), this.peaks = t;
+                }
+                /**
+                 * Set the rendered length (different from the length of the audio)
+                 *
+                 * @param {number} length The rendered length
+                 */
+              }, {
+                key: "setLength",
+                value: function(t) {
+                  if (!(this.mergedPeaks && t == 2 * this.mergedPeaks.length - 1 + 2)) {
+                    this.splitPeaks = [], this.mergedPeaks = [];
+                    var s = this.buffer ? this.buffer.numberOfChannels : 1, i;
+                    for (i = 0; i < s; i++)
+                      this.splitPeaks[i] = [], this.splitPeaks[i][2 * (t - 1)] = 0, this.splitPeaks[i][2 * (t - 1) + 1] = 0;
+                    this.mergedPeaks[2 * (t - 1)] = 0, this.mergedPeaks[2 * (t - 1) + 1] = 0;
+                  }
+                }
+                /**
+                 * Compute the max and min value of the waveform when broken into <length> subranges.
+                 *
+                 * @param {number} length How many subranges to break the waveform into.
+                 * @param {number} first First sample in the required range.
+                 * @param {number} last Last sample in the required range.
+                 * @return {number[]|Number.<Array[]>} Array of 2*<length> peaks or array of arrays of
+                 * peaks consisting of (max, min) values for each subrange.
+                 */
+              }, {
+                key: "getPeaks",
+                value: function(t, s, i) {
+                  if (this.peaks)
+                    return this.peaks;
+                  if (!this.buffer)
+                    return [];
+                  if (s = s || 0, i = i || t - 1, this.setLength(t), !this.buffer)
+                    return this.params.splitChannels ? this.splitPeaks : this.mergedPeaks;
+                  if (!this.buffer.length) {
+                    var e = this.createBuffer(1, 4096, this.sampleRate);
+                    this.buffer = e.buffer;
+                  }
+                  var l = this.buffer.length / t, A = ~~(l / 10) || 1, T = this.buffer.numberOfChannels, S;
+                  for (S = 0; S < T; S++) {
+                    var D = this.splitPeaks[S], B = this.buffer.getChannelData(S), V = void 0;
+                    for (V = s; V <= i; V++) {
+                      var N = ~~(V * l), H = ~~(N + l), L = B[N], U = L, F = void 0;
+                      for (F = N; F < H; F += A) {
+                        var z = B[F];
+                        z > U && (U = z), z < L && (L = z);
+                      }
+                      D[2 * V] = U, D[2 * V + 1] = L, (S == 0 || U > this.mergedPeaks[2 * V]) && (this.mergedPeaks[2 * V] = U), (S == 0 || L < this.mergedPeaks[2 * V + 1]) && (this.mergedPeaks[2 * V + 1] = L);
+                    }
+                  }
+                  return this.params.splitChannels ? this.splitPeaks : this.mergedPeaks;
+                }
+                /**
+                 * Get the position from 0 to 1
+                 *
+                 * @return {number} Position
+                 */
+              }, {
+                key: "getPlayedPercents",
+                value: function() {
+                  return this.state.getPlayedPercents.call(this);
+                }
+                /** @private */
+              }, {
+                key: "disconnectSource",
+                value: function() {
+                  this.source && this.source.disconnect();
+                }
+                /**
+                 * Destroy all references with WebAudio, disconnecting audio nodes and closing Audio Context
+                 */
+              }, {
+                key: "destroyWebAudio",
+                value: function() {
+                  this.disconnectFilters(), this.disconnectSource(), this.gainNode.disconnect(), this.scriptNode && this.scriptNode.disconnect(), this.analyser.disconnect(), this.params.closeAudioContext && (typeof this.ac.close == "function" && this.ac.state != "closed" && this.ac.close(), this.ac = null, this.params.audioContext ? this.params.audioContext = null : window.WaveSurferAudioContext = null, window.WaveSurferOfflineAudioContext = null), this.sinkStreamDestination && (this.sinkAudioElement.pause(), this.sinkAudioElement.srcObject = null, this.sinkStreamDestination.disconnect(), this.sinkStreamDestination = null);
+                }
+                /**
+                 * This is called when wavesurfer is destroyed
+                 */
+              }, {
+                key: "destroy",
+                value: function() {
+                  this.isPaused() || this.pause(), this.unAll(), this.buffer = null, this.destroyed = !0, this.destroyWebAudio();
+                }
+                /**
+                 * Loaded a decoded audio buffer
+                 *
+                 * @param {Object} buffer Decoded audio buffer to load
+                 */
+              }, {
+                key: "load",
+                value: function(t) {
+                  this.startPosition = 0, this.lastPlay = this.ac.currentTime, this.buffer = t, this.createSource();
+                }
+                /** @private */
+              }, {
+                key: "createSource",
+                value: function() {
+                  this.disconnectSource(), this.source = this.ac.createBufferSource(), this.source.start = this.source.start || this.source.noteGrainOn, this.source.stop = this.source.stop || this.source.noteOff, this.setPlaybackRate(this.playbackRate), this.source.buffer = this.buffer, this.source.connect(this.analyser);
+                }
+                /**
+                 * @private
+                 *
+                 * some browsers require an explicit call to #resume before they will play back audio
+                 */
+              }, {
+                key: "resumeAudioContext",
+                value: function() {
+                  this.ac.state == "suspended" && this.ac.resume && this.ac.resume();
+                }
+                /**
+                 * Used by `wavesurfer.isPlaying()` and `wavesurfer.playPause()`
+                 *
+                 * @return {boolean} Whether or not this backend is currently paused
+                 */
+              }, {
+                key: "isPaused",
+                value: function() {
+                  return this.state !== this.states[y];
+                }
+                /**
+                 * Used by `wavesurfer.getDuration()`
+                 *
+                 * @return {number} Duration of loaded buffer
+                 */
+              }, {
+                key: "getDuration",
+                value: function() {
+                  return this.explicitDuration ? this.explicitDuration : this.buffer ? this.buffer.duration : 0;
+                }
+                /**
+                 * Used by `wavesurfer.seekTo()`
+                 *
+                 * @param {number} start Position to start at in seconds
+                 * @param {number} end Position to end at in seconds
+                 * @return {{start: number, end: number}} Object containing start and end
+                 * positions
+                 */
+              }, {
+                key: "seekTo",
+                value: function(t, s) {
+                  if (this.buffer)
+                    return this.scheduledPause = null, t == null && (t = this.getCurrentTime(), t >= this.getDuration() && (t = 0)), s == null && (s = this.getDuration()), this.startPosition = t, this.lastPlay = this.ac.currentTime, this.state === this.states[m] && this.setState(f), {
+                      start: t,
+                      end: s
+                    };
+                }
+                /**
+                 * Get the playback position in seconds
+                 *
+                 * @return {number} The playback position in seconds
+                 */
+              }, {
+                key: "getPlayedTime",
+                value: function() {
+                  return (this.ac.currentTime - this.lastPlay) * this.playbackRate;
+                }
+                /**
+                 * Plays the loaded audio region.
+                 *
+                 * @param {number} start Start offset in seconds, relative to the beginning
+                 * of a clip.
+                 * @param {number} end When to stop relative to the beginning of a clip.
+                 */
+              }, {
+                key: "play",
+                value: function(t, s) {
+                  if (this.buffer) {
+                    this.createSource();
+                    var i = this.seekTo(t, s);
+                    t = i.start, s = i.end, this.scheduledPause = s, this.source.start(0, t), this.resumeAudioContext(), this.setState(y), this.fireEvent("play");
+                  }
+                }
+                /**
+                 * Pauses the loaded audio.
+                 */
+              }, {
+                key: "pause",
+                value: function() {
+                  this.scheduledPause = null, this.startPosition += this.getPlayedTime();
+                  try {
+                    this.source && this.source.stop(0);
+                  } catch {
+                  }
+                  this.setState(f), this.fireEvent("pause");
+                }
+                /**
+                 * Returns the current time in seconds relative to the audio-clip's
+                 * duration.
+                 *
+                 * @return {number} The current time in seconds
+                 */
+              }, {
+                key: "getCurrentTime",
+                value: function() {
+                  return this.state.getCurrentTime.call(this);
+                }
+                /**
+                 * Returns the current playback rate. (0=no playback, 1=normal playback)
+                 *
+                 * @return {number} The current playback rate
+                 */
+              }, {
+                key: "getPlaybackRate",
+                value: function() {
+                  return this.playbackRate;
+                }
+                /**
+                 * Set the audio source playback rate.
+                 *
+                 * @param {number} value The playback rate to use
+                 */
+              }, {
+                key: "setPlaybackRate",
+                value: function(t) {
+                  this.playbackRate = t || 1, this.source && this.source.playbackRate.setValueAtTime(this.playbackRate, this.ac.currentTime);
+                }
+                /**
+                 * Set a point in seconds for playback to stop at.
+                 *
+                 * @param {number} end Position to end at
+                 * @version 3.3.0
+                 */
+              }, {
+                key: "setPlayEnd",
+                value: function(t) {
+                  this.scheduledPause = t;
+                }
+              }]), o;
+            }(g.Observer);
+            h.default = u, j.exports = h.default;
+          }
+        ),
+        /***/
+        "./node_modules/debounce/index.js": (
+          /*!****************************************!*\
+            !*** ./node_modules/debounce/index.js ***!
+            \****************************************/
+          /***/
+          (j) => {
+            function h(C, g, W) {
+              var E, M, x, I, b;
+              g == null && (g = 100);
+              function O() {
+                var _ = Date.now() - I;
+                _ < g && _ >= 0 ? E = setTimeout(O, g - _) : (E = null, W || (b = C.apply(x, M), x = M = null));
+              }
+              var R = function() {
+                x = this, M = arguments, I = Date.now();
+                var _ = W && !E;
+                return E || (E = setTimeout(O, g)), _ && (b = C.apply(x, M), x = M = null), b;
+              };
+              return R.clear = function() {
+                E && (clearTimeout(E), E = null);
+              }, R.flush = function() {
+                E && (b = C.apply(x, M), x = M = null, clearTimeout(E), E = null);
+              }, R;
+            }
+            h.debounce = h, j.exports = h;
+          }
+        )
+        /******/
+      }, Q = {};
+      function G(j) {
+        var h = Q[j];
+        if (h !== void 0)
+          return h.exports;
+        var C = Q[j] = {
+          /******/
+          // no module.id needed
+          /******/
+          // no module.loaded needed
+          /******/
+          exports: {}
+          /******/
+        };
+        return X[j](C, C.exports, G), C.exports;
+      }
+      var K = G("./src/wavesurfer.js");
+      return K;
+    })()
+  ));
+})(re);
+var ne = re.exports;
+const le = /* @__PURE__ */ ue(ne), fe = /* @__PURE__ */ oe({
+  __proto__: null,
+  default: le
+}, [ne]);
+export {
+  fe as w
+};