Upload folder using huggingface_hub

6.26.0/audio/Example.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	let {
+		value,
+		type,
+		selected = false
+	}: {
+		value: string | null;
+		type: "gallery" | "table";
+		selected?: boolean;
+	} = $props();
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value ? value : ""}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

6.26.0/audio/Index.svelte

@@ -0,0 +1,232 @@
+<script lang="ts">
+	import { onMount, tick } from "svelte";
+	import { Gradio } from "@gradio/utils";
+	import { StatusTracker } from "@gradio/statustracker";
+
+	import StaticAudio from "./static/StaticAudio.svelte";
+	import InteractiveAudio from "./interactive/InteractiveAudio.svelte";
+	import { Block, UploadText } from "@gradio/atoms";
+	import type { AudioEvents, AudioProps } from "./shared/types";
+
+	let props = $props();
+	let upload_promise = $state<Promise<any>>();
+
+	props.props.stream_every = 0.1; // default to 0.1s stream interval
+
+	class AudioGradio extends Gradio<AudioEvents, AudioProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	const gradio = new AudioGradio(props);
+	let label = $derived(gradio.shared.label || gradio.i18n("audio.audio"));
+	let minimal = $derived(
+		(props as any).minimal ?? (gradio.props as any).minimal ?? false
+	);
+
+	let active_source = $derived.by(() =>
+		gradio.props.sources ? gradio.props.sources[0] : null
+	);
+	let initial_value = $state(gradio.props.value);
+
+	const handle_reset_value = (): void => {
+		if (initial_value === null || gradio.props.value === initial_value) {
+			return;
+		}
+		gradio.props.value = initial_value;
+	};
+
+	let dragging = $state(false);
+	let recording = $state(gradio.props.recording ?? false);
+	$effect(() => {
+		gradio.props.recording = recording;
+	});
+
+	let color_accent = "darkorange";
+
+	let waveform_settings = $state({
+		height: 50,
+		barWidth: 2,
+		barGap: 3,
+		cursorWidth: 2,
+		cursorColor: "#ddd5e9",
+		autoplay: gradio.props.autoplay,
+		barRadius: 10,
+		dragToSeek: true,
+		normalize: true,
+		minPxPerSec: 20,
+		waveColor: gradio.props.waveform_options.waveform_color || "#9ca3af",
+		progressColor:
+			gradio.props.waveform_options.waveform_progress_color || color_accent,
+		mediaControls: gradio.props.waveform_options.show_controls ?? false,
+		sampleRate: gradio.props.waveform_options.sample_rate || 44100
+	});
+
+	const trim_region_settings = {
+		color: gradio.props.waveform_options.trim_region_color,
+		drag: true,
+		resize: true
+	};
+
+	function set_trim_region_colour(): void {
+		document.documentElement.style.setProperty(
+			"--trim-region-color",
+			trim_region_settings.color || color_accent
+		);
+	}
+
+	function handle_error(detail: string): void {
+		const [level, status] = detail.includes("Invalid file type")
+			? ["warning", "complete"]
+			: ["error", "error"];
+		if (gradio.shared.loading_status) {
+			(gradio.shared.loading_status as any).status = status;
+			(gradio.shared.loading_status as any).message = detail;
+		}
+		gradio.dispatch(level as "error" | "warning", detail);
+	}
+
+	gradio.watch_for_change();
+
+	onMount(() => {
+		set_trim_region_colour();
+	});
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		variant={"solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		allow_overflow={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		visible={gradio.shared.visible}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<StaticAudio
+			i18n={gradio.i18n}
+			show_label={gradio.shared.show_label}
+			buttons={gradio.props.buttons ?? ["download", "share"]}
+			value={gradio.props.value}
+			subtitles={gradio.props.subtitles}
+			{label}
+			loop={gradio.props.loop}
+			{waveform_settings}
+			waveform_options={gradio.props.waveform_options}
+			editable={gradio.props.editable}
+			{minimal}
+			on_custom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+			bind:playback_position={gradio.props.playback_position}
+			onshare={(detail) => gradio.dispatch("share", detail)}
+			onerror={(e) => gradio.dispatch("error", e.detail)}
+			onplay={() => gradio.dispatch("play")}
+			onpause={() => gradio.dispatch("pause")}
+			onstop={() => gradio.dispatch("stop")}
+		/>
+	</Block>
+{:else}
+	<Block
+		variant={gradio.props.value === null && active_source === "upload"
+			? "dashed"
+			: "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		allow_overflow={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		visible={gradio.shared.visible}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+		<InteractiveAudio
+			bind:upload_promise
+			bind:initial_value
+			{label}
+			show_label={gradio.shared.show_label}
+			buttons={gradio.props.buttons ?? []}
+			on_custom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+			value={gradio.props.value}
+			subtitles={gradio.props.subtitles}
+			onchange={(detail) => (gradio.props.value = detail)}
+			onstream={(detail) => {
+				gradio.props.value = detail;
+				gradio.dispatch("stream", gradio.props.value);
+			}}
+			ondrag={(detail) => (dragging = detail)}
+			root={gradio.shared.root}
+			sources={gradio.props.sources}
+			active_source={active_source || undefined}
+			pending={gradio.shared.loading_status.pending}
+			streaming={gradio.props.streaming}
+			bind:recording
+			loop={gradio.props.loop}
+			max_file_size={gradio.shared.max_file_size}
+			{handle_reset_value}
+			editable={gradio.props.editable}
+			bind:dragging
+			bind:playback_position={gradio.props.playback_position}
+			onedit={() => gradio.dispatch("edit")}
+			onplay={() => gradio.dispatch("play")}
+			onpause={() => gradio.dispatch("pause")}
+			onstop={() => gradio.dispatch("stop")}
+			onstart_recording={() => gradio.dispatch("start_recording")}
+			onpause_recording={() => gradio.dispatch("pause_recording")}
+			onstop_recording={() => {
+				gradio.dispatch("stop_recording");
+				gradio.dispatch("input");
+			}}
+			onupload={() => {
+				gradio.dispatch("upload");
+				gradio.dispatch("input");
+			}}
+			onclear={() => {
+				gradio.dispatch("clear");
+				gradio.dispatch("input");
+			}}
+			onerror={handle_error}
+			onclose_stream={() => gradio.dispatch("close_stream", "stream")}
+			i18n={gradio.i18n}
+			{waveform_settings}
+			waveform_options={gradio.props.waveform_options}
+			{trim_region_settings}
+			stream_every={gradio.props.stream_every}
+			stream_state={gradio.shared.loading_status.stream_state}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={(...args) => gradio.shared.client.stream(...args)}
+			time_limit={gradio.shared.loading_status.time_limit}
+		>
+			<UploadText i18n={gradio.i18n} type="audio" />
+		</InteractiveAudio>
+	</Block>
+{/if}

6.26.0/audio/index.ts

@@ -0,0 +1,7 @@
+import { default as Index } from "./Index.svelte";
+export default Index;
+export { default as BaseStaticAudio } from "./static/StaticAudio.svelte";
+export { default as BaseInteractiveAudio } from "./interactive/InteractiveAudio.svelte";
+export { default as BasePlayer } from "./player/AudioPlayer.svelte";
+export type { WaveformOptions } from "./shared/types";
+export { default as BaseExample } from "./Example.svelte";

6.26.0/audio/interactive/InteractiveAudio.svelte

@@ -0,0 +1,429 @@
+<script lang="ts">
+	import { onDestroy } from "svelte";
+	import { Upload, ModifyUpload } from "@gradio/upload";
+	import { prepare_files, type FileData, type Client } from "@gradio/client";
+	import { BlockLabel, ShareButton, CustomButton } from "@gradio/atoms";
+	import { Music } from "@gradio/icons";
+	import { uploadToHuggingFace } from "@gradio/utils";
+	import { StreamingBar } from "@gradio/statustracker";
+	import AudioPlayer from "../player/AudioPlayer.svelte";
+
+	import type { IBlobEvent, IMediaRecorder } from "extendable-media-recorder";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import AudioRecorder from "../recorder/AudioRecorder.svelte";
+	import StreamAudio from "../streaming/StreamAudio.svelte";
+	import { init_media_recorder } from "../streaming/media_recorder";
+	import type { IMediaRecorderConstructor } from "extendable-media-recorder";
+	import { SelectSource } from "@gradio/atoms";
+	import type { WaveformOptions, SubtitleData } from "../shared/types";
+	import type { CustomButton as CustomButtonType } from "@gradio/utils";
+
+	let {
+		value = $bindable(null),
+		subtitles = null,
+		label,
+		root,
+		loop,
+		show_label = true,
+		buttons = ["download", "share"],
+		on_custom_button_click = null,
+		sources = ["microphone", "upload"],
+		pending = false,
+		streaming = false,
+		i18n,
+		waveform_settings,
+		trim_region_settings = {},
+		waveform_options = {},
+		dragging = $bindable(false),
+		active_source = $bindable<"microphone" | "upload">("microphone"),
+		handle_reset_value = () => {},
+		editable = true,
+		max_file_size = null,
+		upload,
+		stream_handler,
+		stream_every = 0.1,
+		uploading = $bindable(false),
+		recording = $bindable(false),
+		class_name = "",
+		upload_promise = $bindable(),
+		initial_value = $bindable(),
+		playback_position = $bindable(),
+		time_limit = null,
+		stream_state = "closed",
+		onchange,
+		onstream,
+		onedit,
+		onplay,
+		onpause,
+		onstop,
+		ondrag,
+		onerror,
+		onupload,
+		onclear,
+		onstart_recording,
+		onpause_recording,
+		onstop_recording,
+		onclose_stream,
+		children
+	}: {
+		value?: null | FileData;
+		subtitles?: null | FileData | SubtitleData[];
+		label: string;
+		root: string;
+		loop?: boolean;
+		show_label?: boolean;
+		buttons?: (string | CustomButtonType)[];
+		on_custom_button_click?: ((id: number) => void) | null;
+		sources?:
+			| ["microphone"]
+			| ["upload"]
+			| ["microphone", "upload"]
+			| ["upload", "microphone"];
+		pending?: boolean;
+		streaming?: boolean;
+		i18n: I18nFormatter;
+		waveform_settings: Record<string, any>;
+		trim_region_settings?: Record<string, any>;
+		waveform_options?: WaveformOptions;
+		dragging?: boolean;
+		active_source?: "microphone" | "upload";
+		handle_reset_value?: () => void;
+		editable?: boolean;
+		max_file_size?: number | null;
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		stream_every?: number;
+		uploading?: boolean;
+		recording?: boolean;
+		class_name?: string;
+		upload_promise?: Promise<any> | null;
+		initial_value?: FileData | null;
+		playback_position?: number;
+		time_limit?: number | null;
+		stream_state?: "open" | "waiting" | "closed";
+		onchange?: (value: FileData | null) => void;
+		onstream?: (value: FileData) => void;
+		onedit?: () => void;
+		onplay?: () => void;
+		onpause?: () => void;
+		onstop?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onerror?: (error: string) => void;
+		onupload?: (value: FileData) => void;
+		onclear?: () => void;
+		onstart_recording?: () => void;
+		onpause_recording?: () => void;
+		onstop_recording?: () => void;
+		onclose_stream?: () => void;
+		children?: import("svelte").Snippet;
+	} = $props();
+
+	$effect(() => {
+		ondrag?.(dragging);
+	});
+
+	// TODO: make use of this
+	// export let type: "normal" | "numpy" = "normal";
+	let recorder: IMediaRecorder;
+	let mode = $state("");
+	let header: Uint8Array | undefined = undefined;
+	let pending_stream: Uint8Array[] = [];
+	let submit_pending_stream_on_pending_end = false;
+	let inited = false;
+	let streaming_media_recorder: IMediaRecorderConstructor;
+
+	const NUM_HEADER_BYTES = 44;
+	let audio_chunks: Blob[] = [];
+	const is_browser = typeof window !== "undefined";
+	if (is_browser && streaming) {
+		init_media_recorder().then((a) => {
+			streaming_media_recorder = a;
+		});
+	}
+
+	const to_blob_parts = (parts: Uint8Array[] | Blob[]): BlobPart[] =>
+		parts.map((part) => {
+			if (part instanceof Blob) return part;
+			return part.slice();
+		});
+
+	const dispatch_blob = async (
+		blobs: Uint8Array[] | Blob[],
+		event: "stream" | "change"
+	): Promise<void> => {
+		let _audio_blob = new File(to_blob_parts(blobs), "audio.wav", {
+			type: "audio/wav"
+		});
+		if (_audio_blob.size === 0) {
+			return;
+		}
+		const val = await prepare_files([_audio_blob], event === "stream");
+		initial_value = value;
+		value = (
+			(await upload(val, root, undefined, max_file_size || undefined))?.filter(
+				Boolean
+			) as FileData[]
+		)[0];
+		if (event === "stream") {
+			onstream?.(value);
+		} else {
+			onchange?.(value);
+		}
+	};
+
+	onDestroy(() => {
+		if (streaming && recorder && recorder.state !== "inactive") {
+			recorder.stop();
+		}
+	});
+
+	async function prepare_audio(): Promise<void> {
+		let stream: MediaStream | null;
+
+		try {
+			stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+		} catch (err) {
+			if (!navigator.mediaDevices) {
+				onerror?.(i18n("audio.no_device_support"));
+				return;
+			}
+			if (err instanceof DOMException && err.name == "NotAllowedError") {
+				onerror?.(i18n("audio.allow_recording_access"));
+				return;
+			}
+			throw err;
+		}
+		if (stream == null) return;
+		if (streaming) {
+			recorder = new streaming_media_recorder(stream, {
+				mimeType: "audio/wav"
+			});
+
+			recorder.addEventListener("dataavailable", handle_chunk);
+		} else {
+			recorder = new MediaRecorder(stream);
+			recorder.addEventListener("dataavailable", (event) => {
+				audio_chunks.push(event.data);
+			});
+			recorder.addEventListener("stop", async () => {
+				recording = false;
+				await dispatch_blob(audio_chunks, "change");
+				onstop_recording?.();
+				audio_chunks = [];
+			});
+		}
+		inited = true;
+	}
+
+	async function handle_chunk(event: IBlobEvent): Promise<void> {
+		let buffer = await event.data.arrayBuffer();
+		let payload = new Uint8Array(buffer);
+		if (!header) {
+			header = new Uint8Array(buffer.slice(0, NUM_HEADER_BYTES));
+			payload = new Uint8Array(buffer.slice(NUM_HEADER_BYTES));
+		}
+		if (pending) {
+			pending_stream.push(payload);
+		} else {
+			let blobParts = [header].concat(pending_stream, [payload]);
+			if (!recording || stream_state === "waiting") return;
+			dispatch_blob(blobParts, "stream");
+			pending_stream = [];
+		}
+	}
+
+	$effect(() => {
+		if (submit_pending_stream_on_pending_end && pending === false) {
+			submit_pending_stream_on_pending_end = false;
+			if (header && pending_stream) {
+				let blobParts: Uint8Array[] = [header].concat(pending_stream);
+				pending_stream = [];
+				dispatch_blob(blobParts, "stream");
+			}
+		}
+	});
+
+	async function record(): Promise<void> {
+		recording = true;
+		onstart_recording?.();
+		if (!inited) await prepare_audio();
+
+		header = undefined;
+		if (streaming && recorder.state != "recording") {
+			recorder.start(stream_every * 1000);
+		}
+	}
+
+	function clear(): void {
+		mode = "";
+		value = null;
+		playback_position = 0;
+		onchange?.(null);
+		onclear?.();
+	}
+
+	function handle_load(detail: FileData): void {
+		value = detail;
+		playback_position = 0;
+		onchange?.(detail);
+		onupload?.(detail);
+	}
+
+	async function stop(): Promise<void> {
+		recording = false;
+
+		if (streaming) {
+			onclose_stream?.();
+			onstop_recording?.();
+			recorder.stop();
+
+			if (pending) {
+				submit_pending_stream_on_pending_end = true;
+			}
+			onclear?.();
+			mode = "";
+		}
+	}
+
+	$effect(() => {
+		if (!recording && recorder && mode !== "") stop();
+	});
+
+	$effect(() => {
+		if (recording && recorder) record();
+	});
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={Music}
+	float={active_source === "upload" && value === null}
+	label={label || i18n("audio.audio")}
+/>
+<div
+	class="audio-container {class_name}"
+	data-testid={label ? "waveform-" + label : "unlabelled-audio"}
+>
+	<StreamingBar {time_limit} />
+	{#if value == null || streaming}
+		{#if active_source === "microphone"}
+			<ModifyUpload {i18n} onclear={clear} />
+			{#if streaming}
+				<StreamAudio
+					{record}
+					{recording}
+					{stop}
+					{i18n}
+					{waveform_settings}
+					{waveform_options}
+					waiting={stream_state === "waiting"}
+				/>
+			{:else}
+				<AudioRecorder
+					bind:mode
+					{i18n}
+					{editable}
+					{recording}
+					{dispatch_blob}
+					{waveform_settings}
+					{waveform_options}
+					{handle_reset_value}
+					onstartrecording={() => onstart_recording?.()}
+					onpauserecording={() => onpause_recording?.()}
+					onstoprecording={() => onstop_recording?.()}
+				/>
+			{/if}
+		{:else if active_source === "upload"}
+			<!-- explicitly listed out audio mimetypes due to iOS bug not recognizing audio/* -->
+			<Upload
+				bind:upload_promise
+				filetype="audio/aac,audio/midi,audio/mpeg,audio/ogg,audio/wav,audio/x-wav,audio/opus,audio/webm,audio/flac,audio/vnd.rn-realaudio,audio/x-ms-wma,audio/x-aiff,audio/amr,audio/*"
+				onload={handle_load}
+				bind:dragging
+				bind:uploading
+				onerror={(detail: string) => onerror?.(detail)}
+				{root}
+				{max_file_size}
+				{upload}
+				{stream_handler}
+				aria_label={i18n("audio.drop_to_upload")}
+			>
+				{#if children}{@render children()}{/if}
+			</Upload>
+		{/if}
+	{:else}
+		<ModifyUpload
+			{i18n}
+			onclear={clear}
+			onedit={() => {
+				mode = "edit";
+				onedit?.();
+			}}
+			download={buttons === null
+				? value.url
+				: buttons.some((btn) => typeof btn === "string" && btn === "download")
+					? value.url
+					: null}
+		>
+			{#if value !== null && buttons}
+				{#each buttons as btn}
+					{#if typeof btn === "string"}
+						{#if btn === "share"}
+							<ShareButton
+								{i18n}
+								{onerror}
+								onshare={() => {}}
+								formatter={async (fileData: FileData) => {
+									if (!fileData || !fileData.url) return "";
+									let url = await uploadToHuggingFace(fileData.url, "url");
+									return `<audio controls src="${url}"></audio>`;
+								}}
+								{value}
+							/>
+						{/if}
+					{:else}
+						<CustomButton
+							button={btn}
+							on_click={(id: number) => {
+								if (on_custom_button_click) {
+									on_custom_button_click(id);
+								}
+							}}
+						/>
+					{/if}
+				{/each}
+			{/if}
+		</ModifyUpload>
+
+		<AudioPlayer
+			bind:mode
+			{value}
+			subtitles={Array.isArray(subtitles) ? subtitles : subtitles?.url}
+			{label}
+			{i18n}
+			{dispatch_blob}
+			{waveform_settings}
+			{waveform_options}
+			{trim_region_settings}
+			{handle_reset_value}
+			{editable}
+			{loop}
+			bind:playback_position
+			interactive
+			{onstop}
+			{onplay}
+			{onpause}
+			{onedit}
+		/>
+	{/if}
+	<SelectSource {sources} bind:active_source handle_clear={clear} />
+</div>
+
+<style>
+	.audio-container {
+		height: calc(var(--size-full) - var(--size-6));
+		display: flex;
+		flex-direction: column;
+		justify-content: space-between;
+	}
+</style>

6.26.0/audio/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "@gradio/audio",
+	"version": "0.24.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/button": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"extendable-media-recorder": "9.0.0",
+		"extendable-media-recorder-wav-encoder": "7.0.76",
+		"hls.js": "1.5.13",
+		"resize-observer-polyfill": "1.5.1",
+		"svelte-range-slider-pips": "4.1.0",
+		"wavesurfer.js": "7.11.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "index.ts",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./index.ts",
+			"svelte": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./shared": {
+			"gradio": "./shared/index.ts",
+			"svelte": "./dist/shared/index.js",
+			"types": "./dist/shared/index.d.ts"
+		},
+		"./base": {
+			"gradio": "./static/StaticAudio.svelte",
+			"svelte": "./dist/static/StaticAudio.svelte",
+			"types": "./dist/static/StaticAudio.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/audio"
+	}
+}

6.26.0/audio/player/AudioPlayer.svelte

@@ -0,0 +1,593 @@
+<script lang="ts">
+	import { onMount, untrack } from "svelte";
+	import { Music } from "@gradio/icons";
+	import { format_time, type I18nFormatter } from "@gradio/utils";
+	import WaveSurfer from "wavesurfer.js";
+	import { skip_audio, process_audio } from "../shared/utils";
+	import WaveformControls from "../shared/WaveformControls.svelte";
+	import { Empty } from "@gradio/atoms";
+	import type { FileData } from "@gradio/client";
+	import type { WaveformOptions, SubtitleData } from "../shared/types";
+
+	import Hls from "hls.js";
+
+	let {
+		value = null,
+		subtitles = null,
+		label,
+		i18n,
+		dispatch_blob = () => Promise.resolve(),
+		interactive = false,
+		editable = true,
+		trim_region_settings = {},
+		waveform_settings,
+		waveform_options,
+		mode = $bindable(),
+		loop,
+		handle_reset_value = () => {},
+		playback_position = $bindable(),
+		onstop,
+		onplay,
+		onpause,
+		onedit,
+		onload
+	}: {
+		value?: null | FileData;
+		subtitles?: null | string | SubtitleData[];
+		label: string;
+		i18n: I18nFormatter;
+		dispatch_blob?: (
+			blobs: Uint8Array[] | Blob[],
+			event: "stream" | "change"
+		) => Promise<void>;
+		interactive?: boolean;
+		editable?: boolean;
+		trim_region_settings?: Record<string, any>;
+		waveform_settings: Record<string, any>;
+		waveform_options: WaveformOptions;
+		mode?: string;
+		loop?: boolean;
+		handle_reset_value?: () => void;
+		playback_position?: number;
+		onstop?: () => void;
+		onplay?: () => void;
+		onpause?: () => void;
+		onedit?: () => void;
+		onload?: () => void;
+	} = $props();
+
+	let url = $derived(value?.url);
+	let old_playback_position = $state(0);
+
+	let container = $state<HTMLDivElement | undefined>(undefined);
+	let waveform_container: HTMLDivElement | undefined = undefined;
+	let waveform: WaveSurfer | undefined;
+	let waveform_ready = $state(false);
+	let waveform_component_wrapper: HTMLDivElement;
+	let playing = $state(false);
+
+	let subtitle_container: HTMLDivElement;
+
+	let timeRef: HTMLTimeElement;
+	let durationRef: HTMLTimeElement;
+	let audio_duration = $state<number>(0);
+
+	let trimDuration = $state(0);
+
+	let show_volume_slider = $state(false);
+	let audio_player = $state<HTMLAudioElement | undefined>(undefined);
+
+	let stream_active = false;
+	let subtitles_toggle = $state(true);
+	let subtitle_event_handlers: (() => void)[] = [];
+
+	let waveform_load_failed = $state(false);
+
+	let use_waveform = $derived(
+		waveform_options.show_recording_waveform && !value?.is_stream
+	);
+
+	let native_fallback_active = $derived(
+		waveform_load_failed && value?.url !== undefined && value?.url !== null
+	);
+
+	// The native element is the player, rather than a hidden decoy, whenever
+	// there is no working waveform to drive playback: the waveform is turned
+	// off, the value is a stream, or the waveform failed to load. Its events
+	// are only meaningful in those cases.
+	let native_player_active = $derived(!use_waveform || native_fallback_active);
+
+	$effect(() => {
+		if (
+			playback_position !== undefined &&
+			old_playback_position !== playback_position
+		) {
+			if (native_player_active) {
+				if (audio_player) {
+					audio_player.currentTime = playback_position;
+					old_playback_position = playback_position;
+				}
+			} else if (waveform_ready && audio_duration) {
+				waveform?.seekTo(playback_position / audio_duration);
+				old_playback_position = playback_position;
+			}
+		}
+	});
+
+	const create_waveform = (): void => {
+		// `container` only exists while the waveform branch is rendered, and it is
+		// a fresh element every time that branch remounts, so bail out when there
+		// is nothing to draw into and rebuild when the element is replaced.
+		if (!container || waveform_container === container) return;
+		waveform?.destroy();
+		waveform_ready = false;
+		waveform_container = container;
+		waveform = WaveSurfer.create({
+			container: container,
+			...waveform_settings
+		});
+		if (subtitles && waveform) {
+			if (subtitles_toggle) {
+				add_subtitles_to_waveform(waveform, subtitles);
+			} else {
+				hide_subtitles();
+			}
+		}
+
+		waveform?.on("init", () => {
+			waveform_ready = true;
+		});
+		waveform?.on("decode", (duration: any) => {
+			audio_duration = duration;
+			durationRef && (durationRef.textContent = format_time(duration));
+		});
+
+		let firstTimeUpdate = true;
+		waveform?.on("timeupdate", (currentTime: any) => {
+			timeRef && (timeRef.textContent = format_time(currentTime));
+			if (firstTimeUpdate) {
+				firstTimeUpdate = false;
+				return;
+			}
+			playback_position = currentTime;
+			old_playback_position = currentTime;
+		});
+
+		waveform?.on("interaction", () => {
+			const currentTime = waveform?.getCurrentTime() || 0;
+			timeRef && (timeRef.textContent = format_time(currentTime));
+			playback_position = currentTime;
+			old_playback_position = currentTime;
+		});
+
+		waveform?.on("ready", () => {
+			if (!waveform_settings.autoplay) {
+				waveform?.stop();
+			} else {
+				waveform?.play();
+			}
+		});
+
+		waveform?.on("finish", () => {
+			if (loop) {
+				waveform?.play();
+			} else {
+				playing = false;
+				onstop?.();
+			}
+		});
+		waveform?.on("pause", () => {
+			playing = false;
+			onpause?.();
+		});
+		waveform?.on("play", () => {
+			playing = true;
+			onplay?.();
+		});
+
+		waveform?.on("load", () => {
+			onload?.();
+		});
+
+		waveform?.on("error", handle_waveform_error);
+	};
+
+	$effect(() => {
+		if (url && waveform_ready) {
+			untrack(() => {
+				if (value?.url && waveform) {
+					waveform_load_failed = false;
+					waveform.load(value.url).catch(handle_waveform_error);
+				}
+			});
+		}
+	});
+
+	function handle_waveform_error(e: Error): void {
+		if (e?.name === "AbortError" || waveform_load_failed) return;
+		console.error("Waveform load error:", e);
+		waveform_load_failed = true;
+		if (audio_player && value?.url) {
+			audio_player.src = value.url;
+		}
+	}
+
+	const handle_trim_audio = async (
+		start: number,
+		end: number
+	): Promise<void> => {
+		mode = "";
+		const decodedData = waveform?.getDecodedData();
+		if (decodedData) {
+			const trimmedBlob = await process_audio(
+				decodedData,
+				start,
+				end,
+				waveform_settings.sampleRate
+			);
+			await dispatch_blob([trimmedBlob], "change");
+		}
+		onedit?.();
+	};
+
+	async function load_audio(data: string): Promise<void> {
+		stream_active = false;
+
+		if (waveform_options.show_recording_waveform) {
+			waveform?.load(data);
+		} else if (audio_player) {
+			audio_player.src = data;
+		}
+	}
+
+	$effect(() => {
+		if (subtitles && waveform) {
+			if (subtitles_toggle) {
+				add_subtitles_to_waveform(waveform, subtitles);
+			} else {
+				hide_subtitles();
+			}
+		}
+	});
+
+	function load_stream(value: FileData | null): void {
+		if (!value || !value.is_stream || !value.url || !audio_player) return;
+
+		if (Hls.isSupported() && !stream_active) {
+			// Set config to start playback after 1 second of data received
+			const hls = new Hls({
+				maxBufferLength: 1,
+				maxMaxBufferLength: 1,
+				lowLatencyMode: true
+			});
+			hls.loadSource(value.url);
+			hls.attachMedia(audio_player);
+			hls.on(Hls.Events.MANIFEST_PARSED, function () {
+				if (waveform_settings.autoplay) audio_player?.play();
+			});
+			hls.on(Hls.Events.ERROR, function (event, data) {
+				console.error("HLS error:", event, data);
+				if (data.fatal) {
+					switch (data.type) {
+						case Hls.ErrorTypes.NETWORK_ERROR:
+							console.error(
+								"Fatal network error encountered, trying to recover"
+							);
+							hls.startLoad();
+							break;
+						case Hls.ErrorTypes.MEDIA_ERROR:
+							console.error("Fatal media error encountered, trying to recover");
+							hls.recoverMediaError();
+							break;
+						default:
+							console.error("Fatal error, cannot recover");
+							hls.destroy();
+							break;
+					}
+				}
+			});
+			stream_active = true;
+		} else if (!stream_active) {
+			audio_player.src = value.url;
+			if (waveform_settings.autoplay) audio_player.play();
+			stream_active = true;
+		}
+	}
+
+	$effect(() => {
+		// Without a waveform there is nothing to become ready, so gating the load
+		// on `waveform_ready` left the native player with no source at all.
+		if (
+			audio_player &&
+			url &&
+			(waveform_ready || !waveform_options.show_recording_waveform)
+		) {
+			load_audio(url);
+		}
+	});
+
+	$effect(() => {
+		if (audio_player && value?.is_stream) {
+			load_stream(value);
+		}
+	});
+
+	$effect(() => {
+		if (container) {
+			untrack(() => create_waveform());
+		}
+	});
+
+	onMount(() => {
+		const handleKeydown = (e: KeyboardEvent): void => {
+			if (!waveform || show_volume_slider) return;
+
+			const is_focused_in_waveform =
+				waveform_component_wrapper &&
+				waveform_component_wrapper.contains(document.activeElement);
+			if (!is_focused_in_waveform) return;
+			if (e.key === "ArrowRight" && mode !== "edit") {
+				skip_audio(waveform, 0.1);
+			} else if (e.key === "ArrowLeft" && mode !== "edit") {
+				skip_audio(waveform, -0.1);
+			}
+		};
+		window.addEventListener("keydown", handleKeydown);
+
+		return () => {
+			waveform?.destroy();
+			window.removeEventListener("keydown", handleKeydown);
+		};
+	});
+
+	async function add_subtitles_to_waveform(
+		wavesurfer: WaveSurfer,
+		subtitle_data: string | SubtitleData[]
+	): Promise<void> {
+		clear_subtitles();
+		try {
+			let subtitles: SubtitleData[];
+			if (Array.isArray(subtitle_data)) {
+				subtitles = subtitle_data;
+			} else {
+				const response = await fetch(subtitle_data);
+				const subtitle_content = await response.text();
+				subtitles = parse_subtitles(subtitle_content);
+			}
+
+			if (subtitles.length > 0) {
+				let current_subtitle = "";
+				if (subtitle_container) {
+					subtitle_container.style.display = "";
+					const audioProcessHandler = (time: number): void => {
+						const subtitle = subtitles.find(
+							(s) => time >= s.start && time <= s.end
+						);
+						if (subtitle && subtitle.text !== current_subtitle) {
+							current_subtitle = subtitle.text;
+							subtitle_container.textContent = current_subtitle;
+						} else if (!subtitle && current_subtitle !== "") {
+							current_subtitle = "";
+							subtitle_container.textContent = "";
+						}
+					};
+					wavesurfer.on("audioprocess", audioProcessHandler);
+					subtitle_event_handlers.push(() => {
+						wavesurfer.un("audioprocess", audioProcessHandler);
+					});
+				}
+			}
+		} catch (error) {}
+	}
+
+	function hide_subtitles(): void {
+		if (subtitle_container) {
+			subtitle_container.style.display = "none";
+		}
+	}
+
+	function clear_subtitles(): void {
+		if (subtitle_container) {
+			subtitle_container.textContent = "";
+		}
+		subtitle_event_handlers.forEach((handler) => handler());
+		subtitle_event_handlers = [];
+	}
+
+	function parse_subtitles(subtitle_content: string): SubtitleData[] {
+		const lines = subtitle_content.split("\n");
+		const subtitles: SubtitleData[] = [];
+
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i].trim();
+			if (line.includes(" --> ")) {
+				const [start_time, end_time] = line.split(" --> ");
+				const start = parse_time_to_seconds(start_time);
+				const end = parse_time_to_seconds(end_time);
+
+				let text = "";
+				for (let j = i + 1; j < lines.length && lines[j].trim() !== ""; j++) {
+					if (text) text += " ";
+					text += lines[j].trim();
+				}
+
+				if (text) {
+					subtitles.push({ start, end, text });
+				}
+			}
+		}
+
+		return subtitles;
+	}
+
+	function parse_time_to_seconds(time_str: string): number {
+		const parts = time_str.split(":");
+		if (parts.length === 3) {
+			const hours = parseInt(parts[0]);
+			const minutes = parseInt(parts[1]);
+			const seconds = parseFloat(parts[2]);
+			return hours * 3600 + minutes * 60 + seconds;
+		}
+		return 0;
+	}
+</script>
+
+<audio
+	class="standard-player"
+	class:hidden={!native_player_active}
+	data-testid={label ? "audio-player-" + label : "unlabelled-audio-player"}
+	controls
+	autoplay={waveform_settings.autoplay}
+	{onload}
+	bind:this={audio_player}
+	onended={() => {
+		if (native_player_active) playing = false;
+		onstop?.();
+	}}
+	onplay={() => {
+		if (native_player_active) playing = true;
+		onplay?.();
+	}}
+	onpause={() => {
+		if (!native_player_active) return;
+		playing = false;
+		onpause?.();
+	}}
+	ontimeupdate={() => {
+		if (!native_player_active || !audio_player) return;
+		playback_position = audio_player.currentTime;
+		old_playback_position = audio_player.currentTime;
+	}}
+	onloadedmetadata={() => {
+		if (native_player_active && audio_player) {
+			audio_duration = audio_player.duration;
+		}
+	}}
+	preload="metadata"
+>
+</audio>
+{#if value === null}
+	<Empty size="small">
+		<Music />
+	</Empty>
+{:else if use_waveform}
+	<div
+		class="component-wrapper"
+		class:hidden={native_fallback_active}
+		data-testid={label ? "waveform-" + label : "unlabelled-audio"}
+		bind:this={waveform_component_wrapper}
+	>
+		<div class="waveform-container">
+			<div
+				id="waveform"
+				bind:this={container}
+				style:height={container ? null : "58px"}
+			/>
+		</div>
+
+		<div class="timestamps">
+			<time bind:this={timeRef} id="time">0:00</time>
+			<div>
+				{#if mode === "edit" && trimDuration > 0}
+					<time id="trim-duration">{format_time(trimDuration)}</time>
+				{/if}
+				<time bind:this={durationRef} id="duration">0:00</time>
+			</div>
+		</div>
+
+		<div
+			bind:this={subtitle_container}
+			class="subtitle-display"
+			data-testid="subtitle-display"
+		></div>
+
+		<WaveformControls
+			{container}
+			{waveform}
+			{playing}
+			{audio_duration}
+			{i18n}
+			{interactive}
+			{handle_trim_audio}
+			bind:mode
+			bind:trimDuration
+			bind:show_volume_slider
+			bind:subtitles_toggle
+			show_redo={interactive}
+			{handle_reset_value}
+			{waveform_options}
+			{trim_region_settings}
+			{editable}
+			show_subtitles={subtitles !== null}
+		/>
+	</div>
+{/if}
+
+<style>
+	.component-wrapper {
+		padding: var(--size-3);
+		width: 100%;
+	}
+
+	:global(::part(wrapper)) {
+		margin-bottom: var(--size-2);
+	}
+
+	.timestamps {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		width: 100%;
+		padding: var(--size-1) 0;
+	}
+
+	#time {
+		color: var(--neutral-400);
+	}
+
+	#duration {
+		color: var(--neutral-400);
+	}
+
+	#trim-duration {
+		color: var(--color-accent);
+		margin-right: var(--spacing-sm);
+	}
+	.waveform-container {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-full);
+	}
+
+	#waveform {
+		width: 100%;
+		height: 100%;
+		position: relative;
+	}
+
+	.standard-player {
+		width: 100%;
+		padding: var(--size-2);
+	}
+
+	.subtitle-display {
+		color: var(--text-secondary);
+		font-size: var(--text-lg);
+		text-align: center;
+		max-width: 600px;
+		line-height: 1.3;
+		min-height: var(--size-4);
+		font-family: var(--font-sans);
+		font-weight: normal;
+		margin: var(--size-2) auto;
+		padding: var(--size-1) var(--size-2);
+		border-radius: 2px;
+		transition: opacity 0.2s ease-in-out;
+	}
+
+	.hidden,
+	.subtitle-display:empty {
+		display: none;
+	}
+</style>

6.26.0/audio/recorder/AudioRecorder.svelte

@@ -0,0 +1,317 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import WaveSurfer from "wavesurfer.js";
+	import { skip_audio, process_audio } from "../shared/utils";
+	import WSRecord from "wavesurfer.js/dist/plugins/record.js";
+	import WaveformControls from "../shared/WaveformControls.svelte";
+	import WaveformRecordControls from "../shared/WaveformRecordControls.svelte";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { WaveformOptions } from "../shared/types";
+	import { format_time } from "@gradio/utils";
+
+	let {
+		mode = $bindable(),
+		i18n,
+		dispatch_blob,
+		waveform_settings,
+		waveform_options = { show_recording_waveform: true },
+		handle_reset_value,
+		editable = true,
+		recording = false,
+		onstartrecording,
+		onpauserecording,
+		onstoprecording,
+		onstop,
+		onplay,
+		onpause,
+		onedit
+	}: {
+		mode?: string;
+		i18n: I18nFormatter;
+		dispatch_blob: (
+			blobs: Uint8Array[] | Blob[],
+			event: "stream" | "change"
+		) => Promise<void> | undefined;
+		waveform_settings: Record<string, any>;
+		waveform_options?: WaveformOptions;
+		handle_reset_value: () => void;
+		editable?: boolean;
+		recording?: boolean;
+		onstartrecording?: () => void;
+		onpauserecording?: () => void;
+		onstoprecording?: () => void;
+		onstop?: () => void;
+		onplay?: () => void;
+		onpause?: () => void;
+		onedit?: () => void;
+	} = $props();
+
+	let micWaveform: WaveSurfer;
+	let recordingWaveform = $state<WaveSurfer | undefined>(undefined);
+	let playing = $state(false);
+
+	let recordingContainer: HTMLDivElement;
+	let microphoneContainer: HTMLDivElement;
+
+	let record = $state<WSRecord | undefined>(undefined);
+	let recordedAudio = $state<string | null>(null);
+
+	// timestamps
+	let timeRef: HTMLTimeElement;
+	let durationRef: HTMLTimeElement;
+	let audio_duration = $state(0);
+	let seconds = $state(0);
+	let interval: NodeJS.Timeout;
+	let timing = $state(false);
+	// trimming
+	let trimDuration = $state(0);
+	let record_mounted = $state(false);
+
+	const start_interval = (): void => {
+		clearInterval(interval);
+		interval = setInterval(() => {
+			seconds++;
+		}, 1000);
+	};
+
+	function record_start_callback(): void {
+		start_interval();
+		timing = true;
+		onstartrecording?.();
+		if (waveform_options.show_recording_waveform) {
+			let waveformCanvas = microphoneContainer;
+			if (waveformCanvas) waveformCanvas.style.display = "block";
+		}
+	}
+
+	async function record_end_callback(blob: Blob): Promise<void> {
+		seconds = 0;
+		timing = false;
+		clearInterval(interval);
+		try {
+			const array_buffer = await blob.arrayBuffer();
+			const context = new AudioContext({
+				sampleRate: waveform_settings.sampleRate
+			});
+			const audio_buffer = await context.decodeAudioData(array_buffer);
+
+			if (audio_buffer)
+				await process_audio(audio_buffer).then(async (audio: Uint8Array) => {
+					await dispatch_blob([audio], "change");
+					onstoprecording?.();
+				});
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	$effect(() => {
+		record?.on("record-resume", () => {
+			start_interval();
+		});
+	});
+
+	$effect(() => {
+		recordingWaveform?.on("decode", (duration: any) => {
+			audio_duration = duration;
+			durationRef && (durationRef.textContent = format_time(duration));
+		});
+	});
+
+	$effect(() => {
+		recordingWaveform?.on(
+			"timeupdate",
+			(currentTime: any) =>
+				timeRef && (timeRef.textContent = format_time(currentTime))
+		);
+	});
+
+	$effect(() => {
+		recordingWaveform?.on("pause", () => {
+			onpause?.();
+			playing = false;
+		});
+	});
+
+	$effect(() => {
+		recordingWaveform?.on("play", () => {
+			onplay?.();
+			playing = true;
+		});
+	});
+
+	$effect(() => {
+		recordingWaveform?.on("finish", () => {
+			onstop?.();
+			playing = false;
+		});
+	});
+
+	const create_mic_waveform = (): void => {
+		if (microphoneContainer) microphoneContainer.innerHTML = "";
+		if (micWaveform !== undefined) micWaveform.destroy();
+		if (!microphoneContainer) return;
+		micWaveform = WaveSurfer.create({
+			...waveform_settings,
+			normalize: false,
+			container: microphoneContainer
+		});
+
+		record = micWaveform.registerPlugin(RecordPlugin.create());
+		record?.on("record-end", record_end_callback);
+		record?.on("record-start", record_start_callback);
+		record?.on("record-pause", () => {
+			onpauserecording?.();
+			clearInterval(interval);
+		});
+
+		record?.on("record-end", (blob) => {
+			recordedAudio = URL.createObjectURL(blob);
+
+			const microphone = microphoneContainer;
+			const recording = recordingContainer;
+
+			if (microphone) microphone.style.display = "none";
+			if (recording && recordedAudio) {
+				recording.innerHTML = "";
+				create_recording_waveform();
+			}
+		});
+		record_mounted = true;
+	};
+
+	const create_recording_waveform = (): void => {
+		let recording = recordingContainer;
+		if (!recordedAudio || !recording) return;
+		recordingWaveform = WaveSurfer.create({
+			container: recording,
+			url: recordedAudio,
+			...waveform_settings
+		});
+	};
+
+	const handle_trim_audio = async (
+		start: number,
+		end: number
+	): Promise<void> => {
+		mode = "edit";
+		const decodedData = recordingWaveform?.getDecodedData();
+		if (decodedData)
+			await process_audio(decodedData, start, end).then(
+				async (trimmedAudio: Uint8Array) => {
+					await dispatch_blob([trimmedAudio], "change");
+					onstoprecording?.();
+					recordingWaveform?.destroy();
+					create_recording_waveform();
+				}
+			);
+		onedit?.();
+	};
+
+	onMount(() => {
+		create_mic_waveform();
+
+		window.addEventListener("keydown", (e) => {
+			const is_focused_in_waveform =
+				recordingContainer &&
+				recordingContainer.contains(document.activeElement);
+			if (!is_focused_in_waveform) return;
+			const waveform = recordingWaveform;
+			if (!waveform) return;
+			if (e.key === "ArrowRight") {
+				skip_audio(waveform, 0.1);
+			} else if (e.key === "ArrowLeft") {
+				skip_audio(waveform, -0.1);
+			}
+		});
+	});
+</script>
+
+<div class="component-wrapper">
+	<div
+		class="microphone"
+		bind:this={microphoneContainer}
+		data-testid="microphone-waveform"
+	/>
+	<div bind:this={recordingContainer} data-testid="recording-waveform" />
+
+	{#if (timing || recordedAudio) && waveform_options.show_recording_waveform}
+		<div class="timestamps">
+			<time bind:this={timeRef} class="time">0:00</time>
+			<div>
+				{#if mode === "edit" && trimDuration > 0}
+					<time class="trim-duration">{format_time(trimDuration)}</time>
+				{/if}
+				{#if timing}
+					<time class="duration">{format_time(seconds)}</time>
+				{:else}
+					<time bind:this={durationRef} class="duration">0:00</time>
+				{/if}
+			</div>
+		</div>
+	{/if}
+
+	{#if record_mounted && !recordedAudio}
+		<WaveformRecordControls
+			record={record!}
+			{i18n}
+			{timing}
+			{recording}
+			show_recording_waveform={waveform_options.show_recording_waveform}
+			record_time={format_time(seconds)}
+		/>
+	{/if}
+
+	{#if recordingWaveform && recordedAudio}
+		<WaveformControls
+			waveform={recordingWaveform}
+			container={recordingContainer}
+			{playing}
+			{audio_duration}
+			{i18n}
+			{editable}
+			interactive={true}
+			{handle_trim_audio}
+			bind:trimDuration
+			bind:mode
+			show_redo
+			{handle_reset_value}
+			{waveform_options}
+		/>
+	{/if}
+</div>
+
+<style>
+	.microphone {
+		width: 100%;
+		display: none;
+	}
+
+	.component-wrapper {
+		padding: var(--size-3);
+		width: 100%;
+	}
+
+	.timestamps {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		width: 100%;
+		padding: var(--size-1) 0;
+		margin: var(--spacing-md) 0;
+	}
+
+	.time {
+		color: var(--neutral-400);
+	}
+
+	.duration {
+		color: var(--neutral-400);
+	}
+
+	.trim-duration {
+		color: var(--color-accent);
+		margin-right: var(--spacing-sm);
+	}
+</style>

6.26.0/audio/shared/Audio.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+	import type { HTMLAudioAttributes } from "svelte/elements";
+
+	let {
+		src = undefined,
+		onplay,
+		onpause,
+		onended,
+		...restProps
+	}: HTMLAudioAttributes & {
+		onplay?: () => void;
+		onpause?: () => void;
+		onended?: () => void;
+	} = $props();
+</script>
+
+<audio {src} {...restProps} {onplay} {onpause} {onended} />

6.26.0/audio/shared/DeviceSelect.svelte

@@ -0,0 +1,73 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	let {
+		i18n,
+		micDevices = $bindable(),
+		onerror
+	}: {
+		i18n: I18nFormatter;
+		micDevices?: MediaDeviceInfo[];
+		onerror?: (error: string) => void;
+	} = $props();
+
+	onMount(() => {
+		if (typeof window !== "undefined" && navigator.mediaDevices) {
+			let tempDevices: MediaDeviceInfo[] = [];
+			RecordPlugin.getAvailableAudioDevices()
+				.then((devices: MediaDeviceInfo[]) => {
+					micDevices = devices;
+					devices.forEach((device) => {
+						if (device.deviceId) {
+							tempDevices.push(device);
+						}
+					});
+					micDevices = tempDevices;
+				})
+				.catch((err) => {
+					if (err instanceof DOMException && err.name == "NotAllowedError") {
+						onerror?.(i18n("audio.allow_recording_access"));
+					}
+				});
+		}
+	});
+</script>
+
+<select
+	class="mic-select"
+	aria-label="Select input device"
+	disabled={!micDevices || micDevices.length === 0}
+>
+	{#if !micDevices || micDevices.length === 0}
+		<option value="">{i18n("audio.no_microphone")}</option>
+	{:else}
+		{#each micDevices as micDevice}
+			<option value={micDevice.deviceId}>{micDevice.label}</option>
+		{/each}
+	{/if}
+</select>
+
+<style>
+	.mic-select {
+		height: var(--size-8);
+		background: var(--block-background-fill);
+		padding: 0px var(--spacing-xxl);
+		border-radius: var(--button-large-radius);
+		font-size: var(--text-md);
+		border: 1px solid var(--block-border-color);
+		gap: var(--size-1);
+	}
+
+	select {
+		text-overflow: ellipsis;
+		max-width: var(--size-40);
+	}
+
+	@media (max-width: 375px) {
+		select {
+			width: 100%;
+		}
+	}
+</style>

6.26.0/audio/shared/MinimalAudioPlayer.svelte

@@ -0,0 +1,190 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+	import type { FileData } from "@gradio/client";
+	import { format_time } from "@gradio/utils";
+
+	let {
+		value,
+		label,
+		loop = false
+	}: {
+		value: FileData;
+		label: string;
+		loop?: boolean;
+	} = $props();
+
+	let container: HTMLDivElement;
+	let waveform: WaveSurfer | undefined;
+	let playing = $state(false);
+	let duration = $state(0);
+	let currentTime = $state(0);
+	let waveform_ready = $state(false);
+
+	let resolved_src = $derived(value.url);
+
+	const create_waveform = async (): Promise<void> => {
+		if (!container || !resolved_src || waveform_ready) return;
+
+		if (waveform) {
+			waveform.destroy();
+		}
+
+		const accentColor =
+			getComputedStyle(document.documentElement).getPropertyValue(
+				"--color-accent"
+			) || "#ff7c00";
+
+		waveform = WaveSurfer.create({
+			container,
+			height: 32,
+			waveColor: "rgba(128, 128, 128, 0.5)",
+			progressColor: accentColor,
+			cursorColor: "transparent",
+			barWidth: 2,
+			barGap: 2,
+			barRadius: 2,
+			normalize: true,
+			interact: true,
+			dragToSeek: true,
+			hideScrollbar: true
+		});
+
+		waveform.on("play", () => (playing = true));
+		waveform.on("pause", () => (playing = false));
+		waveform.on("ready", () => {
+			duration = waveform?.getDuration() || 0;
+			waveform_ready = true;
+		});
+		waveform.on("audioprocess", () => {
+			currentTime = waveform?.getCurrentTime() || 0;
+		});
+		waveform.on("interaction", () => {
+			currentTime = waveform?.getCurrentTime() || 0;
+		});
+		waveform.on("finish", () => {
+			playing = false;
+			if (loop) {
+				waveform?.play();
+			}
+		});
+
+		await waveform.load(resolved_src);
+	};
+
+	onMount(async () => {
+		await create_waveform();
+	});
+
+	onDestroy(() => {
+		if (waveform) {
+			waveform.destroy();
+		}
+	});
+
+	const togglePlay = (): void => {
+		if (waveform) {
+			waveform.playPause();
+		}
+	};
+</script>
+
+<div
+	class="minimal-audio-player"
+	aria-label={label || "Audio"}
+	data-testid={label && typeof label === "string" && label.trim()
+		? "waveform-" + label
+		: "unlabelled-audio"}
+>
+	<button
+		class="play-btn"
+		onclick={togglePlay}
+		aria-label={playing ? "Pause" : "Play"}
+	>
+		{#if playing}
+			<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+				<rect x="6" y="5" width="4" height="14" rx="1" fill="currentColor" />
+				<rect x="14" y="5" width="4" height="14" rx="1" fill="currentColor" />
+			</svg>
+		{:else}
+			<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+				<path
+					d="M8 5.74537C8 5.06444 8.77346 4.64713 9.35139 5.02248L18.0227 10.2771C18.5518 10.6219 18.5518 11.3781 18.0227 11.7229L9.35139 16.9775C8.77346 17.3529 8 16.9356 8 16.2546V5.74537Z"
+					fill="currentColor"
+				/>
+			</svg>
+		{/if}
+	</button>
+
+	<div class="waveform-wrapper" bind:this={container}></div>
+
+	<div class="timestamp">{format_time(playing ? currentTime : duration)}</div>
+</div>
+
+<style>
+	.minimal-audio-player {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-sm);
+		border-radius: var(--radius-sm);
+		width: var(--size-52);
+		padding: var(--spacing-sm);
+	}
+
+	.play-btn {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+		border: none;
+		background: none;
+		color: var(--body-text-color);
+		opacity: 0.7;
+		cursor: pointer;
+		border-radius: 50%;
+		transition: all 0.2s ease;
+		flex-shrink: 0;
+	}
+
+	.play-btn:hover {
+		color: var(--color-accent);
+		opacity: 1;
+	}
+
+	.play-btn:active {
+		transform: scale(0.95);
+	}
+
+	.play-btn svg {
+		width: var(--size-5);
+		height: var(--size-5);
+		display: block;
+	}
+
+	.waveform-wrapper {
+		flex: 1 1 auto;
+		cursor: pointer;
+		width: auto;
+	}
+
+	.waveform-wrapper :global(::part(wrapper)) {
+		margin-bottom: 0;
+	}
+
+	.timestamp {
+		font-size: 13px;
+		font-weight: 500;
+		color: var(--body-text-color);
+		opacity: 0.7;
+		font-variant-numeric: tabular-nums;
+		flex-shrink: 0;
+		min-width: 40px;
+		text-align: center;
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.play-btn {
+			transition: none;
+		}
+	}
+</style>

6.26.0/audio/shared/MinimalAudioRecorder.svelte

@@ -0,0 +1,379 @@
+<script lang="ts">
+	import { onMount, onDestroy, tick } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import { format_time } from "@gradio/utils";
+	import { process_audio } from "./utils";
+	import { prepare_files, type FileData, type Client } from "@gradio/client";
+	import { Square } from "@gradio/icons";
+
+	let {
+		label,
+		waveform_settings = {},
+		recording = $bindable(),
+		upload,
+		root,
+		max_file_size = null,
+		upload_promise = $bindable(),
+		onchange,
+		onstoprecording,
+		onclear
+	}: {
+		label: string;
+		waveform_settings?: Record<string, any>;
+		recording?: boolean;
+		upload: Client["upload"];
+		root: string;
+		max_file_size?: number | null;
+		upload_promise?: Promise<any> | null;
+		onchange?: (value: FileData) => void;
+		onstoprecording?: () => void;
+		onclear?: () => void;
+	} = $props();
+
+	let container: HTMLDivElement;
+	let waveform: WaveSurfer | undefined;
+	let record: RecordPlugin | undefined = $state();
+	let seconds = $state(0);
+	let interval: NodeJS.Timeout;
+	let is_recording = $state(false);
+	let has_started = $state(false);
+	let mic_devices: MediaDeviceInfo[] = $state([]);
+	let selected_device_id: string = $state("");
+	let show_device_selection = $state(false);
+
+	const start_interval = (): void => {
+		clearInterval(interval);
+		interval = setInterval(() => {
+			seconds++;
+		}, 1000);
+	};
+
+	const create_waveform = async (): Promise<void> => {
+		if (!container) return;
+
+		if (waveform) {
+			waveform.destroy();
+		}
+
+		const accentColor =
+			getComputedStyle(document.documentElement).getPropertyValue(
+				"--color-accent"
+			) || "#ff7c00";
+
+		waveform = WaveSurfer.create({
+			container,
+			height: 32,
+			waveColor: "rgba(128, 128, 128, 0.5)",
+			progressColor: accentColor,
+			cursorColor: "transparent",
+			barWidth: 2,
+			barGap: 2,
+			barRadius: 2,
+			interact: false,
+			hideScrollbar: true,
+			...waveform_settings
+		});
+
+		record = waveform.registerPlugin(
+			RecordPlugin.create({
+				scrollingWaveform: true,
+				scrollingWaveformWindow: 7,
+				renderRecordedAudio: false
+			})
+		);
+
+		record.on("record-start", () => {
+			start_interval();
+			is_recording = true;
+			has_started = true;
+		});
+
+		record.on("record-end", async (blob: Blob) => {
+			clearInterval(interval);
+			is_recording = false;
+
+			upload_promise = (async () => {
+				try {
+					const array_buffer = await blob.arrayBuffer();
+					const context = new AudioContext({
+						sampleRate: waveform_settings.sampleRate || 44100
+					});
+					const audio_buffer = await context.decodeAudioData(array_buffer);
+
+					if (audio_buffer) {
+						const audio = await process_audio(audio_buffer);
+						const audio_blob = new File([new Uint8Array(audio)], "audio.wav", {
+							type: "audio/wav"
+						});
+
+						const prepared_files = await prepare_files([audio_blob], false);
+						const uploaded_files = await upload(
+							prepared_files,
+							root,
+							undefined,
+							max_file_size || undefined
+						);
+						const file_data = uploaded_files?.[0];
+
+						if (file_data) {
+							onchange?.(file_data);
+						}
+					}
+				} catch (e) {
+					console.error("Error processing audio:", e);
+				} finally {
+					onstoprecording?.();
+					upload_promise = null;
+				}
+			})();
+
+			await upload_promise;
+		});
+	};
+
+	onMount(async () => {
+		try {
+			const devices = await RecordPlugin.getAvailableAudioDevices();
+			mic_devices = devices.filter((device) => device.deviceId);
+			if (mic_devices.length > 0) {
+				selected_device_id = mic_devices[0].deviceId;
+			}
+
+			if (mic_devices.length > 1) {
+				show_device_selection = true;
+			} else {
+				await create_waveform();
+			}
+		} catch (err) {
+			await create_waveform();
+		}
+	});
+
+	onDestroy(() => {
+		clearInterval(interval);
+		if (record) {
+			record.stopMic();
+		}
+		if (waveform) {
+			waveform.destroy();
+		}
+	});
+
+	$effect(() => {
+		if (
+			recording &&
+			!is_recording &&
+			record &&
+			has_started === false &&
+			mic_devices.length <= 1
+		) {
+			record
+				.startMic({ deviceId: selected_device_id })
+				.then(() => {
+					record?.startRecording();
+				})
+				.catch((err) => {
+					console.error("Failed to access microphone:", err);
+					onclear?.();
+				});
+		} else if (!recording && is_recording && record) {
+			record.stopRecording();
+			seconds = 0;
+		}
+	});
+
+	async function startRecording(): Promise<void> {
+		show_device_selection = false;
+		has_started = true;
+
+		await tick();
+		await create_waveform();
+
+		if (!record) return;
+
+		try {
+			await record.startMic({ deviceId: selected_device_id });
+			record.startRecording();
+		} catch (err) {
+			console.error("Error starting recording:", err);
+			show_device_selection = mic_devices.length > 1;
+			has_started = false;
+			recording = false;
+		}
+	}
+</script>
+
+<div
+	class="minimal-audio-recorder"
+	aria-label={label || "Audio Recorder"}
+	data-testid="minimal-audio-recorder"
+>
+	{#if show_device_selection}
+		<div class="device-selection-wrapper">
+			{#if mic_devices.length > 1}
+				<select
+					bind:value={selected_device_id}
+					class="device-select-large"
+					aria-label="Select input device"
+				>
+					{#each mic_devices as device}
+						<option value={device.deviceId}>{device.label}</option>
+					{/each}
+				</select>
+			{/if}
+			<button
+				class="record-button"
+				onclick={startRecording}
+				aria-label="Start recording"
+			>
+			</button>
+		</div>
+	{:else}
+		<div class="waveform-wrapper" bind:this={container}></div>
+		<div class="timestamp">{format_time(seconds)}</div>
+		<button
+			class="stop-button"
+			onclick={() => {
+				if (is_recording) {
+					recording = false;
+				} else {
+					onclear?.();
+				}
+			}}
+			aria-label="Stop recording"
+		>
+			<Square />
+		</button>
+	{/if}
+</div>
+
+<style>
+	.minimal-audio-recorder {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-sm);
+		border-radius: var(--radius-sm);
+		width: 100%;
+		padding: var(--spacing-sm);
+	}
+
+	.device-selection-wrapper {
+		display: flex;
+		flex-direction: row;
+		align-items: center;
+		justify-content: center;
+		gap: var(--spacing-md);
+		width: 100%;
+	}
+
+	.waveform-wrapper {
+		flex: 1 1 auto;
+		min-width: 0;
+		width: 100%;
+	}
+
+	.waveform-wrapper :global(::part(wrapper)) {
+		margin-bottom: 0;
+	}
+
+	.timestamp {
+		font-size: 13px;
+		font-weight: 500;
+		color: var(--body-text-color);
+		opacity: 0.7;
+		font-variant-numeric: tabular-nums;
+		flex-shrink: 0;
+		min-width: 40px;
+		text-align: center;
+	}
+
+	.device-select-large {
+		max-width: var(--size-60);
+		font-size: var(--text-sm);
+		padding: var(--spacing-sm) var(--spacing-md);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-md);
+		background: var(--background-fill-secondary);
+		color: var(--body-text-color);
+		cursor: pointer;
+		height: var(--size-9);
+	}
+
+	.record-button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		height: var(--size-9);
+		width: var(--size-9);
+		padding: 0;
+		flex-shrink: 0;
+		background-color: var(--block-background-fill);
+		color: var(--body-text-color);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-md);
+		cursor: pointer;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		flex-shrink: 0;
+	}
+
+	.record-button:hover {
+		background-color: var(--block-background-fill);
+		border-color: var(--border-color-accent);
+	}
+
+	.record-button:active {
+		transform: scale(0.98);
+	}
+
+	.stop-button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-9);
+		height: var(--size-9);
+		padding: 0;
+		border: var(--size-px) solid var(--border-color-primary);
+		border-radius: var(--radius-md);
+		background: var(--button-secondary-background-fill);
+		color: var(--error-500);
+		cursor: pointer;
+		flex-shrink: 0;
+	}
+
+	.stop-button:hover {
+		background: var(--button-secondary-background-fill-hover);
+		color: var(--error-600);
+	}
+
+	.stop-button:active {
+		transform: scale(0.95);
+	}
+
+	.stop-button :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.record-btn {
+			transition: none;
+		}
+		.record-btn.recording {
+			animation: none;
+		}
+	}
+
+	@media (max-width: 768px) {
+		.device-select-large {
+			max-width: var(--size-40);
+		}
+	}
+</style>

6.26.0/audio/shared/VolumeControl.svelte

@@ -0,0 +1,86 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+
+	let {
+		currentVolume = $bindable(),
+		show_volume_slider = $bindable(),
+		waveform
+	}: {
+		currentVolume?: number;
+		show_volume_slider?: boolean;
+		waveform: WaveSurfer | undefined;
+	} = $props();
+
+	let volumeElement: HTMLInputElement;
+
+	onMount(() => {
+		adjustSlider();
+	});
+
+	const adjustSlider = (): void => {
+		let slider = volumeElement;
+		if (!slider) return;
+
+		slider.style.background = `linear-gradient(to right, var(--color-accent) ${
+			(currentVolume ?? 1) * 100
+		}%, var(--neutral-400) ${(currentVolume ?? 1) * 100}%)`;
+	};
+
+	$effect(() => {
+		currentVolume;
+		adjustSlider();
+	});
+</script>
+
+<input
+	bind:this={volumeElement}
+	id="volume"
+	class="volume-slider"
+	type="range"
+	min="0"
+	max="1"
+	step="0.01"
+	value={currentVolume ?? 1}
+	onfocusout={() => (show_volume_slider = false)}
+	oninput={(e) => {
+		if (e.target instanceof HTMLInputElement) {
+			currentVolume = parseFloat(e.target.value);
+			waveform?.setVolume(currentVolume);
+		}
+	}}
+/>
+
+<style>
+	.volume-slider {
+		-webkit-appearance: none;
+		appearance: none;
+		width: var(--size-20);
+		accent-color: var(--color-accent);
+		height: 4px;
+		cursor: pointer;
+		outline: none;
+		border-radius: 15px;
+		background-color: var(--neutral-400);
+	}
+
+	input[type="range"]::-webkit-slider-thumb {
+		-webkit-appearance: none;
+		appearance: none;
+		height: 15px;
+		width: 15px;
+		background-color: var(--color-accent);
+		border-radius: 50%;
+		border: none;
+		transition: 0.2s ease-in-out;
+	}
+
+	input[type="range"]::-moz-range-thumb {
+		height: 15px;
+		width: 15px;
+		background-color: var(--color-accent);
+		border-radius: 50%;
+		border: none;
+		transition: 0.2s ease-in-out;
+	}
+</style>

6.26.0/audio/shared/VolumeLevels.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+	import { VolumeMuted, VolumeHigh, VolumeLow } from "@gradio/icons";
+
+	let { currentVolume }: { currentVolume: number } = $props();
+</script>
+
+{#if currentVolume == 0}
+	<VolumeMuted />
+{:else if currentVolume < 0.5}
+	<VolumeLow />
+{:else if currentVolume >= 0.5}
+	<VolumeHigh />
+{/if}

6.26.0/audio/shared/WaveformControls.svelte

@@ -0,0 +1,496 @@
+<script lang="ts">
+	import {
+		Play,
+		Pause,
+		Forward,
+		Backward,
+		ClosedCaption,
+		Undo,
+		Trim
+	} from "@gradio/icons";
+	import { get_skip_rewind_amount } from "../shared/utils";
+	import type { I18nFormatter } from "@gradio/utils";
+	import WaveSurfer from "wavesurfer.js";
+	import RegionsPlugin, {
+		type Region
+	} from "wavesurfer.js/dist/plugins/regions.js";
+	import type { WaveformOptions } from "./types";
+	import VolumeLevels from "./VolumeLevels.svelte";
+	import VolumeControl from "./VolumeControl.svelte";
+	import { onMount } from "svelte";
+
+	let {
+		waveform,
+		audio_duration,
+		i18n,
+		playing,
+		show_redo = false,
+		interactive = false,
+		handle_trim_audio,
+		mode = $bindable(),
+		container,
+		handle_reset_value,
+		waveform_options = {},
+		trim_region_settings = {},
+		show_volume_slider = $bindable(),
+		editable = true,
+		subtitles_toggle = $bindable(),
+		show_subtitles = false,
+		trimDuration = $bindable()
+	}: {
+		waveform: WaveSurfer | undefined;
+		audio_duration: number;
+		i18n: I18nFormatter;
+		playing: boolean;
+		show_redo?: boolean;
+		interactive?: boolean;
+		handle_trim_audio: (start: number, end: number) => void;
+		mode?: string;
+		container: HTMLDivElement;
+		handle_reset_value: () => void;
+		waveform_options?: WaveformOptions;
+		trim_region_settings?: WaveformOptions;
+		show_volume_slider?: boolean;
+		editable?: boolean;
+		subtitles_toggle?: boolean;
+		show_subtitles?: boolean;
+		trimDuration?: number;
+	} = $props();
+
+	let playbackSpeeds = [0.5, 1, 1.5, 2];
+	let playbackSpeed = $state(playbackSpeeds[1]);
+
+	let trimRegion: RegionsPlugin | null = $state(null);
+	let activeRegion: Region | null = $state(null);
+
+	let leftRegionHandle: HTMLDivElement | null = $state(null);
+	let rightRegionHandle: HTMLDivElement | null = $state(null);
+	let activeHandle = $state("");
+
+	let currentVolume = $state(1);
+
+	function ensureTrimRegion(): void {
+		if (container && waveform && !trimRegion) {
+			trimRegion = waveform.registerPlugin(RegionsPlugin.create());
+		}
+	}
+
+	onMount(() => {
+		ensureTrimRegion();
+	});
+
+	$effect(() => {
+		if (!trimRegion) return;
+		const handler = (region: Region): void => {
+			region.play();
+		};
+		trimRegion.on("region-out", handler);
+		return () => {
+			trimRegion?.un("region-out", handler);
+		};
+	});
+
+	$effect(() => {
+		if (!trimRegion) return;
+		const handler = (region: Region): void => {
+			trimDuration = region.end - region.start;
+		};
+		trimRegion.on("region-updated", handler);
+		return () => {
+			trimRegion?.un("region-updated", handler);
+		};
+	});
+
+	$effect(() => {
+		if (!trimRegion) return;
+		const handler = (region: Region, e: Event): void => {
+			e.stopPropagation();
+			activeRegion = region;
+			region.play();
+		};
+		trimRegion.on("region-clicked", handler);
+		return () => {
+			trimRegion?.un("region-clicked", handler);
+		};
+	});
+
+	const addTrimRegion = (): void => {
+		if (!trimRegion) return;
+		activeRegion = trimRegion?.addRegion({
+			start: audio_duration / 4,
+			end: audio_duration / 2,
+			...trim_region_settings
+		});
+
+		trimDuration = activeRegion.end - activeRegion.start;
+	};
+
+	$effect(() => {
+		if (activeRegion) {
+			const shadowRoot = container.children[0]!.shadowRoot!;
+
+			rightRegionHandle = shadowRoot.querySelector('[data-resize="right"]');
+			leftRegionHandle = shadowRoot.querySelector('[data-resize="left"]');
+
+			if (leftRegionHandle && rightRegionHandle) {
+				leftRegionHandle.setAttribute("role", "button");
+				rightRegionHandle.setAttribute("role", "button");
+				leftRegionHandle?.setAttribute(
+					"aria-label",
+					"Drag to adjust start time"
+				);
+				rightRegionHandle?.setAttribute(
+					"aria-label",
+					"Drag to adjust end time"
+				);
+				leftRegionHandle?.setAttribute("tabindex", "0");
+				rightRegionHandle?.setAttribute("tabindex", "0");
+
+				leftRegionHandle.addEventListener("focus", () => {
+					if (trimRegion) activeHandle = "left";
+				});
+
+				rightRegionHandle.addEventListener("focus", () => {
+					if (trimRegion) activeHandle = "right";
+				});
+			}
+		}
+	});
+
+	const trimAudio = (): void => {
+		if (waveform && trimRegion) {
+			if (activeRegion) {
+				const start = activeRegion.start;
+				const end = activeRegion.end;
+				handle_trim_audio(start, end);
+				mode = "";
+				activeRegion = null;
+			}
+		}
+	};
+
+	const clearRegions = (): void => {
+		trimRegion?.getRegions().forEach((region) => {
+			region.remove();
+		});
+		trimRegion?.clearRegions();
+	};
+
+	const toggleTrimmingMode = (): void => {
+		clearRegions();
+		if (mode) {
+			mode = "";
+		} else {
+			mode = "edit";
+			ensureTrimRegion();
+			addTrimRegion();
+		}
+	};
+
+	const toggleSubtitles = (): void => {
+		subtitles_toggle = !subtitles_toggle;
+	};
+
+	const adjustRegionHandles = (handle: string, key: string): void => {
+		let newStart;
+		let newEnd;
+
+		if (!activeRegion) return;
+		if (handle === "left") {
+			if (key === "ArrowLeft") {
+				newStart = activeRegion.start - 0.05;
+				newEnd = activeRegion.end;
+			} else {
+				newStart = activeRegion.start + 0.05;
+				newEnd = activeRegion.end;
+			}
+		} else {
+			if (key === "ArrowLeft") {
+				newStart = activeRegion.start;
+				newEnd = activeRegion.end - 0.05;
+			} else {
+				newStart = activeRegion.start;
+				newEnd = activeRegion.end + 0.05;
+			}
+		}
+
+		activeRegion.setOptions({
+			start: newStart,
+			end: newEnd
+		});
+
+		trimDuration = activeRegion.end - activeRegion.start;
+	};
+
+	$effect(() => {
+		if (trimRegion) {
+			const handleKeydown = (e: KeyboardEvent): void => {
+				if (e.key === "ArrowLeft") {
+					adjustRegionHandles(activeHandle, "ArrowLeft");
+				} else if (e.key === "ArrowRight") {
+					adjustRegionHandles(activeHandle, "ArrowRight");
+				}
+			};
+			window.addEventListener("keydown", handleKeydown);
+			return () => {
+				window.removeEventListener("keydown", handleKeydown);
+			};
+		}
+	});
+</script>
+
+<div class="controls" data-testid="waveform-controls">
+	<div class="control-wrapper">
+		<button
+			class="action icon volume"
+			style:color={show_volume_slider
+				? "var(--color-accent)"
+				: "var(--neutral-400)"}
+			aria-label="Adjust volume"
+			onclick={() => (show_volume_slider = !show_volume_slider)}
+		>
+			<VolumeLevels {currentVolume} />
+		</button>
+
+		{#if show_volume_slider}
+			<VolumeControl bind:currentVolume bind:show_volume_slider {waveform} />
+		{/if}
+
+		<button
+			class:hidden={show_volume_slider}
+			class="playback icon"
+			aria-label={`Adjust playback speed to ${
+				playbackSpeeds[
+					(playbackSpeeds.indexOf(playbackSpeed) + 1) % playbackSpeeds.length
+				]
+			}x`}
+			onclick={() => {
+				playbackSpeed =
+					playbackSpeeds[
+						(playbackSpeeds.indexOf(playbackSpeed) + 1) % playbackSpeeds.length
+					];
+
+				waveform?.setPlaybackRate(playbackSpeed);
+			}}
+		>
+			<span>{playbackSpeed}x</span>
+		</button>
+	</div>
+
+	<div class="play-pause-wrapper">
+		<button
+			class="rewind icon"
+			aria-label={`Skip backwards by ${get_skip_rewind_amount(
+				audio_duration,
+				waveform_options.skip_length
+			)} seconds`}
+			onclick={() =>
+				waveform?.skip(
+					get_skip_rewind_amount(audio_duration, waveform_options.skip_length) *
+						-1
+				)}
+		>
+			<Backward />
+		</button>
+		<button
+			class="play-pause-button icon"
+			onclick={() => waveform?.playPause()}
+			aria-label={playing ? i18n("audio.pause") : i18n("audio.play")}
+		>
+			{#if playing}
+				<Pause />
+			{:else}
+				<Play />
+			{/if}
+		</button>
+		<button
+			class="skip icon"
+			aria-label="Skip forward by {get_skip_rewind_amount(
+				audio_duration,
+				waveform_options.skip_length
+			)} seconds"
+			onclick={() =>
+				waveform?.skip(
+					get_skip_rewind_amount(audio_duration, waveform_options.skip_length)
+				)}
+		>
+			<Forward />
+		</button>
+	</div>
+
+	<div class="settings-wrapper">
+		{#if show_subtitles}
+			<button
+				class="action icon cc-button"
+				data-testid="subtitles-toggle"
+				style="color: {subtitles_toggle
+					? 'var(--color-accent)'
+					: 'var(--neutral-400)'}"
+				onclick={toggleSubtitles}
+			>
+				<ClosedCaption /></button
+			>
+		{/if}
+		{#if editable && interactive}
+			{#if show_redo && !mode}
+				<button
+					class="action icon"
+					aria-label="Reset audio"
+					onclick={() => {
+						handle_reset_value();
+						clearRegions();
+						mode = "";
+					}}
+				>
+					<Undo />
+				</button>
+			{/if}
+
+			{#if !mode}
+				<button
+					class="action icon"
+					aria-label="Trim audio to selection"
+					onclick={toggleTrimmingMode}
+				>
+					<Trim />
+				</button>
+			{:else}
+				<button class="text-button" onclick={trimAudio}>Trim</button>
+				<button class="text-button" onclick={toggleTrimmingMode}>Cancel</button>
+			{/if}
+		{/if}
+	</div>
+</div>
+
+<style>
+	.settings-wrapper {
+		display: flex;
+		justify-self: self-end;
+		align-items: center;
+		grid-area: editing;
+	}
+	.text-button {
+		border: 1px solid var(--neutral-400);
+		border-radius: var(--radius-sm);
+		font-weight: 300;
+		font-size: var(--size-3);
+		text-align: center;
+		color: var(--neutral-400);
+		height: var(--size-5);
+		font-weight: bold;
+		padding: 0 5px;
+		margin-left: 5px;
+	}
+
+	.text-button:hover,
+	.text-button:focus {
+		color: var(--color-accent);
+		border-color: var(--color-accent);
+	}
+
+	.controls {
+		display: grid;
+		grid-template-columns: 1fr 1fr 1fr;
+		grid-template-areas: "controls playback editing";
+		margin-top: 5px;
+		align-items: center;
+		position: relative;
+		flex-wrap: wrap;
+		justify-content: space-between;
+	}
+	.controls div {
+		margin: var(--size-1) 0;
+	}
+
+	@media (max-width: 600px) {
+		.controls {
+			grid-template-columns: 1fr 1fr;
+			grid-template-rows: auto auto;
+			grid-template-areas:
+				"playback playback"
+				"controls editing";
+		}
+	}
+
+	@media (max-width: 319px) {
+		.controls {
+			overflow-x: scroll;
+		}
+	}
+
+	.hidden {
+		display: none;
+	}
+
+	.control-wrapper {
+		display: flex;
+		justify-self: self-start;
+		align-items: center;
+		justify-content: space-between;
+		grid-area: controls;
+	}
+
+	.action {
+		width: var(--size-5);
+		color: var(--neutral-400);
+		margin-left: var(--spacing-md);
+	}
+	.icon:hover,
+	.icon:focus {
+		color: var(--color-accent);
+	}
+	.play-pause-wrapper {
+		display: flex;
+		justify-self: center;
+		grid-area: playback;
+	}
+	.cc-button {
+		width: var(--size-8);
+	}
+
+	@media (max-width: 600px) {
+		.play-pause-wrapper {
+			margin: var(--spacing-md);
+		}
+	}
+	.playback {
+		border: 1px solid var(--neutral-400);
+		border-radius: var(--radius-sm);
+		width: 5.5ch;
+		font-weight: 300;
+		font-size: var(--size-3);
+		text-align: center;
+		color: var(--neutral-400);
+		height: var(--size-5);
+		font-weight: bold;
+	}
+
+	.playback:hover,
+	.playback:focus {
+		color: var(--color-accent);
+		border-color: var(--color-accent);
+	}
+
+	.rewind,
+	.skip {
+		margin: 0 10px;
+		color: var(--neutral-400);
+	}
+
+	.play-pause-button {
+		width: var(--size-8);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		color: var(--neutral-400);
+		fill: var(--neutral-400);
+	}
+
+	.volume {
+		position: relative;
+		display: flex;
+		justify-content: center;
+		margin-right: var(--spacing-xl);
+		width: var(--size-5);
+	}
+</style>

6.26.0/audio/shared/WaveformRecordControls.svelte

@@ -0,0 +1,311 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+	import { Pause } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import DeviceSelect from "./DeviceSelect.svelte";
+
+	let {
+		record,
+		i18n,
+		recording = false,
+		record_time,
+		show_recording_waveform,
+		timing = false
+	}: {
+		record: RecordPlugin;
+		i18n: I18nFormatter;
+		recording?: boolean;
+		record_time: string;
+		show_recording_waveform: boolean | undefined;
+		timing?: boolean;
+	} = $props();
+
+	let micDevices: MediaDeviceInfo[] = $state([]);
+	let recordButton: HTMLButtonElement;
+	let pauseButton: HTMLButtonElement;
+	let resumeButton: HTMLButtonElement;
+	let stopButton: HTMLButtonElement;
+	let stopButtonPaused: HTMLButtonElement;
+	let recording_ongoing = $state(false);
+
+	const handleRecordStart = (): void => {
+		recordButton.style.display = "none";
+		stopButton.style.display = "flex";
+		pauseButton.style.display = "block";
+	};
+
+	const handleRecordEnd = (): void => {
+		if (record.isPaused()) {
+			record.resumeRecording();
+			record.stopRecording();
+		}
+		record.stopMic();
+
+		recordButton.style.display = "flex";
+		stopButton.style.display = "none";
+		pauseButton.style.display = "none";
+		recordButton.disabled = false;
+	};
+
+	const handleRecordPause = (): void => {
+		pauseButton.style.display = "none";
+		resumeButton.style.display = "block";
+		stopButton.style.display = "none";
+		stopButtonPaused.style.display = "flex";
+	};
+
+	const handleRecordResume = (): void => {
+		pauseButton.style.display = "block";
+		resumeButton.style.display = "none";
+		recordButton.style.display = "none";
+		stopButton.style.display = "flex";
+		stopButtonPaused.style.display = "none";
+	};
+
+	onMount(() => {
+		record.on("record-start", handleRecordStart);
+		record.on("record-end", handleRecordEnd);
+		record.on("record-pause", handleRecordPause);
+		record.on("record-resume", handleRecordResume);
+	});
+
+	onDestroy(() => {
+		record.un("record-start", handleRecordStart);
+		record.un("record-end", handleRecordEnd);
+		record.un("record-pause", handleRecordPause);
+		record.un("record-resume", handleRecordResume);
+	});
+
+	$effect(() => {
+		if (recording && !recording_ongoing) {
+			record.startMic().then(() => {
+				record.startRecording();
+				recording_ongoing = true;
+			});
+		} else if (!recording && recording_ongoing) {
+			if (record.isPaused()) {
+				record.resumeRecording();
+			}
+			record.stopRecording();
+			recording_ongoing = false;
+		}
+	});
+</script>
+
+<div class="controls">
+	<div class="wrapper">
+		<button
+			bind:this={recordButton}
+			class="record record-button"
+			onclick={() => record.startRecording()}>{i18n("audio.record")}</button
+		>
+
+		<button
+			bind:this={stopButton}
+			class="stop-button {record.isPaused() ? 'stop-button-paused' : ''}"
+			onclick={() => {
+				if (record.isPaused()) {
+					record.resumeRecording();
+					record.stopRecording();
+				}
+
+				record.stopRecording();
+			}}>{i18n("audio.stop")}</button
+		>
+
+		<button
+			bind:this={stopButtonPaused}
+			id="stop-paused"
+			class="stop-button-paused"
+			onclick={() => {
+				if (record.isPaused()) {
+					record.resumeRecording();
+					record.stopRecording();
+				}
+
+				record.stopRecording();
+			}}>{i18n("audio.stop")}</button
+		>
+
+		<button
+			aria-label="pause"
+			bind:this={pauseButton}
+			class="pause-button"
+			onclick={() => record.pauseRecording()}><Pause /></button
+		>
+		<button
+			bind:this={resumeButton}
+			class="resume-button"
+			onclick={() => record.resumeRecording()}>{i18n("audio.resume")}</button
+		>
+		{#if timing && !show_recording_waveform}
+			<time class="duration-button duration">{record_time}</time>
+		{/if}
+	</div>
+	<DeviceSelect bind:micDevices {i18n} />
+</div>
+
+<style>
+	.controls {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		flex-wrap: wrap;
+	}
+
+	.wrapper {
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+	}
+
+	.record {
+		margin-right: var(--spacing-md);
+	}
+
+	.stop-button-paused {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.stop-button-paused::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+	.stop-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		animation: scaling 1800ms infinite;
+	}
+
+	.stop-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.record-button {
+		height: var(--size-8);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		display: flex;
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		padding-right: var(--spacing-xl);
+	}
+
+	.duration-button {
+		border-radius: var(--button-large-radius);
+	}
+
+	.stop-button:disabled {
+		cursor: not-allowed;
+	}
+
+	.record-button:disabled {
+		cursor: not-allowed;
+		opacity: 0.5;
+	}
+
+	@keyframes scaling {
+		0% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+		50% {
+			background-color: var(--primary-600);
+			scale: 1.2;
+		}
+		100% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+	}
+
+	.pause-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--button-large-radius);
+		padding: var(--spacing-md);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.resume-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--button-large-radius);
+		padding: var(--spacing-xl);
+		line-height: 1px;
+		font-size: var(--text-md);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.duration {
+		display: flex;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		padding: var(--spacing-md);
+		align-items: center;
+		justify-content: center;
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	:global(::part(region)) {
+		border-radius: var(--radius-md);
+		height: 98% !important;
+		border: 1px solid var(--trim-region-color);
+		background-color: unset;
+		border-width: 1px 3px;
+	}
+
+	:global(::part(region))::after {
+		content: "";
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		background: var(--trim-region-color);
+		opacity: 0.2;
+		border-radius: var(--radius-md);
+	}
+
+	:global(::part(region-handle)) {
+		width: 5px !important;
+		border: none;
+	}
+</style>

6.26.0/audio/shared/audioBufferToWav.ts

@@ -0,0 +1,59 @@
+export function audioBufferToWav(audioBuffer: AudioBuffer): Uint8Array {
+	const numOfChan = audioBuffer.numberOfChannels;
+	const length = audioBuffer.length * numOfChan * 2 + 44;
+	const buffer = new ArrayBuffer(length);
+	const view = new DataView(buffer);
+	let offset = 0;
+
+	// Write WAV header
+	const writeString = function (
+		view: DataView,
+		offset: number,
+		string: string
+	): void {
+		for (let i = 0; i < string.length; i++) {
+			view.setUint8(offset + i, string.charCodeAt(i));
+		}
+	};
+
+	writeString(view, offset, "RIFF");
+	offset += 4;
+	view.setUint32(offset, length - 8, true);
+	offset += 4;
+	writeString(view, offset, "WAVE");
+	offset += 4;
+	writeString(view, offset, "fmt ");
+	offset += 4;
+	view.setUint32(offset, 16, true);
+	offset += 4; // Sub-chunk size, 16 for PCM
+	view.setUint16(offset, 1, true);
+	offset += 2; // PCM format
+	view.setUint16(offset, numOfChan, true);
+	offset += 2;
+	view.setUint32(offset, audioBuffer.sampleRate, true);
+	offset += 4;
+	view.setUint32(offset, audioBuffer.sampleRate * 2 * numOfChan, true);
+	offset += 4;
+	view.setUint16(offset, numOfChan * 2, true);
+	offset += 2;
+	view.setUint16(offset, 16, true);
+	offset += 2;
+	writeString(view, offset, "data");
+	offset += 4;
+	view.setUint32(offset, audioBuffer.length * numOfChan * 2, true);
+	offset += 4;
+
+	// Write PCM audio data
+	for (let i = 0; i < audioBuffer.length; i++) {
+		for (let channel = 0; channel < numOfChan; channel++) {
+			const sample = Math.max(
+				-1,
+				Math.min(1, audioBuffer.getChannelData(channel)[i])
+			);
+			view.setInt16(offset, sample * 0x7fff, true);
+			offset += 2;
+		}
+	}
+
+	return new Uint8Array(buffer);
+}

6.26.0/audio/shared/index.ts

@@ -0,0 +1,3 @@
+export { default as Audio } from "./Audio.svelte";
+export { default as MinimalAudioPlayer } from "./MinimalAudioPlayer.svelte";
+export { default as MinimalAudioRecorder } from "./MinimalAudioRecorder.svelte";

6.26.0/audio/shared/types.ts

@@ -0,0 +1,62 @@
+import { FileData } from "@gradio/client";
+import type { CustomButton } from "@gradio/utils";
+
+export type WaveformOptions = {
+	waveform_color?: string;
+	waveform_progress_color?: string;
+	show_controls?: boolean;
+	skip_length?: number;
+	trim_region_color?: string;
+	show_recording_waveform?: boolean;
+	sample_rate?: number;
+};
+
+export interface SubtitleData {
+	start: number;
+	end: number;
+	text: string;
+}
+
+export interface AudioProps {
+	sources:
+		| ["microphone"]
+		| ["upload"]
+		| ["microphone", "upload"]
+		| ["upload", "microphone"];
+	value: FileData | null;
+	type: "numpy" | "filepath";
+	autoplay: boolean;
+	buttons: ("play" | "download" | "share" | CustomButton)[];
+	recording: boolean;
+	loop: boolean;
+	subtitles: FileData | SubtitleData[] | null;
+	waveform_options: WaveformOptions;
+	editable: boolean;
+	pending: boolean;
+	streaming: boolean;
+	stream_every: number;
+	input_ready: boolean;
+	minimal?: boolean;
+	playback_position: number;
+}
+
+export interface AudioEvents {
+	change: any;
+	upload: any;
+	stream: any;
+	clear: any;
+	play: any;
+	pause: any;
+	stop: any;
+	start_recording: any;
+	pause_recording: any;
+	stop_recording: any;
+	input: any;
+	error: any;
+	warning: any;
+	clear_status: any;
+	close_stream: any;
+	edit: any;
+	share: any;
+	custom_button_click: { id: number };
+}

6.26.0/audio/shared/utils.ts

@@ -0,0 +1,78 @@
+import type WaveSurfer from "wavesurfer.js";
+import { audioBufferToWav } from "./audioBufferToWav";
+
+export interface LoadedParams {
+	autoplay?: boolean;
+}
+
+export function blob_to_data_url(blob: Blob): Promise<string> {
+	return new Promise((fulfill, reject) => {
+		let reader = new FileReader();
+		reader.onerror = reject;
+		reader.onload = () => fulfill(reader.result as string);
+		reader.readAsDataURL(blob);
+	});
+}
+
+export const process_audio = async (
+	audioBuffer: AudioBuffer,
+	start?: number,
+	end?: number,
+	waveform_sample_rate?: number
+): Promise<Uint8Array> => {
+	const audioContext = new AudioContext({
+		sampleRate: waveform_sample_rate || audioBuffer.sampleRate
+	});
+	const numberOfChannels = audioBuffer.numberOfChannels;
+	const sampleRate = waveform_sample_rate || audioBuffer.sampleRate;
+
+	let trimmedLength = audioBuffer.length;
+	let startOffset = 0;
+	if (start != null && end != null) {
+		startOffset = Math.round(start * sampleRate);
+		const endOffset = Math.round(end * sampleRate);
+		trimmedLength = endOffset - startOffset;
+	}
+
+	const trimmedAudioBuffer = audioContext.createBuffer(
+		numberOfChannels,
+		trimmedLength,
+		sampleRate
+	);
+
+	for (let channel = 0; channel < numberOfChannels; channel++) {
+		const channelData = audioBuffer.getChannelData(channel);
+		const trimmedData = trimmedAudioBuffer.getChannelData(channel);
+		for (let i = 0; i < trimmedLength; i++) {
+			trimmedData[i] = channelData[startOffset + i];
+		}
+	}
+
+	return audioBufferToWav(trimmedAudioBuffer);
+};
+
+export function loaded(
+	node: HTMLAudioElement,
+	{ autoplay }: LoadedParams = {}
+): void {
+	async function handle_playback(): Promise<void> {
+		if (!autoplay) return;
+		node.pause();
+		await node.play();
+	}
+}
+
+export const skip_audio = (waveform: WaveSurfer, amount: number): void => {
+	if (!waveform) return;
+	waveform.skip(amount);
+};
+
+export const get_skip_rewind_amount = (
+	audio_duration: number,
+	skip_length?: number | null
+): number => {
+	if (!skip_length) {
+		skip_length = 5;
+	}
+	return (audio_duration / 100) * skip_length || 5;
+};

6.26.0/audio/static/StaticAudio.svelte

@@ -0,0 +1,131 @@
+<script lang="ts">
+	import { uploadToHuggingFace } from "@gradio/utils";
+	import { Empty } from "@gradio/atoms";
+	import {
+		ShareButton,
+		IconButton,
+		BlockLabel,
+		DownloadLink,
+		IconButtonWrapper
+	} from "@gradio/atoms";
+	import type { CustomButton as CustomButtonType } from "@gradio/utils";
+	import { Download, Music } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import AudioPlayer from "../player/AudioPlayer.svelte";
+	import MinimalAudioPlayer from "../shared/MinimalAudioPlayer.svelte";
+	import type { FileData } from "@gradio/client";
+	import type { WaveformOptions, SubtitleData } from "../shared/types";
+
+	let {
+		value = null,
+		subtitles = null,
+		label,
+		show_label = true,
+		buttons = [],
+		on_custom_button_click = null,
+		i18n,
+		waveform_settings = {},
+		waveform_options = { show_recording_waveform: true },
+		editable = true,
+		loop,
+		display_icon_button_wrapper_top_corner = false,
+		minimal = false,
+		playback_position = $bindable(),
+		onchange,
+		onplay,
+		onpause,
+		onstop,
+		onshare,
+		onerror
+	}: {
+		value?: null | FileData;
+		subtitles?: null | FileData | SubtitleData[];
+		label: string;
+		show_label?: boolean;
+		buttons?: (string | CustomButtonType)[];
+		on_custom_button_click?: ((id: number) => void) | null;
+		i18n: I18nFormatter;
+		waveform_settings?: Record<string, any>;
+		waveform_options?: WaveformOptions;
+		editable?: boolean;
+		loop?: boolean;
+		display_icon_button_wrapper_top_corner?: boolean;
+		minimal?: boolean;
+		playback_position?: number;
+		onchange?: (value: FileData) => void;
+		onplay?: () => void;
+		onpause?: () => void;
+		onstop?: () => void;
+		onshare?: (detail: any) => void;
+		onerror?: (detail: any) => void;
+	} = $props();
+
+	$effect(() => {
+		if (value) {
+			onchange?.(value);
+		}
+	});
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={Music}
+	float={false}
+	label={label || i18n("audio.audio")}
+/>
+
+{#if value !== null}
+	{#if minimal}
+		<MinimalAudioPlayer {value} label={label || i18n("audio.audio")} {loop} />
+	{:else}
+		<IconButtonWrapper
+			display_top_corner={display_icon_button_wrapper_top_corner}
+			{buttons}
+			{on_custom_button_click}
+		>
+			{#if buttons.some((btn) => typeof btn === "string" && btn === "download")}
+				<DownloadLink
+					href={value.is_stream
+						? value.url?.replace("playlist.m3u8", "playlist-file")
+						: value.url}
+					download={value.orig_name || value.path}
+				>
+					<IconButton Icon={Download} label={i18n("common.download")} />
+				</DownloadLink>
+			{/if}
+			{#if buttons.some((btn) => typeof btn === "string" && btn === "share")}
+				<ShareButton
+					{i18n}
+					{onerror}
+					{onshare}
+					formatter={async (fileData: FileData) => {
+						if (!fileData || !fileData.url) return "";
+						let url = await uploadToHuggingFace(fileData.url, "url");
+						return `<audio controls src="${url}"></audio>`;
+					}}
+					{value}
+				/>
+			{/if}
+		</IconButtonWrapper>
+
+		<AudioPlayer
+			{value}
+			subtitles={Array.isArray(subtitles) ? subtitles : subtitles?.url}
+			{label}
+			{i18n}
+			{waveform_settings}
+			{waveform_options}
+			{editable}
+			{loop}
+			bind:playback_position
+			{onpause}
+			{onplay}
+			{onstop}
+			onload={() => {}}
+		/>
+	{/if}
+{:else}
+	<Empty size="small">
+		<Music />
+	</Empty>
+{/if}

6.26.0/audio/streaming/StreamAudio.svelte

@@ -0,0 +1,214 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { Spinner } from "@gradio/icons";
+	import WaveSurfer from "wavesurfer.js";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { WaveformOptions } from "../shared/types";
+	import DeviceSelect from "../shared/DeviceSelect.svelte";
+
+	let {
+		recording = false,
+		paused_recording = false,
+		stop,
+		record,
+		i18n,
+		waveform_settings,
+		waveform_options = { show_recording_waveform: true },
+		waiting = false
+	}: {
+		recording?: boolean;
+		paused_recording?: boolean;
+		stop: () => void;
+		record: () => void;
+		i18n: I18nFormatter;
+		waveform_settings: Record<string, any>;
+		waveform_options?: WaveformOptions;
+		waiting?: boolean;
+	} = $props();
+
+	let micWaveform: WaveSurfer;
+	let waveformRecord: RecordPlugin;
+
+	let microphoneContainer: HTMLDivElement;
+
+	let micDevices: MediaDeviceInfo[] = $state([]);
+
+	onMount(() => {
+		create_mic_waveform();
+	});
+
+	const create_mic_waveform = (): void => {
+		if (micWaveform !== undefined) micWaveform.destroy();
+		if (!microphoneContainer) return;
+		micWaveform = WaveSurfer.create({
+			...waveform_settings,
+			normalize: false,
+			container: microphoneContainer
+		});
+
+		waveformRecord = micWaveform.registerPlugin(RecordPlugin.create());
+	};
+</script>
+
+<div class="mic-wrap">
+	{#if waveform_options.show_recording_waveform}
+		<div
+			bind:this={microphoneContainer}
+			style:display={recording ? "block" : "none"}
+		/>
+	{/if}
+	<div class="controls">
+		{#if recording && !waiting}
+			<button
+				class={paused_recording ? "stop-button-paused" : "stop-button"}
+				onclick={() => {
+					waveformRecord?.stopMic();
+					stop();
+				}}
+			>
+				<span class="record-icon">
+					<span class="pinger" />
+					<span class="dot" />
+				</span>
+				{paused_recording ? i18n("audio.pause") : i18n("audio.stop")}
+			</button>
+		{:else if recording && waiting}
+			<button
+				class="spinner-button"
+				onclick={() => {
+					stop();
+				}}
+			>
+				<div class="icon">
+					<Spinner />
+				</div>
+				{i18n("audio.waiting")}
+			</button>
+		{:else}
+			<button
+				class="record-button"
+				onclick={() => {
+					waveformRecord?.startMic();
+					record();
+				}}
+			>
+				<span class="record-icon">
+					<span class="dot" />
+				</span>
+				{i18n("audio.record")}
+			</button>
+		{/if}
+
+		<DeviceSelect bind:micDevices {i18n} />
+	</div>
+</div>
+
+<style>
+	.controls {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		flex-wrap: wrap;
+	}
+
+	.mic-wrap {
+		display: block;
+		align-items: center;
+		margin: var(--spacing-xl);
+	}
+
+	.icon {
+		width: var(--size-4);
+		height: var(--size-4);
+		fill: var(--primary-600);
+		stroke: var(--primary-600);
+	}
+
+	.stop-button-paused {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		margin-right: 5px;
+	}
+
+	.stop-button-paused::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.stop-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		animation: scaling 1800ms infinite;
+	}
+
+	.stop-button {
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin-right: 5px;
+		display: flex;
+	}
+
+	.spinner-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--radius-3xl);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		display: flex;
+		justify-content: space-evenly;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.record-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		display: flex;
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+	}
+
+	@keyframes scaling {
+		0% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+		50% {
+			background-color: var(--primary-600);
+			scale: 1.2;
+		}
+		100% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+	}
+</style>

6.26.0/audio/streaming/media_recorder.ts

@@ -0,0 +1,14 @@
+import type { IMediaRecorderConstructor } from "extendable-media-recorder";
+
+let media_recorder_initialized = false;
+let media_recorder;
+
+export async function init_media_recorder(): Promise<IMediaRecorderConstructor> {
+	const { MediaRecorder, register } = await import("extendable-media-recorder");
+	const { connect } = await import("extendable-media-recorder-wav-encoder");
+
+	register(await connect());
+	media_recorder_initialized = true;
+	media_recorder = MediaRecorder;
+	return media_recorder;
+}