@prose-reader/enhancer-audio 1.303.0 → 1.304.0

package/dist/index.js

@@ -1,935 +1,537 @@
-import { ReactiveEntity, mapKeysTo, isDefined, DocumentRenderer, setStylePropertyIfChanged } from '@prose-reader/core';
-import { BehaviorSubject, Subscription, distinctUntilChanged, switchMap, of, concat, map, defaultIfEmpty, defer, from, EMPTY, animationFrames, fromEvent, share, merge, retry, take, shareReplay, combineLatest, Subject, withLatestFrom, filter, tap, catchError, takeUntil } from 'rxjs';
-
-const AUDIO_VISUALIZER_LEVEL_COUNT = 80;
-const AUDIO_VISUALIZER_NOISE_FLOOR = 0.035;
-const getIdleVisualizerLevels = () => Array.from({ length: AUDIO_VISUALIZER_LEVEL_COUNT }, () => 0);
-const getVisualizerLevels = (data) => {
-  if (data.length === 0) return getIdleVisualizerLevels();
-  const bucketSize = Math.max(
-    1,
-    Math.floor(data.length / AUDIO_VISUALIZER_LEVEL_COUNT)
-  );
-  return Array.from({ length: AUDIO_VISUALIZER_LEVEL_COUNT }, (_, index) => {
-    const start = index * bucketSize;
-    const end = Math.min(data.length, start + bucketSize);
-    if (start >= data.length || start === end) return 0;
-    let total = 0;
-    for (let cursor = start; cursor < end; cursor += 1) {
-      total += data[cursor] ?? 0;
-    }
-    const average = total / (end - start);
-    const normalizedAverage = average / 255;
-    const gatedAverage = (normalizedAverage - AUDIO_VISUALIZER_NOISE_FLOOR) / (1 - AUDIO_VISUALIZER_NOISE_FLOOR);
-    return Math.max(0, Math.min(1, gatedAverage));
-  });
-};
-
-const AUDIO_VISUALIZER_FFT_SIZE = 256;
-class VisualizerAudioGraph {
-  constructor(audioElement) {
-    this.audioElement = audioElement;
-  }
-  audioElement;
-  audioContext;
-  audioSourceNode;
-  analyserNode;
-  frequencyData;
-  async resumeIfNeeded() {
-    if (!this.ensure()) {
-      return false;
-    }
-    const audioContext = this.audioContext;
-    if (!audioContext) {
-      return false;
-    }
-    if (audioContext.state !== `suspended`) {
-      return true;
-    }
-    try {
-      await audioContext.resume();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  readLevels() {
-    if (!this.analyserNode || !this.frequencyData) {
-      return getIdleVisualizerLevels();
-    }
-    this.analyserNode.getByteFrequencyData(this.frequencyData);
-    return getVisualizerLevels(this.frequencyData);
-  }
-  destroy() {
-    this.audioSourceNode?.disconnect();
-    this.analyserNode?.disconnect();
-    this.audioContext?.close().catch(() => void 0);
-    this.audioContext = void 0;
-    this.audioSourceNode = void 0;
-    this.analyserNode = void 0;
-    this.frequencyData = void 0;
-  }
-  ensure() {
-    if (this.audioContext && this.analyserNode && this.frequencyData) {
-      return true;
-    }
-    if (typeof window === `undefined` || !window.AudioContext) {
-      return false;
-    }
-    const audioContext = new window.AudioContext();
-    const audioSourceNode = audioContext.createMediaElementSource(
-      this.audioElement
-    );
-    const analyserNode = audioContext.createAnalyser();
-    analyserNode.fftSize = AUDIO_VISUALIZER_FFT_SIZE;
-    analyserNode.smoothingTimeConstant = 0.8;
-    audioSourceNode.connect(analyserNode);
-    analyserNode.connect(audioContext.destination);
-    this.audioContext = audioContext;
-    this.audioSourceNode = audioSourceNode;
-    this.analyserNode = analyserNode;
-    this.frequencyData = new Uint8Array(analyserNode.frequencyBinCount);
-    return true;
-  }
-}
-
-class AudioVisualizer extends ReactiveEntity {
-  audioGraph;
-  playbackState$ = new BehaviorSubject({
-    trackId: void 0,
-    isRunning: false,
-    resetLevels: false
-  });
-  subscriptions = new Subscription();
-  constructor(audioElement) {
-    super({
-      levels: getIdleVisualizerLevels(),
-      isActive: false,
-      trackId: void 0
-    });
-    this.audioGraph = new VisualizerAudioGraph(audioElement);
-    this.subscriptions.add(
-      this.playbackState$.pipe(
-        distinctUntilChanged(
-          (previous, next) => previous.trackId === next.trackId && previous.isRunning === next.isRunning && previous.resetLevels === next.resetLevels
-        ),
-        switchMap(({ trackId, isRunning, resetLevels }) => {
-          if (!trackId || !isRunning) {
-            return of({
-              trackId,
-              isActive: false,
-              ...resetLevels ? { levels: getIdleVisualizerLevels() } : void 0
-            });
-          }
-          const shouldResetLevels = this.value.trackId !== trackId;
-          return concat(
-            of({
-              trackId,
-              isActive: true,
-              ...shouldResetLevels ? { levels: getIdleVisualizerLevels() } : void 0
-            }),
-            this.createLevels$().pipe(
-              map((levels) => ({
-                trackId,
-                levels,
-                isActive: true
-              })),
-              defaultIfEmpty({
-                trackId,
-                isActive: false,
-                levels: getIdleVisualizerLevels()
-              })
-            )
-          );
-        })
-      ).subscribe((value) => {
-        this.mergeCompare(value);
-      })
-    );
-  }
-  start(currentTrack) {
-    if (!currentTrack) return;
-    this.playbackState$.next({
-      trackId: currentTrack.id,
-      isRunning: true,
-      resetLevels: false
-    });
-  }
-  setTrack(trackId) {
-    this.playbackState$.next({
-      trackId,
-      isRunning: false,
-      resetLevels: false
-    });
-  }
-  reset(trackId) {
-    this.playbackState$.next({
-      trackId,
-      isRunning: false,
-      resetLevels: true
-    });
-  }
-  stop({ resetLevels = false } = {}) {
-    this.playbackState$.next({
-      trackId: this.playbackState$.value.trackId,
-      isRunning: false,
-      resetLevels
-    });
-  }
-  destroy() {
-    this.stop({
-      resetLevels: true
-    });
-    this.subscriptions.unsubscribe();
-    this.playbackState$.complete();
-    this.audioGraph.destroy();
-    super.destroy();
-  }
-  createLevels$() {
-    return defer(() => {
-      return from(this.audioGraph.resumeIfNeeded()).pipe(
-        switchMap(
-          (isReady) => isReady ? animationFrames().pipe(map(() => this.audioGraph.readLevels())) : EMPTY
-        )
-      );
-    });
-  }
-}
-
-class AudioElementAdapter {
-  element;
-  canPlay$;
-  ended$;
-  isPlaying$;
-  metrics$;
-  constructor() {
-    this.element = document.createElement(`audio`);
-    this.element.preload = `metadata`;
-    this.canPlay$ = fromEvent(this.element, `canplay`).pipe(share());
-    this.ended$ = fromEvent(this.element, `ended`).pipe(share());
-    this.isPlaying$ = merge(
-      fromEvent(this.element, `play`).pipe(map(() => true)),
-      fromEvent(this.element, `pause`).pipe(map(() => false))
-    ).pipe(share());
-    this.metrics$ = merge(
-      fromEvent(this.element, `timeupdate`),
-      fromEvent(this.element, `seeking`),
-      fromEvent(this.element, `seeked`),
-      fromEvent(this.element, `loadedmetadata`),
-      fromEvent(this.element, `durationchange`),
-      this.canPlay$
-    ).pipe(
-      map(() => ({
-        currentTime: this.element.currentTime,
-        duration: Number.isFinite(this.element.duration) ? this.element.duration : void 0
-      })),
-      share()
-    );
-  }
-  get paused() {
-    return this.element.paused;
-  }
-  get hasSource() {
-    return this.element.hasAttribute(`src`);
-  }
-  play$() {
-    return defer(() => from(this.element.play())).pipe(
-      retry({
-        count: 1,
-        delay: () => this.canPlay$.pipe(take(1))
-      })
-    );
-  }
-  pause() {
-    this.element.pause();
-  }
-  loadSource(src) {
-    this.element.src = src;
-    this.element.load();
-  }
-  unloadSource() {
-    this.element.removeAttribute(`src`);
-    this.element.load();
-  }
-  setCurrentTime(value) {
-    this.element.currentTime = value;
-  }
-}
-
-class ResourcesResolver {
-  cachedSourceByTrackId = /* @__PURE__ */ new Map();
-  hasCachedSource(trackId) {
-    return this.cachedSourceByTrackId.has(trackId);
-  }
-  getTrackResourceUrl$ = (track, resourcesHandler) => {
-    const cachedSource = this.cachedSourceByTrackId.get(track.id);
-    if (cachedSource) {
-      return of(cachedSource.url);
-    }
-    const resource$ = from(resourcesHandler.getResource());
-    return resource$.pipe(
-      switchMap((resource) => {
-        if (resource instanceof URL) {
-          this.cachedSourceByTrackId.set(track.id, {
-            url: resource.href
-          });
-          return of(resource.href);
-        }
-        if (resource instanceof Response) {
-          return from(resource.blob()).pipe(
-            map((blob) => {
-              const objectUrl = URL.createObjectURL(blob);
-              this.cachedSourceByTrackId.set(track.id, {
-                url: objectUrl,
-                release: () => {
-                  URL.revokeObjectURL(objectUrl);
-                }
-              });
-              return objectUrl;
-            })
-          );
-        }
-        this.cachedSourceByTrackId.set(track.id, {
-          url: track.href
-        });
-        return of(track.href);
-      })
-    );
-  };
-  releaseTrackSource(trackId) {
-    const cachedSource = this.cachedSourceByTrackId.get(trackId);
-    if (!cachedSource) return;
-    this.cachedSourceByTrackId.delete(trackId);
-    cachedSource.release?.();
-  }
-  releaseAll() {
-    for (const trackId of this.cachedSourceByTrackId.keys()) {
-      this.releaseTrackSource(trackId);
-    }
-  }
-  destroy() {
-    this.releaseAll();
-  }
-}
-
-const y = (e, t) => e === t ? true : e.length !== t.length ? false : e.every((n, o) => n === t[o]);
-const F = (e, t, n) => {
-  if (Object.is(e, t))
-    return true;
-  if (typeof e != "object" || e === null || typeof t != "object" || t === null)
-    return false;
-  const o = Object.keys(e), r = Object.keys(t);
-  if (o.length !== r.length)
-    return false;
-  const l = n?.customEqual ?? Object.is, c = e, s = t;
-  for (const a of o)
-    if (!Object.hasOwn(s, a) || !l(c[a], s[a]))
-      return false;
-  return true;
-};
-const m = () => {
-  if (!(typeof window > "u"))
-    return window;
+import { DocumentRenderer as e, ReactiveEntity as t, isDefined as n, mapKeysTo as r, setStylePropertyIfChanged as i } from "@prose-reader/core";
+import { BehaviorSubject as a, EMPTY as o, Subject as s, Subscription as c, animationFrames as l, catchError as u, combineLatest as d, concat as f, defaultIfEmpty as p, defer as m, distinctUntilChanged as h, filter as g, from as _, fromEvent as v, map as y, merge as b, of as x, retry as S, share as C, shareReplay as w, switchMap as T, take as E, takeUntil as D, tap as O, withLatestFrom as k } from "rxjs";
+//#region src/visualizer/levels.ts
+var A = 80, j = .035, M = () => Array.from({ length: A }, () => 0), N = (e) => {
+	if (e.length === 0) return M();
+	let t = Math.max(1, Math.floor(e.length / A));
+	return Array.from({ length: A }, (n, r) => {
+		let i = r * t, a = Math.min(e.length, i + t);
+		if (i >= e.length || i === a) return 0;
+		let o = 0;
+		for (let t = i; t < a; t += 1) o += e[t] ?? 0;
+		let s = (o / (a - i) / 255 - j) / (1 - j);
+		return Math.max(0, Math.min(1, s));
+	});
+}, P = 256, ee = class {
+	audioElement;
+	audioContext;
+	audioSourceNode;
+	analyserNode;
+	frequencyData;
+	constructor(e) {
+		this.audioElement = e;
+	}
+	async resumeIfNeeded() {
+		if (!this.ensure()) return !1;
+		let e = this.audioContext;
+		if (!e) return !1;
+		if (e.state !== "suspended") return !0;
+		try {
+			return await e.resume(), !0;
+		} catch {
+			return !1;
+		}
+	}
+	readLevels() {
+		return !this.analyserNode || !this.frequencyData ? M() : (this.analyserNode.getByteFrequencyData(this.frequencyData), N(this.frequencyData));
+	}
+	destroy() {
+		this.audioSourceNode?.disconnect(), this.analyserNode?.disconnect(), this.audioContext?.close().catch(() => void 0), this.audioContext = void 0, this.audioSourceNode = void 0, this.analyserNode = void 0, this.frequencyData = void 0;
+	}
+	ensure() {
+		if (this.audioContext && this.analyserNode && this.frequencyData) return !0;
+		if (typeof window > "u" || !window.AudioContext) return !1;
+		let e = new window.AudioContext(), t = e.createMediaElementSource(this.audioElement), n = e.createAnalyser();
+		return n.fftSize = P, n.smoothingTimeConstant = .8, t.connect(n), n.connect(e.destination), this.audioContext = e, this.audioSourceNode = t, this.analyserNode = n, this.frequencyData = new Uint8Array(n.frequencyBinCount), !0;
+	}
+}, F = class extends t {
+	audioGraph;
+	playbackState$ = new a({
+		trackId: void 0,
+		isRunning: !1,
+		resetLevels: !1
+	});
+	subscriptions = new c();
+	constructor(e) {
+		super({
+			levels: M(),
+			isActive: !1,
+			trackId: void 0
+		}), this.audioGraph = new ee(e), this.subscriptions.add(this.playbackState$.pipe(h((e, t) => e.trackId === t.trackId && e.isRunning === t.isRunning && e.resetLevels === t.resetLevels), T(({ trackId: e, isRunning: t, resetLevels: n }) => !e || !t ? x({
+			trackId: e,
+			isActive: !1,
+			...n ? { levels: M() } : void 0
+		}) : f(x({
+			trackId: e,
+			isActive: !0,
+			...this.value.trackId === e ? void 0 : { levels: M() }
+		}), this.createLevels$().pipe(y((t) => ({
+			trackId: e,
+			levels: t,
+			isActive: !0
+		})), p({
+			trackId: e,
+			isActive: !1,
+			levels: M()
+		}))))).subscribe((e) => {
+			this.mergeCompare(e);
+		}));
+	}
+	start(e) {
+		e && this.playbackState$.next({
+			trackId: e.id,
+			isRunning: !0,
+			resetLevels: !1
+		});
+	}
+	setTrack(e) {
+		this.playbackState$.next({
+			trackId: e,
+			isRunning: !1,
+			resetLevels: !1
+		});
+	}
+	reset(e) {
+		this.playbackState$.next({
+			trackId: e,
+			isRunning: !1,
+			resetLevels: !0
+		});
+	}
+	stop({ resetLevels: e = !1 } = {}) {
+		this.playbackState$.next({
+			trackId: this.playbackState$.value.trackId,
+			isRunning: !1,
+			resetLevels: e
+		});
+	}
+	destroy() {
+		this.stop({ resetLevels: !0 }), this.subscriptions.unsubscribe(), this.playbackState$.complete(), this.audioGraph.destroy(), super.destroy();
+	}
+	createLevels$() {
+		return m(() => _(this.audioGraph.resumeIfNeeded()).pipe(T((e) => e ? l().pipe(y(() => this.audioGraph.readLevels())) : o)));
+	}
+}, I = class {
+	element;
+	canPlay$;
+	ended$;
+	isPlaying$;
+	metrics$;
+	constructor() {
+		this.element = document.createElement("audio"), this.element.preload = "metadata", this.canPlay$ = v(this.element, "canplay").pipe(C()), this.ended$ = v(this.element, "ended").pipe(C()), this.isPlaying$ = b(v(this.element, "play").pipe(y(() => !0)), v(this.element, "pause").pipe(y(() => !1))).pipe(C()), this.metrics$ = b(v(this.element, "timeupdate"), v(this.element, "seeking"), v(this.element, "seeked"), v(this.element, "loadedmetadata"), v(this.element, "durationchange"), this.canPlay$).pipe(y(() => ({
+			currentTime: this.element.currentTime,
+			duration: Number.isFinite(this.element.duration) ? this.element.duration : void 0
+		})), C());
+	}
+	get paused() {
+		return this.element.paused;
+	}
+	get hasSource() {
+		return this.element.hasAttribute("src");
+	}
+	play$() {
+		return m(() => _(this.element.play())).pipe(S({
+			count: 1,
+			delay: () => this.canPlay$.pipe(E(1))
+		}));
+	}
+	pause() {
+		this.element.pause();
+	}
+	loadSource(e) {
+		this.element.src = e, this.element.load();
+	}
+	unloadSource() {
+		this.element.removeAttribute("src"), this.element.load();
+	}
+	setCurrentTime(e) {
+		this.element.currentTime = e;
+	}
+}, L = class {
+	cachedSourceByTrackId = /* @__PURE__ */ new Map();
+	hasCachedSource(e) {
+		return this.cachedSourceByTrackId.has(e);
+	}
+	getTrackResourceUrl$ = (e, t) => {
+		let n = this.cachedSourceByTrackId.get(e.id);
+		return n ? x(n.url) : _(t.getResource()).pipe(T((t) => t instanceof URL ? (this.cachedSourceByTrackId.set(e.id, { url: t.href }), x(t.href)) : t instanceof Response ? _(t.blob()).pipe(y((t) => {
+			let n = URL.createObjectURL(t);
+			return this.cachedSourceByTrackId.set(e.id, {
+				url: n,
+				release: () => {
+					URL.revokeObjectURL(n);
+				}
+			}), n;
+		})) : (this.cachedSourceByTrackId.set(e.id, { url: e.href }), x(e.href))));
+	};
+	releaseTrackSource(e) {
+		let t = this.cachedSourceByTrackId.get(e);
+		t && (this.cachedSourceByTrackId.delete(e), t.release?.());
+	}
+	releaseAll() {
+		for (let e of this.cachedSourceByTrackId.keys()) this.releaseTrackSource(e);
+	}
+	destroy() {
+		this.releaseAll();
+	}
+}, R = (e, t) => e === t ? !0 : e.length === t.length ? e.every((e, n) => e === t[n]) : !1, z = (e, t, n) => {
+	if (Object.is(e, t)) return !0;
+	if (typeof e != "object" || !e || typeof t != "object" || !t) return !1;
+	let r = Object.keys(e), i = Object.keys(t);
+	if (r.length !== i.length) return !1;
+	let a = n?.customEqual ?? Object.is, o = e, s = t;
+	for (let e of r) if (!Object.hasOwn(s, e) || !a(o[e], s[e])) return !1;
+	return !0;
+}, B = () => {
+	if (!(typeof window > "u")) return window;
 };
-function b() {
-  const e = m()?.__PROSE_READER_DEBUG;
-  return e === true || e === "true";
+function V() {
+	let e = B()?.__PROSE_READER_DEBUG;
+	return e === !0 || e === "true";
 }
-const E = (e, t) => typeof e == "boolean" ? {
-  enabled: e,
-  options: t
+var H = (e, t) => typeof e == "boolean" ? {
+	enabled: e,
+	options: t
 } : {
-  enabled: e?.enabled,
-  options: e ?? t
-}, w = (e) => e.at(-1)?.color, u = (e) => {
-  if (!e.length)
-    return;
-  if (!e.some((o) => o.color))
-    return [e.map((o) => o.label).join(" ")];
-  let t = "";
-  const n = [];
-  for (const o of e)
-    t += `%c${t ? ` ${o.label}` : o.label}`, n.push(
-      o.color ? `color: ${o.color}` : ""
-    );
-  return [t, ...n];
-}, p = (e = [], t = b()) => {
-  let n = t;
-  const o = {
-    enable: (c) => {
-      l(c);
-    },
-    namespace: (c, s, a) => {
-      const i = E(
-        s,
-        a
-      ), g = i.options?.color ?? w(e);
-      return p(
-        [
-          ...e,
-          {
-            label: `[${c}]`,
-            color: g
-          }
-        ],
-        i.enabled ?? n
-      );
-    },
-    isEnabled: () => n,
-    debug: () => {
-    },
-    info: () => {
-    },
-    log: () => {
-    },
-    groupCollapsed: () => {
-    },
-    groupEnd: () => {
-    },
-    getGroupArgs: (c) => {
-      const s = u(e);
-      if (!s)
-        return [c];
-      const [a, ...i] = s;
-      return [`${a} ${c}`, ...i];
-    },
-    warn: () => {
-    },
-    error: () => {
-    }
-  }, r = (c) => {
-    if (!c) {
-      o.debug = () => {
-      }, o.info = () => {
-      }, o.log = () => {
-      }, o.groupCollapsed = () => {
-      }, o.groupEnd = () => {
-      }, o.warn = () => {
-      }, o.error = () => {
-      };
-      return;
-    }
-    const s = u(e) ?? [];
-    o.debug = Function.prototype.bind.call(
-      console.debug,
-      console,
-      ...s
-    ), o.info = Function.prototype.bind.call(
-      console.info,
-      console,
-      ...s
-    ), o.log = Function.prototype.bind.call(
-      console.log,
-      console,
-      ...s
-    ), o.groupCollapsed = Function.prototype.bind.call(
-      console.groupCollapsed,
-      console
-    ), o.groupEnd = Function.prototype.bind.call(console.groupEnd, console), o.warn = Function.prototype.bind.call(
-      console.warn,
-      console,
-      ...s
-    ), o.error = Function.prototype.bind.call(
-      console.error,
-      console,
-      ...s
-    );
-  }, l = (c) => {
-    n !== c && (n = c, r(n));
-  };
-  return r(n), o;
-}; p();
-
-const AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
-  `mp3`,
-  `m4a`,
-  `m4b`,
-  `aac`,
-  `ogg`,
-  `oga`,
-  `wav`,
-  `flac`,
-  `opus`
-]);
-const getExtensionFromHref = (href) => {
-  const [pathname = ``] = href.split(/[?#]/);
-  const segments = pathname.split(`/`);
-  const basename = segments.at(-1) ?? ``;
-  const extension = basename.split(`.`).at(-1);
-  return extension?.toLowerCase();
-};
-const isAudioSpineItem = (item) => {
-  const mediaType = item.mediaType?.split(`;`).at(0)?.trim().toLowerCase();
-  if (mediaType?.startsWith(`audio/`)) {
-    return true;
-  }
-  const extension = getExtensionFromHref(item.href);
-  return extension ? AUDIO_EXTENSIONS.has(extension) : false;
-};
-
-const getTrackAtSpineItemIndex = (tracks, index) => {
-  if (index === void 0) return void 0;
-  return tracks.find((track) => track.index === index);
-};
-const getVisibleTracks = (tracks, pagination) => {
-  const beginTrack = getTrackAtSpineItemIndex(
-    tracks,
-    pagination.beginSpineItemIndex
-  );
-  const endTrack = getTrackAtSpineItemIndex(
-    tracks,
-    pagination.endSpineItemIndex
-  );
-  return [beginTrack, endTrack].filter(
-    (track, i, arr) => track !== void 0 && arr.indexOf(track) === i
-  );
-};
-function createTrackStreams(reader, state$) {
-  const tracks$ = reader.context.manifest$.pipe(
-    map(
-      (manifest) => manifest.spineItems.filter(isAudioSpineItem).map((item) => ({
-        id: item.id,
-        href: item.href,
-        index: item.index,
-        mediaType: item.mediaType
-      }))
-    ),
-    shareReplay({ bufferSize: 1, refCount: true })
-  );
-  const pagination$ = reader.pagination.state$.pipe(
-    mapKeysTo([`beginSpineItemIndex`, `endSpineItemIndex`]),
-    distinctUntilChanged(F),
-    shareReplay({ bufferSize: 1, refCount: true })
-  );
-  const visibleTrackIds$ = combineLatest([tracks$, pagination$]).pipe(
-    map(
-      ([tracks, pagination]) => getVisibleTracks(tracks, pagination).map(({ id }) => id)
-    ),
-    distinctUntilChanged(y),
-    shareReplay({ bufferSize: 1, refCount: true })
-  );
-  const currentTrack$ = state$.pipe(
-    map((state) => state.currentTrack),
-    distinctUntilChanged()
-  );
-  const nextTrack$ = combineLatest([tracks$, pagination$, currentTrack$]).pipe(
-    map(([tracks, { endSpineItemIndex }, currentTrack]) => {
-      const nextTrackInPaginationWindow = currentTrack && endSpineItemIndex !== void 0 ? tracks.find(
-        ({ index }) => index > currentTrack.index && index <= endSpineItemIndex
-      ) : void 0;
-      const nextTrackAfterCurrentTrack = currentTrack ? tracks.find(({ index }) => index > currentTrack.index) : void 0;
-      return { nextTrackInPaginationWindow, nextTrackAfterCurrentTrack };
-    }),
-    shareReplay({ bufferSize: 1, refCount: true })
-  );
-  return {
-    tracks$,
-    visibleTrackIds$,
-    nextTrack$
-  };
-}
-
-const initialDesiredPlayback = {
-  shouldPlay: false,
-  trackId: void 0
-};
-const initialState = {
-  tracks: [],
-  currentTrack: void 0,
-  isPlaying: false,
-  isLoading: false,
-  hasError: false,
-  currentTime: 0,
-  duration: void 0
+	enabled: e?.enabled,
+	options: e ?? t
+}, U = (e) => e.at(-1)?.color, W = (e) => {
+	if (!e.length) return;
+	if (!e.some((e) => e.color)) return [e.map((e) => e.label).join(" ")];
+	let t = "", n = [];
+	for (let r of e) t += `%c${t ? ` ${r.label}` : r.label}`, n.push(r.color ? `color: ${r.color}` : "");
+	return [t, ...n];
+}, G = (e = [], t = V()) => {
+	let n = t, r = {
+		enable: (e) => {
+			a(e);
+		},
+		namespace: (t, r, i) => {
+			let a = H(r, i), o = a.options?.color ?? U(e);
+			return G([...e, {
+				label: `[${t}]`,
+				color: o
+			}], a.enabled ?? n);
+		},
+		isEnabled: () => n,
+		debug: () => {},
+		info: () => {},
+		log: () => {},
+		groupCollapsed: () => {},
+		groupEnd: () => {},
+		getGroupArgs: (t) => {
+			let n = W(e);
+			if (!n) return [t];
+			let [r, ...i] = n;
+			return [`${r} ${t}`, ...i];
+		},
+		warn: () => {},
+		error: () => {}
+	}, i = (t) => {
+		if (!t) {
+			r.debug = () => {}, r.info = () => {}, r.log = () => {}, r.groupCollapsed = () => {}, r.groupEnd = () => {}, r.warn = () => {}, r.error = () => {};
+			return;
+		}
+		let n = W(e) ?? [];
+		r.debug = Function.prototype.bind.call(console.debug, console, ...n), r.info = Function.prototype.bind.call(console.info, console, ...n), r.log = Function.prototype.bind.call(console.log, console, ...n), r.groupCollapsed = Function.prototype.bind.call(console.groupCollapsed, console), r.groupEnd = Function.prototype.bind.call(console.groupEnd, console), r.warn = Function.prototype.bind.call(console.warn, console, ...n), r.error = Function.prototype.bind.call(console.error, console, ...n);
+	}, a = (e) => {
+		n !== e && (n = e, i(n));
+	};
+	return i(n), r;
 };
-class AudioController extends ReactiveEntity {
-  reader;
-  audio;
-  visualizer$;
-  resourcesResolver = new ResourcesResolver();
-  visibleTrackIds$;
-  playCommandSubject = new Subject();
-  pauseCommandSubject = new Subject();
-  selectCommandSubject = new Subject();
-  desiredPlayback$ = new BehaviorSubject(
-    initialDesiredPlayback
-  );
-  subscriptions = new Subscription();
-  constructor(reader, audio = new AudioElementAdapter()) {
-    super(initialState);
-    this.reader = reader;
-    this.audio = audio;
-    this.visualizer$ = new AudioVisualizer(this.audio.element);
-    const { tracks$, visibleTrackIds$, nextTrack$ } = createTrackStreams(
-      this.reader,
-      this.state$
-    );
-    this.visibleTrackIds$ = visibleTrackIds$;
-    const firstVisibleTrackId$ = this.visibleTrackIds$.pipe(
-      map((trackIds) => trackIds[0]),
-      distinctUntilChanged(),
-      share()
-    );
-    const visibleTrackReset$ = firstVisibleTrackId$.pipe(
-      withLatestFrom(this.state$),
-      filter(
-        ([trackId, state]) => trackId === void 0 && (state.currentTrack?.id !== void 0 || state.isLoading)
-      ),
-      map(([, state]) => state.tracks)
-    );
-    const visibleTrackSelectionIntent$ = firstVisibleTrackId$.pipe(
-      filter((trackId) => trackId !== void 0),
-      withLatestFrom(this.desiredPlayback$),
-      map(([trackId, { shouldPlay }]) => ({
-        trackId,
-        options: {
-          navigate: false,
-          play: shouldPlay ? true : void 0
-        }
-      }))
-    );
-    const tracksChanged$ = tracks$.pipe(
-      tap(() => this.resourcesResolver.releaseAll())
-    );
-    const playbackReset$ = merge(visibleTrackReset$, tracksChanged$).pipe(
-      tap((tracks) => {
-        this.emitDesiredPlayback({ shouldPlay: false, trackId: void 0 });
-        this.visualizer$.stop({ resetLevels: true });
-        this.unmountCurrentSource();
-        this.mergeCompare({
-          tracks,
-          currentTrack: void 0,
-          isLoading: false,
-          isPlaying: false,
-          hasError: false,
-          currentTime: 0,
-          duration: void 0
-        });
-        this.visualizer$.reset(void 0);
-      }),
-      share()
-    );
-    const playSelectionIntent$ = this.playCommandSubject.pipe(
-      filter(() => !this.audio.hasSource),
-      map(() => this.state.currentTrack ?? this.state.tracks[0]),
-      filter(isDefined),
-      map((track) => ({
-        trackId: track.id,
-        options: { navigate: false, play: true }
-      }))
-    );
-    const resumePlayback$ = this.playCommandSubject.pipe(
-      filter(() => this.audio.hasSource),
-      tap(() => {
-        this.emitDesiredPlayback({
-          shouldPlay: true,
-          trackId: this.state.currentTrack?.id
-        });
-      })
-    );
-    const endedSelectionIntent$ = this.audio.ended$.pipe(
-      withLatestFrom(nextTrack$),
-      switchMap(
-        ([, { nextTrackAfterCurrentTrack, nextTrackInPaginationWindow }]) => {
-          this.visualizer$.stop({ resetLevels: true });
-          if (nextTrackInPaginationWindow) {
-            return of({
-              trackId: nextTrackInPaginationWindow.id,
-              options: { navigate: false, play: true }
-            });
-          }
-          if (!nextTrackAfterCurrentTrack) {
-            this.emitDesiredPlayback({ shouldPlay: false, trackId: void 0 });
-          }
-          this.reader.navigation.goToRightOrBottomSpineItem();
-          return EMPTY;
-        }
-      )
-    );
-    const selection$ = merge(
-      this.selectCommandSubject,
-      visibleTrackSelectionIntent$,
-      endedSelectionIntent$,
-      playSelectionIntent$
-    ).pipe(
-      withLatestFrom(this.state$),
-      filter(
-        ([selectionIntent, state]) => state.tracks.some(({ id }) => id === selectionIntent.trackId)
-      ),
-      map(([selectionIntent, state]) => ({
-        selectionIntent,
-        state,
-        isReselectionWhileLoading: state.currentTrack?.id === selectionIntent.trackId && state.isLoading
-      })),
-      tap(({ selectionIntent, state, isReselectionWhileLoading }) => {
-        if (selectionIntent.options.navigate !== false) {
-          this.reader.navigation.navigate({
-            spineItem: selectionIntent.trackId,
-            animation: `turn`
-          });
-        }
-        if (isReselectionWhileLoading && selectionIntent.options.play !== void 0) {
-          this.emitDesiredPlayback({
-            shouldPlay: selectionIntent.options.play,
-            trackId: state.currentTrack?.id
-          });
-        }
-      }),
-      filter(({ isReselectionWhileLoading }) => !isReselectionWhileLoading),
-      switchMap(
-        ({ selectionIntent: { trackId, options } }) => this.selectTrack$({ trackId, options, playbackReset$ })
-      )
-    );
-    const playback$ = merge(resumePlayback$, selection$).pipe(
-      withLatestFrom(this.desiredPlayback$),
-      switchMap(([, { shouldPlay, trackId }]) => {
-        if (!shouldPlay || !this.audio.hasSource || this.state.currentTrack?.id !== trackId) {
-          return EMPTY;
-        }
-        this.mergeCompare({ hasError: false });
-        return this.audio.play$().pipe(
-          catchError(() => {
-            this.mergeCompare({ hasError: true });
-            return EMPTY;
-          })
-        );
-      })
-    );
-    this.subscriptions.add(playbackReset$.subscribe());
-    this.subscriptions.add(playback$.subscribe());
-    this.subscriptions.add(
-      this.pauseCommandSubject.subscribe(() => {
-        this.emitDesiredPlayback({ shouldPlay: false, trackId: void 0 });
-      })
-    );
-    this.subscriptions.add(
-      this.audio.isPlaying$.subscribe((isPlaying) => {
-        this.mergeCompare({ isPlaying });
-        if (!isPlaying) {
-          this.visualizer$.stop();
-          return;
-        }
-        if (!this.state.currentTrack) return;
-        this.visualizer$.start(this.state.currentTrack);
-      })
-    );
-    this.subscriptions.add(
-      this.audio.metrics$.subscribe(({ currentTime, duration }) => {
-        this.mergeCompare({ currentTime, duration });
-      })
-    );
-  }
-  get state() {
-    return this.value;
-  }
-  get visualizer() {
-    return this.visualizer$.value;
-  }
-  resetTrackSelection({
-    currentTrack,
-    isLoading
-  }) {
-    this.mergeCompare({
-      currentTrack,
-      isLoading,
-      isPlaying: false,
-      hasError: false,
-      currentTime: 0,
-      duration: void 0
-    });
-    this.visualizer$.reset(currentTrack?.id);
-  }
-  emitDesiredPlayback({ shouldPlay, trackId }) {
-    this.desiredPlayback$.next({
-      shouldPlay,
-      trackId: shouldPlay ? trackId : void 0
-    });
-    if (!shouldPlay) {
-      this.audio.pause();
-    }
-  }
-  unmountCurrentSource() {
-    if (!this.audio.hasSource) return;
-    const trackId = this.state.currentTrack?.id;
-    if (!this.audio.paused) {
-      this.audio.pause();
-    }
-    this.audio.unloadSource();
-    if (trackId) {
-      this.resourcesResolver.releaseTrackSource(trackId);
-    }
-  }
-  mountSource(source) {
-    this.unmountCurrentSource();
-    this.audio.loadSource(source);
-  }
-  resolveTrackSource(track) {
-    const spineItem = this.reader.spineItemsManager.get(track.index);
-    if (!spineItem) return EMPTY;
-    return this.resourcesResolver.getTrackResourceUrl$(
-      track,
-      spineItem.resourcesHandler
-    );
-  }
-  selectTrack$({
-    trackId,
-    options,
-    playbackReset$
-  }) {
-    const track = this.state.tracks.find(({ id }) => id === trackId);
-    if (!track) return EMPTY;
-    const currentTrack = this.state.currentTrack;
-    const shouldPlay = options.play ?? (!this.audio.paused && currentTrack !== void 0);
-    this.emitDesiredPlayback({ shouldPlay, trackId: track.id });
-    if (currentTrack?.id === track.id && this.audio.hasSource) {
-      this.visualizer$.setTrack(track.id);
-      return shouldPlay ? of(void 0) : EMPTY;
-    }
-    this.unmountCurrentSource();
-    this.resetTrackSelection({
-      currentTrack: track,
-      isLoading: true
-    });
-    return this.resolveTrackSource(track).pipe(
-      map((source) => ({ source })),
-      defaultIfEmpty({ source: void 0 }),
-      catchError(() => of({ source: void 0 })),
-      takeUntil(playbackReset$),
-      tap(({ source }) => {
-        if (!source) {
-          this.emitDesiredPlayback({ shouldPlay: false, trackId: void 0 });
-        } else {
-          this.mountSource(source);
-        }
-        this.mergeCompare({ isLoading: false });
-      }),
-      filter(({ source }) => source !== void 0),
-      map(() => void 0)
-    );
-  }
-  select(trackId, options = {}) {
-    this.selectCommandSubject.next({ trackId, options });
-  }
-  play() {
-    this.playCommandSubject.next();
-  }
-  pause() {
-    this.pauseCommandSubject.next();
-  }
-  toggle() {
-    if (this.audio.paused) {
-      this.play();
-      return;
-    }
-    this.pause();
-  }
-  setCurrentTime(value) {
-    this.mergeCompare({ currentTime: value });
-    this.audio.setCurrentTime(value);
-  }
-  destroy() {
-    this.subscriptions.unsubscribe();
-    this.playCommandSubject.complete();
-    this.pauseCommandSubject.complete();
-    this.selectCommandSubject.complete();
-    this.desiredPlayback$.complete();
-    this.visualizer$.destroy();
-    this.unmountCurrentSource();
-    this.resourcesResolver.destroy();
-    super.destroy();
-  }
+G();
+//#endregion
+//#region src/utils.ts
+var K = new Set([
+	"mp3",
+	"m4a",
+	"m4b",
+	"aac",
+	"ogg",
+	"oga",
+	"wav",
+	"flac",
+	"opus"
+]), q = (e) => {
+	let [t = ""] = e.split(/[?#]/);
+	return (t.split("/").at(-1) ?? "").split(".").at(-1)?.toLowerCase();
+}, J = (e) => {
+	if ((e.mediaType?.split(";").at(0)?.trim().toLowerCase())?.startsWith("audio/")) return !0;
+	let t = q(e.href);
+	return t ? K.has(t) : !1;
+}, Y = (e, t) => {
+	if (t !== void 0) return e.find((e) => e.index === t);
+}, X = (e, t) => [Y(e, t.beginSpineItemIndex), Y(e, t.endSpineItemIndex)].filter((e, t, n) => e !== void 0 && n.indexOf(e) === t);
+function Z(e, t) {
+	let n = e.context.manifest$.pipe(y((e) => e.spineItems.filter(J).map((e) => ({
+		id: e.id,
+		href: e.href,
+		index: e.index,
+		mediaType: e.mediaType
+	}))), w({
+		bufferSize: 1,
+		refCount: !0
+	})), i = e.pagination.state$.pipe(r(["beginSpineItemIndex", "endSpineItemIndex"]), h(z), w({
+		bufferSize: 1,
+		refCount: !0
+	}));
+	return {
+		tracks$: n,
+		visibleTrackIds$: d([n, i]).pipe(y(([e, t]) => X(e, t).map(({ id: e }) => e)), h(R), w({
+			bufferSize: 1,
+			refCount: !0
+		})),
+		nextTrack$: d([
+			n,
+			i,
+			t.pipe(y((e) => e.currentTrack), h())
+		]).pipe(y(([e, { endSpineItemIndex: t }, n]) => ({
+			nextTrackInPaginationWindow: n && t !== void 0 ? e.find(({ index: e }) => e > n.index && e <= t) : void 0,
+			nextTrackAfterCurrentTrack: n ? e.find(({ index: e }) => e > n.index) : void 0
+		})), w({
+			bufferSize: 1,
+			refCount: !0
+		}))
+	};
 }
-
-class AudioRenderer extends DocumentRenderer {
-  onCreateDocument() {
-    const ownerDocument = this.containerElement.ownerDocument;
-    const rootElement = ownerDocument.createElement(`div`);
-    rootElement.style.cssText = `
-      box-sizing: border-box;
-      width: 100%;
-      height: 100%;
-      display: block;
-    `;
-    rootElement.setAttribute(`data-prose-reader-audio-page`, this.item.id);
-    this.setDocumentContainer(rootElement);
-    return of(rootElement);
-  }
-  onLoadDocument() {
-    this.attach();
-    return EMPTY;
-  }
-  onUnload() {
-    this.detach();
-    return EMPTY;
-  }
-  onLayout() {
-    const { width, height } = this.viewport.pageSize;
-    const rootElement = this.documentContainer;
-    if (rootElement) {
-      setStylePropertyIfChanged(rootElement.style, `width`, `${width}px`);
-      setStylePropertyIfChanged(rootElement.style, `height`, `${height}px`);
-    }
-    return of({ width, height });
-  }
-  onRenderHeadless() {
-    return EMPTY;
-  }
-  getDocumentFrame() {
-    return void 0;
-  }
-  /**
-   * Audio spine items are always pre-paginated (one track per page).
-   * Mixed audio/text books with reflowable audio chapters may need
-   * to revisit this if that use case arises.
-   */
-  get renditionLayout() {
-    return `pre-paginated`;
-  }
-}
-
-const audioEnhancer = (next) => (options) => {
-  const readerOptions = { ...options };
-  const reader = next({
-    ...readerOptions,
-    getRenderer(item) {
-      const maybeFactory = options.getRenderer?.(item);
-      if (maybeFactory) {
-        return maybeFactory;
-      }
-      if (isAudioSpineItem(item)) {
-        return (params) => new AudioRenderer(params);
-      }
-      return void 0;
-    }
-  });
-  const controller = new AudioController(reader);
-  const destroy = () => {
-    controller.destroy();
-    reader.destroy();
-  };
-  return {
-    ...reader,
-    __PROSE_READER_ENHANCER_AUDIO: true,
-    destroy,
-    audio: {
-      state$: controller.state$,
-      visualizer$: controller.visualizer$,
-      visibleTrackIds$: controller.visibleTrackIds$,
-      get state() {
-        return controller.state;
-      },
-      get visualizer() {
-        return controller.visualizer;
-      },
-      isAudioRenderer: (renderer) => renderer instanceof AudioRenderer,
-      play: () => controller.play(),
-      pause: () => controller.pause(),
-      toggle: () => controller.toggle(),
-      setCurrentTime: (value) => controller.setCurrentTime(value),
-      select: (trackId, options2) => controller.select(trackId, options2)
-    }
-  };
+//#endregion
+//#region src/playback/AudioController.ts
+var Q = {
+	shouldPlay: !1,
+	trackId: void 0
+}, te = {
+	tracks: [],
+	currentTrack: void 0,
+	isPlaying: !1,
+	isLoading: !1,
+	hasError: !1,
+	currentTime: 0,
+	duration: void 0
+}, ne = class extends t {
+	reader;
+	audio;
+	visualizer$;
+	resourcesResolver = new L();
+	visibleTrackIds$;
+	playCommandSubject = new s();
+	pauseCommandSubject = new s();
+	selectCommandSubject = new s();
+	desiredPlayback$ = new a(Q);
+	subscriptions = new c();
+	constructor(e, t = new I()) {
+		super(te), this.reader = e, this.audio = t, this.visualizer$ = new F(this.audio.element);
+		let { tracks$: r, visibleTrackIds$: i, nextTrack$: a } = Z(this.reader, this.state$);
+		this.visibleTrackIds$ = i;
+		let s = this.visibleTrackIds$.pipe(y((e) => e[0]), h(), C()), c = s.pipe(k(this.state$), g(([e, t]) => e === void 0 && (t.currentTrack?.id !== void 0 || t.isLoading)), y(([, e]) => e.tracks)), l = s.pipe(g((e) => e !== void 0), k(this.desiredPlayback$), y(([e, { shouldPlay: t }]) => ({
+			trackId: e,
+			options: {
+				navigate: !1,
+				play: t ? !0 : void 0
+			}
+		}))), d = b(c, r.pipe(O(() => this.resourcesResolver.releaseAll()))).pipe(O((e) => {
+			this.emitDesiredPlayback({
+				shouldPlay: !1,
+				trackId: void 0
+			}), this.visualizer$.stop({ resetLevels: !0 }), this.unmountCurrentSource(), this.mergeCompare({
+				tracks: e,
+				currentTrack: void 0,
+				isLoading: !1,
+				isPlaying: !1,
+				hasError: !1,
+				currentTime: 0,
+				duration: void 0
+			}), this.visualizer$.reset(void 0);
+		}), C()), f = this.playCommandSubject.pipe(g(() => !this.audio.hasSource), y(() => this.state.currentTrack ?? this.state.tracks[0]), g(n), y((e) => ({
+			trackId: e.id,
+			options: {
+				navigate: !1,
+				play: !0
+			}
+		}))), p = this.playCommandSubject.pipe(g(() => this.audio.hasSource), O(() => {
+			this.emitDesiredPlayback({
+				shouldPlay: !0,
+				trackId: this.state.currentTrack?.id
+			});
+		})), m = this.audio.ended$.pipe(k(a), T(([, { nextTrackAfterCurrentTrack: e, nextTrackInPaginationWindow: t }]) => (this.visualizer$.stop({ resetLevels: !0 }), t ? x({
+			trackId: t.id,
+			options: {
+				navigate: !1,
+				play: !0
+			}
+		}) : (e || this.emitDesiredPlayback({
+			shouldPlay: !1,
+			trackId: void 0
+		}), this.reader.navigation.goToRightOrBottomSpineItem(), o)))), _ = b(p, b(this.selectCommandSubject, l, m, f).pipe(k(this.state$), g(([e, t]) => t.tracks.some(({ id: t }) => t === e.trackId)), y(([e, t]) => ({
+			selectionIntent: e,
+			state: t,
+			isReselectionWhileLoading: t.currentTrack?.id === e.trackId && t.isLoading
+		})), O(({ selectionIntent: e, state: t, isReselectionWhileLoading: n }) => {
+			e.options.navigate !== !1 && this.reader.navigation.navigate({
+				spineItem: e.trackId,
+				animation: "turn"
+			}), n && e.options.play !== void 0 && this.emitDesiredPlayback({
+				shouldPlay: e.options.play,
+				trackId: t.currentTrack?.id
+			});
+		}), g(({ isReselectionWhileLoading: e }) => !e), T(({ selectionIntent: { trackId: e, options: t } }) => this.selectTrack$({
+			trackId: e,
+			options: t,
+			playbackReset$: d
+		})))).pipe(k(this.desiredPlayback$), T(([, { shouldPlay: e, trackId: t }]) => !e || !this.audio.hasSource || this.state.currentTrack?.id !== t ? o : (this.mergeCompare({ hasError: !1 }), this.audio.play$().pipe(u(() => (this.mergeCompare({ hasError: !0 }), o))))));
+		this.subscriptions.add(d.subscribe()), this.subscriptions.add(_.subscribe()), this.subscriptions.add(this.pauseCommandSubject.subscribe(() => {
+			this.emitDesiredPlayback({
+				shouldPlay: !1,
+				trackId: void 0
+			});
+		})), this.subscriptions.add(this.audio.isPlaying$.subscribe((e) => {
+			if (this.mergeCompare({ isPlaying: e }), !e) {
+				this.visualizer$.stop();
+				return;
+			}
+			this.state.currentTrack && this.visualizer$.start(this.state.currentTrack);
+		})), this.subscriptions.add(this.audio.metrics$.subscribe(({ currentTime: e, duration: t }) => {
+			this.mergeCompare({
+				currentTime: e,
+				duration: t
+			});
+		}));
+	}
+	get state() {
+		return this.value;
+	}
+	get visualizer() {
+		return this.visualizer$.value;
+	}
+	resetTrackSelection({ currentTrack: e, isLoading: t }) {
+		this.mergeCompare({
+			currentTrack: e,
+			isLoading: t,
+			isPlaying: !1,
+			hasError: !1,
+			currentTime: 0,
+			duration: void 0
+		}), this.visualizer$.reset(e?.id);
+	}
+	emitDesiredPlayback({ shouldPlay: e, trackId: t }) {
+		this.desiredPlayback$.next({
+			shouldPlay: e,
+			trackId: e ? t : void 0
+		}), e || this.audio.pause();
+	}
+	unmountCurrentSource() {
+		if (!this.audio.hasSource) return;
+		let e = this.state.currentTrack?.id;
+		this.audio.paused || this.audio.pause(), this.audio.unloadSource(), e && this.resourcesResolver.releaseTrackSource(e);
+	}
+	mountSource(e) {
+		this.unmountCurrentSource(), this.audio.loadSource(e);
+	}
+	resolveTrackSource(e) {
+		let t = this.reader.spineItemsManager.get(e.index);
+		return t ? this.resourcesResolver.getTrackResourceUrl$(e, t.resourcesHandler) : o;
+	}
+	selectTrack$({ trackId: e, options: t, playbackReset$: n }) {
+		let r = this.state.tracks.find(({ id: t }) => t === e);
+		if (!r) return o;
+		let i = this.state.currentTrack, a = t.play ?? (!this.audio.paused && i !== void 0);
+		return this.emitDesiredPlayback({
+			shouldPlay: a,
+			trackId: r.id
+		}), i?.id === r.id && this.audio.hasSource ? (this.visualizer$.setTrack(r.id), a ? x(void 0) : o) : (this.unmountCurrentSource(), this.resetTrackSelection({
+			currentTrack: r,
+			isLoading: !0
+		}), this.resolveTrackSource(r).pipe(y((e) => ({ source: e })), p({ source: void 0 }), u(() => x({ source: void 0 })), D(n), O(({ source: e }) => {
+			e ? this.mountSource(e) : this.emitDesiredPlayback({
+				shouldPlay: !1,
+				trackId: void 0
+			}), this.mergeCompare({ isLoading: !1 });
+		}), g(({ source: e }) => e !== void 0), y(() => void 0)));
+	}
+	select(e, t = {}) {
+		this.selectCommandSubject.next({
+			trackId: e,
+			options: t
+		});
+	}
+	play() {
+		this.playCommandSubject.next();
+	}
+	pause() {
+		this.pauseCommandSubject.next();
+	}
+	toggle() {
+		if (this.audio.paused) {
+			this.play();
+			return;
+		}
+		this.pause();
+	}
+	setCurrentTime(e) {
+		this.mergeCompare({ currentTime: e }), this.audio.setCurrentTime(e);
+	}
+	destroy() {
+		this.subscriptions.unsubscribe(), this.playCommandSubject.complete(), this.pauseCommandSubject.complete(), this.selectCommandSubject.complete(), this.desiredPlayback$.complete(), this.visualizer$.destroy(), this.unmountCurrentSource(), this.resourcesResolver.destroy(), super.destroy();
+	}
+}, $ = class extends e {
+	onCreateDocument() {
+		let e = this.containerElement.ownerDocument.createElement("div");
+		return e.style.cssText = "\n      box-sizing: border-box;\n      width: 100%;\n      height: 100%;\n      display: block;\n    ", e.setAttribute("data-prose-reader-audio-page", this.item.id), this.setDocumentContainer(e), x(e);
+	}
+	onLoadDocument() {
+		return this.attach(), o;
+	}
+	onUnload() {
+		return this.detach(), o;
+	}
+	onLayout() {
+		let { width: e, height: t } = this.viewport.pageSize, n = this.documentContainer;
+		return n && (i(n.style, "width", `${e}px`), i(n.style, "height", `${t}px`)), x({
+			width: e,
+			height: t
+		});
+	}
+	onRenderHeadless() {
+		return o;
+	}
+	getDocumentFrame() {}
+	get renditionLayout() {
+		return "pre-paginated";
+	}
+}, re = (e) => (t) => {
+	let n = e({
+		...t,
+		getRenderer(e) {
+			let n = t.getRenderer?.(e);
+			if (n) return n;
+			if (J(e)) return (e) => new $(e);
+		}
+	}), r = new ne(n), i = () => {
+		r.destroy(), n.destroy();
+	};
+	return {
+		...n,
+		__PROSE_READER_ENHANCER_AUDIO: !0,
+		destroy: i,
+		audio: {
+			state$: r.state$,
+			visualizer$: r.visualizer$,
+			visibleTrackIds$: r.visibleTrackIds$,
+			get state() {
+				return r.state;
+			},
+			get visualizer() {
+				return r.visualizer;
+			},
+			isAudioRenderer: (e) => e instanceof $,
+			play: () => r.play(),
+			pause: () => r.pause(),
+			toggle: () => r.toggle(),
+			setCurrentTime: (e) => r.setCurrentTime(e),
+			select: (e, t) => r.select(e, t)
+		}
+	};
 };
+//#endregion
+export { $ as AudioRenderer, re as audioEnhancer, J as isAudioSpineItem };
 
-export { AudioRenderer, audioEnhancer, isAudioSpineItem };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map