@orangelogic/design-system 2.103.0 → 2.105.0

package/library/chunks/wavesurfer.esm.Cwi1pz64.js

@@ -0,0 +1,1276 @@
+function x(h, t, e, i) {
+  return new (e || (e = Promise))(function(s, n) {
+    function r(o) {
+      try {
+        a(i.next(o));
+      } catch (u) {
+        n(u);
+      }
+    }
+    function l(o) {
+      try {
+        a(i.throw(o));
+      } catch (u) {
+        n(u);
+      }
+    }
+    function a(o) {
+      var u;
+      o.done ? s(o.value) : (u = o.value, u instanceof e ? u : new e(function(p) {
+        p(u);
+      })).then(r, l);
+    }
+    a((i = i.apply(h, t || [])).next());
+  });
+}
+class N {
+  constructor() {
+    this.listeners = {};
+  }
+  on(t, e, i) {
+    if (this.listeners[t] || (this.listeners[t] = /* @__PURE__ */ new Set()), i?.once) {
+      const s = (...n) => {
+        this.un(t, s), e(...n);
+      };
+      return this.listeners[t].add(s), () => this.un(t, s);
+    }
+    return this.listeners[t].add(e), () => this.un(t, e);
+  }
+  un(t, e) {
+    var i;
+    (i = this.listeners[t]) === null || i === void 0 || i.delete(e);
+  }
+  once(t, e) {
+    return this.on(t, e, { once: !0 });
+  }
+  unAll() {
+    this.listeners = {};
+  }
+  emit(t, ...e) {
+    this.listeners[t] && this.listeners[t].forEach((i) => i(...e));
+  }
+}
+const H = { decode: function(h, t) {
+  return x(this, void 0, void 0, function* () {
+    const e = new AudioContext({ sampleRate: t });
+    try {
+      return yield e.decodeAudioData(h);
+    } finally {
+      e.close();
+    }
+  });
+}, createBuffer: function(h, t) {
+  if (!h || h.length === 0) throw new Error("channelData must be a non-empty array");
+  if (t <= 0) throw new Error("duration must be greater than 0");
+  if (typeof h[0] == "number" && (h = [h]), !h[0] || h[0].length === 0) throw new Error("channelData must contain non-empty channel arrays");
+  (function(i) {
+    const s = i[0];
+    if (s.some((n) => n > 1 || n < -1)) {
+      const n = s.length;
+      let r = 0;
+      for (let l = 0; l < n; l++) {
+        const a = Math.abs(s[l]);
+        a > r && (r = a);
+      }
+      for (const l of i) for (let a = 0; a < n; a++) l[a] /= r;
+    }
+  })(h);
+  const e = h.map((i) => i instanceof Float32Array ? i : Float32Array.from(i));
+  return { duration: t, length: e[0].length, sampleRate: e[0].length / t, numberOfChannels: e.length, getChannelData: (i) => {
+    const s = e[i];
+    if (!s) throw new Error(`Channel ${i} not found`);
+    return s;
+  }, copyFromChannel: AudioBuffer.prototype.copyFromChannel, copyToChannel: AudioBuffer.prototype.copyToChannel };
+} };
+function q(h, t) {
+  const e = t.xmlns ? document.createElementNS(t.xmlns, h) : document.createElement(h);
+  for (const [i, s] of Object.entries(t)) if (i === "children" && s) for (const [n, r] of Object.entries(s)) r instanceof Node ? e.appendChild(r) : typeof r == "string" ? e.appendChild(document.createTextNode(r)) : e.appendChild(q(n, r));
+  else i === "style" ? Object.assign(e.style, s) : i === "textContent" ? e.textContent = s : e.setAttribute(i, s.toString());
+  return e;
+}
+function F(h, t, e) {
+  const i = q(h, t || {});
+  return e?.appendChild(i), i;
+}
+function G(h) {
+  return h instanceof HTMLElement || typeof h == "object" && h !== null && h.nodeType === Node.ELEMENT_NODE && typeof h.style == "object";
+}
+var Q = Object.freeze({ __proto__: null, createElement: F, default: F, isHTMLElement: G });
+const tt = { fetchBlob: function(h, t, e) {
+  return x(this, void 0, void 0, function* () {
+    var i;
+    const s = yield fetch(h, e);
+    if (s.status >= 400) throw new Error(`Failed to fetch ${h}: ${s.status} (${s.statusText})`);
+    return function(n, r, l) {
+      x(this, void 0, void 0, function* () {
+        var a;
+        if (!n.body || !n.headers) return;
+        const o = n.body.getReader(), u = Number(n.headers.get("Content-Length")) || 0;
+        let p = 0;
+        const d = () => {
+          o.cancel();
+        };
+        if (l) {
+          if (l.aborted) return void o.cancel();
+          l.addEventListener("abort", d, { once: !0 });
+        }
+        try {
+          for (; ; ) {
+            const m = yield o.read();
+            if (m.done) break;
+            if (p += ((a = m.value) === null || a === void 0 ? void 0 : a.length) || 0, u > 0) {
+              const c = Math.round(p / u * 100);
+              r(c);
+            }
+          }
+        } catch (m) {
+          if (m instanceof DOMException && m.name === "AbortError") return;
+          console.warn("Progress tracking error:", m);
+        } finally {
+          l && l.removeEventListener("abort", d);
+        }
+      });
+    }(s.clone(), t, (i = e?.signal) !== null && i !== void 0 ? i : void 0), s.blob();
+  });
+} };
+function y(h) {
+  let t = h;
+  const e = /* @__PURE__ */ new Set();
+  return { get value() {
+    return t;
+  }, set(i) {
+    Object.is(t, i) || (t = i, e.forEach((s) => s(t)));
+  }, update(i) {
+    this.set(i(t));
+  }, subscribe: (i) => (e.add(i), () => e.delete(i)) };
+}
+function A(h, t) {
+  const e = y(h());
+  return t.forEach((i) => i.subscribe(() => {
+    const s = h();
+    Object.is(e.value, s) || e.set(s);
+  })), { get value() {
+    return e.value;
+  }, subscribe: (i) => e.subscribe(i) };
+}
+function L(h, t) {
+  let e;
+  const i = () => {
+    e && (e(), e = void 0), e = h();
+  }, s = t.map((n) => n.subscribe(i));
+  return i(), () => {
+    e && (e(), e = void 0), s.forEach((n) => n());
+  };
+}
+class et extends N {
+  get isPlayingSignal() {
+    return this._isPlaying;
+  }
+  get currentTimeSignal() {
+    return this._currentTime;
+  }
+  get durationSignal() {
+    return this._duration;
+  }
+  get volumeSignal() {
+    return this._volume;
+  }
+  get mutedSignal() {
+    return this._muted;
+  }
+  get playbackRateSignal() {
+    return this._playbackRate;
+  }
+  get seekingSignal() {
+    return this._seeking;
+  }
+  constructor(t) {
+    super(), this.isExternalMedia = !1, this._ownBlobUrl = null, this.reactiveMediaEventCleanups = [], t.media ? (this.media = t.media, this.isExternalMedia = !0) : this.media = document.createElement("audio"), this._isPlaying = y(!1), this._currentTime = y(0), this._duration = y(0), this._volume = y(this.media.volume), this._muted = y(this.media.muted), this._playbackRate = y(this.media.playbackRate || 1), this._seeking = y(!1), this.setupReactiveMediaEvents(), t.mediaControls && (this.media.controls = !0), t.autoplay && (this.media.autoplay = !0), t.playbackRate != null && this.onMediaEvent("canplay", () => {
+      t.playbackRate != null && (this.media.playbackRate = t.playbackRate);
+    }, { once: !0 });
+  }
+  setupReactiveMediaEvents() {
+    this.reactiveMediaEventCleanups.push(this.onMediaEvent("play", () => {
+      this._isPlaying.set(!0);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("pause", () => {
+      this._isPlaying.set(!1);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("ended", () => {
+      this._isPlaying.set(!1);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("timeupdate", () => {
+      this._currentTime.set(this.media.currentTime);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("durationchange", () => {
+      this._duration.set(this.media.duration || 0);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("loadedmetadata", () => {
+      this._duration.set(this.media.duration || 0);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("seeking", () => {
+      this._seeking.set(!0);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("seeked", () => {
+      this._seeking.set(!1);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("volumechange", () => {
+      this._volume.set(this.media.volume), this._muted.set(this.media.muted);
+    })), this.reactiveMediaEventCleanups.push(this.onMediaEvent("ratechange", () => {
+      this._playbackRate.set(this.media.playbackRate);
+    }));
+  }
+  onMediaEvent(t, e, i) {
+    return this.media.addEventListener(t, e, i), () => this.media.removeEventListener(t, e, i);
+  }
+  getSrc() {
+    return this.media.currentSrc || this.media.src || "";
+  }
+  revokeSrc() {
+    this._ownBlobUrl && (URL.revokeObjectURL(this._ownBlobUrl), this._ownBlobUrl = null);
+  }
+  canPlayType(t) {
+    return this.media.canPlayType(t) !== "";
+  }
+  setSrc(t, e) {
+    const i = this.getSrc();
+    if (t && i === t) return;
+    this.revokeSrc();
+    const s = e instanceof Blob && (this.canPlayType(e.type) || !t) ? URL.createObjectURL(e) : t;
+    if (s !== t && (this._ownBlobUrl = s), i && this.media.removeAttribute("src"), s || t) try {
+      this.media.src = s;
+    } catch {
+      this.media.src = t;
+    }
+  }
+  destroy() {
+    this.reactiveMediaEventCleanups.forEach((t) => t()), this.reactiveMediaEventCleanups = [], this.revokeSrc(), this.unAll(), this.isExternalMedia || (this.media.pause(), this.media.removeAttribute("src"), this.media.load(), this.media.remove());
+  }
+  setMediaElement(t) {
+    this.reactiveMediaEventCleanups.forEach((e) => e()), this.reactiveMediaEventCleanups = [], this.media = t, this.setupReactiveMediaEvents();
+  }
+  play() {
+    return x(this, void 0, void 0, function* () {
+      try {
+        return yield this.media.play();
+      } catch (t) {
+        if (t instanceof DOMException && t.name === "AbortError") return;
+        throw t;
+      }
+    });
+  }
+  pause() {
+    this.media.pause();
+  }
+  isPlaying() {
+    return !this.media.paused && !this.media.ended;
+  }
+  setTime(t) {
+    this.media.currentTime = Math.max(0, Math.min(t, this.getDuration()));
+  }
+  getDuration() {
+    return this.media.duration;
+  }
+  getCurrentTime() {
+    return this.media.currentTime;
+  }
+  getVolume() {
+    return this.media.volume;
+  }
+  setVolume(t) {
+    this.media.volume = t;
+  }
+  getMuted() {
+    return this.media.muted;
+  }
+  setMuted(t) {
+    this.media.muted = t;
+  }
+  getPlaybackRate() {
+    return this.media.playbackRate;
+  }
+  isSeeking() {
+    return this.media.seeking;
+  }
+  setPlaybackRate(t, e) {
+    e != null && (this.media.preservesPitch = e), this.media.playbackRate = t;
+  }
+  getMediaElement() {
+    return this.media;
+  }
+  setSinkId(t) {
+    return this.media.setSinkId(t);
+  }
+}
+function it({ maxTop: h, maxBottom: t, halfHeight: e, vScale: i, barMinHeight: s = 0, barAlign: n }) {
+  let r = Math.round(h * e * i), l = r + Math.round(t * e * i) || 1;
+  return l < s && (l = s, n || (r = l / 2)), { topHeight: r, totalHeight: l };
+}
+function st({ barAlign: h, halfHeight: t, topHeight: e, totalHeight: i, canvasHeight: s }) {
+  return h === "top" ? 0 : h === "bottom" ? s - i : t - e;
+}
+function V(h, t, e) {
+  const i = t - h.left, s = e - h.top;
+  return [i / h.width, s / h.height];
+}
+function Y(h) {
+  return !!(h.barWidth || h.barGap || h.barAlign);
+}
+function X(h, t) {
+  if (!Y(t)) return h;
+  const e = t.barWidth || 0.5, i = e + (t.barGap || e / 2);
+  return i === 0 ? h : Math.floor(h / i) * i;
+}
+function U({ scrollLeft: h, totalWidth: t, numCanvases: e }) {
+  if (t === 0) return [0];
+  const i = h / t, s = Math.floor(i * e);
+  return [s - 1, s, s + 1];
+}
+function Z(h) {
+  const t = h._cleanup;
+  typeof t == "function" && t();
+}
+function nt(h) {
+  const t = y({ scrollLeft: h.scrollLeft, scrollWidth: h.scrollWidth, clientWidth: h.clientWidth }), e = A(() => function(n) {
+    const { scrollLeft: r, scrollWidth: l, clientWidth: a } = n;
+    if (l === 0) return { startX: 0, endX: 1 };
+    const o = r / l, u = (r + a) / l;
+    return { startX: Math.max(0, Math.min(1, o)), endX: Math.max(0, Math.min(1, u)) };
+  }(t.value), [t]), i = A(() => function(n) {
+    return { left: n.scrollLeft, right: n.scrollLeft + n.clientWidth };
+  }(t.value), [t]), s = () => {
+    t.set({ scrollLeft: h.scrollLeft, scrollWidth: h.scrollWidth, clientWidth: h.clientWidth });
+  };
+  return h.addEventListener("scroll", s, { passive: !0 }), { scrollData: t, percentages: e, bounds: i, cleanup: () => {
+    h.removeEventListener("scroll", s), Z(t);
+  } };
+}
+class rt extends N {
+  constructor(t, e) {
+    super(), this.timeouts = [], this.isScrollable = !1, this.audioData = null, this.resizeObserver = null, this.lastContainerWidth = 0, this.isDragging = !1, this.subscriptions = [], this.unsubscribeOnScroll = [], this.dragStream = null, this.scrollStream = null, this.containerInlinePadding = 0, this.onClickWrapper = (r) => {
+      const l = this.wrapper.getBoundingClientRect(), [a, o] = V(l, r.clientX, r.clientY);
+      this.emit("click", a, o);
+    }, this.onDblClickWrapper = (r) => {
+      const l = this.wrapper.getBoundingClientRect(), [a, o] = V(l, r.clientX, r.clientY);
+      this.emit("dblclick", a, o);
+    }, this.subscriptions = [], this.options = t;
+    const i = this.parentFromOptionsContainer(t.container);
+    this.parent = i;
+    const [s, n] = this.initHtml();
+    i.appendChild(s), this.container = s, this.scrollContainer = n.querySelector(".scroll"), this.wrapper = n.querySelector(".wrapper"), this.canvasWrapper = n.querySelector(".canvases"), this.progressWrapper = n.querySelector(".progress"), this.cursor = n.querySelector(".cursor"), this.calculateInlinePadding(), e && n.appendChild(e), this.initEvents();
+  }
+  parentFromOptionsContainer(t) {
+    let e;
+    if (typeof t == "string" ? e = document.querySelector(t) : G(t) && (e = t), !e) throw new Error("Container not found");
+    return e;
+  }
+  initEvents() {
+    this.wrapper.addEventListener("click", this.onClickWrapper), this.wrapper.addEventListener("dblclick", this.onDblClickWrapper), this.options.dragToSeek !== !0 && typeof this.options.dragToSeek != "object" || this.initDrag(), this.scrollStream = nt(this.scrollContainer);
+    const t = L(() => {
+      const { startX: e, endX: i } = this.scrollStream.percentages.value, { left: s, right: n } = this.scrollStream.bounds.value;
+      this.emit("scroll", e, i, s, n);
+    }, [this.scrollStream.percentages, this.scrollStream.bounds]);
+    if (this.subscriptions.push(t), typeof ResizeObserver == "function") {
+      const e = this.createDelay(100);
+      this.resizeObserver = new ResizeObserver(() => {
+        e().then(() => this.onContainerResize()).catch(() => {
+        });
+      }), this.resizeObserver.observe(this.scrollContainer);
+    }
+  }
+  onContainerResize() {
+    const t = this.parent.clientWidth;
+    this.calculateInlinePadding(), t === this.lastContainerWidth && this.options.height !== "auto" || (this.lastContainerWidth = t, this.reRender(), this.emit("resize"));
+  }
+  initDrag() {
+    if (this.dragStream) return;
+    this.dragStream = function(e, i = {}) {
+      const { threshold: s = 3, mouseButton: n = 0, touchDelay: r = 100 } = i, l = y(null), a = /* @__PURE__ */ new Map(), o = matchMedia("(pointer: coarse)").matches;
+      let u = () => {
+      };
+      const p = (d) => {
+        if (d.button !== n || a.has(d.pointerId) || (a.set(d.pointerId, d), a.size > 1)) return;
+        const m = d.pointerId;
+        let c = d.clientX, f = d.clientY, g = !1;
+        const E = Date.now(), k = e.getBoundingClientRect(), { left: M, top: C } = k, P = (b) => {
+          if (b.pointerId !== m || b.defaultPrevented || a.size > 1 || o && Date.now() - E < r) return;
+          const T = b.clientX, D = b.clientY, _ = T - c, v = D - f;
+          (g || Math.abs(_) > s || Math.abs(v) > s) && (b.preventDefault(), b.stopPropagation(), g || (l.set({ type: "start", x: c - M, y: f - C }), g = !0), l.set({ type: "move", x: T - M, y: D - C, deltaX: _, deltaY: v }), c = T, f = D);
+        }, S = (b) => {
+          if (a.delete(b.pointerId)) {
+            if (b.pointerId === m && g) {
+              const T = b.clientX, D = b.clientY;
+              l.set({ type: "end", x: T - M, y: D - C });
+            }
+            a.size === 0 && u();
+          }
+        }, w = (b) => {
+          b.relatedTarget && b.relatedTarget !== document.documentElement || S(b);
+        }, R = (b) => {
+          g && (b.stopPropagation(), b.preventDefault());
+        }, W = (b) => {
+          b.defaultPrevented || a.size > 1 || g && b.preventDefault();
+        };
+        document.addEventListener("pointermove", P), document.addEventListener("pointerup", S), document.addEventListener("pointerout", w), document.addEventListener("pointercancel", w), document.addEventListener("touchmove", W, { passive: !1 }), document.addEventListener("click", R, { capture: !0 }), u = () => {
+          document.removeEventListener("pointermove", P), document.removeEventListener("pointerup", S), document.removeEventListener("pointerout", w), document.removeEventListener("pointercancel", w), document.removeEventListener("touchmove", W), setTimeout(() => {
+            document.removeEventListener("click", R, { capture: !0 });
+          }, 10);
+        };
+      };
+      return e.addEventListener("pointerdown", p), { signal: l, cleanup: () => {
+        u(), e.removeEventListener("pointerdown", p), a.clear(), Z(l);
+      } };
+    }(this.wrapper);
+    const t = L(() => {
+      const e = this.dragStream.signal.value;
+      if (!e) return;
+      const i = this.wrapper.getBoundingClientRect().width, s = (n = e.x / i) < 0 ? 0 : n > 1 ? 1 : n;
+      var n;
+      e.type === "start" ? (this.isDragging = !0, this.emit("dragstart", s)) : e.type === "move" ? this.emit("drag", s) : e.type === "end" && (this.isDragging = !1, this.emit("dragend", s));
+    }, [this.dragStream.signal]);
+    this.subscriptions.push(t);
+  }
+  calculateInlinePadding() {
+    const { paddingLeft: t, paddingRight: e } = getComputedStyle(this.scrollContainer), i = parseFloat(t) + parseFloat(e);
+    this.containerInlinePadding = Number.isNaN(i) ? 0 : i;
+  }
+  initHtml() {
+    const t = document.createElement("div"), e = t.attachShadow({ mode: "open" }), i = this.options.cspNonce && typeof this.options.cspNonce == "string" ? this.options.cspNonce.replace(/"/g, "") : "";
+    return e.innerHTML = `
+      <style${i ? ` nonce="${i}"` : ""}>
+        :host {
+          user-select: none;
+          min-width: 1px;
+        }
+        :host audio {
+          display: block;
+          width: 100%;
+        }
+        :host .scroll {
+          overflow-x: auto;
+          overflow-y: hidden;
+          width: 100%;
+          position: relative;
+        }
+        :host .noScrollbar {
+          scrollbar-color: transparent;
+          scrollbar-width: none;
+        }
+        :host .noScrollbar::-webkit-scrollbar {
+          display: none;
+          -webkit-appearance: none;
+        }
+        :host .wrapper {
+          position: relative;
+          overflow: visible;
+          z-index: 2;
+        }
+        :host .canvases {
+          min-height: ${this.getHeight(this.options.height, this.options.splitChannels)}px;
+          pointer-events: none;
+        }
+        :host .canvases > div {
+          position: relative;
+        }
+        :host canvas {
+          display: block;
+          position: absolute;
+          top: 0;
+          image-rendering: pixelated;
+        }
+        :host .progress {
+          pointer-events: none;
+          position: absolute;
+          z-index: 2;
+          top: 0;
+          left: 0;
+          width: 0;
+          height: 100%;
+          overflow: hidden;
+        }
+        :host .progress > div {
+          position: relative;
+        }
+        :host .cursor {
+          pointer-events: none;
+          position: absolute;
+          z-index: 5;
+          top: 0;
+          left: 0;
+          height: 100%;
+          border-radius: 2px;
+        }
+      </style>
+
+      <div class="scroll" part="scroll">
+        <div class="wrapper" part="wrapper">
+          <div class="canvases" part="canvases"></div>
+          <div class="progress" part="progress"></div>
+          <div class="cursor" part="cursor"></div>
+        </div>
+      </div>
+    `, [t, e];
+  }
+  setOptions(t) {
+    var e;
+    if (this.options.container !== t.container) {
+      const i = this.parentFromOptionsContainer(t.container);
+      i.appendChild(this.container), this.parent = i;
+    }
+    t.dragToSeek === !0 || typeof this.options.dragToSeek == "object" ? this.initDrag() : ((e = this.dragStream) === null || e === void 0 || e.cleanup(), this.dragStream = null), this.options = t, this.reRender();
+  }
+  getWrapper() {
+    return this.wrapper;
+  }
+  getWidth() {
+    return this.scrollContainer.clientWidth - this.containerInlinePadding;
+  }
+  getScroll() {
+    return this.scrollContainer.scrollLeft;
+  }
+  setScroll(t) {
+    this.scrollContainer.scrollLeft = t;
+  }
+  setScrollPercentage(t) {
+    const { scrollWidth: e } = this.scrollContainer, i = e * t;
+    this.setScroll(i);
+  }
+  destroy() {
+    var t;
+    this.wrapper.removeEventListener("click", this.onClickWrapper), this.wrapper.removeEventListener("dblclick", this.onDblClickWrapper), this.timeouts.forEach((e) => e()), this.timeouts = [], this.subscriptions.forEach((e) => e()), this.container.remove(), this.resizeObserver && (this.resizeObserver.disconnect(), this.resizeObserver = null), (t = this.unsubscribeOnScroll) === null || t === void 0 || t.forEach((e) => e()), this.unsubscribeOnScroll = [], this.dragStream && (this.dragStream.cleanup(), this.dragStream = null), this.scrollStream && (this.scrollStream.cleanup(), this.scrollStream = null);
+  }
+  createDelay(t = 10) {
+    let e, i;
+    const s = () => {
+      e && (clearTimeout(e), e = void 0), i && (i(), i = void 0);
+    };
+    return this.timeouts.push(s), () => new Promise((n, r) => {
+      s(), i = r, e = setTimeout(() => {
+        e = void 0, i = void 0, n();
+      }, t);
+    });
+  }
+  getHeight(t, e) {
+    var i;
+    const s = ((i = this.audioData) === null || i === void 0 ? void 0 : i.numberOfChannels) || 1;
+    return function({ optionsHeight: n, optionsSplitChannels: r, parentHeight: l, numberOfChannels: a, defaultHeight: o = 128 }) {
+      if (n == null) return o;
+      const u = Number(n);
+      if (!isNaN(u)) return u;
+      if (n === "auto") {
+        const p = l || o;
+        return r?.every((d) => !d.overlay) ? p / a : p;
+      }
+      return o;
+    }({ optionsHeight: t, optionsSplitChannels: e, parentHeight: this.parent.clientHeight, numberOfChannels: s, defaultHeight: 128 });
+  }
+  convertColorValues(t, e) {
+    return function(i, s, n) {
+      if (!Array.isArray(i)) return i || "";
+      if (i.length === 0) return "#999";
+      if (i.length < 2) return i[0] || "";
+      const r = document.createElement("canvas"), l = r.getContext("2d");
+      if (!l) return i[0] || "";
+      const a = n || r.height * s, o = l.createLinearGradient(0, 0, 0, a), u = 1 / (i.length - 1);
+      return i.forEach((p, d) => {
+        o.addColorStop(d * u, p);
+      }), o;
+    }(t, this.getPixelRatio(), e?.canvas.height);
+  }
+  getPixelRatio() {
+    return t = window.devicePixelRatio, Math.max(1, t || 1);
+    var t;
+  }
+  renderBarWaveform(t, e, i, s) {
+    const { width: n, height: r } = i.canvas, { halfHeight: l, barWidth: a, barRadius: o, barIndexScale: u, barSpacing: p, barMinHeight: d } = function({ width: c, height: f, length: g, options: E, pixelRatio: k }) {
+      const M = f / 2, C = E.barWidth ? E.barWidth * k : 1, P = E.barGap ? E.barGap * k : E.barWidth ? C / 2 : 0, S = C + P || 1;
+      return { halfHeight: M, barWidth: C, barGap: P, barRadius: E.barRadius || 0, barMinHeight: E.barMinHeight ? E.barMinHeight * k : 0, barIndexScale: g > 0 ? c / S / g : 0, barSpacing: S };
+    }({ width: n, height: r, length: (t[0] || []).length, options: e, pixelRatio: this.getPixelRatio() }), m = function({ channelData: c, barIndexScale: f, barSpacing: g, barWidth: E, halfHeight: k, vScale: M, canvasHeight: C, barAlign: P, barMinHeight: S }) {
+      const w = c[0] || [], R = c[1] || w, W = w.length, b = [];
+      let T = 0, D = 0, _ = 0;
+      for (let v = 0; v <= W; v++) {
+        const O = Math.round(v * f);
+        if (O > T) {
+          const { topHeight: J, totalHeight: j } = it({ maxTop: D, maxBottom: _, halfHeight: k, vScale: M, barMinHeight: S, barAlign: P }), K = st({ barAlign: P, halfHeight: k, topHeight: J, totalHeight: j, canvasHeight: C });
+          b.push({ x: T * g, y: K, width: E, height: j }), T = O, D = 0, _ = 0;
+        }
+        const z = Math.abs(w[v] || 0), $ = Math.abs(R[v] || 0);
+        z > D && (D = z), $ > _ && (_ = $);
+      }
+      return b;
+    }({ channelData: t, barIndexScale: u, barSpacing: p, barWidth: a, halfHeight: l, vScale: s, canvasHeight: r, barAlign: e.barAlign, barMinHeight: d });
+    i.beginPath();
+    for (const c of m) o && "roundRect" in i ? i.roundRect(c.x, c.y, c.width, c.height, o) : i.rect(c.x, c.y, c.width, c.height);
+    i.fill(), i.closePath();
+  }
+  renderLineWaveform(t, e, i, s) {
+    const { width: n, height: r } = i.canvas, l = function({ channelData: a, width: o, height: u, vScale: p }) {
+      const d = u / 2, m = a[0] || [];
+      return [m, a[1] || m].map((c, f) => {
+        const g = c.length, E = g ? o / g : 0, k = d, M = f === 0 ? -1 : 1, C = [{ x: 0, y: k }];
+        let P = 0, S = 0;
+        for (let w = 0; w <= g; w++) {
+          const R = Math.round(w * E);
+          if (R > P) {
+            const b = k + (Math.round(S * d * p) || 1) * M;
+            C.push({ x: P, y: b }), P = R, S = 0;
+          }
+          const W = Math.abs(c[w] || 0);
+          W > S && (S = W);
+        }
+        return C.push({ x: P, y: k }), C;
+      });
+    }({ channelData: t, width: n, height: r, vScale: s });
+    i.beginPath();
+    for (const a of l) if (a.length) {
+      i.moveTo(a[0].x, a[0].y);
+      for (let o = 1; o < a.length; o++) {
+        const u = a[o];
+        i.lineTo(u.x, u.y);
+      }
+    }
+    i.fill(), i.closePath();
+  }
+  renderWaveform(t, e, i) {
+    if (i.fillStyle = this.convertColorValues(e.waveColor, i), e.renderFunction) return void e.renderFunction(t, i);
+    const s = function({ channelData: n, barHeight: r, normalize: l, maxPeak: a }) {
+      var o;
+      const u = r || 1;
+      if (!l) return u;
+      const p = n[0];
+      if (!p || p.length === 0) return u;
+      let d = a ?? 0;
+      if (!a) for (let m = 0; m < p.length; m++) {
+        const c = (o = p[m]) !== null && o !== void 0 ? o : 0, f = Math.abs(c);
+        f > d && (d = f);
+      }
+      return d ? u / d : u;
+    }({ channelData: t, barHeight: e.barHeight, normalize: e.normalize, maxPeak: e.maxPeak });
+    Y(e) ? this.renderBarWaveform(t, e, i, s) : this.renderLineWaveform(t, e, i, s);
+  }
+  renderSingleCanvas(t, e, i, s, n, r, l) {
+    const a = this.getPixelRatio(), o = document.createElement("canvas");
+    o.width = Math.round(i * a), o.height = Math.round(s * a), o.style.width = `${i}px`, o.style.height = `${s}px`, o.style.left = `${Math.round(n)}px`, r.appendChild(o);
+    const u = o.getContext("2d");
+    if (e.renderFunction ? (u.fillStyle = this.convertColorValues(e.waveColor, u), e.renderFunction(t, u)) : this.renderWaveform(t, e, u), o.width > 0 && o.height > 0) {
+      const p = o.cloneNode(), d = p.getContext("2d");
+      d.drawImage(o, 0, 0), d.globalCompositeOperation = "source-in", d.fillStyle = this.convertColorValues(e.progressColor, d), d.fillRect(0, 0, o.width, o.height), l.appendChild(p);
+    }
+  }
+  renderMultiCanvas(t, e, i, s, n, r) {
+    const l = this.getPixelRatio(), { clientWidth: a } = this.scrollContainer, o = i / l, u = function({ clientWidth: c, totalWidth: f, options: g }) {
+      return X(Math.min(8e3, c, f), g);
+    }({ clientWidth: a, totalWidth: o, options: e });
+    let p = {};
+    if (u === 0) return;
+    const d = (c) => {
+      if (c < 0 || c >= m || p[c]) return;
+      p[c] = !0;
+      const f = c * u;
+      let g = Math.min(o - f, u);
+      if (g = X(g, e), g <= 0) return;
+      const E = function({ channelData: k, offset: M, clampedWidth: C, totalWidth: P }) {
+        return k.map((S) => {
+          const w = Math.floor(M / P * S.length), R = Math.floor((M + C) / P * S.length);
+          return S.slice(w, R);
+        });
+      }({ channelData: t, offset: f, clampedWidth: g, totalWidth: o });
+      this.renderSingleCanvas(E, e, g, s, f, n, r);
+    }, m = Math.ceil(o / u);
+    if (!this.isScrollable) {
+      for (let c = 0; c < m; c++) d(c);
+      return;
+    }
+    if (U({ scrollLeft: this.scrollContainer.scrollLeft, totalWidth: o, numCanvases: m }).forEach((c) => d(c)), m > 1) {
+      const c = this.on("scroll", () => {
+        const { scrollLeft: f } = this.scrollContainer;
+        Object.keys(p).length > 10 && (n.innerHTML = "", r.innerHTML = "", p = {}), U({ scrollLeft: f, totalWidth: o, numCanvases: m }).forEach((g) => d(g));
+      });
+      this.unsubscribeOnScroll.push(c);
+    }
+  }
+  renderChannel(t, e, i, s) {
+    var { overlay: n } = e, r = function(u, p) {
+      var d = {};
+      for (var m in u) Object.prototype.hasOwnProperty.call(u, m) && p.indexOf(m) < 0 && (d[m] = u[m]);
+      if (u != null && typeof Object.getOwnPropertySymbols == "function") {
+        var c = 0;
+        for (m = Object.getOwnPropertySymbols(u); c < m.length; c++) p.indexOf(m[c]) < 0 && Object.prototype.propertyIsEnumerable.call(u, m[c]) && (d[m[c]] = u[m[c]]);
+      }
+      return d;
+    }(e, ["overlay"]);
+    const l = document.createElement("div"), a = this.getHeight(r.height, r.splitChannels);
+    l.style.height = `${a}px`, n && s > 0 && (l.style.marginTop = `-${a}px`), this.canvasWrapper.style.minHeight = `${a}px`, this.canvasWrapper.appendChild(l);
+    const o = l.cloneNode();
+    this.progressWrapper.appendChild(o), this.renderMultiCanvas(t, r, i, a, l, o);
+  }
+  render(t) {
+    return x(this, void 0, void 0, function* () {
+      var e;
+      this.timeouts.forEach((o) => o()), this.timeouts = [], this.unsubscribeOnScroll.forEach((o) => o()), this.unsubscribeOnScroll = [], this.canvasWrapper.innerHTML = "", this.progressWrapper.innerHTML = "", this.options.width != null && (this.scrollContainer.style.width = typeof this.options.width == "number" ? `${this.options.width}px` : this.options.width);
+      const i = this.getPixelRatio(), s = this.scrollContainer.clientWidth - this.containerInlinePadding, { scrollWidth: n, isScrollable: r, useParentWidth: l, width: a } = function({ duration: o, minPxPerSec: u = 0, parentWidth: p, fillParent: d, pixelRatio: m }) {
+        const c = Math.ceil(o * u), f = c > p, g = !!(d && !f);
+        return { scrollWidth: c, isScrollable: f, useParentWidth: g, width: (g ? p : c) * m };
+      }({ duration: t.duration, minPxPerSec: this.options.minPxPerSec || 0, parentWidth: s, fillParent: this.options.fillParent, pixelRatio: i });
+      if (this.isScrollable = r, this.wrapper.style.width = l ? "100%" : `${n}px`, this.scrollContainer.style.overflowX = this.isScrollable ? "auto" : "hidden", this.scrollContainer.classList.toggle("noScrollbar", !!this.options.hideScrollbar), this.cursor.style.backgroundColor = `${this.options.cursorColor || this.options.progressColor}`, this.cursor.style.width = `${this.options.cursorWidth}px`, this.audioData = t, this.emit("render"), this.options.splitChannels) for (let o = 0; o < t.numberOfChannels; o++) {
+        const u = Object.assign(Object.assign({}, this.options), (e = this.options.splitChannels) === null || e === void 0 ? void 0 : e[o]);
+        this.renderChannel([t.getChannelData(o)], u, a, o);
+      }
+      else {
+        const o = [t.getChannelData(0)];
+        t.numberOfChannels > 1 && o.push(t.getChannelData(1)), this.renderChannel(o, this.options, a, 0);
+      }
+      Promise.resolve().then(() => this.emit("rendered"));
+    });
+  }
+  reRender() {
+    if (this.unsubscribeOnScroll.forEach((i) => i()), this.unsubscribeOnScroll = [], !this.audioData) return;
+    const { scrollWidth: t } = this.scrollContainer, { right: e } = this.progressWrapper.getBoundingClientRect();
+    if (this.render(this.audioData), !this.isScrollable && this.scrollContainer.scrollLeft) this.scrollContainer.scrollLeft = 0;
+    else if (this.isScrollable && t !== this.scrollContainer.scrollWidth) {
+      const { right: i } = this.progressWrapper.getBoundingClientRect(), s = function(n) {
+        const r = 2 * n;
+        return (r < 0 ? Math.floor(r) : Math.ceil(r)) / 2;
+      }(i - e);
+      this.scrollContainer.scrollLeft += s;
+    }
+  }
+  zoom(t) {
+    this.options.minPxPerSec = t, this.reRender();
+  }
+  scrollIntoView(t, e = !1) {
+    var i;
+    const { scrollLeft: s, scrollWidth: n, clientWidth: r } = this.scrollContainer, l = t * n, a = s, o = s + r, u = r / 2;
+    if (this.isDragging)
+      l + 30 > o ? this.scrollContainer.scrollLeft += 30 : l - 30 < a && (this.scrollContainer.scrollLeft -= 30);
+    else {
+      (l < a || l > o) && (this.scrollContainer.scrollLeft = l - (this.options.autoCenter ? u : 0));
+      const p = l - s - u;
+      if (e && this.options.autoCenter && p > 0) {
+        const d = (i = this.audioData) === null || i === void 0 ? void 0 : i.duration;
+        if (d === void 0 || d <= 0) return void (this.scrollContainer.scrollLeft += p);
+        const m = n / d;
+        this.scrollContainer.scrollLeft += m <= 600 ? Math.min(p, 10) : p;
+      }
+    }
+  }
+  renderProgress(t, e) {
+    if (isNaN(t)) return;
+    const i = 100 * t;
+    this.canvasWrapper.style.clipPath = `polygon(${i}% 0%, 100% 0%, 100% 100%, ${i}% 100%)`, this.progressWrapper.style.width = `${i}%`, this.cursor.style.left = `${i}%`, this.cursor.style.transform = this.options.cursorWidth ? `translateX(-${t * this.options.cursorWidth}px)` : "", this.isScrollable && this.options.autoScroll && this.audioData && this.audioData.duration > 0 && this.scrollIntoView(t, e);
+  }
+  exportImage(t, e, i) {
+    return x(this, void 0, void 0, function* () {
+      const s = this.canvasWrapper.querySelectorAll("canvas");
+      if (!s.length) throw new Error("No waveform data");
+      if (i === "dataURL") {
+        const n = Array.from(s).map((r) => r.toDataURL(t, e));
+        return Promise.resolve(n);
+      }
+      return Promise.all(Array.from(s).map((n) => new Promise((r, l) => {
+        n.toBlob((a) => {
+          a ? r(a) : l(new Error("Could not export image"));
+        }, t, e);
+      })));
+    });
+  }
+}
+class ot extends N {
+  constructor() {
+    super(...arguments), this.animationFrameId = null, this.isRunning = !1;
+  }
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = !0;
+    const t = () => {
+      this.isRunning && (this.emit("tick"), this.animationFrameId = requestAnimationFrame(t));
+    };
+    t();
+  }
+  stop() {
+    this.isRunning = !1, this.animationFrameId !== null && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null);
+  }
+  destroy() {
+    this.stop(), this.unAll();
+  }
+}
+class I extends N {
+  constructor(t) {
+    super(), this.bufferNode = null, this.playStartTime = 0, this.playbackPosition = 0, this._muted = !1, this._playbackRate = 1, this._duration = void 0, this.buffer = null, this.currentSrc = "", this.paused = !0, this.crossOrigin = null, this.seeking = !1, this.autoplay = !1, this.addEventListener = this.on, this.removeEventListener = this.un, this._destroyed = !1, function() {
+      const e = globalThis.navigator;
+      if (e?.audioSession) try {
+        e.audioSession.type = "playback";
+      } catch (i) {
+        console.warn("Setting navigator.audioSession.type failed:", i);
+      }
+    }(), this.audioContext = t || new AudioContext(), this.gainNode = this.audioContext.createGain(), this.gainNode.connect(this.audioContext.destination);
+  }
+  load() {
+    return x(this, void 0, void 0, function* () {
+    });
+  }
+  remove() {
+    this.destroy();
+  }
+  destroy() {
+    if (!this._destroyed) {
+      if (this._destroyed = !0, this.currentSrc = "", this.bufferNode) {
+        this.bufferNode.onended = null;
+        try {
+          this.bufferNode.stop();
+        } catch {
+        }
+        this.bufferNode.disconnect(), this.bufferNode = null;
+      }
+      this.gainNode.disconnect(), typeof this.audioContext.close == "function" && Promise.resolve(this.audioContext.close.call(this.audioContext)).catch(() => {
+      }), this.buffer = null, this.unAll();
+    }
+  }
+  get src() {
+    return this.currentSrc;
+  }
+  set src(t) {
+    if (this.currentSrc = t, this._duration = void 0, !t) return this.buffer = null, void this.emit("emptied");
+    fetch(t).then((e) => {
+      if (e.status >= 400) throw new Error(`Failed to fetch ${t}: ${e.status} (${e.statusText})`);
+      return e.arrayBuffer();
+    }).then((e) => this.currentSrc !== t ? null : this.audioContext.decodeAudioData(e)).then((e) => {
+      this.currentSrc === t && (this.buffer = e, this.emit("loadedmetadata"), this.emit("canplay"), this.autoplay && this.play());
+    }).catch((e) => {
+      console.error("WebAudioPlayer load error:", e);
+    });
+  }
+  _play() {
+    if (!this.paused) return;
+    this.paused = !1, this.bufferNode && (this.bufferNode.onended = null, this.bufferNode.disconnect()), this.bufferNode = this.audioContext.createBufferSource(), this.buffer && (this.bufferNode.buffer = this.buffer), this.bufferNode.playbackRate.value = this._playbackRate, this.bufferNode.connect(this.gainNode);
+    let t = this.playbackPosition;
+    (t >= this.duration || t < 0) && (t = 0, this.playbackPosition = 0), this.bufferNode.start(this.audioContext.currentTime, t), this.playStartTime = this.audioContext.currentTime, this.bufferNode.onended = () => {
+      !this.paused && this.duration - this.currentTime < 0.01 && (this.pause(), this.emit("ended"));
+    };
+  }
+  _pause() {
+    if (this.paused = !0, this.bufferNode) {
+      this.bufferNode.onended = null;
+      try {
+        this.bufferNode.stop();
+      } catch {
+      }
+    }
+    this.playbackPosition += (this.audioContext.currentTime - this.playStartTime) * this._playbackRate;
+  }
+  play() {
+    return x(this, void 0, void 0, function* () {
+      this.paused && (this._play(), this.emit("play"));
+    });
+  }
+  pause() {
+    this.paused || (this._pause(), this.emit("pause"));
+  }
+  stopAt(t) {
+    const e = (t - this.currentTime) / this._playbackRate, i = this.bufferNode;
+    i?.stop(this.audioContext.currentTime + e), i?.addEventListener("ended", () => {
+      i === this.bufferNode && (this.bufferNode = null, this.pause(), this.playbackPosition = Math.min(t, this.duration), this.emit("timeupdate"));
+    }, { once: !0 });
+  }
+  setSinkId(t) {
+    return x(this, void 0, void 0, function* () {
+      return this.audioContext.setSinkId(t);
+    });
+  }
+  get playbackRate() {
+    return this._playbackRate;
+  }
+  set playbackRate(t) {
+    const e = !this.paused;
+    e && this._pause(), this._playbackRate = t, e && this._play(), this.bufferNode && (this.bufferNode.playbackRate.value = t);
+  }
+  get currentTime() {
+    return this.paused ? this.playbackPosition : this.playbackPosition + (this.audioContext.currentTime - this.playStartTime) * this._playbackRate;
+  }
+  set currentTime(t) {
+    const e = !this.paused;
+    e && this._pause(), this.playbackPosition = t, e && this._play(), this.emit("seeking"), this.emit("timeupdate");
+  }
+  get duration() {
+    var t, e;
+    return (t = this._duration) !== null && t !== void 0 ? t : ((e = this.buffer) === null || e === void 0 ? void 0 : e.duration) || 0;
+  }
+  set duration(t) {
+    this._duration = t;
+  }
+  get volume() {
+    return this.gainNode.gain.value;
+  }
+  set volume(t) {
+    this.gainNode.gain.value = t, this.emit("volumechange");
+  }
+  get muted() {
+    return this._muted;
+  }
+  set muted(t) {
+    this._muted !== t && (this._muted = t, this._muted ? this.gainNode.disconnect() : this.gainNode.connect(this.audioContext.destination));
+  }
+  canPlayType(t) {
+    return /^(audio|video)\//.test(t);
+  }
+  getGainNode() {
+    return this.gainNode;
+  }
+  getChannelData() {
+    const t = [];
+    if (!this.buffer) return t;
+    const e = this.buffer.numberOfChannels;
+    for (let i = 0; i < e; i++) t.push(this.buffer.getChannelData(i));
+    return t;
+  }
+  removeAttribute(t) {
+    switch (t) {
+      case "src":
+        this.src = "";
+        break;
+      case "playbackRate":
+        this.playbackRate = 0;
+        break;
+      case "currentTime":
+        this.currentTime = 0;
+        break;
+      case "duration":
+        this.duration = 0;
+        break;
+      case "volume":
+        this.volume = 0;
+        break;
+      case "muted":
+        this.muted = !1;
+    }
+  }
+}
+const at = { waveColor: "#999", progressColor: "#555", cursorWidth: 1, minPxPerSec: 0, fillParent: !0, interact: !0, dragToSeek: !1, autoScroll: !0, autoCenter: !0, sampleRate: 8e3 };
+class B extends et {
+  static create(t) {
+    return new B(t);
+  }
+  getState() {
+    return this.wavesurferState;
+  }
+  getRenderer() {
+    return this.renderer;
+  }
+  constructor(t) {
+    const e = t.media || (t.backend === "WebAudio" ? new I() : void 0);
+    super({ media: e, mediaControls: t.mediaControls, autoplay: t.autoplay, playbackRate: t.audioRate }), this.plugins = [], this.decodedData = null, this.stopAtPosition = null, this.subscriptions = [], this.mediaSubscriptions = [], this.abortController = null, this._isDestroyed = !1, this._loadVersion = 0, this.reactiveCleanups = [], this.options = Object.assign({}, at, t);
+    const { state: i, actions: s } = function(l) {
+      var a, o, u, p, d, m;
+      const c = (a = l?.currentTime) !== null && a !== void 0 ? a : y(0), f = (o = l?.duration) !== null && o !== void 0 ? o : y(0), g = (u = l?.isPlaying) !== null && u !== void 0 ? u : y(!1), E = (p = l?.isSeeking) !== null && p !== void 0 ? p : y(!1), k = (d = l?.volume) !== null && d !== void 0 ? d : y(1), M = (m = l?.playbackRate) !== null && m !== void 0 ? m : y(1), C = y(null), P = y(null), S = y(""), w = y(0), R = y(0), W = A(() => !g.value, [g]), b = A(() => C.value !== null, [C]), T = A(() => b.value && f.value > 0, [b, f]), D = A(() => c.value, [c]), _ = A(() => f.value > 0 ? c.value / f.value : 0, [c, f]);
+      return { state: { currentTime: c, duration: f, isPlaying: g, isPaused: W, isSeeking: E, volume: k, playbackRate: M, audioBuffer: C, peaks: P, url: S, zoom: w, scrollPosition: R, canPlay: b, isReady: T, progress: D, progressPercent: _ }, actions: { setCurrentTime: (v) => {
+        const O = Math.max(0, Math.min(f.value || 1 / 0, v));
+        c.set(O);
+      }, setDuration: (v) => {
+        f.set(Math.max(0, v));
+      }, setPlaying: (v) => {
+        g.set(v);
+      }, setSeeking: (v) => {
+        E.set(v);
+      }, setVolume: (v) => {
+        const O = Math.max(0, Math.min(1, v));
+        k.set(O);
+      }, setPlaybackRate: (v) => {
+        const O = Math.max(0.1, Math.min(16, v));
+        M.set(O);
+      }, setAudioBuffer: (v) => {
+        C.set(v), v && f.set(v.duration);
+      }, setPeaks: (v) => {
+        P.set(v);
+      }, setUrl: (v) => {
+        S.set(v);
+      }, setZoom: (v) => {
+        w.set(Math.max(0, v));
+      }, setScrollPosition: (v) => {
+        R.set(Math.max(0, v));
+      } } };
+    }({ isPlaying: this.isPlayingSignal, currentTime: this.currentTimeSignal, duration: this.durationSignal, volume: this.volumeSignal, playbackRate: this.playbackRateSignal, isSeeking: this.seekingSignal });
+    this.wavesurferState = i, this.wavesurferActions = s, this.timer = new ot();
+    const n = e ? void 0 : this.getMediaElement();
+    this.renderer = new rt(this.options, n), this.initPlayerEvents(), this.initRendererEvents(), this.initTimerEvents(), this.initReactiveState(), this.initPlugins();
+    const r = this.options.url || this.getSrc() || "";
+    Promise.resolve().then(() => {
+      this.emit("init");
+      const { peaks: l, duration: a } = this.options;
+      (r || l && a) && this.load(r, l, a).catch(() => {
+      });
+    });
+  }
+  updateProgress(t = this.getCurrentTime()) {
+    return this.renderer.renderProgress(t / this.getDuration(), this.isPlaying()), t;
+  }
+  initTimerEvents() {
+    this.subscriptions.push(this.timer.on("tick", () => {
+      if (!this.isSeeking()) {
+        const t = this.updateProgress();
+        if (this.emit("timeupdate", t), this.emit("audioprocess", t), this.stopAtPosition != null && this.isPlaying() && t >= this.stopAtPosition) {
+          const e = this.stopAtPosition;
+          this.pause(), this.setTime(e);
+        }
+      }
+    }));
+  }
+  initReactiveState() {
+    this.reactiveCleanups.push(function(t, e) {
+      const i = [];
+      i.push(L(() => {
+        const r = t.isPlaying.value;
+        e.emit(r ? "play" : "pause");
+      }, [t.isPlaying])), i.push(L(() => {
+        const r = t.currentTime.value;
+        e.emit("timeupdate", r), t.isPlaying.value && e.emit("audioprocess", r);
+      }, [t.currentTime, t.isPlaying])), i.push(L(() => {
+        t.isSeeking.value && e.emit("seeking", t.currentTime.value);
+      }, [t.isSeeking, t.currentTime]));
+      let s = !1;
+      i.push(L(() => {
+        t.isReady.value && !s && (s = !0, e.emit("ready", t.duration.value));
+      }, [t.isReady, t.duration])), i.push(L(() => {
+        t.audioBuffer.value === null && (s = !1);
+      }, [t.audioBuffer]));
+      let n = !1;
+      return i.push(L(() => {
+        const r = t.isPlaying.value, l = t.currentTime.value, a = t.duration.value, o = a > 0 && l >= a;
+        n && !r && o && e.emit("finish"), n = r && o;
+      }, [t.isPlaying, t.currentTime, t.duration])), i.push(L(() => {
+        const r = t.zoom.value;
+        r > 0 && e.emit("zoom", r);
+      }, [t.zoom])), () => {
+        i.forEach((r) => r());
+      };
+    }(this.wavesurferState, { emit: this.emit.bind(this) }));
+  }
+  initPlayerEvents() {
+    this.isPlaying() && (this.emit("play"), this.timer.start()), this.mediaSubscriptions.push(this.onMediaEvent("timeupdate", () => {
+      const t = this.updateProgress();
+      this.emit("timeupdate", t);
+    }), this.onMediaEvent("play", () => {
+      this.emit("play"), this.timer.start();
+    }), this.onMediaEvent("pause", () => {
+      this.emit("pause"), this.timer.stop(), this.stopAtPosition = null;
+    }), this.onMediaEvent("emptied", () => {
+      this.timer.stop(), this.stopAtPosition = null;
+    }), this.onMediaEvent("ended", () => {
+      this.emit("timeupdate", this.getDuration()), this.emit("finish"), this.stopAtPosition = null;
+    }), this.onMediaEvent("seeking", () => {
+      this.emit("seeking", this.getCurrentTime());
+    }), this.onMediaEvent("error", () => {
+      var t;
+      this.emit("error", (t = this.getMediaElement().error) !== null && t !== void 0 ? t : new Error("Media error")), this.stopAtPosition = null;
+    }));
+  }
+  initRendererEvents() {
+    this.subscriptions.push(this.renderer.on("click", (t, e) => {
+      this.options.interact && (this.seekTo(t), this.emit("interaction", t * this.getDuration()), this.emit("click", t, e));
+    }), this.renderer.on("dblclick", (t, e) => {
+      this.emit("dblclick", t, e);
+    }), this.renderer.on("scroll", (t, e, i, s) => {
+      const n = this.getDuration();
+      this.emit("scroll", t * n, e * n, i, s);
+    }), this.renderer.on("render", () => {
+      this.emit("redraw");
+    }), this.renderer.on("rendered", () => {
+      this.emit("redrawcomplete");
+    }), this.renderer.on("dragstart", (t) => {
+      this.emit("dragstart", t);
+    }), this.renderer.on("dragend", (t) => {
+      this.emit("dragend", t);
+    }), this.renderer.on("resize", () => {
+      this.emit("resize");
+    }));
+    {
+      let t;
+      const e = this.renderer.on("drag", (i) => {
+        var s;
+        if (!this.options.interact) return;
+        this.renderer.renderProgress(i), clearTimeout(t);
+        let n = 0;
+        const r = this.options.dragToSeek;
+        this.isPlaying() ? n = 0 : r === !0 ? n = 200 : r && typeof r == "object" && (n = (s = r.debounceTime) !== null && s !== void 0 ? s : 200), t = setTimeout(() => {
+          this.seekTo(i);
+        }, n), this.emit("interaction", i * this.getDuration()), this.emit("drag", i);
+      });
+      this.subscriptions.push(() => {
+        clearTimeout(t), e();
+      });
+    }
+  }
+  initPlugins() {
+    var t;
+    !((t = this.options.plugins) === null || t === void 0) && t.length && this.options.plugins.forEach((e) => {
+      this.registerPlugin(e);
+    });
+  }
+  unsubscribePlayerEvents() {
+    this.mediaSubscriptions.forEach((t) => t()), this.mediaSubscriptions = [];
+  }
+  setOptions(t) {
+    this.options = Object.assign({}, this.options, t), t.duration && !t.peaks && (this.decodedData = H.createBuffer(this.exportPeaks(), t.duration)), t.peaks && t.duration && (this.decodedData = H.createBuffer(t.peaks, t.duration)), this.renderer.setOptions(this.options), t.audioRate && this.setPlaybackRate(t.audioRate), t.mediaControls != null && (this.getMediaElement().controls = t.mediaControls);
+  }
+  registerPlugin(t) {
+    if (this.plugins.includes(t)) return t;
+    t._init(this), this.plugins.push(t);
+    const e = t.once("destroy", () => {
+      this.plugins = this.plugins.filter((i) => i !== t), this.subscriptions = this.subscriptions.filter((i) => i !== e);
+    });
+    return this.subscriptions.push(e), t;
+  }
+  unregisterPlugin(t) {
+    this.plugins = this.plugins.filter((e) => e !== t), t.destroy();
+  }
+  getWrapper() {
+    return this.renderer.getWrapper();
+  }
+  getWidth() {
+    return this.renderer.getWidth();
+  }
+  getScroll() {
+    return this.renderer.getScroll();
+  }
+  setScroll(t) {
+    return this.renderer.setScroll(t);
+  }
+  setScrollTime(t) {
+    const e = t / this.getDuration();
+    this.renderer.setScrollPercentage(e);
+  }
+  getActivePlugins() {
+    return this.plugins;
+  }
+  loadAudio(t, e, i, s) {
+    return x(this, void 0, void 0, function* () {
+      var n;
+      const r = ++this._loadVersion;
+      if (this._isDestroyed = !1, this.emit("load", t), !this.options.media && this.isPlaying() && this.pause(), this.decodedData = null, this.stopAtPosition = null, (n = this.abortController) === null || n === void 0 || n.abort(), this.abortController = null, !e && !i) {
+        const a = this.options.fetchParams || {};
+        window.AbortController && !a.signal && (this.abortController = new AbortController(), a.signal = this.abortController.signal);
+        const o = (p) => this.emit("loading", p);
+        if (e = yield tt.fetchBlob(t, o, a), this._isDestroyed || r !== this._loadVersion) return;
+        const u = this.options.blobMimeType;
+        u && (e = new Blob([e], { type: u }));
+      }
+      if (this._isDestroyed || r !== this._loadVersion) return;
+      this.setSrc(t, e);
+      const l = yield new Promise((a) => {
+        const o = s || this.getDuration();
+        o ? a(o) : this.mediaSubscriptions.push(this.onMediaEvent("loadedmetadata", () => a(this.getDuration()), { once: !0 }));
+      });
+      if (!this._isDestroyed && r === this._loadVersion) {
+        if (!t && !e) {
+          const a = this.getMediaElement();
+          a instanceof I && (a.duration = l);
+        }
+        if (i) this.decodedData = H.createBuffer(i, l || 0);
+        else if (e) {
+          const a = yield e.arrayBuffer();
+          if (this._isDestroyed || r !== this._loadVersion) return;
+          this.decodedData = yield H.decode(a, this.options.sampleRate);
+        }
+        this._isDestroyed || r !== this._loadVersion || (this.decodedData && (this.emit("decode", this.getDuration()), this.renderer.render(this.decodedData)), this.emit("ready", this.getDuration()));
+      }
+    });
+  }
+  load(t, e, i) {
+    return x(this, void 0, void 0, function* () {
+      try {
+        return yield this.loadAudio(t, void 0, e, i);
+      } catch (s) {
+        throw this.emit("error", s), s;
+      }
+    });
+  }
+  loadBlob(t, e, i) {
+    return x(this, void 0, void 0, function* () {
+      try {
+        return yield this.loadAudio("", t, e, i);
+      } catch (s) {
+        throw this.emit("error", s), s;
+      }
+    });
+  }
+  zoom(t) {
+    if (!this.decodedData) throw new Error("No audio loaded");
+    this.renderer.zoom(t), this.emit("zoom", t);
+  }
+  getDecodedData() {
+    return this.decodedData;
+  }
+  exportPeaks({ channels: t = 2, maxLength: e = 8e3, precision: i = 1e4 } = {}) {
+    if (!this.decodedData) throw new Error("The audio has not been decoded yet");
+    const s = Math.min(t, this.decodedData.numberOfChannels), n = [];
+    for (let r = 0; r < s; r++) {
+      const l = this.decodedData.getChannelData(r), a = [], o = l.length / e;
+      for (let u = 0; u < e; u++) {
+        const p = l.slice(Math.floor(u * o), Math.ceil((u + 1) * o));
+        let d = 0;
+        for (let m = 0; m < p.length; m++) {
+          const c = p[m];
+          Math.abs(c) > Math.abs(d) && (d = c);
+        }
+        a.push(Math.round(d * i) / i);
+      }
+      n.push(a);
+    }
+    return n;
+  }
+  getDuration() {
+    let t = super.getDuration() || 0;
+    return t !== 0 && t !== 1 / 0 || !this.decodedData || (t = this.decodedData.duration), t;
+  }
+  toggleInteraction(t) {
+    this.options.interact = t;
+  }
+  setTime(t) {
+    this.stopAtPosition = null, super.setTime(t), this.updateProgress(t), this.emit("timeupdate", t);
+  }
+  seekTo(t) {
+    const e = this.getDuration() * t;
+    this.setTime(e);
+  }
+  play(t, e) {
+    const i = Object.create(null, { play: { get: () => super.play } });
+    return x(this, void 0, void 0, function* () {
+      t != null && this.setTime(t);
+      const s = yield i.play.call(this);
+      return e != null && (this.media instanceof I ? this.media.stopAt(e) : this.stopAtPosition = e), s;
+    });
+  }
+  playPause() {
+    return x(this, void 0, void 0, function* () {
+      return this.isPlaying() ? this.pause() : this.play();
+    });
+  }
+  stop() {
+    this.pause(), this.setTime(0);
+  }
+  skip(t) {
+    this.setTime(this.getCurrentTime() + t);
+  }
+  empty() {
+    this.load("", [[0]], 1e-3);
+  }
+  setMediaElement(t) {
+    this.unsubscribePlayerEvents(), super.setMediaElement(t), this.initPlayerEvents();
+  }
+  exportImage() {
+    return x(this, arguments, void 0, function* (t = "image/png", e = 1, i = "dataURL") {
+      return this.renderer.exportImage(t, e, i);
+    });
+  }
+  destroy() {
+    var t;
+    this._isDestroyed = !0, this.emit("destroy"), (t = this.abortController) === null || t === void 0 || t.abort(), this.plugins.forEach((e) => e.destroy()), this.subscriptions.forEach((e) => e()), this.unsubscribePlayerEvents(), this.reactiveCleanups.forEach((e) => e()), this.reactiveCleanups = [], this.timer.destroy(), this.renderer.destroy(), super.destroy();
+  }
+}
+B.BasePlugin = class extends N {
+  constructor(h) {
+    super(), this.subscriptions = [], this.isDestroyed = !1, this.options = h;
+  }
+  onInit() {
+  }
+  _init(h) {
+    this.isDestroyed && (this.subscriptions = [], this.isDestroyed = !1), this.wavesurfer = h, this.onInit();
+  }
+  destroy() {
+    this.emit("destroy"), this.subscriptions.forEach((h) => h()), this.subscriptions = [], this.isDestroyed = !0, this.wavesurfer = void 0;
+  }
+}, B.dom = Q;
+export {
+  B as default
+};