Upload folder using huggingface_hub

6.25.0/imageslider/Example.svelte

@@ -0,0 +1,76 @@
+<script lang="ts">
+	let {
+		value,
+		samples_dir,
+		type,
+		selected = false
+	}: {
+		value: [string, string];
+		samples_dir: string;
+		type: "gallery" | "table";
+		selected?: boolean;
+	} = $props();
+</script>
+
+<!-- TODO: fix -->
+<!-- svelte-ignore a11y-missing-attribute -->
+<div
+	class="wrap"
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	<img src={samples_dir + value[0]} />
+
+	<img src={samples_dir + value[1]} />
+	<span></span>
+</div>
+
+<style>
+	.wrap {
+		position: relative;
+		height: var(--size-64);
+		width: var(--size-40);
+		overflow: hidden;
+		border-radius: var(--radius-lg);
+	}
+	img {
+		height: var(--size-64);
+		width: var(--size-40);
+		position: absolute;
+		/* border-radius: var(--radius-lg); */
+		/* max-width: none; */
+		object-fit: cover;
+	}
+
+	.wrap.selected {
+		border-color: var(--color-accent);
+	}
+	.wrap img:first-child {
+		clip-path: inset(0 50% 0 0%);
+	}
+
+	.wrap img:nth-of-type(2) {
+		clip-path: inset(0 0 0 50%);
+	}
+	span {
+		position: absolute;
+		top: 0;
+		left: calc(50% - 0.75px);
+		height: var(--size-64);
+		width: 1.5px;
+		background: var(--border-color-primary);
+	}
+
+	.table {
+		margin: 0 auto;
+		border: 2px solid var(--border-color-primary);
+		border-radius: var(--radius-lg);
+	}
+
+	.gallery {
+		border: 2px solid var(--border-color-primary);
+		/* max-height: var(--size-20); */
+		object-fit: cover;
+	}
+</style>

6.25.0/imageslider/Index.svelte

@@ -0,0 +1,160 @@
+<script lang="ts">
+	import { tick } from "svelte";
+	import type { ImageSliderProps, ImageSliderEvents } from "./types";
+	import { Gradio } from "@gradio/utils";
+	import StaticImage from "./shared/SliderPreview.svelte";
+	import ImageUploader from "./shared/SliderUpload.svelte";
+
+	import { Block, Empty, UploadText } from "@gradio/atoms";
+	import { Image } from "@gradio/icons";
+	import { StatusTracker } from "@gradio/statustracker";
+
+	type sources = "upload" | "webcam" | "clipboard" | null;
+
+	let upload_promise = $state<Promise<any>>();
+
+	class ImageSliderGradio extends Gradio<ImageSliderEvents, ImageSliderProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+
+			const data = await super.get_data();
+			return data;
+		}
+	}
+
+	const props = $props();
+	const gradio = new ImageSliderGradio(props);
+
+	let fullscreen = $state(false);
+	let dragging = $state(false);
+	let active_source: sources = $state(null);
+	let value = $state(gradio.props.value ?? [null, null]);
+
+	let normalised_slider_position = $derived(
+		Math.max(0, Math.min(100, gradio.props.slider_position)) / 100
+	);
+
+	gradio.watch_for_change();
+
+	$effect(() => {
+		value = gradio.props.value ?? [null, null];
+	});
+
+	$effect(() => {
+		gradio.props.value = value;
+	});
+</script>
+
+{#if !gradio.shared.interactive || (value?.[1] && value?.[0])}
+	<Block
+		visible={gradio.shared.visible}
+		variant={"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}
+		allow_overflow={false}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		bind:fullscreen
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+		/>
+		<StaticImage
+			onclear={() => {
+				gradio.dispatch("clear");
+				gradio.dispatch("input");
+			}}
+			onfullscreen={(detail) => {
+				fullscreen = detail;
+			}}
+			{fullscreen}
+			interactive={gradio.shared.interactive}
+			bind:value
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			show_download_button={gradio.props.buttons.some(
+				(btn) => typeof btn === "string" && btn === "download"
+			)}
+			i18n={gradio.i18n}
+			show_fullscreen_button={gradio.props.buttons.some(
+				(btn) => typeof btn === "string" && btn === "fullscreen"
+			)}
+			buttons={gradio.props.buttons}
+			on_custom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+			position={normalised_slider_position}
+			slider_color={gradio.props.slider_color}
+			max_height={gradio.props.max_height}
+		/>
+	</Block>
+{:else}
+	<Block
+		visible={gradio.shared.visible}
+		variant={value?.[0] || value?.[1] ? "solid" : "dashed"}
+		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}
+		allow_overflow={false}
+		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)}
+		/>
+
+		<ImageUploader
+			bind:upload_promise
+			bind:value
+			bind:dragging
+			root={gradio.shared.root}
+			onclear={() => {
+				gradio.dispatch("clear");
+				gradio.dispatch("input");
+			}}
+			ondrag={(detail) => (dragging = detail)}
+			onupload={() => {
+				gradio.dispatch("upload");
+				gradio.dispatch("input");
+			}}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			upload_count={gradio.props.upload_count}
+			max_file_size={gradio.shared.max_file_size}
+			i18n={gradio.i18n}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={gradio.shared.client?.stream}
+			max_height={gradio.props.max_height}
+		>
+			{#if active_source === "upload" || !active_source}
+				<UploadText
+					i18n={gradio.i18n}
+					type="image"
+					placeholder={gradio.props.placeholder}
+				/>
+			{:else if active_source === "clipboard"}
+				<UploadText i18n={gradio.i18n} type="clipboard" mode="short" />
+			{:else}
+				<Empty unpadded_box={true} size="large"><Image /></Empty>
+			{/if}
+		</ImageUploader>
+	</Block>
+{/if}

6.25.0/imageslider/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@gradio/imageslider",
+	"version": "0.7.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@types/d3-drag": "^3.0.7",
+		"@types/d3-selection": "^3.0.11",
+		"d3-drag": "^3.0.0",
+		"d3-selection": "^3.0.0"
+	},
+	"exports": {
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/imageslider"
+	}
+}

6.25.0/imageslider/shared/ClearImage.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+	import { IconButton } from "@gradio/atoms";
+	import { Clear } from "@gradio/icons";
+
+	let { onremove_image }: { onremove_image?: () => void } = $props();
+</script>
+
+<div>
+	<IconButton
+		Icon={Clear}
+		label="Remove Image"
+		onclick={(event) => {
+			onremove_image?.();
+			event.stopPropagation();
+		}}
+	/>
+</div>
+
+<style>
+	div {
+		display: flex;
+		position: absolute;
+		top: var(--size-2);
+		right: var(--size-2);
+		justify-content: flex-end;
+		gap: var(--spacing-sm);
+		z-index: var(--layer-5);
+	}
+</style>

6.25.0/imageslider/shared/Image.svelte

@@ -0,0 +1,256 @@
+<script lang="ts">
+	import Slider from "./Slider.svelte";
+	import { tick, type Snippet } from "svelte";
+	import { BlockLabel, Empty, IconButton, DownloadLink } from "@gradio/atoms";
+	import { Download } from "@gradio/icons";
+	import { Image } from "@gradio/icons";
+	import { type I18nFormatter } from "@gradio/utils";
+	import ClearImage from "./ClearImage.svelte";
+	import ImageEl from "./ImageEl.svelte";
+
+	import { Upload } from "@gradio/upload";
+
+	import { type FileData, type Client } from "@gradio/client";
+
+	let {
+		value = $bindable<[FileData | null, FileData | null]>([null, null]),
+		label = undefined,
+		show_label,
+		root,
+		position = $bindable(0.5),
+		upload_count = 2,
+		show_download_button = true,
+		slider_color,
+		upload,
+		stream_handler,
+		max_file_size = null,
+		i18n,
+		max_height,
+		upload_promise = $bindable(),
+		dragging = $bindable(false),
+		onclear,
+		ondrag,
+		onupload,
+		children
+	}: {
+		value?: [FileData | null, FileData | null];
+		label?: string;
+		show_label: boolean;
+		root: string;
+		position?: number;
+		upload_count?: number;
+		show_download_button?: boolean;
+		slider_color: string;
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		max_file_size?: number | null;
+		i18n: I18nFormatter;
+		max_height: number;
+		upload_promise?: Promise<any>;
+		dragging?: boolean;
+		onclear?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onupload?: (value: [FileData | null, FileData | null]) => void;
+		children?: Snippet;
+	} = $props();
+
+	let value_ = $state<[FileData | null, FileData | null]>(
+		value || [null, null]
+	);
+
+	let img: HTMLImageElement;
+	let el_width = $state(0);
+	let el_height = $state(0);
+
+	async function handle_upload(
+		detail: Blob | File | FileData | FileData[],
+		n: number
+	): Promise<void> {
+		const file_data = Array.isArray(detail) ? detail : [detail as FileData];
+		const new_value = [value[0], value[1]] as [
+			FileData | null,
+			FileData | null
+		];
+		if (file_data.length > 1) {
+			new_value[n] = file_data[0];
+		} else {
+			new_value[n] = file_data[n];
+		}
+		value = new_value;
+		await tick();
+
+		onupload?.(new_value);
+	}
+
+	let old_value = "";
+
+	$effect(() => {
+		if (JSON.stringify(value) === old_value) return;
+		old_value = JSON.stringify(value);
+		value_ = value;
+	});
+
+	$effect(() => {
+		ondrag?.(dragging);
+	});
+</script>
+
+<BlockLabel {show_label} Icon={Image} label={label || i18n("image.image")} />
+
+<div
+	data-testid="image"
+	class="image-container"
+	bind:clientWidth={el_width}
+	bind:clientHeight={el_height}
+>
+	{#if value?.[0]?.url || value?.[1]?.url}
+		<ClearImage
+			onremove_image={() => {
+				position = 0.5;
+				value = [null, null];
+				onclear?.();
+			}}
+		/>
+	{/if}
+	{#if value?.[1]?.url}
+		<div class="icon-buttons">
+			{#if show_download_button}
+				<DownloadLink
+					href={value[1].url}
+					download={value[1].orig_name || "image"}
+				>
+					<IconButton Icon={Download} />
+				</DownloadLink>
+			{/if}
+		</div>
+	{/if}
+	<Slider
+		bind:position
+		disabled={upload_count == 2 || !value?.[0]}
+		{slider_color}
+	>
+		<div
+			class="upload-wrap"
+			style:display={upload_count === 2 ? "flex" : "block"}
+			class:side-by-side={upload_count === 2}
+		>
+			{#if !value_?.[0]}
+				<div class="wrap" class:half-wrap={upload_count === 1}>
+					<Upload
+						bind:upload_promise
+						bind:dragging
+						filetype="image/*"
+						onload={(e) => handle_upload(e, 0)}
+						disable_click={!!value?.[0]}
+						{root}
+						file_count="multiple"
+						{upload}
+						{stream_handler}
+						{max_file_size}
+					>
+						{#if children}{@render children()}{/if}
+					</Upload>
+				</div>
+			{:else}
+				<ImageEl
+					variant="upload"
+					src={value_[0]?.url}
+					alt=""
+					bind:img_el={img}
+					{max_height}
+				/>
+			{/if}
+
+			{#if !value_?.[1] && upload_count === 2}
+				<Upload
+					bind:upload_promise
+					bind:dragging
+					filetype="image/*"
+					onload={(e) => handle_upload(e, 1)}
+					disable_click={!!value?.[1]}
+					{root}
+					file_count="multiple"
+					{upload}
+					{stream_handler}
+					{max_file_size}
+				>
+					{#if children}{@render children()}{/if}
+				</Upload>
+			{:else if !value_?.[1] && upload_count === 1}
+				<div
+					class="empty-wrap fixed"
+					style:width="{el_width * (1 - position)}px"
+					style:transform="translateX({el_width * position}px)"
+					class:white-icon={!value?.[0]?.url}
+				>
+					<Empty unpadded_box={true} size="large"><Image /></Empty>
+				</div>
+			{:else if value_?.[1]}
+				<ImageEl
+					variant="upload"
+					src={value_[1].url}
+					alt=""
+					fixed={upload_count === 1}
+					transform="translate(0px, 0px) scale(1)"
+					{max_height}
+				/>
+			{/if}
+		</div>
+	</Slider>
+</div>
+
+<style>
+	.upload-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		height: 100%;
+		width: 100%;
+	}
+
+	.wrap {
+		width: 100%;
+	}
+
+	.half-wrap {
+		width: 50%;
+	}
+	.image-container,
+	.empty-wrap {
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.fixed {
+		--anim-block-background-fill: 255, 255, 255;
+		position: absolute;
+		top: 0;
+		left: 0;
+		background-color: rgba(var(--anim-block-background-fill), 0.8);
+		z-index: 0;
+	}
+
+	@media (prefers-color-scheme: dark) {
+		.fixed {
+			--anim-block-background-fill: 31, 41, 55;
+		}
+	}
+
+	.side-by-side :global(img) {
+		/* width: 100%; */
+		width: 50%;
+		object-fit: contain;
+	}
+
+	.empty-wrap {
+		pointer-events: none;
+	}
+
+	.icon-buttons {
+		display: flex;
+		position: absolute;
+		right: 8px;
+		z-index: var(--layer-top);
+		top: 8px;
+	}
+</style>

6.25.0/imageslider/shared/ImageEl.svelte

@@ -0,0 +1,141 @@
+<script lang="ts">
+	import type { HTMLImgAttributes } from "svelte/elements";
+	import { onMount, tick } from "svelte";
+	interface Props extends Omit<HTMLImgAttributes, "onload"> {
+		"data-testid"?: string;
+		fixed?: boolean;
+		transform?: string;
+		img_el?: HTMLImageElement | null;
+		hidden?: boolean;
+		variant?: "preview" | "upload";
+		max_height?: number;
+		fullscreen?: boolean;
+		onload?: (size: {
+			top: number;
+			left: number;
+			width: number;
+			height: number;
+		}) => void;
+	}
+
+	let {
+		src = undefined,
+		fullscreen = false,
+		fixed = false,
+		transform = "translate(0px, 0px) scale(1)",
+		img_el = $bindable<HTMLImageElement | null>(),
+		hidden = false,
+		variant = "upload",
+		max_height = 500,
+		onload,
+		...restProps
+	}: Props = $props();
+
+	function get_image_size(img: HTMLImageElement | null): {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	} {
+		if (!img) return { top: 0, left: 0, width: 0, height: 0 };
+		const container = img.parentElement?.getBoundingClientRect();
+
+		if (!container) return { top: 0, left: 0, width: 0, height: 0 };
+
+		const naturalAspect = img.naturalWidth / img.naturalHeight;
+		const containerAspect = container.width / container.height;
+		let displayedWidth, displayedHeight;
+
+		if (naturalAspect > containerAspect) {
+			displayedWidth = container.width;
+			displayedHeight = container.width / naturalAspect;
+		} else {
+			displayedHeight = container.height;
+			displayedWidth = container.height * naturalAspect;
+		}
+
+		const offsetX = (container.width - displayedWidth) / 2;
+		const offsetY = (container.height - displayedHeight) / 2;
+
+		return {
+			top: offsetY,
+			left: offsetX,
+			width: displayedWidth,
+			height: displayedHeight
+		};
+	}
+
+	onMount(() => {
+		const resizer = new ResizeObserver(async (entries) => {
+			for (const entry of entries) {
+				await tick();
+				onload?.(get_image_size(img_el));
+			}
+		});
+
+		resizer.observe(img_el!);
+
+		return () => {
+			resizer.disconnect();
+		};
+	});
+</script>
+
+<!-- svelte-ignore a11y-missing-attribute -->
+<img
+	{src}
+	data-testid="imageslider-image"
+	{...restProps}
+	class:fixed
+	style:transform
+	bind:this={img_el}
+	class:hidden
+	class:preview={variant === "preview"}
+	class:slider={variant === "upload"}
+	style:max-height={max_height && !fullscreen ? `${max_height}px` : null}
+	class:fullscreen
+	class:small={!fullscreen}
+	onload={() => onload?.(get_image_size(img_el))}
+/>
+
+<style>
+	.preview {
+		object-fit: contain;
+		width: 100%;
+		transform-origin: top left;
+		margin: auto;
+	}
+
+	.small {
+		max-height: 500px;
+	}
+
+	.upload {
+		object-fit: contain;
+		max-height: 500px;
+	}
+
+	.fixed {
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+	}
+
+	.fullscreen {
+		width: 100%;
+		height: 100%;
+	}
+
+	:global(.image-container:fullscreen) img {
+		width: 100%;
+		height: 100%;
+		max-height: none;
+		max-width: none;
+	}
+
+	.hidden {
+		opacity: 0;
+	}
+</style>

6.25.0/imageslider/shared/Slider.svelte

@@ -0,0 +1,216 @@
+<script lang="ts">
+	import { onMount, type Snippet } from "svelte";
+	import { drag } from "d3-drag";
+	import { select } from "d3-selection";
+
+	function clamp(value: number, min: number, max: number): number {
+		return Math.min(Math.max(value, min), max);
+	}
+
+	let {
+		position = $bindable(0.5),
+		disabled = false,
+		slider_color = "var(--border-color-primary)",
+		image_size = { top: 0, left: 0, width: 0, height: 0 },
+		el = $bindable<HTMLDivElement | undefined>(undefined),
+		parent_el = $bindable<HTMLDivElement | undefined>(undefined),
+		children
+	}: {
+		position?: number;
+		disabled?: boolean;
+		slider_color?: string;
+		image_size?: {
+			top: number;
+			left: number;
+			width: number;
+			height: number;
+		};
+		el?: HTMLDivElement;
+		parent_el?: HTMLDivElement;
+		children?: Snippet;
+	} = $props();
+
+	let inner: Element;
+	let px = $state(0);
+	let active = $state(false);
+	let container_width = $state(0);
+
+	function set_position(width: number): void {
+		container_width = parent_el?.getBoundingClientRect().width || 0;
+		if (width === 0) {
+			image_size.width = el?.getBoundingClientRect().width || 0;
+		}
+
+		px = clamp(
+			image_size.width * position + image_size.left,
+			0,
+			container_width
+		);
+	}
+
+	function round(n: number, points: number): number {
+		const mod = Math.pow(10, points);
+		return Math.round((n + Number.EPSILON) * mod) / mod;
+	}
+
+	function update_position(x: number): void {
+		px = clamp(x, 0, container_width);
+		position = round((x - image_size.left) / image_size.width, 5);
+	}
+
+	function drag_start(event: any): void {
+		if (disabled) return;
+		active = true;
+		update_position(event.x);
+	}
+
+	function drag_move(event: any): void {
+		if (disabled) return;
+		update_position(event.x);
+	}
+
+	function drag_end(): void {
+		if (disabled) return;
+		active = false;
+	}
+
+	function update_position_from_pc(pc: number): void {
+		px = clamp(image_size.width * pc + image_size.left, 0, container_width);
+	}
+
+	$effect(() => {
+		set_position(image_size.width);
+	});
+	$effect(() => {
+		update_position_from_pc(position);
+	});
+
+	onMount(() => {
+		set_position(image_size.width);
+		const drag_handler = drag()
+			.on("start", drag_start)
+			.on("drag", drag_move)
+			.on("end", drag_end);
+		select(inner).call(drag_handler);
+	});
+</script>
+
+<svelte:window onresize={() => set_position(image_size.width)} />
+
+<div class="wrap" role="none" bind:this={parent_el}>
+	<div class="content" bind:this={el}>
+		{#if children}{@render children()}{/if}
+	</div>
+	<div
+		class="outer"
+		class:disabled
+		data-testid="slider"
+		bind:this={inner}
+		role="none"
+		style="transform: translateX({px}px)"
+		class:grab={active}
+	>
+		<span class="icon-wrap" class:active class:disabled
+			><span class="icon left">◢</span><span
+				class="icon center"
+				style:--color={slider_color}
+			></span><span class="icon right">◢</span></span
+		>
+		<div class="inner" style:--color={slider_color}></div>
+	</div>
+</div>
+
+<style>
+	.wrap {
+		position: relative;
+		width: 100%;
+		height: 100%;
+		z-index: var(--layer-1);
+		overflow: hidden;
+	}
+
+	.icon-wrap {
+		display: block;
+		position: absolute;
+		top: 50%;
+		transform: translate(-20.5px, -50%);
+		left: 10px;
+		width: 40px;
+		transition: 0.2s;
+		color: var(--body-text-color);
+		height: 30px;
+		border-radius: 5px;
+		background-color: var(--color-accent);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		z-index: var(--layer-3);
+		box-shadow: 0px 0px 5px 2px rgba(0, 0, 0, 0.3);
+		font-size: 12px;
+	}
+
+	.icon.left {
+		transform: rotate(135deg);
+		text-shadow: -1px -1px 1px rgba(0, 0, 0, 0.1);
+	}
+
+	.icon.right {
+		transform: rotate(-45deg);
+		text-shadow: -1px -1px 1px rgba(0, 0, 0, 0.1);
+	}
+
+	.icon.center {
+		display: block;
+		width: 1px;
+		height: 100%;
+		background-color: var(--color);
+		opacity: 0.1;
+	}
+
+	.icon-wrap.active {
+		opacity: 0;
+	}
+
+	.icon-wrap.disabled {
+		opacity: 0;
+	}
+
+	.outer {
+		width: 20px;
+		height: 100%;
+		position: absolute;
+		cursor: grab;
+		position: absolute;
+		top: 0;
+		left: -10px;
+		pointer-events: auto;
+		z-index: var(--layer-2);
+	}
+	.grab {
+		cursor: grabbing;
+	}
+
+	.inner {
+		width: 1px;
+		height: 100%;
+		background: var(--color);
+		position: absolute;
+		left: calc((100% - 2px) / 2);
+	}
+
+	.disabled {
+		cursor: auto;
+	}
+
+	.disabled .inner {
+		box-shadow: none;
+	}
+
+	.content {
+		width: 100%;
+		height: 100%;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+</style>

6.25.0/imageslider/shared/SliderPreview.svelte

@@ -0,0 +1,270 @@
+<script lang="ts">
+	import Slider from "./Slider.svelte";
+	import ImageEl from "./ImageEl.svelte";
+	import {
+		BlockLabel,
+		Empty,
+		IconButton,
+		IconButtonWrapper,
+		FullscreenButton,
+		DownloadLink
+	} from "@gradio/atoms";
+	import type { CustomButton as CustomButtonType } from "@gradio/utils";
+	import { Image, Download, Undo, Clear } from "@gradio/icons";
+	import { type FileData } from "@gradio/client";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { ZoomableImage } from "./zoom";
+	import { onMount } from "svelte";
+	import { tweened, type Tweened } from "svelte/motion";
+
+	let {
+		value = $bindable<[null | FileData, null | FileData]>([null, null]),
+		label = undefined,
+		show_download_button = true,
+		show_label,
+		i18n,
+		position = $bindable(0.5),
+		layer_images = true,
+		show_single = false,
+		slider_color,
+		show_fullscreen_button = true,
+		fullscreen = $bindable(false),
+		buttons = null,
+		on_custom_button_click = null,
+		el_width = $bindable(0),
+		max_height,
+		interactive = true,
+		onclear,
+		onfullscreen
+	}: {
+		value?: [null | FileData, null | FileData];
+		label?: string;
+		show_download_button?: boolean;
+		show_label: boolean;
+		i18n: I18nFormatter;
+		position?: number;
+		layer_images?: boolean;
+		show_single?: boolean;
+		slider_color: string;
+		show_fullscreen_button?: boolean;
+		fullscreen?: boolean;
+		buttons?: (string | CustomButtonType)[] | null;
+		on_custom_button_click?: ((id: number) => void) | null;
+		el_width?: number;
+		max_height: number;
+		interactive?: boolean;
+		onclear?: () => void;
+		onfullscreen?: (fullscreen: boolean) => void;
+	} = $props();
+
+	let img = $state<HTMLImageElement>();
+	let slider_wrap = $state<HTMLDivElement>();
+	let image_container: HTMLDivElement;
+
+	let transform: Tweened<{ x: number; y: number; z: number }> = tweened(
+		{ x: 0, y: 0, z: 1 },
+		{
+			duration: 75
+		}
+	);
+	let parent_el: HTMLDivElement;
+	let img_width = $state(0);
+	let viewport_width = $state(0);
+	let image_size = $state<{
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	}>({ top: 0, left: 0, width: 0, height: 0 });
+
+	let coords_at_viewport = $derived(
+		get_coords_at_viewport(
+			position,
+			viewport_width,
+			image_size.width,
+			image_size.left,
+			$transform.x,
+			$transform.z
+		)
+	);
+	let style = $derived(
+		layer_images ? `clip-path: inset(0 0 0 ${coords_at_viewport * 100}%)` : ""
+	);
+
+	function get_coords_at_viewport(
+		viewport_percent_x: number, // 0-1
+		viewportWidth: number,
+		image_width: number,
+		img_offset_x: number,
+		tx: number, // image translation x (in pixels)
+		scale: number // image scale (uniform)
+	): number {
+		const px_relative_to_image = viewport_percent_x * image_width;
+		const pixel_position = px_relative_to_image + img_offset_x;
+
+		const normalised_position = (pixel_position - tx) / scale;
+		const percent_position = normalised_position / viewportWidth;
+
+		return percent_position;
+	}
+
+	let zoomable_image: ZoomableImage | null = null;
+	let observer: ResizeObserver | null = null;
+
+	function init_image(
+		img: HTMLImageElement | undefined,
+		slider_wrap: HTMLDivElement | undefined
+	): void {
+		if (!img || !slider_wrap) return;
+		zoomable_image?.destroy();
+		observer?.disconnect();
+		img_width = img?.getBoundingClientRect().width || 0;
+		viewport_width = slider_wrap?.getBoundingClientRect().width || 0;
+		zoomable_image = new ZoomableImage(slider_wrap, img);
+		zoomable_image.subscribe(({ x, y, scale }) => {
+			transform.set({ x, y, z: scale });
+		});
+
+		observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				if (entry.target === slider_wrap) {
+					viewport_width = entry.contentRect.width;
+				}
+
+				if (entry.target === img) {
+					img_width = entry.contentRect.width;
+				}
+			}
+		});
+		observer.observe(slider_wrap);
+		observer.observe(img);
+	}
+
+	$effect(() => {
+		init_image(img, slider_wrap);
+	});
+
+	onMount(() => {
+		return () => {
+			zoomable_image?.destroy();
+			observer?.disconnect();
+		};
+	});
+
+	let slider_wrap_parent: HTMLDivElement;
+
+	function handle_image_load(size: {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	}): void {
+		image_size = size;
+	}
+</script>
+
+<BlockLabel {show_label} Icon={Image} label={label || i18n("image.image")} />
+{#if (value === null || value[0] === null || value[1] === null) && !show_single}
+	<Empty unpadded_box={true} size="large"><Image /></Empty>
+{:else}
+	<div class="image-container" bind:this={image_container}>
+		<IconButtonWrapper {buttons} {on_custom_button_click}>
+			<IconButton
+				Icon={Undo}
+				label={i18n("common.undo")}
+				disabled={$transform.z === 1}
+				onclick={() => zoomable_image?.reset_zoom()}
+			/>
+			{#if show_fullscreen_button}
+				<FullscreenButton
+					{fullscreen}
+					onclick={(is_fullscreen) => {
+						fullscreen = is_fullscreen;
+						onfullscreen?.(is_fullscreen);
+					}}
+				/>
+			{/if}
+
+			{#if show_download_button}
+				<DownloadLink
+					href={value[1]?.url}
+					download={value[1]?.orig_name || "image"}
+				>
+					<IconButton Icon={Download} label={i18n("common.download")} />
+				</DownloadLink>
+			{/if}
+			{#if interactive}
+				<IconButton
+					Icon={Clear}
+					label="Remove Image"
+					onclick={(event) => {
+						value = [null, null];
+						onclear?.();
+						event.stopPropagation();
+					}}
+				/>
+			{/if}
+		</IconButtonWrapper>
+		<div
+			class="slider-wrap"
+			bind:this={slider_wrap_parent}
+			bind:clientWidth={el_width}
+			class:limit_height={!fullscreen}
+		>
+			<Slider
+				bind:position
+				{slider_color}
+				bind:el={slider_wrap}
+				bind:parent_el
+				{image_size}
+			>
+				<ImageEl
+					src={value?.[0]?.url}
+					alt=""
+					loading="lazy"
+					bind:img_el={img}
+					variant="preview"
+					transform="translate({$transform.x}px, {$transform.y}px) scale({$transform.z})"
+					{fullscreen}
+					{max_height}
+					onload={handle_image_load}
+				/>
+				<ImageEl
+					variant="preview"
+					fixed={layer_images}
+					hidden={!value?.[1]?.url}
+					src={value?.[1]?.url}
+					alt=""
+					loading="lazy"
+					style="{style}; background: var(--block-background-fill);"
+					transform="translate({$transform.x}px, {$transform.y}px) scale({$transform.z})"
+					{fullscreen}
+					{max_height}
+					onload={handle_image_load}
+				/>
+			</Slider>
+		</div>
+	</div>
+{/if}
+
+<style>
+	.slider-wrap {
+		user-select: none;
+		height: 100%;
+		width: 100%;
+		position: relative;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.limit_height :global(img) {
+		max-height: 500px;
+	}
+
+	.image-container {
+		height: 100%;
+		position: relative;
+		min-width: var(--size-20);
+	}
+</style>

6.25.0/imageslider/shared/SliderUpload.svelte

@@ -0,0 +1,69 @@
+<script lang="ts">
+	import type { Snippet } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import Image from "./Image.svelte";
+	import { type Client } from "@gradio/client";
+
+	import type { FileData } from "@gradio/client";
+
+	let {
+		value = $bindable<[FileData | null, FileData | null]>([null, null]),
+		upload,
+		stream_handler,
+		label,
+		show_label,
+		i18n,
+		root,
+		upload_count = 1,
+		dragging = $bindable(false),
+		max_height,
+		max_file_size = null,
+		upload_promise = $bindable(),
+		onclear,
+		ondrag,
+		onupload,
+		children
+	}: {
+		value?: [FileData | null, FileData | null];
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		label: string;
+		show_label: boolean;
+		i18n: I18nFormatter;
+		root: string;
+		upload_count?: number;
+		dragging?: boolean;
+		max_height: number;
+		max_file_size?: number | null;
+		upload_promise?: Promise<any>;
+		onclear?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onupload?: (value: [FileData | null, FileData | null]) => void;
+		children?: Snippet;
+	} = $props();
+</script>
+
+<Image
+	bind:upload_promise
+	slider_color="var(--border-color-primary)"
+	position={0.5}
+	bind:value
+	bind:dragging
+	{root}
+	{onclear}
+	ondrag={(detail) => {
+		dragging = detail;
+		ondrag?.(detail);
+	}}
+	{onupload}
+	{label}
+	{show_label}
+	{upload_count}
+	{stream_handler}
+	{upload}
+	{max_file_size}
+	{max_height}
+	{i18n}
+>
+	{#if children}{@render children()}{/if}
+</Image>

6.25.0/imageslider/shared/zoom.ts

@@ -0,0 +1,487 @@
+export class ZoomableImage {
+	container: HTMLDivElement;
+	image: HTMLImageElement;
+	scale: number;
+	offsetX: number;
+	offsetY: number;
+	isDragging: boolean;
+	lastX: number;
+	lastY: number;
+	initial_left_padding: number;
+	initial_top_padding: number;
+	initial_width: number;
+	initial_height: number;
+	subscribers: (({
+		x,
+		y,
+		scale
+	}: {
+		x: number;
+		y: number;
+		scale: number;
+	}) => void)[];
+	handleImageLoad: () => void;
+	real_image_size: {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	} = { top: 0, left: 0, width: 0, height: 0 };
+
+	last_touch_distance: number;
+
+	constructor(container: HTMLDivElement, image: HTMLImageElement) {
+		this.container = container;
+		this.image = image;
+
+		this.scale = 1;
+		this.offsetX = 0;
+		this.offsetY = 0;
+		this.isDragging = false;
+		this.lastX = 0;
+		this.lastY = 0;
+		this.initial_left_padding = 0;
+		this.initial_top_padding = 0;
+		this.initial_width = 0;
+		this.initial_height = 0;
+		this.subscribers = [];
+		this.last_touch_distance = 0;
+
+		this.handleWheel = this.handleWheel.bind(this);
+		this.handleMouseDown = this.handleMouseDown.bind(this);
+		this.handleMouseMove = this.handleMouseMove.bind(this);
+		this.handleMouseUp = this.handleMouseUp.bind(this);
+		this.handleImageLoad = this.init.bind(this);
+		this.handleTouchStart = this.handleTouchStart.bind(this);
+		this.handleTouchMove = this.handleTouchMove.bind(this);
+		this.handleTouchEnd = this.handleTouchEnd.bind(this);
+
+		this.image.addEventListener("load", this.handleImageLoad);
+
+		this.container.addEventListener("wheel", this.handleWheel);
+		this.container.addEventListener("mousedown", this.handleMouseDown);
+		document.addEventListener("mousemove", this.handleMouseMove);
+		document.addEventListener("mouseup", this.handleMouseUp);
+
+		this.container.addEventListener("touchstart", this.handleTouchStart);
+		document.addEventListener("touchmove", this.handleTouchMove);
+		document.addEventListener("touchend", this.handleTouchEnd);
+
+		const observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				if (entry.target === this.container) {
+					this.handleResize();
+					this.get_image_size(this.image);
+				}
+			}
+		});
+		observer.observe(this.container);
+	}
+
+	handleResize(): void {
+		this.init();
+	}
+
+	init(): void {
+		const containerRect = this.container.getBoundingClientRect();
+
+		const imageRect = this.image.getBoundingClientRect();
+		this.initial_left_padding = imageRect.left - containerRect.left;
+		this.initial_top_padding = imageRect.top - containerRect.top;
+		this.initial_width = imageRect.width;
+		this.initial_height = imageRect.height;
+
+		this.reset_zoom();
+
+		this.updateTransform();
+	}
+
+	reset_zoom(): void {
+		this.scale = 1;
+		this.offsetX = 0;
+		this.offsetY = 0;
+		this.updateTransform();
+	}
+
+	handleMouseDown(e: MouseEvent): void {
+		const imageRect = this.image.getBoundingClientRect();
+
+		if (
+			e.clientX >= imageRect.left &&
+			e.clientX <= imageRect.right &&
+			e.clientY >= imageRect.top &&
+			e.clientY <= imageRect.bottom
+		) {
+			e.preventDefault();
+			if (this.scale === 1) return;
+			this.isDragging = true;
+			this.lastX = e.clientX;
+			this.lastY = e.clientY;
+			this.image.style.cursor = "grabbing";
+		}
+	}
+
+	handleMouseMove(e: MouseEvent): void {
+		if (!this.isDragging) return;
+
+		const deltaX = e.clientX - this.lastX;
+		const deltaY = e.clientY - this.lastY;
+
+		this.offsetX += deltaX;
+		this.offsetY += deltaY;
+
+		this.lastX = e.clientX;
+		this.lastY = e.clientY;
+
+		this.updateTransform();
+
+		this.updateTransform();
+	}
+
+	handleMouseUp(): void {
+		if (this.isDragging) {
+			this.constrain_to_bounds(true);
+			this.updateTransform();
+			this.isDragging = false;
+			this.image.style.cursor = this.scale > 1 ? "grab" : "zoom-in";
+		}
+	}
+
+	async handleWheel(e: WheelEvent): Promise<void> {
+		e.preventDefault();
+
+		const containerRect = this.container.getBoundingClientRect();
+		const imageRect = this.image.getBoundingClientRect();
+
+		if (
+			e.clientX < imageRect.left ||
+			e.clientX > imageRect.right ||
+			e.clientY < imageRect.top ||
+			e.clientY > imageRect.bottom
+		) {
+			return;
+		}
+
+		const zoomFactor = 1.05;
+		const oldScale = this.scale;
+		const newScale =
+			-Math.sign(e.deltaY) > 0
+				? Math.min(15, oldScale * zoomFactor) // in
+				: Math.max(1, oldScale / zoomFactor); // out
+
+		if (newScale === oldScale) return;
+
+		const cursorX = e.clientX - containerRect.left - this.initial_left_padding;
+		const cursorY = e.clientY - containerRect.top - this.initial_top_padding;
+
+		this.scale = newScale;
+		this.offsetX = this.compute_new_offset({
+			cursor_position: cursorX,
+			current_offset: this.offsetX,
+			new_scale: newScale,
+			old_scale: oldScale
+		});
+		this.offsetY = this.compute_new_offset({
+			cursor_position: cursorY,
+			current_offset: this.offsetY,
+			new_scale: newScale,
+			old_scale: oldScale
+		});
+
+		this.updateTransform(); // apply before constraints
+
+		this.constrain_to_bounds();
+		this.updateTransform(); // apply again after constraints
+
+		this.image.style.cursor = this.scale > 1 ? "grab" : "zoom-in";
+	}
+
+	// compute_offset_for_positions({ position: number, scale: number }) {
+	// 	return position - (scale / this.scale) * (position - this.offset);
+	// }
+
+	compute_new_position({
+		position,
+		scale,
+		anchor_position
+	}: {
+		position: number;
+		scale: number;
+		anchor_position: number;
+	}): number {
+		return position - (position - anchor_position) * (scale / this.scale);
+	}
+
+	compute_new_offset({
+		cursor_position,
+		current_offset,
+		new_scale,
+		old_scale
+	}: {
+		cursor_position: number;
+		current_offset: number;
+		new_scale: number;
+		old_scale: number;
+	}): number {
+		return (
+			cursor_position -
+			(new_scale / old_scale) * (cursor_position - current_offset)
+		);
+	}
+
+	constrain_to_bounds(pan = false): void {
+		if (this.scale === 1) {
+			this.offsetX = 0;
+			this.offsetY = 0;
+			return;
+		}
+		const onscreen = {
+			top: this.real_image_size.top * this.scale + this.offsetY,
+			left: this.real_image_size.left * this.scale + this.offsetX,
+			width: this.real_image_size.width * this.scale,
+			height: this.real_image_size.height * this.scale,
+
+			bottom:
+				this.real_image_size.top * this.scale +
+				this.offsetY +
+				this.real_image_size.height * this.scale,
+			right:
+				this.real_image_size.left * this.scale +
+				this.offsetX +
+				this.real_image_size.width * this.scale
+		};
+
+		const real_image_size_right =
+			this.real_image_size.left + this.real_image_size.width;
+		const real_image_size_bottom =
+			this.real_image_size.top + this.real_image_size.height;
+
+		if (pan) {
+			if (onscreen.top > this.real_image_size.top) {
+				this.offsetY = this.calculate_position(
+					this.real_image_size.top,
+					0,
+					"y"
+				);
+			} else if (onscreen.bottom < real_image_size_bottom) {
+				this.offsetY = this.calculate_position(real_image_size_bottom, 1, "y");
+			}
+
+			if (onscreen.left > this.real_image_size.left) {
+				this.offsetX = this.calculate_position(
+					this.real_image_size.left,
+					0,
+					"x"
+				);
+			} else if (onscreen.right < real_image_size_right) {
+				this.offsetX = this.calculate_position(real_image_size_right, 1, "x");
+			}
+		}
+	}
+
+	updateTransform(): void {
+		this.notify({ x: this.offsetX, y: this.offsetY, scale: this.scale });
+	}
+
+	destroy(): void {
+		this.container.removeEventListener("wheel", this.handleWheel);
+		this.container.removeEventListener("mousedown", this.handleMouseDown);
+		document.removeEventListener("mousemove", this.handleMouseMove);
+		document.removeEventListener("mouseup", this.handleMouseUp);
+		this.container.removeEventListener("touchstart", this.handleTouchStart);
+		document.removeEventListener("touchmove", this.handleTouchMove);
+		document.removeEventListener("touchend", this.handleTouchEnd);
+		this.image.removeEventListener("load", this.handleImageLoad);
+	}
+
+	subscribe(
+		cb: ({ x, y, scale }: { x: number; y: number; scale: number }) => void
+	): void {
+		this.subscribers.push(cb);
+	}
+
+	unsubscribe(
+		cb: ({ x, y, scale }: { x: number; y: number; scale: number }) => void
+	): void {
+		this.subscribers = this.subscribers.filter(
+			(subscriber) => subscriber !== cb
+		);
+	}
+
+	notify({ x, y, scale }: { x: number; y: number; scale: number }): void {
+		this.subscribers.forEach((subscriber) => subscriber({ x, y, scale }));
+	}
+
+	handleTouchStart(e: TouchEvent): void {
+		e.preventDefault();
+		const imageRect = this.image.getBoundingClientRect();
+		const touch = e.touches[0];
+
+		if (
+			touch.clientX >= imageRect.left &&
+			touch.clientX <= imageRect.right &&
+			touch.clientY >= imageRect.top &&
+			touch.clientY <= imageRect.bottom
+		) {
+			if (e.touches.length === 1 && this.scale > 1) {
+				// one finger == prepare pan
+				this.isDragging = true;
+				this.lastX = touch.clientX;
+				this.lastY = touch.clientY;
+			} else if (e.touches.length === 2) {
+				// two fingers == prepare pinch zoom
+				const touch1 = e.touches[0];
+				const touch2 = e.touches[1];
+				this.last_touch_distance = Math.hypot(
+					touch2.clientX - touch1.clientX,
+					touch2.clientY - touch1.clientY
+				);
+			}
+		}
+	}
+
+	get_image_size(img: HTMLImageElement | null): void {
+		if (!img) return;
+		const container = img.parentElement?.getBoundingClientRect();
+
+		if (!container) return;
+
+		const naturalAspect = img.naturalWidth / img.naturalHeight;
+		const containerAspect = container.width / container.height;
+		let displayedWidth, displayedHeight;
+
+		if (naturalAspect > containerAspect) {
+			displayedWidth = container.width;
+			displayedHeight = container.width / naturalAspect;
+		} else {
+			displayedHeight = container.height;
+			displayedWidth = container.height * naturalAspect;
+		}
+
+		const offsetX = (container.width - displayedWidth) / 2;
+		const offsetY = (container.height - displayedHeight) / 2;
+
+		this.real_image_size = {
+			top: offsetY,
+			left: offsetX,
+			width: displayedWidth,
+			height: displayedHeight
+		};
+	}
+
+	handleTouchMove(e: TouchEvent): void {
+		if (e.touches.length === 1 && this.isDragging) {
+			// one finger == pan
+			e.preventDefault();
+			const touch = e.touches[0];
+
+			const deltaX = touch.clientX - this.lastX;
+			const deltaY = touch.clientY - this.lastY;
+
+			this.offsetX += deltaX;
+			this.offsetY += deltaY;
+
+			this.lastX = touch.clientX;
+			this.lastY = touch.clientY;
+
+			this.updateTransform();
+		} else if (e.touches.length === 2) {
+			// two fingers == pinch zoom
+			e.preventDefault();
+
+			const touch1 = e.touches[0];
+			const touch2 = e.touches[1];
+
+			const current_distance = Math.hypot(
+				touch2.clientX - touch1.clientX,
+				touch2.clientY - touch1.clientY
+			);
+
+			if (this.last_touch_distance === 0) {
+				this.last_touch_distance = current_distance;
+				return;
+			}
+
+			const zoomFactor = current_distance / this.last_touch_distance;
+
+			const oldScale = this.scale;
+			const newScale = Math.min(15, Math.max(1, oldScale * zoomFactor));
+
+			if (newScale === oldScale) {
+				this.last_touch_distance = current_distance;
+				return;
+			}
+
+			// midpoint of touches relative to image
+			const containerRect = this.container.getBoundingClientRect();
+			const midX =
+				(touch1.clientX + touch2.clientX) / 2 -
+				containerRect.left -
+				this.initial_left_padding;
+			const midY =
+				(touch1.clientY + touch2.clientY) / 2 -
+				containerRect.top -
+				this.initial_top_padding;
+
+			this.scale = newScale;
+			this.offsetX = this.compute_new_offset({
+				cursor_position: midX,
+				current_offset: this.offsetX,
+				new_scale: newScale,
+				old_scale: oldScale
+			});
+			this.offsetY = this.compute_new_offset({
+				cursor_position: midY,
+				current_offset: this.offsetY,
+				new_scale: newScale,
+				old_scale: oldScale
+			});
+
+			this.updateTransform();
+			this.constrain_to_bounds();
+			this.updateTransform();
+
+			this.last_touch_distance = current_distance;
+
+			this.image.style.cursor = this.scale > 1 ? "grab" : "zoom-in";
+		}
+	}
+
+	handleTouchEnd(e: TouchEvent): void {
+		if (this.isDragging) {
+			this.constrain_to_bounds(true);
+			this.updateTransform();
+			this.isDragging = false;
+		}
+
+		if (e.touches.length === 0) {
+			this.last_touch_distance = 0;
+		}
+	}
+
+	calculate_position(
+		screen_coord: number,
+		image_anchor: number,
+		axis: "x" | "y"
+	): number {
+		const containerRect = this.container.getBoundingClientRect();
+
+		// Calculate X offset if requested
+		if (axis === "x") {
+			const relative_screen_x = screen_coord;
+			const anchor_x =
+				this.real_image_size.left + image_anchor * this.real_image_size.width;
+			return relative_screen_x - anchor_x * this.scale;
+		}
+
+		// Calculate Y offset if requested
+		if (axis === "y") {
+			const relative_screen_y = screen_coord;
+			const anchor_y =
+				this.real_image_size.top + image_anchor * this.real_image_size.height;
+			return relative_screen_y - anchor_y * this.scale;
+		}
+
+		return 0;
+	}
+}

6.25.0/imageslider/types.ts

@@ -0,0 +1,37 @@
+import type {
+	SelectData,
+	ValueData,
+	ShareData,
+	CustomButton
+} from "@gradio/utils";
+import type { ILoadingStatus as LoadingStatus } from "@gradio/statustracker";
+import type { FileData } from "@gradio/client";
+
+export interface ImageSliderEvents {
+	input: never;
+	change: never;
+	error: string;
+	edit: never;
+	stream: ValueData;
+	drag: never;
+	upload: never;
+	clear: never;
+	select: SelectData;
+	share: ShareData;
+	clear_status: LoadingStatus;
+	close_stream: string;
+	custom_button_click: { id: number };
+}
+
+export interface ImageSliderProps {
+	value: [FileData | null, FileData | null];
+	height: number | undefined;
+	width: number | undefined;
+	placeholder: string | undefined;
+	buttons: (string | CustomButton)[];
+	input_ready: boolean;
+	slider_position: number;
+	upload_count: number;
+	slider_color: string;
+	max_height: number;
+}