Upload folder using huggingface_hub

6.0.1/video/Example.svelte

@@ -0,0 +1,78 @@
+<script lang="ts">
+	import Video from "./shared/Video.svelte";
+	import { playable } from "./shared/utils";
+	import { type FileData } from "@gradio/client";
+
+	export let type: "gallery" | "table";
+	export let selected = false;
+	export let value: null | FileData = null;
+	export let loop: boolean;
+	let video: HTMLVideoElement;
+
+	async function init(): Promise<void> {
+		video.muted = true;
+		video.playsInline = true;
+		video.controls = false;
+		video.setAttribute("muted", "");
+
+		await video.play();
+		video.pause();
+	}
+</script>
+
+{#if value}
+	{#if playable()}
+		<div
+			class="container"
+			class:table={type === "table"}
+			class:gallery={type === "gallery"}
+			class:selected
+		>
+			<Video
+				muted
+				playsinline
+				bind:node={video}
+				on:loadeddata={init}
+				on:mouseover={video.play.bind(video)}
+				on:mouseout={video.pause.bind(video)}
+				src={value?.url}
+				is_stream={false}
+				{loop}
+			/>
+		</div>
+	{:else}
+		<div>{value}</div>
+	{/if}
+{/if}
+
+<style>
+	.container {
+		flex: none;
+		max-width: none;
+	}
+	.container :global(video) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: cover;
+	}
+
+	.container:hover,
+	.container.selected {
+		border-color: var(--border-color-accent);
+	}
+	.container.table {
+		margin: 0 auto;
+		border: 2px solid var(--border-color-primary);
+		border-radius: var(--radius-lg);
+		overflow: hidden;
+		width: var(--size-20);
+		height: var(--size-20);
+		object-fit: cover;
+	}
+
+	.container.gallery {
+		height: var(--size-20);
+		max-height: var(--size-20);
+		object-fit: cover;
+	}
+</style>

6.0.1/video/Index.svelte

@@ -0,0 +1,180 @@
+<svelte:options accessors={true} />
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import type { FileData } from "@gradio/client";
+	import { Block, UploadText } from "@gradio/atoms";
+	import StaticVideo from "./shared/VideoPreview.svelte";
+	import Video from "./shared/InteractiveVideo.svelte";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { Gradio } from "@gradio/utils";
+	import type { VideoProps, VideoEvents } from "./types";
+
+	const props = $props();
+
+	let upload_promise = $state<Promise<any>>();
+
+	class VideoGradio extends Gradio<VideoEvents, VideoProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	const gradio = new VideoGradio(props);
+	let old_value = $state(gradio.props.value);
+
+	let uploading = $state(false);
+	let dragging = $state(false);
+	let active_source = $derived.by(() =>
+		gradio.props.sources ? gradio.props.sources[0] : undefined
+	);
+	let initial_value: FileData | null = gradio.props.value;
+
+	$effect(() => {
+		if (old_value != gradio.props.value) {
+			old_value = gradio.props.value;
+			gradio.dispatch("change");
+		}
+	});
+
+	const handle_reset_value = (): void => {
+		if (initial_value === null || gradio.props.value === initial_value) {
+			return;
+		}
+		gradio.props.value = initial_value;
+	};
+
+	function handle_change({ detail }: CustomEvent<FileData | null>): void {
+		if (detail != null) {
+			gradio.props.value = detail as FileData;
+		} else {
+			gradio.props.value = null;
+		}
+	}
+
+	function handle_error({ detail }: CustomEvent<string>): void {
+		const [level, status] = detail.includes("Invalid file type")
+			? ["warning", "complete"]
+			: ["error", "error"];
+		gradio.shared.loading_status.status = status as any;
+		gradio.shared.loading_status.message = detail;
+		gradio.dispatch(level as "error" | "warning", detail);
+	}
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null && active_source === "upload"
+			? "dashed"
+			: "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height || undefined}
+		width={gradio.props.width}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		allow_overflow={false}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<StaticVideo
+			value={gradio.props.value}
+			subtitle={gradio.props.subtitles}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			autoplay={gradio.props.autoplay}
+			loop={gradio.props.loop}
+			show_share_button={(gradio.props.buttons || []).includes("share")}
+			show_download_button={(gradio.props.buttons || ["download"]).includes(
+				"download"
+			)}
+			on:play={() => gradio.dispatch("play")}
+			on:pause={() => gradio.dispatch("pause")}
+			on:stop={() => gradio.dispatch("stop")}
+			on:end={() => gradio.dispatch("end")}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => gradio.dispatch("error", detail)}
+			i18n={gradio.i18n}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+		/>
+	</Block>
+{:else}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null && active_source === "upload"
+			? "dashed"
+			: "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height || undefined}
+		width={gradio.props.width}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		allow_overflow={false}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<Video
+			bind:upload_promise
+			value={gradio.props.value}
+			subtitle={gradio.props.subtitles}
+			on:change={handle_change}
+			on:drag={({ detail }) => (dragging = detail)}
+			on:error={handle_error}
+			bind:uploading
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			show_download_button={(gradio.props.buttons || []).includes("download")}
+			sources={gradio.props.sources}
+			{active_source}
+			webcam_options={gradio.props.webcam_options}
+			include_audio={gradio.props.include_audio}
+			autoplay={gradio.props.autoplay}
+			root={gradio.shared.root}
+			loop={gradio.props.loop}
+			{handle_reset_value}
+			on:clear={() => {
+				gradio.props.value = null;
+				gradio.dispatch("clear");
+			}}
+			on:play={() => gradio.dispatch("play")}
+			on:pause={() => gradio.dispatch("pause")}
+			on:upload={() => gradio.dispatch("upload")}
+			on:stop={() => gradio.dispatch("stop")}
+			on:end={() => gradio.dispatch("end")}
+			on:start_recording={() => gradio.dispatch("start_recording")}
+			on:stop_recording={() => gradio.dispatch("stop_recording")}
+			i18n={gradio.i18n}
+			max_file_size={gradio.shared.max_file_size}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={(...args) => gradio.shared.client.stream(...args)}
+		>
+			<UploadText i18n={gradio.i18n} type="video" />
+		</Video>
+	</Block>
+{/if}

6.0.1/video/index.ts

@@ -0,0 +1,7 @@
+export { default as BaseInteractiveVideo } from "./shared/InteractiveVideo.svelte";
+export { default as BaseStaticVideo } from "./shared/VideoPreview.svelte";
+export { default as BasePlayer } from "./shared/Player.svelte";
+export { prettyBytes, playable, loaded } from "./shared/utils";
+export { default as BaseExample } from "./Example.svelte";
+import { default as Index } from "./Index.svelte";
+export default Index;

6.0.1/video/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "@gradio/video",
+	"version": "0.17.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@ffmpeg/ffmpeg": "^0.12.15",
+		"@ffmpeg/util": "^0.12.2",
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/image": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"hls.js": "^1.6.13",
+		"mrmime": "^2.0.1"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"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": "./shared/VideoPreview.svelte",
+			"svelte": "./dist/shared/VideoPreview.svelte",
+			"types": "./dist/shared/VideoPreview.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.43.4"
+	},
+	"main": "index.ts",
+	"main_changeset": true,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/video"
+	}
+}

6.0.1/video/shared/InteractiveVideo.svelte

@@ -0,0 +1,178 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { Upload, ModifyUpload } from "@gradio/upload";
+	import type { FileData, Client } from "@gradio/client";
+	import { BlockLabel } from "@gradio/atoms";
+	import { Webcam } from "@gradio/image";
+	import { Video } from "@gradio/icons";
+	import type { WebcamOptions } from "./utils";
+	import { prettyBytes, playable } from "./utils";
+	import Player from "./Player.svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { SelectSource } from "@gradio/atoms";
+
+	export let value: FileData | null = null;
+	export let subtitle: FileData | null = null;
+	export let sources:
+		| ["webcam"]
+		| ["upload"]
+		| ["webcam", "upload"]
+		| ["upload", "webcam"] = ["webcam", "upload"];
+	export let label: string | undefined = undefined;
+	export let show_download_button = false;
+	export let show_label = true;
+	export let webcam_options: WebcamOptions;
+	export let include_audio: boolean;
+	export let autoplay: boolean;
+	export let root: string;
+	export let i18n: I18nFormatter;
+	export let active_source: "webcam" | "upload" = "webcam";
+	export let handle_reset_value: () => void = () => {};
+	export let max_file_size: number | null = null;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let loop: boolean;
+	export let uploading = false;
+	export let upload_promise: Promise<any> | null = null;
+
+	let has_change_history = false;
+
+	const dispatch = createEventDispatcher<{
+		change: FileData | null;
+		clear?: never;
+		play?: never;
+		pause?: never;
+		end?: never;
+		drag: boolean;
+		error: string;
+		upload: FileData;
+		start_recording?: never;
+		stop_recording?: never;
+	}>();
+
+	function handle_load({ detail }: CustomEvent<FileData | null>): void {
+		value = detail;
+		dispatch("change", detail);
+		dispatch("upload", detail!);
+	}
+
+	function handle_clear(): void {
+		value = null;
+		dispatch("change", null);
+		dispatch("clear");
+	}
+
+	function handle_change(video: FileData): void {
+		has_change_history = true;
+		dispatch("change", video);
+	}
+
+	function handle_capture({
+		detail
+	}: CustomEvent<FileData | any | null>): void {
+		dispatch("change", detail);
+	}
+
+	let dragging = false;
+	$: dispatch("drag", dragging);
+</script>
+
+<BlockLabel {show_label} Icon={Video} label={label || "Video"} />
+<div data-testid="video" class="video-container">
+	{#if value === null || value?.url === undefined}
+		<div class="upload-container">
+			{#if active_source === "upload"}
+				<Upload
+					bind:upload_promise
+					bind:dragging
+					bind:uploading
+					filetype="video/x-m4v,video/*"
+					on:load={handle_load}
+					{max_file_size}
+					on:error={({ detail }) => dispatch("error", detail)}
+					{root}
+					{upload}
+					{stream_handler}
+					aria_label={i18n("video.drop_to_upload")}
+				>
+					<slot />
+				</Upload>
+			{:else if active_source === "webcam"}
+				<Webcam
+					{root}
+					mirror_webcam={webcam_options.mirror}
+					webcam_constraints={webcam_options.constraints}
+					{include_audio}
+					mode="video"
+					on:error
+					on:capture={handle_capture}
+					on:start_recording
+					on:stop_recording
+					{i18n}
+					{upload}
+					stream_every={1}
+				/>
+			{/if}
+		</div>
+	{:else if value?.url}
+		{#key value?.url}
+			<Player
+				{upload}
+				{root}
+				interactive
+				{autoplay}
+				src={value.url}
+				subtitle={subtitle?.url}
+				is_stream={false}
+				on:play
+				on:pause
+				on:stop
+				on:end
+				on:error
+				mirror={webcam_options.mirror && active_source === "webcam"}
+				{label}
+				{handle_change}
+				{handle_reset_value}
+				{loop}
+				{value}
+				{i18n}
+				{show_download_button}
+				{handle_clear}
+				{has_change_history}
+			/>
+		{/key}
+	{:else if value.size}
+		<div class="file-name">{value.orig_name || value.url}</div>
+		<div class="file-size">
+			{prettyBytes(value.size)}
+		</div>
+	{/if}
+
+	<SelectSource {sources} bind:active_source {handle_clear} />
+</div>
+
+<style>
+	.file-name {
+		padding: var(--size-6);
+		font-size: var(--text-xxl);
+		word-break: break-all;
+	}
+
+	.file-size {
+		padding: var(--size-2);
+		font-size: var(--text-xl);
+	}
+
+	.upload-container {
+		height: 100%;
+		width: 100%;
+	}
+
+	.video-container {
+		display: flex;
+		height: 100%;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+	}
+</style>

6.0.1/video/shared/Player.svelte

@@ -0,0 +1,276 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { Play, Pause, Maximize, Undo } from "@gradio/icons";
+	import Video from "./Video.svelte";
+	import VideoControls from "./VideoControls.svelte";
+	import type { FileData, Client } from "@gradio/client";
+	import { prepare_files } from "@gradio/client";
+	import { format_time } from "@gradio/utils";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	export let root = "";
+	export let src: string;
+	export let subtitle: string | null = null;
+	export let mirror: boolean;
+	export let autoplay: boolean;
+	export let loop: boolean;
+	export let label = "test";
+	export let interactive = false;
+	export let handle_change: (video: FileData) => void = () => {};
+	export let handle_reset_value: () => void = () => {};
+	export let upload: Client["upload"];
+	export let is_stream: boolean | undefined;
+	export let i18n: I18nFormatter;
+	export let show_download_button = false;
+	export let value: FileData | null = null;
+	export let handle_clear: () => void = () => {};
+	export let has_change_history = false;
+
+	const dispatch = createEventDispatcher<{
+		play: undefined;
+		pause: undefined;
+		stop: undefined;
+		end: undefined;
+		clear: undefined;
+	}>();
+
+	let time = 0;
+	let duration: number;
+	let paused = true;
+	let video: HTMLVideoElement;
+	let processingVideo = false;
+
+	function handleMove(e: TouchEvent | MouseEvent): void {
+		if (!duration) return;
+
+		if (e.type === "click") {
+			handle_click(e as MouseEvent);
+			return;
+		}
+
+		if (e.type !== "touchmove" && !((e as MouseEvent).buttons & 1)) return;
+
+		const clientX =
+			e.type === "touchmove"
+				? (e as TouchEvent).touches[0].clientX
+				: (e as MouseEvent).clientX;
+		const { left, right } = (
+			e.currentTarget as HTMLProgressElement
+		).getBoundingClientRect();
+		time = (duration * (clientX - left)) / (right - left);
+	}
+
+	async function play_pause(): Promise<void> {
+		if (document.fullscreenElement != video) {
+			const isPlaying =
+				video.currentTime > 0 &&
+				!video.paused &&
+				!video.ended &&
+				video.readyState > video.HAVE_CURRENT_DATA;
+
+			if (!isPlaying) {
+				await video.play();
+			} else video.pause();
+		}
+	}
+
+	function handle_click(e: MouseEvent): void {
+		const { left, right } = (
+			e.currentTarget as HTMLProgressElement
+		).getBoundingClientRect();
+		time = (duration * (e.clientX - left)) / (right - left);
+	}
+
+	function handle_end(): void {
+		dispatch("stop");
+		dispatch("end");
+	}
+
+	const handle_trim_video = async (videoBlob: Blob): Promise<void> => {
+		let _video_blob = new File([videoBlob], "video.mp4");
+		const val = await prepare_files([_video_blob]);
+		let value = ((await upload(val, root))?.filter(Boolean) as FileData[])[0];
+
+		handle_change(value);
+	};
+
+	function open_full_screen(): void {
+		video.requestFullscreen();
+	}
+
+	$: time = time || 0;
+	$: duration = duration || 0;
+</script>
+
+<div class="wrap">
+	<div class="mirror-wrap" class:mirror>
+		<Video
+			{src}
+			preload="auto"
+			{autoplay}
+			{loop}
+			{is_stream}
+			on:click={play_pause}
+			on:play
+			on:pause
+			on:error
+			on:ended={handle_end}
+			bind:currentTime={time}
+			bind:duration
+			bind:paused
+			bind:node={video}
+			data-testid={`${label}-player`}
+			{processingVideo}
+			on:loadstart
+			on:loadeddata
+			on:loadedmetadata
+		>
+			<track kind="captions" src={subtitle} default />
+		</Video>
+	</div>
+
+	<div class="controls">
+		<div class="inner">
+			<span
+				role="button"
+				tabindex="0"
+				class="icon"
+				aria-label="play-pause-replay-button"
+				on:click={play_pause}
+				on:keydown={play_pause}
+			>
+				{#if time === duration}
+					<Undo />
+				{:else if paused}
+					<Play />
+				{:else}
+					<Pause />
+				{/if}
+			</span>
+
+			<span class="time">{format_time(time)} / {format_time(duration)}</span>
+
+			<!-- TODO: implement accessible video timeline for 4.0 -->
+			<!-- svelte-ignore a11y-click-events-have-key-events -->
+			<!-- svelte-ignore a11y-no-noninteractive-element-interactions -->
+			<progress
+				value={time / duration || 0}
+				on:mousemove={handleMove}
+				on:touchmove|preventDefault={handleMove}
+				on:click|stopPropagation|preventDefault={handle_click}
+			/>
+
+			<div
+				role="button"
+				tabindex="0"
+				class="icon"
+				aria-label="full-screen"
+				on:click={open_full_screen}
+				on:keypress={open_full_screen}
+			>
+				<Maximize />
+			</div>
+		</div>
+	</div>
+</div>
+{#if interactive}
+	<VideoControls
+		videoElement={video}
+		showRedo
+		{handle_trim_video}
+		{handle_reset_value}
+		bind:processingVideo
+		{value}
+		{i18n}
+		{show_download_button}
+		{handle_clear}
+		{has_change_history}
+	/>
+{/if}
+
+<style lang="postcss">
+	span {
+		text-shadow: 0 0 8px rgba(0, 0, 0, 0.5);
+	}
+
+	progress {
+		margin-right: var(--size-3);
+		border-radius: var(--radius-sm);
+		width: var(--size-full);
+		height: var(--size-2);
+	}
+
+	progress::-webkit-progress-bar {
+		border-radius: 2px;
+		background-color: rgba(255, 255, 255, 0.2);
+		overflow: hidden;
+	}
+
+	progress::-webkit-progress-value {
+		background-color: rgba(255, 255, 255, 0.9);
+	}
+
+	.mirror {
+		transform: scaleX(-1);
+	}
+
+	.mirror-wrap {
+		position: relative;
+		height: 100%;
+		width: 100%;
+	}
+
+	.controls {
+		position: absolute;
+		bottom: 0;
+		opacity: 0;
+		transition: 500ms;
+		margin: var(--size-2);
+		border-radius: var(--radius-md);
+		background: var(--color-grey-800);
+		padding: var(--size-2) var(--size-1);
+		width: calc(100% - 0.375rem * 2);
+		width: calc(100% - var(--size-2) * 2);
+	}
+	.wrap:hover .controls {
+		opacity: 1;
+	}
+
+	.inner {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		padding-right: var(--size-2);
+		padding-left: var(--size-2);
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.icon {
+		display: flex;
+		justify-content: center;
+		cursor: pointer;
+		width: var(--size-6);
+		color: white;
+	}
+
+	.time {
+		flex-shrink: 0;
+		margin-right: var(--size-3);
+		margin-left: var(--size-3);
+		color: white;
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+	}
+	.wrap {
+		position: relative;
+		background-color: var(--background-fill-secondary);
+		height: var(--size-full);
+		width: var(--size-full);
+		border-radius: var(--radius-xl);
+	}
+	.wrap :global(video) {
+		height: var(--size-full);
+		width: var(--size-full);
+	}
+</style>

6.0.1/video/shared/Video.svelte

@@ -0,0 +1,178 @@
+<script lang="ts">
+	import type { HTMLVideoAttributes } from "svelte/elements";
+	import { createEventDispatcher } from "svelte";
+	import { loaded } from "./utils";
+
+	import Hls from "hls.js";
+
+	export let src: HTMLVideoAttributes["src"] = undefined;
+
+	export let muted: HTMLVideoAttributes["muted"] = undefined;
+	export let playsinline: HTMLVideoAttributes["playsinline"] = undefined;
+	export let preload: HTMLVideoAttributes["preload"] = undefined;
+	export let autoplay: HTMLVideoAttributes["autoplay"] = undefined;
+	export let controls: HTMLVideoAttributes["controls"] = undefined;
+
+	export let currentTime: number | undefined = undefined;
+	export let duration: number | undefined = undefined;
+	export let paused: boolean | undefined = undefined;
+
+	export let node: HTMLVideoElement | undefined = undefined;
+	export let loop: boolean;
+	export let is_stream;
+
+	export let processingVideo = false;
+
+	let stream_active = false;
+
+	const dispatch = createEventDispatcher();
+
+	function load_stream(
+		src: string | null | undefined,
+		is_stream: boolean,
+		node: HTMLVideoElement
+	): void {
+		if (!src || !is_stream) return;
+
+		if (Hls.isSupported() && !stream_active) {
+			const hls = new Hls({
+				maxBufferLength: 1, // 0.5 seconds (500 ms)
+				maxMaxBufferLength: 1, // Maximum max buffer length in seconds
+				lowLatencyMode: true // Enable low latency mode
+			});
+			hls.loadSource(src);
+			hls.attachMedia(node);
+			hls.on(Hls.Events.MANIFEST_PARSED, function () {
+				(node as HTMLVideoElement).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;
+		}
+	}
+
+	$: (src, (stream_active = false));
+
+	$: if (node && src && is_stream) {
+		load_stream(src, is_stream, node);
+	}
+</script>
+
+<!--
+The spread operator with `$$props` or `$$restProps` can't be used here
+to pass props from the parent component to the <video> element
+because of its unexpected behavior: https://github.com/sveltejs/svelte/issues/7404
+For example, if we add {...$$props} or {...$$restProps}, the boolean props aside it like `controls` will be compiled as string "true" or "false" on the actual DOM.
+Then, even when `controls` is false, the compiled DOM would be `<video controls="false">` which is equivalent to `<video controls>` since the string "false" is even truthy.
+-->
+<div class:hidden={!processingVideo} class="overlay">
+	<span class="load-wrap">
+		<span class="loader" />
+	</span>
+</div>
+<video
+	{src}
+	{muted}
+	{playsinline}
+	{preload}
+	{autoplay}
+	{controls}
+	{loop}
+	on:loadeddata={dispatch.bind(null, "loadeddata")}
+	on:click={dispatch.bind(null, "click")}
+	on:play={dispatch.bind(null, "play")}
+	on:pause={dispatch.bind(null, "pause")}
+	on:ended={dispatch.bind(null, "ended")}
+	on:mouseover={dispatch.bind(null, "mouseover")}
+	on:mouseout={dispatch.bind(null, "mouseout")}
+	on:focus={dispatch.bind(null, "focus")}
+	on:blur={dispatch.bind(null, "blur")}
+	on:error={dispatch.bind(null, "error", "Video not playable")}
+	on:loadstart
+	on:loadeddata
+	on:loadedmetadata
+	bind:currentTime
+	bind:duration
+	bind:paused
+	bind:this={node}
+	use:loaded={{ autoplay: autoplay ?? false }}
+	data-testid={$$props["data-testid"]}
+	crossorigin="anonymous"
+>
+	<slot />
+</video>
+
+<style>
+	.overlay {
+		position: absolute;
+		background-color: rgba(0, 0, 0, 0.4);
+		width: 100%;
+		height: 100%;
+	}
+
+	.hidden {
+		display: none;
+	}
+
+	.load-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		height: 100%;
+	}
+
+	.loader {
+		display: flex;
+		position: relative;
+		background-color: var(--border-color-accent-subdued);
+		animation: shadowPulse 2s linear infinite;
+		box-shadow:
+			-24px 0 var(--border-color-accent-subdued),
+			24px 0 var(--border-color-accent-subdued);
+		margin: var(--spacing-md);
+		border-radius: 50%;
+		width: 10px;
+		height: 10px;
+		scale: 0.5;
+	}
+
+	@keyframes shadowPulse {
+		33% {
+			box-shadow:
+				-24px 0 var(--border-color-accent-subdued),
+				24px 0 #fff;
+			background: #fff;
+		}
+		66% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 #fff;
+			background: var(--border-color-accent-subdued);
+		}
+		100% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 var(--border-color-accent-subdued);
+			background: #fff;
+		}
+	}
+</style>

6.0.1/video/shared/VideoControls.svelte

@@ -0,0 +1,202 @@
+<script lang="ts">
+	import { Undo, Trim, Clear } from "@gradio/icons";
+	import VideoTimeline from "./VideoTimeline.svelte";
+	import { trimVideo } from "./utils";
+	import { FFmpeg } from "@ffmpeg/ffmpeg";
+	import loadFfmpeg from "./utils";
+	import { onMount } from "svelte";
+	import { format_time } from "@gradio/utils";
+	import { IconButton } from "@gradio/atoms";
+	import { ModifyUpload } from "@gradio/upload";
+	import type { FileData } from "@gradio/client";
+
+	export let videoElement: HTMLVideoElement;
+
+	export let showRedo = false;
+	export let interactive = true;
+	export let mode = "";
+	export let handle_reset_value: () => void;
+	export let handle_trim_video: (videoBlob: Blob) => void;
+	export let processingVideo = false;
+	export let i18n: (key: string) => string;
+	export let value: FileData | null = null;
+	export let show_download_button = false;
+	export let handle_clear: () => void = () => {};
+	export let has_change_history = false;
+
+	let ffmpeg: FFmpeg;
+
+	onMount(async () => {
+		ffmpeg = await loadFfmpeg();
+	});
+
+	$: if (mode === "edit" && trimmedDuration === null && videoElement)
+		trimmedDuration = videoElement.duration;
+
+	let trimmedDuration: number | null = null;
+	let dragStart = 0;
+	let dragEnd = 0;
+
+	let loadingTimeline = false;
+
+	const toggleTrimmingMode = (): void => {
+		if (mode === "edit") {
+			mode = "";
+			trimmedDuration = videoElement.duration;
+		} else {
+			mode = "edit";
+		}
+	};
+</script>
+
+<div class="container" class:hidden={mode !== "edit"}>
+	{#if mode === "edit"}
+		<div class="timeline-wrapper">
+			<VideoTimeline
+				{videoElement}
+				bind:dragStart
+				bind:dragEnd
+				bind:trimmedDuration
+				bind:loadingTimeline
+			/>
+		</div>
+	{/if}
+
+	<div class="controls" data-testid="waveform-controls">
+		{#if mode === "edit" && trimmedDuration !== null}
+			<time
+				aria-label="duration of selected region in seconds"
+				class:hidden={loadingTimeline}>{format_time(trimmedDuration)}</time
+			>
+			<div class="edit-buttons">
+				<button
+					class:hidden={loadingTimeline}
+					class="text-button"
+					on:click={() => {
+						mode = "";
+						processingVideo = true;
+						trimVideo(ffmpeg, dragStart, dragEnd, videoElement)
+							.then((videoBlob) => {
+								handle_trim_video(videoBlob);
+							})
+							.then(() => {
+								processingVideo = false;
+							});
+					}}>Trim</button
+				>
+				<button
+					class="text-button"
+					class:hidden={loadingTimeline}
+					on:click={toggleTrimmingMode}>Cancel</button
+				>
+			</div>
+		{:else}
+			<div />
+		{/if}
+	</div>
+</div>
+
+<ModifyUpload
+	{i18n}
+	on:clear={() => handle_clear()}
+	download={show_download_button ? value?.url : null}
+>
+	{#if showRedo && mode === ""}
+		<IconButton
+			Icon={Undo}
+			label="Reset video to initial value"
+			disabled={processingVideo || !has_change_history}
+			on:click={() => {
+				handle_reset_value();
+				mode = "";
+			}}
+		/>
+	{/if}
+
+	{#if interactive && mode === ""}
+		<IconButton
+			Icon={Trim}
+			label="Trim video to selection"
+			disabled={processingVideo}
+			on:click={toggleTrimmingMode}
+		/>
+	{/if}
+</ModifyUpload>
+
+<style>
+	.container {
+		width: 100%;
+	}
+	time {
+		color: var(--color-accent);
+		font-weight: bold;
+		padding-left: var(--spacing-xs);
+	}
+
+	.timeline-wrapper {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 100%;
+	}
+
+	.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: flex;
+		justify-content: space-between;
+		align-items: center;
+		margin: var(--spacing-lg);
+		overflow: hidden;
+	}
+
+	.edit-buttons {
+		display: flex;
+		gap: var(--spacing-sm);
+	}
+
+	@media (max-width: 320px) {
+		.controls {
+			flex-direction: column;
+			align-items: flex-start;
+		}
+
+		.edit-buttons {
+			margin-top: var(--spacing-sm);
+		}
+
+		.controls * {
+			margin: var(--spacing-sm);
+		}
+
+		.controls .text-button {
+			margin-left: 0;
+		}
+	}
+
+	.container {
+		display: flex;
+		flex-direction: column;
+	}
+
+	.hidden {
+		display: none;
+	}
+</style>

6.0.1/video/shared/VideoPreview.svelte

@@ -0,0 +1,118 @@
+<script lang="ts">
+	import { createEventDispatcher, afterUpdate, tick } from "svelte";
+	import {
+		BlockLabel,
+		Empty,
+		IconButton,
+		ShareButton,
+		IconButtonWrapper,
+		DownloadLink
+	} from "@gradio/atoms";
+	import type { FileData, Client } from "@gradio/client";
+	import { Video, Download } from "@gradio/icons";
+	import { uploadToHuggingFace } from "@gradio/utils";
+
+	import Player from "./Player.svelte";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+
+	export let value: FileData | null = null;
+	export let subtitle: FileData | null = null;
+	export let label: string | undefined = undefined;
+	export let show_label = true;
+	export let autoplay: boolean;
+	export let show_share_button = true;
+	export let show_download_button = true;
+	export let loop: boolean;
+	export let i18n: I18nFormatter;
+	export let upload: Client["upload"];
+	export let display_icon_button_wrapper_top_corner = false;
+
+	let old_value: FileData | null = null;
+	let old_subtitle: FileData | null = null;
+
+	const dispatch = createEventDispatcher<{
+		change: FileData;
+		play: undefined;
+		pause: undefined;
+		end: undefined;
+		stop: undefined;
+		load: undefined;
+	}>();
+
+	$: value && dispatch("change", value);
+
+	afterUpdate(async () => {
+		// needed to bust subtitle caching issues on Chrome
+		if (
+			value !== old_value &&
+			subtitle !== old_subtitle &&
+			old_subtitle !== null
+		) {
+			old_value = value;
+			value = null;
+			await tick();
+			value = old_value;
+		}
+		old_value = value;
+		old_subtitle = subtitle;
+	});
+</script>
+
+<BlockLabel {show_label} Icon={Video} label={label || "Video"} />
+{#if !value || value.url === undefined}
+	<Empty unpadded_box={true} size="large"><Video /></Empty>
+{:else}
+	{#key value.url}
+		<Player
+			src={value.url}
+			subtitle={subtitle?.url}
+			is_stream={value.is_stream}
+			{autoplay}
+			on:play
+			on:pause
+			on:stop
+			on:end
+			on:loadedmetadata={() => {
+				// Deal with `<video>`'s `loadedmetadata` event as `VideoPreview`'s `load` event
+				// to represent not only the video is loaded but also the metadata is loaded
+				// so its dimensions (w/h) are known. This is used for Chatbot's auto scroll.
+				dispatch("load");
+			}}
+			mirror={false}
+			{label}
+			{loop}
+			interactive={false}
+			{upload}
+			{i18n}
+		/>
+	{/key}
+	<div data-testid="download-div">
+		<IconButtonWrapper
+			display_top_corner={display_icon_button_wrapper_top_corner}
+		>
+			{#if show_download_button}
+				<DownloadLink
+					href={value.is_stream
+						? value.url?.replace("playlist.m3u8", "playlist-file")
+						: value.url}
+					download={value.orig_name || value.path}
+				>
+					<IconButton Icon={Download} label="Download" />
+				</DownloadLink>
+			{/if}
+			{#if show_share_button}
+				<ShareButton
+					{i18n}
+					on:error
+					on:share
+					{value}
+					formatter={async (value) => {
+						if (!value) return "";
+						let url = await uploadToHuggingFace(value.data, "url");
+						return url;
+					}}
+				/>
+			{/if}
+		</IconButtonWrapper>
+	</div>
+{/if}

6.0.1/video/shared/VideoTimeline.svelte

@@ -0,0 +1,279 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+
+	export let videoElement: HTMLVideoElement;
+	export let trimmedDuration: number | null;
+	export let dragStart: number;
+	export let dragEnd: number;
+	export let loadingTimeline: boolean;
+
+	let thumbnails: string[] = [];
+	let numberOfThumbnails = 10;
+	let intervalId: ReturnType<typeof setInterval> | undefined;
+	let videoDuration: number;
+
+	let leftHandlePosition = 0;
+	let rightHandlePosition = 100;
+
+	let dragging: string | null = null;
+
+	const startDragging = (side: string | null): void => {
+		dragging = side;
+	};
+
+	$: loadingTimeline = thumbnails.length !== numberOfThumbnails;
+
+	const stopDragging = (): void => {
+		dragging = null;
+	};
+
+	const drag = (event: { clientX: number }, distance?: number): void => {
+		if (dragging) {
+			const timeline = document.getElementById("timeline");
+
+			if (!timeline) return;
+
+			const rect = timeline.getBoundingClientRect();
+			let newPercentage = ((event.clientX - rect.left) / rect.width) * 100;
+
+			if (distance) {
+				// Move handle based on arrow key press
+				newPercentage =
+					dragging === "left"
+						? leftHandlePosition + distance
+						: rightHandlePosition + distance;
+			} else {
+				// Move handle based on mouse drag
+				newPercentage = ((event.clientX - rect.left) / rect.width) * 100;
+			}
+
+			newPercentage = Math.max(0, Math.min(newPercentage, 100)); // Keep within 0 and 100
+
+			if (dragging === "left") {
+				leftHandlePosition = Math.min(newPercentage, rightHandlePosition);
+
+				// Calculate the new time and set it for the videoElement
+				const newTimeLeft = (leftHandlePosition / 100) * videoDuration;
+				videoElement.currentTime = newTimeLeft;
+
+				dragStart = newTimeLeft;
+			} else if (dragging === "right") {
+				rightHandlePosition = Math.max(newPercentage, leftHandlePosition);
+
+				const newTimeRight = (rightHandlePosition / 100) * videoDuration;
+				videoElement.currentTime = newTimeRight;
+
+				dragEnd = newTimeRight;
+			}
+
+			const startTime = (leftHandlePosition / 100) * videoDuration;
+			const endTime = (rightHandlePosition / 100) * videoDuration;
+			trimmedDuration = endTime - startTime;
+
+			leftHandlePosition = leftHandlePosition;
+			rightHandlePosition = rightHandlePosition;
+		}
+	};
+
+	const moveHandle = (e: KeyboardEvent): void => {
+		if (dragging) {
+			// Calculate the movement distance as a percentage of the video duration
+			const distance = (1 / videoDuration) * 100;
+
+			if (e.key === "ArrowLeft") {
+				drag({ clientX: 0 }, -distance);
+			} else if (e.key === "ArrowRight") {
+				drag({ clientX: 0 }, distance);
+			}
+		}
+	};
+
+	const generateThumbnail = (): void => {
+		const canvas = document.createElement("canvas");
+		const ctx = canvas.getContext("2d");
+		if (!ctx) return;
+
+		canvas.width = videoElement.videoWidth;
+		canvas.height = videoElement.videoHeight;
+
+		ctx.drawImage(videoElement, 0, 0, canvas.width, canvas.height);
+
+		const thumbnail: string = canvas.toDataURL("image/jpeg", 0.7);
+		thumbnails = [...thumbnails, thumbnail];
+	};
+
+	onMount(() => {
+		const loadMetadata = (): void => {
+			videoDuration = videoElement.duration;
+
+			const interval = videoDuration / numberOfThumbnails;
+			let captures = 0;
+
+			const onSeeked = (): void => {
+				generateThumbnail();
+				captures++;
+
+				if (captures < numberOfThumbnails) {
+					videoElement.currentTime += interval;
+				} else {
+					videoElement.removeEventListener("seeked", onSeeked);
+				}
+			};
+
+			videoElement.addEventListener("seeked", onSeeked);
+			videoElement.currentTime = 0;
+		};
+
+		if (videoElement.readyState >= 1) {
+			loadMetadata();
+		} else {
+			videoElement.addEventListener("loadedmetadata", loadMetadata);
+		}
+	});
+
+	onDestroy(() => {
+		window.removeEventListener("mousemove", drag);
+		window.removeEventListener("mouseup", stopDragging);
+		window.removeEventListener("keydown", moveHandle);
+
+		if (intervalId !== undefined) {
+			clearInterval(intervalId);
+		}
+	});
+
+	onMount(() => {
+		window.addEventListener("mousemove", drag);
+		window.addEventListener("mouseup", stopDragging);
+		window.addEventListener("keydown", moveHandle);
+	});
+</script>
+
+<div class="container">
+	{#if loadingTimeline}
+		<div class="load-wrap">
+			<span aria-label="loading timeline" class="loader" />
+		</div>
+	{:else}
+		<div id="timeline" class="thumbnail-wrapper">
+			<button
+				aria-label="start drag handle for trimming video"
+				class="handle left"
+				on:mousedown={() => startDragging("left")}
+				on:blur={stopDragging}
+				on:keydown={(e) => {
+					if (e.key === "ArrowLeft" || e.key == "ArrowRight") {
+						startDragging("left");
+					}
+				}}
+				style="left: {leftHandlePosition}%;"
+			/>
+
+			<div
+				class="opaque-layer"
+				style="left: {leftHandlePosition}%; right: {100 - rightHandlePosition}%"
+			/>
+
+			{#each thumbnails as thumbnail, i (i)}
+				<img src={thumbnail} alt={`frame-${i}`} draggable="false" />
+			{/each}
+			<button
+				aria-label="end drag handle for trimming video"
+				class="handle right"
+				on:mousedown={() => startDragging("right")}
+				on:blur={stopDragging}
+				on:keydown={(e) => {
+					if (e.key === "ArrowLeft" || e.key == "ArrowRight") {
+						startDragging("right");
+					}
+				}}
+				style="left: {rightHandlePosition}%;"
+			/>
+		</div>
+	{/if}
+</div>
+
+<style>
+	.load-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		height: 100%;
+	}
+	.loader {
+		display: flex;
+		position: relative;
+		background-color: var(--border-color-accent-subdued);
+		animation: shadowPulse 2s linear infinite;
+		box-shadow:
+			-24px 0 var(--border-color-accent-subdued),
+			24px 0 var(--border-color-accent-subdued);
+		margin: var(--spacing-md);
+		border-radius: 50%;
+		width: 10px;
+		height: 10px;
+		scale: 0.5;
+	}
+
+	@keyframes shadowPulse {
+		33% {
+			box-shadow:
+				-24px 0 var(--border-color-accent-subdued),
+				24px 0 #fff;
+			background: #fff;
+		}
+		66% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 #fff;
+			background: var(--border-color-accent-subdued);
+		}
+		100% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 var(--border-color-accent-subdued);
+			background: #fff;
+		}
+	}
+
+	.container {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		margin: var(--spacing-lg) var(--spacing-lg) 0 var(--spacing-lg);
+	}
+
+	#timeline {
+		display: flex;
+		height: var(--size-10);
+		flex: 1;
+		position: relative;
+	}
+
+	img {
+		flex: 1 1 auto;
+		min-width: 0;
+		object-fit: cover;
+		height: var(--size-12);
+		border: 1px solid var(--block-border-color);
+		user-select: none;
+		z-index: 1;
+	}
+
+	.handle {
+		width: 3px;
+		background-color: var(--color-accent);
+		cursor: ew-resize;
+		height: var(--size-12);
+		z-index: 3;
+		position: absolute;
+	}
+
+	.opaque-layer {
+		background-color: rgba(230, 103, 40, 0.25);
+		border: 1px solid var(--color-accent);
+		height: var(--size-12);
+		position: absolute;
+		z-index: 2;
+	}
+</style>

6.0.1/video/shared/index.ts

@@ -0,0 +1 @@
+export { default as Video } from "./Video.svelte";

6.0.1/video/shared/types.ts

@@ -0,0 +1,5 @@
+export interface SubtitleData {
+	start: number;
+	end: number;
+	text: string;
+}

6.0.1/video/shared/utils.ts

@@ -0,0 +1,151 @@
+import { toBlobURL } from "@ffmpeg/util";
+import { FFmpeg } from "@ffmpeg/ffmpeg";
+import { lookup } from "mrmime";
+
+export const prettyBytes = (bytes: number): string => {
+	let units = ["B", "KB", "MB", "GB", "PB"];
+	let i = 0;
+	while (bytes > 1024) {
+		bytes /= 1024;
+		i++;
+	}
+	let unit = units[i];
+	return bytes.toFixed(1) + " " + unit;
+};
+
+export const playable = (): boolean => {
+	// TODO: Fix this
+	// let video_element = document.createElement("video");
+	// let mime_type = mime.lookup(filename);
+	// return video_element.canPlayType(mime_type) != "";
+	return true; // FIX BEFORE COMMIT - mime import causing issues
+};
+
+export function loaded(
+	node: HTMLVideoElement,
+	{ autoplay }: { autoplay: boolean }
+): any {
+	async function handle_playback(): Promise<void> {
+		if (!autoplay) return;
+		await node.play();
+	}
+
+	node.addEventListener("loadeddata", handle_playback);
+
+	return {
+		destroy(): void {
+			node.removeEventListener("loadeddata", handle_playback);
+		}
+	};
+}
+
+export default async function loadFfmpeg(): Promise<FFmpeg> {
+	const ffmpeg = new FFmpeg();
+	const baseURL = "https://unpkg.com/@ffmpeg/core@0.12.4/dist/esm";
+
+	await ffmpeg.load({
+		coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, "text/javascript"),
+		wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, "application/wasm")
+	});
+
+	return ffmpeg;
+}
+
+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 async function trimVideo(
+	ffmpeg: FFmpeg,
+	startTime: number,
+	endTime: number,
+	videoElement: HTMLVideoElement
+): Promise<any> {
+	const videoUrl = videoElement.src;
+	const mimeType = lookup(videoElement.src) || "video/mp4";
+	const blobUrl = await toBlobURL(videoUrl, mimeType);
+	const response = await fetch(blobUrl);
+	const vidBlob = await response.blob();
+	const type = getVideoExtensionFromMimeType(mimeType) || "mp4";
+	const inputName = `input.${type}`;
+	const outputName = `output.${type}`;
+
+	try {
+		if (startTime === 0 && endTime === 0) {
+			return vidBlob;
+		}
+
+		await ffmpeg.writeFile(
+			inputName,
+			new Uint8Array(await vidBlob.arrayBuffer())
+		);
+
+		let command = [
+			"-i",
+			inputName,
+			...(startTime !== 0 ? ["-ss", startTime.toString()] : []),
+			...(endTime !== 0 ? ["-to", endTime.toString()] : []),
+			"-c:a",
+			"copy",
+			outputName
+		];
+
+		await ffmpeg.exec(command);
+		const outputData = await ffmpeg.readFile(outputName);
+		const outputBlob = new Blob([outputData], {
+			type: `video/${type}`
+		});
+
+		return outputBlob;
+	} catch (error) {
+		console.error("Error initializing FFmpeg:", error);
+		return vidBlob;
+	}
+}
+
+const getVideoExtensionFromMimeType = (mimeType: string): string | null => {
+	const videoMimeToExtensionMap: { [key: string]: string } = {
+		"video/mp4": "mp4",
+		"video/webm": "webm",
+		"video/ogg": "ogv",
+		"video/quicktime": "mov",
+		"video/x-msvideo": "avi",
+		"video/x-matroska": "mkv",
+		"video/mpeg": "mpeg",
+		"video/3gpp": "3gp",
+		"video/3gpp2": "3g2",
+		"video/h261": "h261",
+		"video/h263": "h263",
+		"video/h264": "h264",
+		"video/jpeg": "jpgv",
+		"video/jpm": "jpm",
+		"video/mj2": "mj2",
+		"video/mpv": "mpv",
+		"video/vnd.ms-playready.media.pyv": "pyv",
+		"video/vnd.uvvu.mp4": "uvu",
+		"video/vnd.vivo": "viv",
+		"video/x-f4v": "f4v",
+		"video/x-fli": "fli",
+		"video/x-flv": "flv",
+		"video/x-m4v": "m4v",
+		"video/x-ms-asf": "asf",
+		"video/x-ms-wm": "wm",
+		"video/x-ms-wmv": "wmv",
+		"video/x-ms-wmx": "wmx",
+		"video/x-ms-wvx": "wvx",
+		"video/x-sgi-movie": "movie",
+		"video/x-smv": "smv"
+	};
+
+	return videoMimeToExtensionMap[mimeType] || null;
+};
+
+export interface WebcamOptions {
+	mirror: boolean;
+	constraints: Record<string, any>;
+}

6.0.1/video/types.ts

@@ -0,0 +1,37 @@
+import type { FileData } from "@gradio/client";
+import type { LoadingStatus } from "@gradio/statustracker";
+import type { WebcamOptions } from "./shared/utils";
+
+export interface VideoProps {
+	value: FileData | null;
+	height: number | undefined;
+	width: number | undefined;
+	autoplay: boolean;
+	buttons: ("share" | "download" | "fullscreen")[];
+	sources:
+		| ["webcam"]
+		| ["upload"]
+		| ["webcam", "upload"]
+		| ["upload", "webcam"];
+	webcam_options: WebcamOptions;
+	include_audio: boolean;
+	loop: boolean;
+	webcam_constraints: object;
+	subtitles: FileData | null;
+}
+
+export interface VideoEvents {
+	change: never;
+	clear: never;
+	play: never;
+	pause: never;
+	upload: never;
+	stop: never;
+	end: never;
+	start_recording: never;
+	stop_recording: never;
+	clear_status: LoadingStatus;
+	share: any;
+	error: any;
+	warning: any;
+}