@langchain/react 0.3.4 → 1.0.0

package/dist/use-audio-player.cjs

@@ -0,0 +1,679 @@
+"use client";
+let react = require("react");
+//#region src/use-audio-player.ts
+const DEFAULT_SAMPLE_RATE = 24e3;
+const DEFAULT_CHANNELS = 1;
+const ANALYSER_FFT_SIZE = 512;
+/**
+* Module-level registry of shared readers keyed by {@link MediaBase}
+* identity. We hold exactly one {@link ReadableStreamDefaultReader} per
+* media handle and fan the chunks out to every live hook subscriber.
+*
+* Keying on identity (WeakMap) gives us three properties for free:
+* - React StrictMode's simulated unmount/remount finds the same
+*   controller on re-attach, so we never `getReader()` twice on the
+*   same locked stream.
+* - New media instances get a fresh reader — no cross-talk.
+* - When callers drop their last reference to the media handle, the
+*   WeakMap entry is reclaimed alongside it.
+*/
+const pumpRegistry = /* @__PURE__ */ new WeakMap();
+function attachToPump(media, listener) {
+	let controller = pumpRegistry.get(media);
+	if (controller == null) {
+		const reader = media.stream.getReader();
+		controller = {
+			chunks: [],
+			finished: false,
+			error: void 0,
+			listeners: /* @__PURE__ */ new Set()
+		};
+		pumpRegistry.set(media, controller);
+		const owned = controller;
+		(async () => {
+			try {
+				while (true) {
+					const { value, done } = await reader.read();
+					if (done) break;
+					if (value == null || value.byteLength === 0) continue;
+					owned.chunks.push(value);
+					for (const l of owned.listeners) try {
+						l({
+							type: "chunk",
+							bytes: value
+						});
+					} catch {}
+				}
+				owned.finished = true;
+				for (const l of owned.listeners) try {
+					l({ type: "finished" });
+				} catch {}
+			} catch (err) {
+				owned.error = err;
+				for (const l of owned.listeners) try {
+					l({
+						type: "error",
+						error: err
+					});
+				} catch {}
+			} finally {
+				try {
+					reader.releaseLock();
+				} catch {}
+			}
+		})();
+	}
+	for (const chunk of controller.chunks) listener({
+		type: "chunk",
+		bytes: chunk
+	});
+	if (controller.finished) listener({ type: "finished" });
+	if (controller.error != null) listener({
+		type: "error",
+		error: controller.error
+	});
+	controller.listeners.add(listener);
+	return () => {
+		controller.listeners.delete(listener);
+	};
+}
+/**
+* Parse the RIFF/WAVE header of a WAV stream. Only the `fmt ` and `data`
+* chunks are interpreted; other chunks are skipped. The parser
+* requires the complete `fmt ` chunk and the `data` chunk header before
+* returning `"parsed"`, so callers may need several retries while
+* buffering incoming bytes. WAV uses little-endian integers throughout.
+*/
+function tryParseWavHeader(bytes) {
+	if (bytes.byteLength < 12) return { status: "need-more" };
+	if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70 || bytes[8] !== 87 || bytes[9] !== 65 || bytes[10] !== 86 || bytes[11] !== 69) return {
+		status: "invalid",
+		reason: "not a RIFF/WAVE stream"
+	};
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let fmt = null;
+	let offset = 12;
+	while (offset + 8 <= bytes.byteLength) {
+		const id = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+		const size = view.getUint32(offset + 4, true);
+		const payloadStart = offset + 8;
+		if (id === "fmt ") {
+			if (payloadStart + 16 > bytes.byteLength) return { status: "need-more" };
+			fmt = {
+				audioFormat: view.getUint16(payloadStart, true),
+				channels: view.getUint16(payloadStart + 2, true),
+				sampleRate: view.getUint32(payloadStart + 4, true),
+				bitsPerSample: view.getUint16(payloadStart + 14, true)
+			};
+			if (fmt.audioFormat !== 1) return {
+				status: "invalid",
+				reason: `unsupported WAV audioFormat=${fmt.audioFormat} (expected 1, linear PCM)`
+			};
+			if (fmt.bitsPerSample !== 16) return {
+				status: "invalid",
+				reason: `unsupported WAV bitsPerSample=${fmt.bitsPerSample} (expected 16)`
+			};
+		} else if (id === "data") {
+			if (fmt == null) return {
+				status: "invalid",
+				reason: "data chunk preceded fmt chunk"
+			};
+			return {
+				status: "parsed",
+				format: {
+					sampleRate: fmt.sampleRate,
+					channels: fmt.channels,
+					bitsPerSample: fmt.bitsPerSample
+				},
+				dataOffset: payloadStart
+			};
+		}
+		offset = payloadStart + size + (size & 1);
+	}
+	return { status: "need-more" };
+}
+function concatChunks(chunks) {
+	if (chunks.length === 1) return chunks[0];
+	let total = 0;
+	for (const c of chunks) total += c.byteLength;
+	const out = new Uint8Array(total);
+	let at = 0;
+	for (const c of chunks) {
+		out.set(c, at);
+		at += c.byteLength;
+	}
+	return out;
+}
+function resolveAudioContextCtor() {
+	if (typeof window === "undefined") return void 0;
+	return window.AudioContext ?? window.webkitAudioContext;
+}
+/**
+* Decide which playback strategy the hook should use for a handle.
+* PCM16 / L16 / WAV flow through the progressive Web Audio path; every
+* other mime drops to a hidden `HTMLAudioElement`.
+*/
+function detectStrategy(mimeType, override, pcmPrefixes) {
+	if (override === "pcm" || override === "element") return override;
+	const m = mimeType ?? "";
+	return m === "audio/pcm" || m === "audio/L16" || m.startsWith("audio/pcm;") || m.startsWith("audio/L16;") || m === "audio/wav" || m === "audio/wave" || m === "audio/x-wav" || m === "audio/vnd.wave" || (pcmPrefixes?.some((p) => m.startsWith(p)) ?? false) ? "pcm" : "element";
+}
+/**
+* Progressive audio playback for {@link AudioMedia} handles with a
+* uniform surface across PCM (streamed) and container (`HTMLAudioElement`)
+* strategies.
+*
+* ### Behaviour
+*
+* - Strategy selection is derived from `media.mimeType` and may be
+*   overridden via `options.strategy`. PCM / L16 / WAV all flow through
+*   the progressive Web Audio path; every other mime uses a hidden
+*   `HTMLAudioElement`.
+*
+* - **PCM strategy.** Chunks are decoded in real time and scheduled on
+*   a single `AudioContext`; playback begins within one chunk of the
+*   first byte. `seek` / `duration` are `undefined` because random
+*   access on a live scheduled buffer is not supported.
+*
+* - **Element strategy.** `status` stays in `"buffering"` until
+*   `message-finish` materialises a blob URL; the element then owns
+*   playback. `seek` / `duration` are available.
+*
+* - Both strategies expose `level`, `getFrequencyData()`, and
+*   `getTimeDomainData()` by tapping an {@link AnalyserNode} in the
+*   audio graph.
+*
+* - React StrictMode's simulated unmount/remount is safe: the shared
+*   reader and replay buffer mean a second attach sees the same bytes
+*   that the first one did.
+*
+* @param media - Audio handle from `useAudio` etc.
+* @param options - Strategy overrides and PCM format hints.
+*/
+function useAudioPlayer(media, options) {
+	const sampleRate = options?.pcm?.sampleRate ?? DEFAULT_SAMPLE_RATE;
+	const channels = options?.pcm?.channels ?? DEFAULT_CHANNELS;
+	const pcmPrefixes = options?.pcmMimePrefixes;
+	const strategyOverride = options?.strategy ?? "auto";
+	const autoPlay = options?.autoPlay ?? false;
+	const strategy = media ? detectStrategy(media.mimeType, strategyOverride, pcmPrefixes) : "element";
+	const [status, setStatus] = (0, react.useState)("idle");
+	const [error, setError] = (0, react.useState)(void 0);
+	const [currentTime, setCurrentTime] = (0, react.useState)(0);
+	const [duration, setDuration] = (0, react.useState)(void 0);
+	const [level, setLevel] = (0, react.useState)(0);
+	const ctxRef = (0, react.useRef)(null);
+	const analyserRef = (0, react.useRef)(null);
+	const freqBufRef = (0, react.useRef)(null);
+	const timeBufRef = (0, react.useRef)(null);
+	const rafRef = (0, react.useRef)(null);
+	const playStartCtxTimeRef = (0, react.useRef)(0);
+	const nextStartTimeRef = (0, react.useRef)(0);
+	const shouldPlayRef = (0, react.useRef)(false);
+	const pendingChunksRef = (0, react.useRef)([]);
+	const activeSourcesRef = (0, react.useRef)(/* @__PURE__ */ new Set());
+	const formatRef = (0, react.useRef)(null);
+	const upstreamFinishedRef = (0, react.useRef)(false);
+	const audioElRef = (0, react.useRef)(null);
+	const elementSourceRef = (0, react.useRef)(null);
+	const pendingSrcRef = (0, react.useRef)(void 0);
+	const statusRef = (0, react.useRef)("idle");
+	(0, react.useEffect)(() => {
+		statusRef.current = status;
+	}, [status]);
+	const pendingResolveRef = (0, react.useRef)(null);
+	const pendingRejectRef = (0, react.useRef)(null);
+	const resolvePending = (0, react.useCallback)(() => {
+		const resolve = pendingResolveRef.current;
+		pendingResolveRef.current = null;
+		pendingRejectRef.current = null;
+		resolve?.();
+	}, []);
+	const rejectPending = (0, react.useCallback)((err) => {
+		const reject = pendingRejectRef.current;
+		pendingResolveRef.current = null;
+		pendingRejectRef.current = null;
+		reject?.(err);
+	}, []);
+	(0, react.useEffect)(() => {
+		if (status === "finished" || status === "paused" || status === "idle") resolvePending();
+		else if (status === "error") rejectPending(error ?? /* @__PURE__ */ new Error("playback error"));
+	}, [
+		status,
+		error,
+		resolvePending,
+		rejectPending
+	]);
+	const tickAnalyser = (0, react.useCallback)(() => {
+		const analyser = analyserRef.current;
+		const ctx = ctxRef.current;
+		if (analyser == null) {
+			rafRef.current = null;
+			return;
+		}
+		const buf = timeBufRef.current;
+		if (buf != null) {
+			analyser.getByteTimeDomainData(buf);
+			let sum = 0;
+			for (let i = 0; i < buf.length; i += 1) {
+				const v = (buf[i] - 128) / 128;
+				sum += v * v;
+			}
+			setLevel(Math.sqrt(sum / buf.length));
+		}
+		if (ctx != null && statusRef.current === "playing") setCurrentTime(ctx.currentTime - playStartCtxTimeRef.current);
+		if (typeof window !== "undefined") rafRef.current = window.requestAnimationFrame(tickAnalyser);
+	}, []);
+	const startAnalyserLoop = (0, react.useCallback)(() => {
+		if (rafRef.current != null) return;
+		if (typeof window === "undefined") return;
+		rafRef.current = window.requestAnimationFrame(tickAnalyser);
+	}, [tickAnalyser]);
+	const stopAnalyserLoop = (0, react.useCallback)(() => {
+		if (rafRef.current == null) return;
+		if (typeof window !== "undefined") window.cancelAnimationFrame(rafRef.current);
+		rafRef.current = null;
+		setLevel(0);
+	}, []);
+	const ensureAnalyser = (0, react.useCallback)((ctx) => {
+		if (analyserRef.current != null) return analyserRef.current;
+		const analyser = ctx.createAnalyser();
+		analyser.fftSize = ANALYSER_FFT_SIZE;
+		analyser.connect(ctx.destination);
+		analyserRef.current = analyser;
+		freqBufRef.current = new Uint8Array(analyser.frequencyBinCount);
+		timeBufRef.current = new Uint8Array(analyser.fftSize);
+		return analyser;
+	}, []);
+	const ensureContextForPcm = (0, react.useCallback)(() => {
+		if (ctxRef.current != null) return ctxRef.current;
+		const format = formatRef.current;
+		if (format == null) return null;
+		const AudioCtx = resolveAudioContextCtor();
+		if (AudioCtx == null) {
+			setError(/* @__PURE__ */ new Error("Web Audio API is not available in this environment"));
+			setStatus("error");
+			return null;
+		}
+		const ctx = new AudioCtx({ sampleRate: format.sampleRate });
+		ctxRef.current = ctx;
+		nextStartTimeRef.current = ctx.currentTime;
+		ensureAnalyser(ctx);
+		return ctx;
+	}, [ensureAnalyser]);
+	const ensureContextForElement = (0, react.useCallback)(() => {
+		if (ctxRef.current != null) return ctxRef.current;
+		const AudioCtx = resolveAudioContextCtor();
+		if (AudioCtx == null) return null;
+		const ctx = new AudioCtx();
+		ctxRef.current = ctx;
+		ensureAnalyser(ctx);
+		return ctx;
+	}, [ensureAnalyser]);
+	const scheduleChunk = (0, react.useCallback)((ctx, bytes) => {
+		const format = formatRef.current;
+		const analyser = analyserRef.current;
+		if (format == null || analyser == null) return;
+		const { sampleRate: bufSampleRate, channels: bufChannels } = format;
+		const sampleCount = Math.floor(bytes.byteLength / 2);
+		if (sampleCount === 0) return;
+		const framesPerChannel = Math.floor(sampleCount / bufChannels);
+		if (framesPerChannel === 0) return;
+		const buffer = ctx.createBuffer(bufChannels, framesPerChannel, bufSampleRate);
+		const view = new DataView(bytes.buffer, bytes.byteOffset, framesPerChannel * bufChannels * 2);
+		for (let channel = 0; channel < bufChannels; channel += 1) {
+			const channelData = buffer.getChannelData(channel);
+			for (let frame = 0; frame < framesPerChannel; frame += 1) {
+				const sampleOffset = (frame * bufChannels + channel) * 2;
+				const int = view.getInt16(sampleOffset, true);
+				channelData[frame] = int < 0 ? int / 32768 : int / 32767;
+			}
+		}
+		const source = ctx.createBufferSource();
+		source.buffer = buffer;
+		source.connect(analyser);
+		const now = ctx.currentTime;
+		const startAt = Math.max(now, nextStartTimeRef.current);
+		source.start(startAt);
+		nextStartTimeRef.current = startAt + buffer.duration;
+		activeSourcesRef.current.add(source);
+		source.onended = () => {
+			activeSourcesRef.current.delete(source);
+			if (activeSourcesRef.current.size === 0 && upstreamFinishedRef.current && pendingChunksRef.current.length === 0) setStatus("finished");
+		};
+	}, []);
+	const flushPendingPcm = (0, react.useCallback)(() => {
+		if (!shouldPlayRef.current) return;
+		const ctx = ensureContextForPcm();
+		if (ctx == null) return;
+		if (ctx.state === "suspended") ctx.resume();
+		const chunks = pendingChunksRef.current;
+		pendingChunksRef.current = [];
+		for (const bytes of chunks) scheduleChunk(ctx, bytes);
+		if (chunks.length > 0 && statusRef.current !== "playing") {
+			playStartCtxTimeRef.current = ctx.currentTime;
+			setCurrentTime(0);
+			setStatus("playing");
+			startAnalyserLoop();
+		}
+	}, [
+		ensureContextForPcm,
+		scheduleChunk,
+		startAnalyserLoop
+	]);
+	const play = (0, react.useCallback)(() => {
+		if (media == null) return;
+		if (statusRef.current === "error") return;
+		if (strategy === "pcm") {
+			shouldPlayRef.current = true;
+			if (statusRef.current !== "playing") setStatus("buffering");
+			const ctx = ensureContextForPcm();
+			if (ctx != null && ctx.state === "suspended") ctx.resume();
+			flushPendingPcm();
+			return;
+		}
+		const audio = audioElRef.current;
+		if (audio == null) {
+			shouldPlayRef.current = true;
+			setStatus("buffering");
+			return;
+		}
+		shouldPlayRef.current = true;
+		const ctx = ensureContextForElement();
+		if (ctx != null && ctx.state === "suspended") ctx.resume();
+		audio.play().catch((err) => {
+			setError(err);
+			setStatus("error");
+		});
+	}, [
+		media,
+		strategy,
+		ensureContextForPcm,
+		ensureContextForElement,
+		flushPendingPcm
+	]);
+	const pause = (0, react.useCallback)(() => {
+		shouldPlayRef.current = false;
+		if (strategy === "pcm") {
+			const ctx = ctxRef.current;
+			if (ctx != null && ctx.state === "running") ctx.suspend();
+		} else audioElRef.current?.pause();
+		if (statusRef.current === "playing" || statusRef.current === "buffering") setStatus("paused");
+	}, [strategy]);
+	const stop = (0, react.useCallback)(() => {
+		shouldPlayRef.current = false;
+		stopAnalyserLoop();
+		if (strategy === "pcm") {
+			for (const source of activeSourcesRef.current) try {
+				source.stop();
+			} catch {}
+			activeSourcesRef.current.clear();
+			pendingChunksRef.current = [];
+			nextStartTimeRef.current = 0;
+		} else {
+			const audio = audioElRef.current;
+			if (audio != null) {
+				audio.pause();
+				audio.currentTime = 0;
+			}
+		}
+		const ctx = ctxRef.current;
+		ctxRef.current = null;
+		analyserRef.current = null;
+		freqBufRef.current = null;
+		timeBufRef.current = null;
+		elementSourceRef.current = null;
+		if (ctx != null) ctx.close();
+		setCurrentTime(0);
+		setStatus(media == null ? "idle" : "paused");
+	}, [
+		strategy,
+		media,
+		stopAnalyserLoop
+	]);
+	const reset = (0, react.useCallback)(() => {
+		stop();
+		setError(void 0);
+		setDuration(void 0);
+		upstreamFinishedRef.current = false;
+		setStatus("idle");
+	}, [stop]);
+	const toggle = (0, react.useCallback)(() => {
+		if (statusRef.current === "playing") pause();
+		else play();
+	}, [play, pause]);
+	const playToEnd = (0, react.useCallback)(() => {
+		pendingResolveRef.current?.();
+		pendingResolveRef.current = null;
+		pendingRejectRef.current = null;
+		return new Promise((resolve, reject) => {
+			pendingResolveRef.current = resolve;
+			pendingRejectRef.current = reject;
+			play();
+		});
+	}, [play]);
+	const seek = (0, react.useCallback)((seconds) => {
+		if (strategy !== "element") return;
+		const audio = audioElRef.current;
+		if (audio == null) return;
+		audio.currentTime = seconds;
+		setCurrentTime(seconds);
+	}, [strategy]);
+	const getFrequencyData = (0, react.useCallback)(() => {
+		const analyser = analyserRef.current;
+		const buf = freqBufRef.current;
+		if (analyser == null || buf == null) return void 0;
+		analyser.getByteFrequencyData(buf);
+		return buf;
+	}, []);
+	const getTimeDomainData = (0, react.useCallback)(() => {
+		const analyser = analyserRef.current;
+		const buf = timeBufRef.current;
+		if (analyser == null || buf == null) return void 0;
+		analyser.getByteTimeDomainData(buf);
+		return buf;
+	}, []);
+	const autoPlayRef = (0, react.useRef)(autoPlay);
+	(0, react.useEffect)(() => {
+		autoPlayRef.current = autoPlay;
+	}, [autoPlay]);
+	(0, react.useEffect)(() => {
+		if (media?.error == null) return;
+		setError(new Error(media.error.message));
+		setStatus("error");
+	}, [media]);
+	(0, react.useEffect)(() => {
+		if (media == null || strategy !== "pcm") return void 0;
+		setError(void 0);
+		setStatus("buffering");
+		setCurrentTime(0);
+		setDuration(void 0);
+		upstreamFinishedRef.current = false;
+		pendingChunksRef.current = [];
+		const mimeType = media.mimeType ?? "";
+		const isRawPcm = mimeType === "audio/pcm" || mimeType === "audio/L16" || mimeType.startsWith("audio/pcm;") || mimeType.startsWith("audio/L16;") || pcmPrefixes != null && pcmPrefixes.some((prefix) => mimeType.startsWith(prefix));
+		const isWav = mimeType === "audio/wav" || mimeType === "audio/wave" || mimeType === "audio/x-wav" || mimeType === "audio/vnd.wave";
+		if (isRawPcm) formatRef.current = {
+			sampleRate,
+			channels,
+			bitsPerSample: 16
+		};
+		else if (isWav) formatRef.current = null;
+		else {
+			setError(/* @__PURE__ */ new Error(`useAudioPlayer: forced PCM strategy for unsupported mime ${JSON.stringify(mimeType)}`));
+			setStatus("error");
+			return;
+		}
+		const wavHeaderChunks = [];
+		let wavHeaderParsed = !isWav;
+		let wavHeaderFailed = false;
+		const routeChunk = (bytes) => {
+			if (wavHeaderFailed) return;
+			if (wavHeaderParsed) {
+				pendingChunksRef.current.push(bytes);
+				if (shouldPlayRef.current) flushPendingPcm();
+				return;
+			}
+			wavHeaderChunks.push(bytes);
+			const combined = concatChunks(wavHeaderChunks);
+			const result = tryParseWavHeader(combined);
+			if (result.status === "need-more") return;
+			if (result.status === "invalid") {
+				wavHeaderFailed = true;
+				setError(/* @__PURE__ */ new Error(`useAudioPlayer: invalid WAV stream: ${result.reason}`));
+				setStatus("error");
+				return;
+			}
+			formatRef.current = result.format;
+			wavHeaderParsed = true;
+			wavHeaderChunks.length = 0;
+			const tail = combined.subarray(result.dataOffset);
+			if (tail.byteLength > 0) {
+				pendingChunksRef.current.push(tail);
+				if (shouldPlayRef.current) flushPendingPcm();
+			}
+		};
+		if (autoPlayRef.current) shouldPlayRef.current = true;
+		const unsubscribe = attachToPump(media, (event) => {
+			switch (event.type) {
+				case "chunk":
+					routeChunk(event.bytes);
+					break;
+				case "finished":
+					upstreamFinishedRef.current = true;
+					if (pendingChunksRef.current.length === 0 && activeSourcesRef.current.size === 0) setStatus("finished");
+					break;
+				case "error":
+					setError(event.error);
+					setStatus("error");
+					break;
+			}
+		});
+		return () => {
+			unsubscribe();
+			stop();
+		};
+	}, [
+		media,
+		strategy,
+		sampleRate,
+		channels,
+		pcmPrefixes,
+		flushPendingPcm,
+		stop
+	]);
+	(0, react.useEffect)(() => {
+		if (media == null || strategy !== "element") return void 0;
+		if (typeof window === "undefined") return void 0;
+		setError(void 0);
+		setStatus("buffering");
+		setCurrentTime(0);
+		setDuration(void 0);
+		let cancelled = false;
+		let audio = null;
+		media.objectURL.then((resolved) => {
+			if (cancelled) return;
+			pendingSrcRef.current = resolved;
+			audio = new Audio(resolved);
+			audio.preload = "auto";
+			audioElRef.current = audio;
+			const onPlay = () => {
+				if (statusRef.current === "error") return;
+				const ctx = ensureContextForElement();
+				if (ctx != null && elementSourceRef.current == null && audio != null) try {
+					const src = ctx.createMediaElementSource(audio);
+					src.connect(analyserRef.current);
+					elementSourceRef.current = src;
+				} catch {}
+				playStartCtxTimeRef.current = 0;
+				setCurrentTime(audio?.currentTime ?? 0);
+				setStatus("playing");
+				startAnalyserLoop();
+			};
+			const onPause = () => {
+				if (audio != null && audio.ended) return;
+				if (statusRef.current === "playing") setStatus("paused");
+			};
+			const onEnded = () => {
+				setStatus("finished");
+			};
+			const onTimeUpdate = () => {
+				if (audio != null) setCurrentTime(audio.currentTime);
+			};
+			const onLoadedMetadata = () => {
+				if (audio != null && Number.isFinite(audio.duration)) setDuration(audio.duration);
+			};
+			const onError = () => {
+				setError(/* @__PURE__ */ new Error("HTMLAudioElement error"));
+				setStatus("error");
+			};
+			audio.addEventListener("play", onPlay);
+			audio.addEventListener("pause", onPause);
+			audio.addEventListener("ended", onEnded);
+			audio.addEventListener("timeupdate", onTimeUpdate);
+			audio.addEventListener("loadedmetadata", onLoadedMetadata);
+			audio.addEventListener("error", onError);
+			if (shouldPlayRef.current || autoPlayRef.current) audio.play().catch((err) => {
+				setError(err);
+				setStatus("error");
+			});
+			else setStatus("paused");
+		}, () => {
+			if (!cancelled) {
+				setError(/* @__PURE__ */ new Error("media failed to materialise"));
+				setStatus("error");
+			}
+		});
+		return () => {
+			cancelled = true;
+			const el = audioElRef.current;
+			audioElRef.current = null;
+			elementSourceRef.current = null;
+			if (el != null) try {
+				el.pause();
+				el.removeAttribute("src");
+				el.load();
+			} catch {}
+			stop();
+			try {
+				media.revoke();
+			} catch {}
+		};
+	}, [
+		media,
+		strategy,
+		ensureContextForElement,
+		startAnalyserLoop,
+		stop
+	]);
+	(0, react.useEffect)(() => {
+		if (media != null) return;
+		setStatus("idle");
+		setError(void 0);
+		setCurrentTime(0);
+		setDuration(void 0);
+		setLevel(0);
+		upstreamFinishedRef.current = false;
+	}, [media]);
+	return {
+		status,
+		strategy,
+		play,
+		pause,
+		stop,
+		toggle,
+		reset,
+		playToEnd,
+		currentTime,
+		duration: strategy === "element" ? duration : void 0,
+		seek: strategy === "element" ? seek : void 0,
+		level,
+		getFrequencyData,
+		getTimeDomainData,
+		error
+	};
+}
+//#endregion
+exports.useAudioPlayer = useAudioPlayer;
+
+//# sourceMappingURL=use-audio-player.cjs.map