Add files using upload-large-folder tool

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/build/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@self/build",
+	"version": "0.1.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"main": "out/index.js",
+	"private": "true",
+	"author": "",
+	"license": "ISC",
+	"scripts": {
+		"build": "esbuild src/index.ts --platform=node --format=esm --target=node18 --bundle --packages=external --outfile=out/index.js && cp src/component_loader.js out/"
+	},
+	"dependencies": {
+		"@gradio/theme": "workspace:^",
+		"esbuild": "^0.21.0",
+		"svelte-i18n": "^3.6.0"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"main_changeset": true,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/build"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/build/src/index.ts

@@ -0,0 +1,400 @@
+import type { Plugin } from "vite";
+import { parse, HTMLElement } from "node-html-parser";
+
+import { join } from "path";
+import { writeFileSync } from "fs";
+
+export function inject_ejs(): Plugin {
+	return {
+		name: "inject-ejs",
+		enforce: "post",
+		transformIndexHtml: (html) => {
+			const replace_gradio_info_info_html = html.replace(
+				/%gradio_api_info%/,
+				`<script>window.gradio_api_info = {{ gradio_api_info | toorjson }};</script>`
+			);
+			return replace_gradio_info_info_html.replace(
+				/%gradio_config%/,
+				`<script>window.gradio_config = {{ config | toorjson }};</script>`
+			);
+		}
+	};
+}
+
+export function generate_cdn_entry({
+	version,
+	cdn_base
+}: {
+	version: string;
+	cdn_base: string;
+}): Plugin {
+	return {
+		name: "generate-cdn-entry",
+		enforce: "post",
+		writeBundle(config, bundle) {
+			if (
+				!config.dir ||
+				!bundle["index.html"] ||
+				bundle["index.html"].type !== "asset"
+			)
+				return;
+
+			const source = bundle["index.html"].source as string;
+			const tree = parse(source);
+
+			const script = Array.from(
+				tree.querySelectorAll("script[type=module]")
+			).find((node) => node.attributes.src?.includes("assets"));
+
+			const output_location = join(config.dir, "gradio.js");
+
+			writeFileSync(output_location, make_entry(script?.attributes.src || ""));
+
+			if (!script) return;
+
+			const transformed_html =
+				(bundle["index.html"].source as string).substring(0, script?.range[0]) +
+				`<script type="module" crossorigin src="${cdn_base}/${version}/gradio.js"></script>` +
+				(bundle["index.html"].source as string).substring(
+					script?.range[1],
+					source.length
+				);
+
+			const share_html_location = join(config.dir, "share.html");
+			writeFileSync(share_html_location, transformed_html);
+		}
+	};
+}
+
+const RE_SVELTE_IMPORT =
+	/import\s+([\w*{},\s]+)\s+from\s+['"](svelte|svelte\/internal)['"]/g;
+
+export function generate_dev_entry({ enable }: { enable: boolean }): Plugin {
+	return {
+		name: "generate-dev-entry",
+		transform(code, id) {
+			if (!enable) return;
+
+			const new_code = code.replace(RE_SVELTE_IMPORT, (str, $1, $2) => {
+				return `const ${$1
+					.replace(/\* as /, "")
+					.replace(/ as /g, ": ")} = window.__gradio__svelte__internal;`;
+			});
+
+			return {
+				code: new_code,
+				map: null
+			};
+		}
+	};
+}
+
+function make_entry(script: string): string {
+	return `import("${script}");
+`;
+}
+
+export function handle_ce_css(): Plugin {
+	return {
+		enforce: "post",
+		name: "custom-element-css",
+
+		writeBundle(config, bundle) {
+			let file_to_insert = {
+				filename: "",
+				source: ""
+			};
+
+			if (
+				!config.dir ||
+				!bundle["index.html"] ||
+				bundle["index.html"].type !== "asset"
+			)
+				return;
+
+			for (const key in bundle) {
+				const chunk = bundle[key];
+				if (chunk.type === "chunk") {
+					const _chunk = chunk;
+
+					const found = _chunk.code?.indexOf("ENTRY_CSS");
+
+					if (found > -1)
+						file_to_insert = {
+							filename: join(config.dir, key),
+							source: _chunk.code
+						};
+				}
+			}
+
+			const tree = parse(bundle["index.html"].source as string);
+
+			const { style, fonts } = Array.from(
+				tree.querySelectorAll("link[rel=stylesheet]")
+			).reduce(
+				(acc, next) => {
+					if (/.*\/index(.*?)\.css/.test(next.attributes.href)) {
+						return { ...acc, style: next };
+					}
+					return { ...acc, fonts: [...acc.fonts, next.attributes.href] };
+				},
+				{ fonts: [], style: undefined } as {
+					fonts: string[];
+					style: HTMLElement | undefined;
+				}
+			);
+
+			writeFileSync(
+				file_to_insert.filename,
+				file_to_insert.source
+					.replace("__ENTRY_CSS__", style!.attributes.href)
+					.replace(
+						'"__FONTS_CSS__"',
+						`[${fonts.map((f) => `"${f}"`).join(",")}]`
+					)
+			);
+
+			const share_html_location = join(config.dir, "share.html");
+			const share_html = readFileSync(share_html_location, "utf8");
+			const share_tree = parse(share_html);
+			const node = Array.from(
+				share_tree.querySelectorAll("link[rel=stylesheet]")
+			).find((node) => /.*\/index(.*?)\.css/.test(node.attributes.href));
+
+			if (!node) return;
+			const transformed_html =
+				share_html.substring(0, node.range[0]) +
+				share_html.substring(node.range[1], share_html.length);
+
+			writeFileSync(share_html_location, transformed_html);
+		}
+	};
+}
+
+// generate component importsy
+
+import * as url from "url";
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+
+import { readdirSync, existsSync, readFileSync, statSync } from "fs";
+
+function get_export_path(
+	path: string,
+	root: string,
+	pkg_json: Record<string, any>
+): boolean {
+	if (!pkg_json.exports) return false;
+	if ( typeof pkg_json.exports[`${path}`] === "object") return true;
+	const _path = join(root, "..", `${pkg_json.exports[`${path}`]}`);
+
+	return existsSync(_path);
+}
+
+const ignore_list = [
+	"tootils",
+	"_cdn-test",
+	"_spaces-test",
+	"_website",
+	"app",
+	"atoms",
+	"fallback",
+	"icons",
+	"lite",
+	"preview",
+	"simpledropdown",
+	"simpleimage",
+	"simpletextbox",
+	"storybook",
+	"theme",
+	"timeseries",
+	"tooltip",
+	"upload",
+	"utils",
+	"wasm"
+];
+function generate_component_imports(): string {
+	const exports = readdirSync(join(__dirname, "..", ".."))
+		.map((dir) => {
+			if (ignore_list.includes(dir)) return undefined;
+			if (!statSync(join(__dirname, "..","..", dir)).isDirectory()) return undefined;
+
+			const package_json_path = join(__dirname, "..","..", dir, "package.json");
+			if (existsSync(package_json_path)) {
+				const package_json = JSON.parse(
+					readFileSync(package_json_path, "utf8")
+				);
+
+				const component = get_export_path(".", package_json_path, package_json);
+				const example = get_export_path(
+					"./example",
+					package_json_path,
+					package_json
+				);
+
+				const base = get_export_path("./base", package_json_path, package_json);
+
+				if (!component && !example) return undefined;
+
+				return {
+					name: package_json.name,
+					component,
+					example,
+					base
+				};
+			}
+			return undefined;
+		})
+		.filter((x) => x !== undefined);
+
+
+	const imports = exports.reduce((acc, _export) => {
+		if (!_export) return acc;
+
+		const example = _export.example
+			? `example: () => import("${_export.name}/example"),\n`
+			: "";
+		const base = _export.base
+			? `base: () => import("${_export.name}/base"),\n`
+			: "";
+		return `${acc}"${_export.name.replace("@gradio/", "")}": {
+			${base}
+			${example}
+			component: () => import("${_export.name}")
+			},\n`;
+	}, "");
+
+	return imports;
+}
+
+function load_virtual_component_loader(mode: string): string {
+	const loader_path = join(__dirname, "component_loader.js");
+	let component_map = "";
+
+	if (mode === "test") {
+		component_map = `
+		const component_map = {
+			"test-component-one": {
+				component: () => import("@gradio-test/test-one"),
+				example: () => import("@gradio-test/test-one/example")
+			},
+			"dataset": {
+				component: () => import("@gradio-test/test-two"),
+				example: () => import("@gradio-test/test-two/example")
+			},
+			"image": {
+				component: () => import("@gradio/image"),
+				example: () => import("@gradio/image/example"),
+				base: () => import("@gradio/image/base")
+			},
+			"audio": {
+				component: () => import("@gradio/audio"),
+				example: () => import("@gradio/audio/example"),
+				base: () => import("@gradio/audio/base")
+			},
+			"video": {
+				component: () => import("@gradio/video"),
+				example: () => import("@gradio/video/example"),
+				base: () => import("@gradio/video/base")
+			},
+			// "test-component-one": {
+			// 	component: () => import("@gradio-test/test-one"),
+			// 	example: () => import("@gradio-test/test-one/example")
+			// },
+		};
+		`;
+	} else {
+		component_map = `
+		const component_map = {
+			${generate_component_imports()}
+		};
+		`;
+	}
+
+	return `${component_map}\n\n${readFileSync(loader_path, "utf8")}`;
+}
+
+export function inject_component_loader({ mode }: { mode: string }): Plugin {
+	const v_id = "virtual:component-loader";
+	const resolved_v_id = "\0" + v_id;
+
+	return {
+		name: "inject-component-loader",
+		enforce: "pre",
+		resolveId(id: string) {
+			if (id === v_id) return resolved_v_id;
+		},
+		load(id: string) {
+			this.addWatchFile(join(__dirname, "component_loader.js"));
+			if (id === resolved_v_id) {
+				return load_virtual_component_loader(mode);
+			}
+		}
+	};
+}
+
+export function resolve_svelte(enable: boolean): Plugin {
+	return {
+		enforce: "pre",
+		name: "resolve-svelte",
+		async resolveId(id: string) {
+			if (!enable) return;
+
+			if (
+				id === "./svelte/svelte.js" ||
+				id === "svelte" ||
+				id === "svelte/internal"
+			) {
+				const mod = join(
+					__dirname,
+					"..",
+					"..",
+					"..",
+					"gradio",
+					"templates",
+					"frontend",
+					"assets",
+					"svelte",
+					"svelte.js"
+				);
+				return { id: mod, external: "absolute" };
+			}
+		}
+	};
+}
+
+export function mock_modules(): Plugin {
+	const v_id_1 = "@gradio-test/test-one";
+	const v_id_2 = "@gradio-test/test-two";
+	const v_id_1_example = "@gradio-test/test-one/example";
+	const v_id_2_example = "@gradio-test/test-two/example";
+	const resolved_v_id = "\0" + v_id_1;
+	const resolved_v_id_2 = "\0" + v_id_2;
+	const resolved_v_id_1_example = "\0" + v_id_1_example;
+	const resolved_v_id_2_example = "\0" + v_id_2_example;
+	const fallback_example = "@gradio/fallback/example";
+	const resolved_fallback_example = "\0" + fallback_example;
+
+	return {
+		name: "mock-modules",
+		enforce: "pre",
+		resolveId(id: string) {
+			if (id === v_id_1) return resolved_v_id;
+			if (id === v_id_2) return resolved_v_id_2;
+			if (id === v_id_1_example) return resolved_v_id_1_example;
+			if (id === v_id_2_example) return resolved_v_id_2_example;
+			if (id === fallback_example) return resolved_fallback_example;
+		},
+		load(id: string) {
+			if (
+				id === resolved_v_id ||
+				id === resolved_v_id_2 ||
+				id === resolved_v_id_1_example ||
+				id === resolved_v_id_2_example ||
+				id === resolved_fallback_example
+			) {
+				return `export default {}`;
+			}
+		}
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/ButtonPanel.svelte

@@ -0,0 +1,119 @@
+<script lang="ts">
+	import LikeDislike from "./LikeDislike.svelte";
+	import Copy from "./Copy.svelte";
+	import type { FileData } from "@gradio/client";
+	import DownloadIcon from "./Download.svelte";
+	import { DownloadLink } from "@gradio/wasm/svelte";
+	import type { NormalisedMessage, TextMessage } from "../types";
+	import { is_component_message } from "./utils";
+	import { Retry, Undo } from "@gradio/icons";
+	import { IconButtonWrapper, IconButton } from "@gradio/atoms";
+
+	export let likeable: boolean;
+	export let show_retry: boolean;
+	export let show_undo: boolean;
+	export let show_copy_button: boolean;
+	export let show: boolean;
+	export let message: NormalisedMessage | NormalisedMessage[];
+	export let position: "right" | "left";
+	export let avatar: FileData | null;
+	export let generating: boolean;
+
+	export let handle_action: (selected: string | null) => void;
+	export let layout: "bubble" | "panel";
+
+	function is_all_text(
+		message: NormalisedMessage[] | NormalisedMessage
+	): message is TextMessage[] | TextMessage {
+		return (
+			(Array.isArray(message) &&
+				message.every((m) => typeof m.content === "string")) ||
+			(!Array.isArray(message) && typeof message.content === "string")
+		);
+	}
+
+	function all_text(message: TextMessage[] | TextMessage): string {
+		if (Array.isArray(message)) {
+			return message.map((m) => m.content).join("\n");
+		}
+		return message.content;
+	}
+
+	$: message_text = is_all_text(message) ? all_text(message) : "";
+
+	$: show_copy = show_copy_button && message && is_all_text(message);
+	$: show_download =
+		!Array.isArray(message) &&
+		is_component_message(message) &&
+		message.content.value?.url;
+</script>
+
+{#if show}
+	<div
+		class="message-buttons-{position} {layout} message-buttons {avatar !==
+			null && 'with-avatar'}"
+	>
+		<IconButtonWrapper top_panel={false}>
+			{#if show_copy}
+				<Copy value={message_text} />
+			{/if}
+			{#if show_download && !Array.isArray(message) && is_component_message(message)}
+				<DownloadLink
+					href={message?.content?.value.url}
+					download={message.content.value.orig_name || "image"}
+				>
+					<IconButton Icon={DownloadIcon} />
+				</DownloadLink>
+			{/if}
+			{#if show_retry}
+				<IconButton
+					Icon={Retry}
+					label="Retry"
+					on:click={() => handle_action("retry")}
+					disabled={generating}
+				/>
+			{/if}
+			{#if show_undo}
+				<IconButton
+					label="Undo"
+					Icon={Undo}
+					on:click={() => handle_action("undo")}
+					disabled={generating}
+				/>
+			{/if}
+			{#if likeable}
+				<LikeDislike {handle_action} />
+			{/if}
+		</IconButtonWrapper>
+	</div>
+{/if}
+
+<style>
+	.bubble :global(.icon-button-wrapper) {
+		margin: 0px calc(var(--spacing-xl) * 2);
+	}
+
+	.message-buttons-left {
+		align-self: flex-start;
+	}
+
+	.bubble.message-buttons-right {
+		align-self: flex-end;
+	}
+
+	.message-buttons-right :global(.icon-button-wrapper) {
+		margin-left: auto;
+	}
+
+	.bubble.with-avatar {
+		margin-left: calc(var(--spacing-xl) * 5);
+		margin-right: calc(var(--spacing-xl) * 5);
+	}
+
+	.panel {
+		display: flex;
+		align-self: flex-start;
+		padding: 0 var(--spacing-xl);
+		z-index: var(--layer-1);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/Component.svelte

@@ -0,0 +1,86 @@
+<script lang="ts">
+	export let type: "gallery" | "plot" | "audio" | "video" | "image" | string;
+	export let components;
+	export let value;
+	export let target;
+	export let theme_mode;
+	export let props;
+	export let i18n;
+	export let upload;
+	export let _fetch;
+</script>
+
+{#if type === "gallery"}
+	<svelte:component
+		this={components[type]}
+		{value}
+		show_label={false}
+		{i18n}
+		label=""
+		{_fetch}
+		allow_preview={false}
+		interactive={false}
+		mode="minimal"
+		fixed_height={1}
+		on:load
+	/>
+{:else if type === "plot"}
+	<svelte:component
+		this={components[type]}
+		{value}
+		{target}
+		{theme_mode}
+		bokeh_version={props.bokeh_version}
+		caption=""
+		show_actions_button={true}
+		on:load
+	/>
+{:else if type === "audio"}
+	<svelte:component
+		this={components[type]}
+		{value}
+		show_label={false}
+		show_share_button={true}
+		{i18n}
+		label=""
+		waveform_settings={{}}
+		waveform_options={{}}
+		show_download_button={false}
+		on:load
+	/>
+{:else if type === "video"}
+	<svelte:component
+		this={components[type]}
+		autoplay={true}
+		value={value.video || value}
+		show_label={false}
+		show_share_button={true}
+		{i18n}
+		{upload}
+		show_download_button={false}
+		on:load
+	>
+		<track kind="captions" />
+	</svelte:component>
+{:else if type === "image"}
+	<svelte:component
+		this={components[type]}
+		{value}
+		show_label={false}
+		label="chatbot-image"
+		show_download_button={false}
+		on:load
+		{i18n}
+	/>
+{:else if type === "html"}
+	<svelte:component
+		this={components[type]}
+		{value}
+		show_label={false}
+		label="chatbot-image"
+		show_share_button={true}
+		{i18n}
+		gradio={{ dispatch: () => {} }}
+		on:load
+	/>
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/Copy.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+	import { onDestroy } from "svelte";
+	import { Copy, Check } from "@gradio/icons";
+	import { IconButton } from "@gradio/atoms";
+
+	let copied = false;
+	export let value: string;
+	let timer: NodeJS.Timeout;
+
+	function copy_feedback(): void {
+		copied = true;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			copied = false;
+		}, 2000);
+	}
+
+	async function handle_copy(): Promise<void> {
+		if ("clipboard" in navigator) {
+			await navigator.clipboard.writeText(value);
+			copy_feedback();
+		} else {
+			const textArea = document.createElement("textarea");
+			textArea.value = value;
+
+			textArea.style.position = "absolute";
+			textArea.style.left = "-999999px";
+
+			document.body.prepend(textArea);
+			textArea.select();
+
+			try {
+				document.execCommand("copy");
+				copy_feedback();
+			} catch (error) {
+				console.error(error);
+			} finally {
+				textArea.remove();
+			}
+		}
+	}
+
+	onDestroy(() => {
+		if (timer) clearTimeout(timer);
+	});
+</script>
+
+<IconButton
+	on:click={handle_copy}
+	label={copied ? "Copied message" : "Copy message"}
+	Icon={copied ? Check : Copy}
+/>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/Remove.svelte

@@ -0,0 +1,11 @@
+<svg
+	id="fi_3502539"
+	fill="currentColor"
+	height="100%"
+	viewBox="0 0 24 24"
+	width="100%"
+	xmlns="http://www.w3.org/2000/svg"
+	><path
+		d="m7 16a1 1 0 0 0 .71-.3 1 1 0 0 0 0-1.41l-3.33-3.29h10.13a4.49 4.49 0 0 1 0 9h-2.51a1 1 0 0 0 0 2h2.51a6.49 6.49 0 0 0 0-13h-10.14l3.33-3.29a1 1 0 0 0 -1.4-1.42l-5.07 5a1 1 0 0 0 -.29.71 1 1 0 0 0 .3.71l5.06 5a1 1 0 0 0 .7.29z"
+	></path></svg
+>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/ThumbDownDefault.svelte

@@ -0,0 +1,12 @@
+<svg
+	width="100%"
+	height="100%"
+	viewBox="0 0 12 12"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M2.25 8.11523H4.5V10.3652C4.5003 10.6635 4.61892 10.9495 4.82983 11.1604C5.04075 11.3713 5.32672 11.4899 5.625 11.4902H6.42488C6.60519 11.4895 6.77926 11.4241 6.91549 11.3059C7.05172 11.1878 7.14109 11.0248 7.16737 10.8464L7.48425 8.62748L8.82562 6.61523H11.25V1.36523H3.375C2.67911 1.36623 2.01201 1.64311 1.51994 2.13517C1.02787 2.62724 0.750992 3.29435 0.75 3.99023V6.61523C0.750496 7.01291 0.908691 7.39415 1.18989 7.67535C1.47109 7.95654 1.85233 8.11474 2.25 8.11523ZM9 2.11523H10.5V5.86523H9V2.11523ZM1.5 3.99023C1.5006 3.49314 1.69833 3.01657 2.04983 2.66507C2.40133 2.31356 2.8779 2.11583 3.375 2.11523H8.25V6.12661L6.76575 8.35298L6.4245 10.7402H5.625C5.52554 10.7402 5.43016 10.7007 5.35983 10.6304C5.28951 10.5601 5.25 10.4647 5.25 10.3652V7.36523H2.25C2.05118 7.36494 1.86059 7.28582 1.72 7.14524C1.57941 7.00465 1.5003 6.81406 1.5 6.61523V3.99023Z"
+		fill="currentColor"
+	/>
+</svg>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/ThumbUpActive.svelte

@@ -0,0 +1,12 @@
+<svg
+	width="100%"
+	height="100%"
+	viewBox="0 0 12 12"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M0.75 6.24023H2.625V11.4902H0.75V6.24023ZM8.625 11.4902H3.375V5.93911L4.51575 4.22798L4.83263 2.00911C4.85892 1.83065 4.94834 1.66754 5.08465 1.5494C5.22096 1.43125 5.39512 1.36591 5.5755 1.36523H5.625C5.92328 1.36553 6.20925 1.48415 6.42017 1.69507C6.63108 1.90598 6.7497 2.19196 6.75 2.49023V4.74023H9.75C10.1477 4.74073 10.5289 4.89893 10.8101 5.18012C11.0913 5.46132 11.2495 5.84256 11.25 6.24023V8.86523C11.249 9.56112 10.9721 10.2282 10.4801 10.7203C9.98799 11.2124 9.32089 11.4892 8.625 11.4902Z"
+		fill="currentColor"
+	/>
+</svg>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/column/Index.svelte

@@ -0,0 +1,75 @@
+<script lang="ts">
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { Gradio } from "@gradio/utils";
+
+	export let scale: number | null = null;
+	export let gap = true;
+	export let min_width = 0;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let variant: "default" | "panel" | "compact" = "default";
+	export let loading_status: LoadingStatus | undefined = undefined;
+	export let gradio: Gradio | undefined = undefined;
+	export let show_progress = false;
+</script>
+
+<div
+	id={elem_id}
+	class="column {elem_classes.join(' ')}"
+	class:gap
+	class:compact={variant === "compact"}
+	class:panel={variant === "panel"}
+	class:hide={!visible}
+	style:flex-grow={scale}
+	style:min-width="calc(min({min_width}px, 100%))"
+>
+	{#if loading_status && show_progress && gradio}
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			status={loading_status
+				? loading_status.status == "pending"
+					? "generating"
+					: loading_status.status
+				: null}
+		/>
+	{/if}
+	<slot />
+</div>
+
+<style>
+	div {
+		display: flex;
+		position: relative;
+		flex-direction: column;
+	}
+
+	div > :global(*),
+	div > :global(.form > *) {
+		width: var(--size-full);
+	}
+
+	.gap {
+		gap: var(--layout-gap);
+	}
+
+	.hide {
+		display: none;
+	}
+
+	.compact > :global(*),
+	.compact :global(.box) {
+		border-radius: 0;
+	}
+
+	.compact,
+	.panel {
+		border: solid var(--panel-border-width) var(--panel-border-color);
+		border-radius: var(--container-radius);
+		background: var(--panel-background-fill);
+		padding: var(--spacing-lg);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/file/Example.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+	import type { FileData } from "@gradio/client";
+
+	export let value: FileData | null;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value ? (Array.isArray(value) ? value.join(", ") : value) : ""}
+</div>
+
+<style>
+	div {
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.gallery {
+		display: flex;
+		align-items: center;
+		cursor: pointer;
+		padding: var(--size-1) var(--size-2);
+		text-align: left;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/file/Index.svelte

@@ -0,0 +1,126 @@
+<svelte:options accessors={true} />
+
+<script context="module" lang="ts">
+	export { default as FilePreview } from "./shared/FilePreview.svelte";
+	export { default as BaseFileUpload } from "./shared/FileUpload.svelte";
+	export { default as BaseFile } from "./shared/File.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import File from "./shared/File.svelte";
+	import FileUpload from "./shared/FileUpload.svelte";
+	import type { FileData } from "@gradio/client";
+	import { Block, UploadText } from "@gradio/atoms";
+
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: null | FileData | FileData[];
+
+	export let interactive: boolean;
+	export let root: string;
+	export let label: string;
+	export let show_label: boolean;
+	export let height: number | undefined = undefined;
+
+	export let _selectable = false;
+	export let loading_status: LoadingStatus;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let gradio: Gradio<{
+		change: never;
+		error: string;
+		upload: never;
+		clear: never;
+		select: SelectData;
+		clear_status: LoadingStatus;
+		delete: FileData;
+	}>;
+	export let file_count: "single" | "multiple" | "directory";
+	export let file_types: string[] = ["file"];
+	export let input_ready: boolean;
+	let uploading = false;
+	$: input_ready = !uploading;
+
+	let old_value = value;
+	$: if (JSON.stringify(old_value) !== JSON.stringify(value)) {
+		gradio.dispatch("change");
+		old_value = value;
+	}
+
+	let dragging = false;
+	let pending_upload = false;
+</script>
+
+<Block
+	{visible}
+	variant={value ? "solid" : "dashed"}
+	border_mode={dragging ? "focus" : "base"}
+	padding={false}
+	{elem_id}
+	{elem_classes}
+	{container}
+	{scale}
+	{min_width}
+	allow_overflow={false}
+>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		status={pending_upload
+			? "generating"
+			: loading_status?.status || "complete"}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+	{#if !interactive}
+		<File
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			selectable={_selectable}
+			{value}
+			{label}
+			{show_label}
+			{height}
+			i18n={gradio.i18n}
+		/>
+	{:else}
+		<FileUpload
+			upload={(...args) => gradio.client.upload(...args)}
+			stream_handler={(...args) => gradio.client.stream(...args)}
+			{label}
+			{show_label}
+			{value}
+			{file_count}
+			{file_types}
+			selectable={_selectable}
+			{root}
+			{height}
+			bind:uploading
+			max_file_size={gradio.max_file_size}
+			on:change={({ detail }) => {
+				value = detail;
+			}}
+			on:drag={({ detail }) => (dragging = detail)}
+			on:clear={() => gradio.dispatch("clear")}
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			on:upload={() => gradio.dispatch("upload")}
+			on:error={({ detail }) => {
+				loading_status = loading_status || {};
+				loading_status.status = "error";
+				gradio.dispatch("error", detail);
+			}}
+			on:delete={({ detail }) => {
+				gradio.dispatch("delete", detail);
+			}}
+			i18n={gradio.i18n}
+		>
+			<UploadText i18n={gradio.i18n} type="file" />
+		</FileUpload>
+	{/if}
+</Block>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/file/shared/File.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+	import type { FileData } from "@gradio/client";
+	import { BlockLabel, Empty } from "@gradio/atoms";
+	import { File } from "@gradio/icons";
+	import FilePreview from "./FilePreview.svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	export let value: FileData | FileData[] | null = null;
+	export let label: string;
+	export let show_label = true;
+	export let selectable = false;
+	export let height: number | undefined = undefined;
+	export let i18n: I18nFormatter;
+</script>
+
+<BlockLabel
+	{show_label}
+	float={value === null}
+	Icon={File}
+	label={label || "File"}
+/>
+
+{#if value && (Array.isArray(value) ? value.length > 0 : true)}
+	<FilePreview {i18n} {selectable} on:select {value} {height} />
+{:else}
+	<Empty unpadded_box={true} size="large"><File /></Empty>
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/file/shared/FilePreview.svelte

@@ -0,0 +1,201 @@
+<script lang="ts">
+	import type { FileData } from "@gradio/client";
+	import { prettyBytes } from "./utils";
+	import { createEventDispatcher } from "svelte";
+	import type { I18nFormatter, SelectData } from "@gradio/utils";
+	import { DownloadLink } from "@gradio/wasm/svelte";
+
+	const dispatch = createEventDispatcher<{
+		select: SelectData;
+		change: FileData[] | FileData;
+		delete: FileData;
+	}>();
+	export let value: FileData | FileData[];
+	export let selectable = false;
+	export let height: number | undefined = undefined;
+	export let i18n: I18nFormatter;
+
+	function split_filename(filename: string): [string, string] {
+		const last_dot = filename.lastIndexOf(".");
+		if (last_dot === -1) {
+			return [filename, ""];
+		}
+		return [filename.slice(0, last_dot), filename.slice(last_dot)];
+	}
+
+	$: normalized_files = (Array.isArray(value) ? value : [value]).map((file) => {
+		const [filename_stem, filename_ext] = split_filename(file.orig_name ?? "");
+		return {
+			...file,
+			filename_stem,
+			filename_ext
+		};
+	});
+
+	function handle_row_click(
+		event: MouseEvent & { currentTarget: HTMLTableRowElement },
+		index: number
+	): void {
+		const tr = event.currentTarget;
+		const should_select =
+			event.target === tr || // Only select if the click is on the row itself
+			(tr &&
+				tr.firstElementChild &&
+				event.composedPath().includes(tr.firstElementChild)); // Or if the click is on the name column
+
+		if (should_select) {
+			dispatch("select", { value: normalized_files[index].orig_name, index });
+		}
+	}
+
+	function remove_file(index: number): void {
+		const removed = normalized_files.splice(index, 1);
+		normalized_files = [...normalized_files];
+		value = normalized_files;
+		dispatch("delete", removed[0]);
+		dispatch("change", normalized_files);
+	}
+
+	const is_browser = typeof window !== "undefined";
+</script>
+
+<div
+	class="file-preview-holder"
+	style="max-height: {typeof height === undefined ? 'auto' : height + 'px'};"
+>
+	<table class="file-preview">
+		<tbody>
+			{#each normalized_files as file, i (file)}
+				<tr
+					class="file"
+					class:selectable
+					on:click={(event) => {
+						handle_row_click(event, i);
+					}}
+				>
+					<td class="filename" aria-label={file.orig_name}>
+						<span class="stem">{file.filename_stem}</span>
+						<span class="ext">{file.filename_ext}</span>
+					</td>
+
+					<td class="download">
+						{#if file.url}
+							<DownloadLink
+								href={file.url}
+								download={is_browser && window.__is_colab__
+									? null
+									: file.orig_name}
+							>
+								{@html file.size != null
+									? prettyBytes(file.size)
+									: "(size unknown)"}&nbsp;&#8675;
+							</DownloadLink>
+						{:else}
+							{i18n("file.uploading")}
+						{/if}
+					</td>
+
+					{#if normalized_files.length > 1}
+						<td>
+							<button
+								class="label-clear-button"
+								aria-label="Remove this file"
+								on:click={() => {
+									remove_file(i);
+								}}
+								on:keydown={(event) => {
+									if (event.key === "Enter") {
+										remove_file(i);
+									}
+								}}
+								>×
+							</button>
+						</td>
+					{/if}
+				</tr>
+			{/each}
+		</tbody>
+	</table>
+</div>
+
+<style>
+	.label-clear-button {
+		color: var(--body-text-color-subdued);
+		position: relative;
+		left: -3px;
+	}
+
+	.label-clear-button:hover {
+		color: var(--body-text-color);
+	}
+
+	.file-preview {
+		table-layout: fixed;
+		width: var(--size-full);
+		max-height: var(--size-60);
+		overflow-y: auto;
+		margin-top: var(--size-1);
+		color: var(--body-text-color);
+	}
+
+	.file-preview-holder {
+		overflow: auto;
+	}
+
+	.file {
+		display: flex;
+		width: var(--size-full);
+	}
+
+	.file > * {
+		padding: var(--size-1) var(--size-2-5);
+	}
+
+	.filename {
+		flex-grow: 1;
+		display: flex;
+		overflow: hidden;
+	}
+	.filename .stem {
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.filename .ext {
+		white-space: nowrap;
+	}
+
+	.download {
+		min-width: 8rem;
+		width: 10%;
+		white-space: nowrap;
+		text-align: right;
+	}
+	.download:hover {
+		text-decoration: underline;
+	}
+	.download > :global(a) {
+		color: var(--link-text-color);
+	}
+
+	.download > :global(a:hover) {
+		color: var(--link-text-color-hover);
+	}
+	.download > :global(a:visited) {
+		color: var(--link-text-color-visited);
+	}
+	.download > :global(a:active) {
+		color: var(--link-text-color-active);
+	}
+	.selectable {
+		cursor: pointer;
+	}
+
+	tbody > tr:nth-child(even) {
+		background: var(--block-background-fill);
+	}
+
+	tbody > tr:nth-child(odd) {
+		background: var(--table-odd-background-fill);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/fileexplorer/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "@gradio/fileexplorer",
+	"version": "0.5.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/checkbox": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/file": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"dequal": "^2.0.2"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"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"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/fileexplorer"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/shared/Image.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">
+	import type { HTMLImgAttributes } from "svelte/elements";
+
+	interface Props extends HTMLImgAttributes {
+		"data-testid"?: string;
+	}
+	type $$Props = Props;
+
+	import { resolve_wasm_src } from "@gradio/wasm/svelte";
+
+	export let src: HTMLImgAttributes["src"] = undefined;
+
+	let resolved_src: typeof src;
+
+	// The `src` prop can be updated before the Promise from `resolve_wasm_src` is resolved.
+	// In such a case, the resolved value for the old `src` has to be discarded,
+	// This variable `latest_src` is used to pick up only the value resolved for the latest `src` prop.
+	let latest_src: typeof src;
+	$: {
+		// In normal (non-Wasm) Gradio, the `<img>` element should be rendered with the passed `src` props immediately
+		// without waiting for `resolve_wasm_src()` to resolve.
+		// If it waits, a blank image is displayed until the async task finishes
+		// and it leads to undesirable flickering.
+		// So set `src` to `resolved_src` here.
+		resolved_src = src;
+
+		latest_src = src;
+		const resolving_src = src;
+		resolve_wasm_src(resolving_src).then((s) => {
+			if (latest_src === resolving_src) {
+				resolved_src = s;
+			}
+		});
+	}
+</script>
+
+<!-- svelte-ignore a11y-missing-attribute -->
+<img src={resolved_src} {...$$restProps} on:load />
+
+<style>
+	img {
+		object-fit: cover;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/Example.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">
+	import { BaseImage as Image } from "@gradio/image";
+	import type { EditorData } from "./shared/InteractiveImageEditor.svelte";
+
+	export let value: EditorData;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class="container"
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	<Image src={value.composite?.url || value.background?.url} alt="" />
+</div>
+
+<style>
+	.container :global(img) {
+		width: 100%;
+		height: 100%;
+	}
+
+	.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);
+		width: var(--size-20);
+		height: var(--size-20);
+		object-fit: cover;
+	}
+
+	.container.gallery {
+		border: 2px solid var(--border-color-primary);
+		height: var(--size-20);
+		max-height: var(--size-20);
+		object-fit: cover;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/Index.svelte

@@ -0,0 +1,226 @@
+<svelte:options accessors={true} immutable={true} />
+
+<script lang="ts">
+	import type { Brush, Eraser } from "./shared/tools/Brush.svelte";
+	import type {
+		EditorData,
+		ImageBlobs
+	} from "./shared/InteractiveImageEditor.svelte";
+
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import { BaseStaticImage as StaticImage } from "@gradio/image";
+	import InteractiveImageEditor from "./shared/InteractiveImageEditor.svelte";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import { tick } from "svelte";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: EditorData | null = {
+		background: null,
+		layers: [],
+		composite: null
+	};
+	export let label: string;
+	export let show_label: boolean;
+	export let show_download_button: boolean;
+	export let root: string;
+	export let value_is_output = false;
+
+	export let height: number | undefined = 450;
+	export let width: number | undefined;
+
+	export let _selectable = false;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let show_share_button = false;
+	export let sources: ("clipboard" | "webcam" | "upload")[] = [
+		"upload",
+		"clipboard",
+		"webcam"
+	];
+	export let interactive: boolean;
+	export let placeholder: string | undefined;
+
+	export let brush: Brush;
+	export let eraser: Eraser;
+	export let crop_size: [number, number] | `${string}:${string}` | null = null;
+	export let transforms: "crop"[] = ["crop"];
+	export let layers = true;
+	export let attached_events: string[] = [];
+	export let server: {
+		accept_blobs: (a: any) => void;
+	};
+	export let canvas_size: [number, number] | undefined;
+	export let show_fullscreen_button = true;
+
+	export let gradio: Gradio<{
+		change: never;
+		error: string;
+		input: never;
+		edit: never;
+		drag: never;
+		apply: never;
+		upload: never;
+		clear: never;
+		select: SelectData;
+		share: ShareData;
+		clear_status: LoadingStatus;
+	}>;
+
+	let editor_instance: InteractiveImageEditor;
+	let image_id: null | string = null;
+
+	export async function get_value(): Promise<ImageBlobs | { id: string }> {
+		if (image_id) {
+			const val = { id: image_id };
+			image_id = null;
+			return val;
+		}
+
+		const blobs = await editor_instance.get_data();
+
+		return blobs;
+	}
+
+	let dragging: boolean;
+
+	$: value && handle_change();
+	const is_browser = typeof window !== "undefined";
+	const raf = is_browser
+		? window.requestAnimationFrame
+		: (cb: (...args: any[]) => void) => cb();
+
+	function wait_for_next_frame(): Promise<void> {
+		return new Promise((resolve) => {
+			raf(() => raf(() => resolve()));
+		});
+	}
+
+	async function handle_change(): Promise<void> {
+		await wait_for_next_frame();
+
+		if (
+			value &&
+			(value.background || value.layers?.length || value.composite)
+		) {
+			gradio.dispatch("change");
+		}
+	}
+
+	function handle_save(): void {
+		gradio.dispatch("apply");
+	}
+
+	function handle_history_change(): void {
+		gradio.dispatch("change");
+		if (!value_is_output) {
+			gradio.dispatch("input");
+			tick().then((_) => (value_is_output = false));
+		}
+	}
+
+	$: has_value = value?.background || value?.layers?.length || value?.composite;
+</script>
+
+{#if !interactive}
+	<Block
+		{visible}
+		variant={"solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		{elem_id}
+		{elem_classes}
+		height={height || undefined}
+		{width}
+		allow_overflow={false}
+		{container}
+		{scale}
+		{min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+		<StaticImage
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => gradio.dispatch("error", detail)}
+			value={value?.composite || null}
+			{label}
+			{show_label}
+			{show_download_button}
+			selectable={_selectable}
+			{show_share_button}
+			i18n={gradio.i18n}
+			{show_fullscreen_button}
+		/>
+	</Block>
+{:else}
+	<Block
+		{visible}
+		variant={has_value ? "solid" : "dashed"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		{elem_id}
+		{elem_classes}
+		height={height || undefined}
+		{width}
+		allow_overflow={false}
+		{container}
+		{scale}
+		{min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+
+		<InteractiveImageEditor
+			bind:dragging
+			{canvas_size}
+			on:change={() => handle_history_change()}
+			bind:image_id
+			{crop_size}
+			{value}
+			bind:this={editor_instance}
+			{root}
+			{sources}
+			{label}
+			{show_label}
+			{height}
+			on:save={(e) => handle_save()}
+			on:edit={() => gradio.dispatch("edit")}
+			on:clear={() => gradio.dispatch("clear")}
+			on:drag={({ detail }) => (dragging = detail)}
+			on:upload={() => gradio.dispatch("upload")}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => {
+				loading_status = loading_status || {};
+				loading_status.status = "error";
+				gradio.dispatch("error", detail);
+			}}
+			on:error
+			{brush}
+			{eraser}
+			changeable={attached_events.includes("apply")}
+			realtime={attached_events.includes("change")}
+			i18n={gradio.i18n}
+			{transforms}
+			accept_blobs={server.accept_blobs}
+			{layers}
+			status={loading_status?.status}
+			upload={(...args) => gradio.client.upload(...args)}
+			stream_handler={(...args) => gradio.client.stream(...args)}
+			{placeholder}
+		></InteractiveImageEditor>
+	</Block>
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@gradio/imageeditor",
+	"version": "0.11.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/image": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@gradio/wasm": "workspace:^",
+		"@types/tinycolor2": "^1.4.6",
+		"pixi.js": "^7.3.2",
+		"tinycolor2": "^1.6.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"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"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/imageeditor"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/Controls.svelte

@@ -0,0 +1,78 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import { Undo, Redo, Check, Trash } from "@gradio/icons";
+
+	/**
+	 * Can the current image be undone?
+	 */
+	export let can_undo = false;
+	/**
+	 * Can the current image be redone?
+	 */
+	export let can_redo = false;
+
+	export let can_save = false;
+	export let changeable = false;
+
+	const dispatch = createEventDispatcher<{
+		/**
+		 * Remove the current image.
+		 */
+		remove_image: void;
+		/**
+		 * Undo the last action.
+		 */
+		undo: void;
+		/**
+		 * Redo the last action.
+		 */
+		redo: void;
+		/**
+		 * Save the current image.
+		 */
+		save: void;
+	}>();
+</script>
+
+<IconButtonWrapper>
+	{#if changeable}
+		<IconButton
+			disabled={!can_save}
+			Icon={Check}
+			label="Save changes"
+			on:click={(event) => {
+				dispatch("save");
+				event.stopPropagation();
+			}}
+			background={"var(--color-green-500)"}
+			color={"#fff"}
+		/>
+	{/if}
+	<IconButton
+		disabled={!can_undo}
+		Icon={Undo}
+		label="Undo"
+		on:click={(event) => {
+			dispatch("undo");
+			event.stopPropagation();
+		}}
+	/>
+	<IconButton
+		disabled={!can_redo}
+		Icon={Redo}
+		label="Redo"
+		on:click={(event) => {
+			dispatch("redo");
+			event.stopPropagation();
+		}}
+	/>
+	<IconButton
+		Icon={Trash}
+		label="Clear canvas"
+		on:click={(event) => {
+			dispatch("remove_image");
+			event.stopPropagation();
+		}}
+	/>
+</IconButtonWrapper>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/ImageEditor.svelte

@@ -0,0 +1,429 @@
+<script lang="ts" context="module">
+	import type { Writable, Readable } from "svelte/store";
+	import type { Spring } from "svelte/motion";
+	import { type PixiApp } from "./utils/pixi";
+	import { type CommandManager } from "./utils/commands";
+
+	export const EDITOR_KEY = Symbol("editor");
+	export type context_type = "bg" | "layers" | "crop" | "draw" | "erase";
+	type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>;
+	import { type tool } from "./tools";
+
+	export interface EditorContext {
+		pixi: Writable<PixiApp | null>;
+		current_layer: Writable<LayerScene | null>;
+		dimensions: Writable<[number, number]>;
+		editor_box: Writable<{
+			parent_width: number;
+			parent_height: number;
+			parent_left: number;
+			parent_top: number;
+			parent_right: number;
+			parent_bottom: number;
+			child_width: number;
+			child_height: number;
+			child_left: number;
+			child_top: number;
+			child_right: number;
+			child_bottom: number;
+		}>;
+		active_tool: Writable<tool>;
+		toolbar_box: Writable<DOMRect | Record<string, never>>;
+		crop: Writable<[number, number, number, number]>;
+		position_spring: Spring<{
+			x: number;
+			y: number;
+		}>;
+		command_manager: CommandManager;
+		current_history: CommandManager["current_history"];
+		register_context: (
+			type: context_type,
+			{
+				reset_fn,
+				init_fn
+			}: {
+				reset_fn?: () => void;
+				init_fn?: (dimensions?: [number, number]) => void;
+			}
+		) => void;
+		reset: (clear_image: boolean, dimensions: [number, number]) => void;
+	}
+</script>
+
+<script lang="ts">
+	import { onMount, setContext, createEventDispatcher, tick } from "svelte";
+	import { writable } from "svelte/store";
+	import { spring } from "svelte/motion";
+	import { Rectangle } from "pixi.js";
+
+	import { command_manager } from "./utils/commands";
+
+	import { type LayerScene } from "./layers/utils";
+	import { create_pixi_app, type ImageBlobs } from "./utils/pixi";
+	import Controls from "./Controls.svelte";
+	export let antialias = true;
+	export let crop_size: [number, number] | undefined;
+	export let changeable = false;
+	export let history: boolean;
+	export let bg = false;
+	export let sources: ("clipboard" | "webcam" | "upload")[];
+	const dispatch = createEventDispatcher<{
+		clear?: never;
+		save: void;
+		change: void;
+	}>();
+	export let crop_constraint = false;
+	export let canvas_size: [number, number] | undefined;
+	export let parent_height: number;
+
+	$: orig_canvas_size = canvas_size;
+
+	const BASE_DIMENSIONS: [number, number] = canvas_size || [800, 600];
+
+	let dimensions = writable(BASE_DIMENSIONS);
+	export let height = 0;
+
+	let editor_box: EditorContext["editor_box"] = writable({
+		parent_width: 0,
+		parent_height: parent_height,
+		parent_top: 0,
+		parent_left: 0,
+		parent_right: 0,
+		parent_bottom: 0,
+		child_width: 0,
+		child_height: parent_height,
+		child_top: 0,
+		child_left: 0,
+		child_right: 0,
+		child_bottom: 0
+	});
+
+	$: height = $editor_box.child_height;
+
+	const crop = writable<[number, number, number, number]>([0, 0, 1, 1]);
+	const position_spring = spring(
+		{ x: 0, y: 0 },
+		{
+			stiffness: 0.1,
+			damping: 0.5
+		}
+	);
+	const pixi = writable<PixiApp | null>(null);
+
+	const CommandManager = command_manager();
+
+	const { can_redo, can_undo, current_history } = CommandManager;
+
+	$: $current_history.previous, dispatch("change");
+
+	$: {
+		history = !!$current_history.previous || $active_tool !== "bg";
+	}
+	const is_browser = typeof window !== "undefined";
+
+	const active_tool: Writable<tool> = writable("bg");
+	const reset_context: Writable<PartialRecord<context_type, () => void>> =
+		writable({});
+	const init_context: Writable<
+		PartialRecord<context_type, (dimensions?: typeof $dimensions) => void>
+	> = writable({});
+	const contexts: Writable<context_type[]> = writable([]);
+	const toolbar_box: Writable<DOMRect | Record<string, never>> = writable(
+		is_browser ? new DOMRect() : {}
+	);
+
+	const sort_order = ["bg", "layers", "crop", "draw", "erase"] as const;
+	const editor_context = setContext<EditorContext>(EDITOR_KEY, {
+		pixi,
+		current_layer: writable(null),
+		dimensions,
+		editor_box,
+		toolbar_box,
+		active_tool,
+		crop,
+		position_spring,
+		command_manager: CommandManager,
+		current_history,
+		register_context: (
+			type: context_type,
+			{
+				reset_fn,
+				init_fn
+			}: {
+				reset_fn?: () => void;
+				init_fn?: (dimensions?: [number, number]) => void;
+			}
+		) => {
+			contexts.update((c) => [...c, type]);
+			init_context.update((c) => ({ ...c, [type]: init_fn }));
+			reset_context.update((c) => ({ ...c, [type]: reset_fn }));
+		},
+		reset: (clear_image: boolean, dimensions: [number, number]) => {
+			bg = false;
+
+			const _sorted_contexts = $contexts.sort((a, b) => {
+				return sort_order.indexOf(a) - sort_order.indexOf(b);
+			});
+			for (const k of _sorted_contexts) {
+				if (k in $reset_context && typeof $reset_context[k] === "function") {
+					$reset_context[k]?.();
+				}
+			}
+
+			for (const k of _sorted_contexts) {
+				if (k in $init_context && typeof $init_context[k] === "function") {
+					if (k === "bg" && !clear_image) {
+						continue;
+					} else {
+						$init_context[k]?.(dimensions);
+					}
+				}
+				CommandManager.reset();
+				$pixi?.resize?.(...dimensions);
+			}
+		}
+	});
+
+	let pixi_target: HTMLDivElement;
+
+	let canvas_wrap: HTMLDivElement;
+
+	function get_dimensions(parent: HTMLDivElement, child: HTMLDivElement): void {
+		if (!parent || !child) return;
+		const {
+			width: parent_width,
+			height: parent_height,
+			top: parent_top,
+			left: parent_left,
+			right: parent_right,
+			bottom: parent_bottom
+		} = canvas_wrap.getBoundingClientRect();
+		const {
+			width: child_width,
+			height: child_height,
+			top: child_top,
+			left: child_left,
+			right: child_right,
+			bottom: child_bottom
+		} = child.getBoundingClientRect();
+		editor_box.set({
+			child_width,
+			child_height,
+			child_left,
+			child_right,
+			child_top,
+			child_bottom,
+
+			parent_width,
+			parent_height,
+			parent_left,
+			parent_right,
+			parent_top,
+			parent_bottom
+		});
+	}
+
+	$: if (crop_constraint && bg && !history) {
+		set_crop();
+	}
+
+	function set_crop(): void {
+		requestAnimationFrame(() => {
+			tick().then((v) => ($active_tool = "crop"));
+		});
+	}
+
+	function reposition_canvas(): void {
+		if (!$editor_box) return;
+		const [l, t, w, h] = $crop;
+
+		const cx = l * $editor_box.child_width;
+		const cy = t * $editor_box.child_height;
+		const cw = w * $editor_box.child_width;
+		const ch = h * $editor_box.child_height;
+
+		const x = 0.5 * $editor_box.child_width - cx - cw / 2;
+		const y = 0.5 * $editor_box.child_height - cy - ch / 2;
+
+		position_spring.set({ x, y });
+	}
+
+	export async function get_blobs(): Promise<ImageBlobs> {
+		if (!$pixi || !$pixi.get_layers)
+			return { background: null, layers: [], composite: null };
+		const [l, t, w, h] = $crop;
+
+		return $pixi?.get_blobs(
+			$pixi.get_layers(),
+			new Rectangle(
+				Math.round(l * $dimensions[0]),
+				Math.round(t * $dimensions[1]),
+				Math.round(w * $dimensions[0]),
+				Math.round(h * $dimensions[1])
+			),
+			$dimensions
+		);
+	}
+
+	$: $crop && reposition_canvas();
+	$: $position_spring && get_dimensions(canvas_wrap, pixi_target);
+
+	export function handle_remove(): void {
+		editor_context.reset(
+			true,
+			orig_canvas_size ? orig_canvas_size : $dimensions
+		);
+		if (!sources.length) {
+			set_tool("draw");
+		} else {
+			set_tool("bg");
+		}
+		dispatch("clear");
+
+		let _size = (canvas_size ? canvas_size : crop_size) || [800, 600];
+		editor_context.reset(true, _size);
+	}
+
+	onMount(() => {
+		const _size = (canvas_size ? canvas_size : crop_size) || [800, 600];
+		const app = create_pixi_app({
+			target: pixi_target,
+			dimensions: _size,
+			antialias
+		});
+
+		function resize(width: number, height: number): void {
+			app.resize(width, height);
+			dimensions.set([width, height]);
+		}
+
+		pixi.set({ ...app, resize });
+
+		const resizer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				get_dimensions(canvas_wrap, pixi_target);
+			}
+		});
+
+		resizer.observe(canvas_wrap);
+		resizer.observe(pixi_target);
+
+		for (const k of $contexts) {
+			if (k in $init_context && typeof $init_context[k] === "function") {
+				$init_context[k]?.($dimensions);
+			}
+		}
+
+		resize(...$dimensions);
+
+		return () => {
+			$pixi?.destroy();
+			resizer.disconnect();
+			for (const k of $contexts) {
+				if (k in $reset_context) {
+					$reset_context[k]?.();
+				}
+			}
+		};
+	});
+
+	let saved_history: null | typeof $current_history = $current_history;
+
+	function handle_save(): void {
+		saved_history = $current_history;
+		dispatch("save");
+	}
+
+	export function set_tool(tool: tool): void {
+		$active_tool = tool;
+	}
+</script>
+
+<svelte:window on:scroll={() => get_dimensions(canvas_wrap, pixi_target)} />
+
+<div data-testid="image" class="image-container">
+	<Controls
+		can_undo={$can_undo}
+		can_redo={$can_redo}
+		can_save={saved_history !== $current_history}
+		{changeable}
+		on:undo={CommandManager.undo}
+		on:redo={CommandManager.redo}
+		on:remove_image={handle_remove}
+		on:save={handle_save}
+	/>
+	<div class="container">
+		<div class="wrap" bind:this={canvas_wrap}>
+			<div bind:this={pixi_target} class="stage-wrap" class:bg={!bg}></div>
+		</div>
+		<div class="tools-wrap">
+			<slot />
+		</div>
+		<div
+			class="canvas"
+			class:no-border={!bg && $active_tool === "bg" && !history}
+			style:width="{$crop[2] * $editor_box.child_width + 1}px"
+			style:height="{$crop[3] * $editor_box.child_height + 1}px"
+			style:top="{$crop[1] * $editor_box.child_height +
+				($editor_box.child_top - $editor_box.parent_top) -
+				0.5}px"
+			style:left="{$crop[0] * $editor_box.child_width +
+				($editor_box.child_left - $editor_box.parent_left) -
+				0.5}px"
+		></div>
+	</div>
+</div>
+
+<style>
+	.wrap {
+		display: flex;
+		width: 100%;
+		height: 100%;
+		position: relative;
+		justify-content: center;
+	}
+	.canvas {
+		position: absolute;
+		border: var(--block-border-color) 1px solid;
+		pointer-events: none;
+		border-radius: var(--radius-md);
+	}
+
+	.container {
+		position: relative;
+		margin: var(--spacing-md);
+	}
+
+	.no-border {
+		border: none;
+	}
+
+	.stage-wrap {
+		margin-bottom: var(--size-1);
+		border-radius: var(--radius-md);
+		overflow: hidden;
+		height: fit-content;
+		width: auto;
+	}
+
+	.tools-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		padding: 0 var(--spacing-xl) 0 0;
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--radius-sm);
+		margin: var(--spacing-xxl) 0 var(--spacing-xxl) 0;
+		width: fit-content;
+		margin: 0 auto;
+	}
+
+	.image-container {
+		display: flex;
+		height: 100%;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		max-height: 100%;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/InteractiveImageEditor.svelte

@@ -0,0 +1,331 @@
+<script lang="ts" context="module">
+	export interface EditorData {
+		background: FileData | null;
+		layers: FileData[] | null;
+		composite: FileData | null;
+	}
+
+	export interface ImageBlobs {
+		background: FileData | null;
+		layers: FileData[];
+		composite: FileData | null;
+	}
+</script>
+
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { type I18nFormatter } from "@gradio/utils";
+	import { prepare_files, type FileData, type Client } from "@gradio/client";
+
+	import ImageEditor from "./ImageEditor.svelte";
+	import Layers from "./layers/Layers.svelte";
+	import { type Brush as IBrush } from "./tools/Brush.svelte";
+	import { type Eraser } from "./tools/Brush.svelte";
+
+	import { Tools, Crop, Brush, Sources } from "./tools";
+	import { BlockLabel } from "@gradio/atoms";
+	import { Image as ImageIcon } from "@gradio/icons";
+	import { inject } from "./utils/parse_placeholder";
+
+	export let brush: IBrush | null;
+	export let eraser: Eraser | null;
+	export let sources: ("clipboard" | "webcam" | "upload")[];
+	export let crop_size: [number, number] | `${string}:${string}` | null = null;
+	export let i18n: I18nFormatter;
+	export let root: string;
+	export let label: string | undefined = undefined;
+	export let show_label: boolean;
+	export let changeable = false;
+	export let value: EditorData | null = {
+		background: null,
+		layers: [],
+		composite: null
+	};
+	export let transforms: "crop"[] = ["crop"];
+	export let layers: boolean;
+	export let accept_blobs: (a: any) => void;
+	export let status:
+		| "pending"
+		| "complete"
+		| "error"
+		| "generating"
+		| "streaming" = "complete";
+	export let canvas_size: [number, number] | undefined;
+	export let realtime: boolean;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let dragging: boolean;
+	export let placeholder: string | undefined = undefined;
+	export let height = 450;
+
+	const dispatch = createEventDispatcher<{
+		clear?: never;
+		upload?: never;
+		change?: never;
+	}>();
+
+	let editor: ImageEditor;
+
+	function is_not_null(o: Blob | null): o is Blob {
+		return !!o;
+	}
+
+	function is_file_data(o: null | FileData): o is FileData {
+		return !!o;
+	}
+
+	$: if (bg) dispatch("upload");
+
+	export async function get_data(): Promise<ImageBlobs> {
+		const blobs = await editor.get_blobs();
+
+		const bg = blobs.background
+			? upload(
+					await prepare_files([new File([blobs.background], "background.png")]),
+					root
+				)
+			: Promise.resolve(null);
+
+		const layers = blobs.layers
+			.filter(is_not_null)
+			.map(async (blob, i) =>
+				upload(await prepare_files([new File([blob], `layer_${i}.png`)]), root)
+			);
+
+		const composite = blobs.composite
+			? upload(
+					await prepare_files([new File([blobs.composite], "composite.png")]),
+					root
+				)
+			: Promise.resolve(null);
+
+		const [background, composite_, ...layers_] = await Promise.all([
+			bg,
+			composite,
+			...layers
+		]);
+
+		return {
+			background: Array.isArray(background) ? background[0] : background,
+			layers: layers_
+				.flatMap((layer) => (Array.isArray(layer) ? layer : [layer]))
+				.filter(is_file_data),
+			composite: Array.isArray(composite_) ? composite_[0] : composite_
+		};
+	}
+
+	function handle_value(value: EditorData | null): void {
+		if (!editor) return;
+		if (value == null) {
+			editor.handle_remove();
+		}
+	}
+
+	$: handle_value(value);
+
+	$: crop_constraint = crop_size;
+	let bg = false;
+	let history = false;
+
+	export let image_id: null | string = null;
+
+	$: editor &&
+		editor.set_tool &&
+		(sources && sources.length
+			? editor.set_tool("bg")
+			: editor.set_tool("draw"));
+
+	type BinaryImages = [string, string, File, number | null][];
+
+	function nextframe(): Promise<void> {
+		return new Promise((resolve) => setTimeout(() => resolve(), 30));
+	}
+
+	let uploading = false;
+	let pending = false;
+	async function handle_change(e: CustomEvent<Blob | any>): Promise<void> {
+		if (!realtime) return;
+		if (uploading) {
+			pending = true;
+			return;
+		}
+
+		uploading = true;
+
+		await nextframe();
+		const blobs = await editor.get_blobs();
+
+		const images: BinaryImages = [];
+
+		let id = Math.random().toString(36).substring(2);
+
+		if (blobs.background)
+			images.push([
+				id,
+				"background",
+				new File([blobs.background], "background.png"),
+				null
+			]);
+		if (blobs.composite)
+			images.push([
+				id,
+				"composite",
+				new File([blobs.composite], "composite.png"),
+				null
+			]);
+		blobs.layers.forEach((layer, i) => {
+			if (layer)
+				images.push([
+					id as string,
+					`layer`,
+					new File([layer], `layer_${i}.png`),
+					i
+				]);
+		});
+
+		await Promise.all(
+			images.map(async ([image_id, type, data, index]) => {
+				return accept_blobs({
+					binary: true,
+					data: { file: data, id: image_id, type, index }
+				});
+			})
+		);
+		image_id = id;
+		dispatch("change");
+
+		await nextframe();
+		uploading = false;
+		if (pending) {
+			pending = false;
+			uploading = false;
+			handle_change(e);
+		}
+	}
+
+	let active_mode: "webcam" | "color" | null = null;
+	let editor_height = height - 100;
+
+	$: [heading, paragraph] = placeholder ? inject(placeholder) : [false, false];
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={ImageIcon}
+	label={label || i18n("image.image")}
+/>
+<ImageEditor
+	{canvas_size}
+	crop_size={Array.isArray(crop_size) ? crop_size : undefined}
+	bind:this={editor}
+	bind:height={editor_height}
+	parent_height={height}
+	{changeable}
+	on:save
+	on:change={handle_change}
+	on:clear={() => dispatch("clear")}
+	bind:history
+	bind:bg
+	{sources}
+	crop_constraint={!!crop_constraint}
+>
+	<Tools {i18n}>
+		<Layers layer_files={value?.layers || null} enable_layers={layers} />
+
+		<Sources
+			bind:dragging
+			{i18n}
+			{root}
+			{sources}
+			{upload}
+			{stream_handler}
+			bind:bg
+			bind:active_mode
+			background_file={value?.background || value?.composite || null}
+		></Sources>
+
+		{#if transforms.includes("crop")}
+			<Crop {crop_constraint} />
+		{/if}
+		{#if brush}
+			<Brush
+				color_mode={brush.color_mode}
+				default_color={brush.default_color}
+				default_size={brush.default_size}
+				colors={brush.colors}
+				mode="draw"
+			/>
+		{/if}
+
+		{#if brush && eraser}
+			<Brush default_size={eraser.default_size} mode="erase" />
+		{/if}
+	</Tools>
+
+	{#if !bg && !history && active_mode !== "webcam" && status !== "error"}
+		<div class="empty wrap" style:height={`${editor_height}px`}>
+			{#if sources && sources.length}
+				{#if heading || paragraph}
+					{#if heading}
+						<h2>{heading}</h2>
+					{/if}
+					{#if paragraph}
+						<p>{paragraph}</p>
+					{/if}
+				{:else}
+					<div>Upload an image</div>
+				{/if}
+			{/if}
+
+			{#if sources && sources.length && brush && !placeholder}
+				<div class="or">or</div>
+			{/if}
+			{#if brush && !placeholder}
+				<div>select the draw tool to start</div>
+			{/if}
+		</div>
+	{/if}
+</ImageEditor>
+
+<style>
+	h2 {
+		font-size: var(--text-xl);
+	}
+
+	p,
+	h2 {
+		white-space: pre-line;
+	}
+
+	.empty {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		position: absolute;
+		height: 100%;
+		width: 100%;
+		left: 0;
+		right: 0;
+		margin: auto;
+		z-index: var(--layer-top);
+		text-align: center;
+		color: var(--body-text-color);
+		top: var(--size-8);
+	}
+
+	.wrap {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		color: var(--block-label-text-color);
+		line-height: var(--line-md);
+		font-size: var(--text-md);
+		pointer-events: none;
+	}
+
+	.or {
+		color: var(--body-text-color-subdued);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/layers/Layers.svelte

@@ -0,0 +1,235 @@
+<script lang="ts">
+	import { getContext, onMount, tick } from "svelte";
+
+	import { click_outside } from "../utils/events";
+	import { layer_manager, type LayerScene } from "./utils";
+	import { EDITOR_KEY, type EditorContext } from "../ImageEditor.svelte";
+	import type { FileData } from "@gradio/client";
+	import { Layers } from "@gradio/icons";
+
+	let show_layers = false;
+
+	export let layer_files: (FileData | null)[] | null = [];
+	export let enable_layers = true;
+
+	const { pixi, current_layer, dimensions, register_context } =
+		getContext<EditorContext>(EDITOR_KEY);
+
+	const LayerManager = layer_manager();
+	let layers: LayerScene[] = [];
+
+	register_context("layers", {
+		init_fn: () => {
+			new_layer();
+		},
+		reset_fn: () => {
+			LayerManager.reset();
+		}
+	});
+
+	async function validate_layers(): Promise<void> {
+		let invalid = layers.some(
+			(layer) =>
+				layer.composite.texture?.width != $dimensions[0] ||
+				layer.composite.texture?.height != $dimensions[1]
+		);
+		if (invalid) {
+			LayerManager.reset();
+			if (!layer_files || layer_files.length == 0) new_layer();
+			else render_layer_files(layer_files);
+		}
+	}
+	$: $dimensions, validate_layers();
+
+	async function new_layer(): Promise<void> {
+		if (!$pixi) return;
+
+		const [active_layer, all_layers] = LayerManager.add_layer(
+			$pixi.layer_container,
+			$pixi.renderer,
+			...$dimensions
+		);
+
+		$current_layer = active_layer;
+		layers = all_layers;
+	}
+
+	$: render_layer_files(layer_files);
+
+	function is_not_null<T>(x: T | null): x is T {
+		return x !== null;
+	}
+
+	async function render_layer_files(
+		_layer_files: typeof layer_files
+	): Promise<void> {
+		await tick();
+		if (!_layer_files || _layer_files.length == 0) {
+			LayerManager.reset();
+			new_layer();
+			return;
+		}
+		if (!$pixi) return;
+
+		const fetch_promises = await Promise.all(
+			_layer_files.map((f) => {
+				if (!f || !f.url) return null;
+
+				return fetch(f.url);
+			})
+		);
+
+		const blobs = await Promise.all(
+			fetch_promises.map((p) => {
+				if (!p) return null;
+				return p.blob();
+			})
+		);
+
+		LayerManager.reset();
+
+		let last_layer: [LayerScene, LayerScene[]] | null = null;
+		for (const blob of blobs.filter(is_not_null)) {
+			last_layer = await LayerManager.add_layer_from_blob(
+				$pixi.layer_container,
+				$pixi.renderer,
+				blob,
+				$pixi.view
+			);
+		}
+
+		if (!last_layer) return;
+
+		$current_layer = last_layer[0];
+		layers = last_layer[1];
+	}
+
+	onMount(async () => {
+		await tick();
+		if (!$pixi) return;
+
+		$pixi = { ...$pixi!, get_layers: LayerManager.get_layers };
+	});
+</script>
+
+{#if enable_layers}
+	<div
+		class="layer-wrap"
+		class:closed={!show_layers}
+		use:click_outside={() => (show_layers = false)}
+	>
+		<button
+			aria-label="Show Layers"
+			on:click={() => (show_layers = !show_layers)}
+			><span class="icon"><Layers /></span> Layer {layers.findIndex(
+				(l) => l === $current_layer
+			) + 1}
+		</button>
+		{#if show_layers}
+			<ul>
+				{#each layers as layer, i (i)}
+					<li>
+						<button
+							class:selected_layer={$current_layer === layer}
+							on:click={() =>
+								($current_layer = LayerManager.change_active_layer(i))}
+							>Layer {i + 1}</button
+						>
+					</li>
+				{/each}
+				<li>
+					<button aria-label="Add Layer" on:click={new_layer}> +</button>
+				</li>
+			</ul>
+		{/if}
+
+		<span class="sep"></span>
+	</div>
+{/if}
+
+<style>
+	.icon {
+		width: 14px;
+		margin-right: var(--spacing-md);
+		color: var(--block-label-text-color);
+		margin-right: var(--spacing-lg);
+		margin-top: 1px;
+	}
+
+	.layer-wrap {
+		position: relative;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+
+	.layer-wrap button {
+		justify-content: flex-start;
+		align-items: flex-start;
+		width: 100%;
+		border-bottom: 1px solid var(--block-border-color);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		font-size: var(--scale-000);
+		line-height: var(--line-sm);
+		padding-bottom: 1px;
+		margin-left: var(--spacing-xl);
+		padding: var(--spacing-sm) 0;
+	}
+
+	.layer-wrap li:last-child button {
+		border-bottom: none;
+		text-align: center;
+		font-size: var(--scale-0);
+		line-height: 1;
+		font-weight: var(--weight-bold);
+		padding: 5px 0 1px 0;
+	}
+
+	.closed > button {
+		border-bottom: none;
+	}
+
+	.layer-wrap button:hover {
+		background-color: none;
+	}
+
+	.layer-wrap button:hover .icon {
+		color: var(--color-accent);
+	}
+
+	.selected_layer {
+		background-color: var(--block-background-fill);
+		color: var(--color-accent);
+		font-weight: bold;
+	}
+
+	ul {
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		background: var(--block-background-fill);
+		width: calc(100% + 1px);
+		list-style: none;
+		z-index: var(--layer-top);
+		border: 1px solid var(--block-border-color);
+		padding: var(--spacing-sm) 0;
+		text-wrap: none;
+		transform: translate(-1px, 1px);
+		border-radius: var(--radius-sm);
+		border-bottom-right-radius: 0;
+	}
+
+	.layer-wrap ul > li > button {
+		margin-left: 0;
+	}
+
+	.sep {
+		height: 12px;
+		background-color: var(--block-border-color);
+		width: 1px;
+		display: block;
+		margin-left: var(--spacing-xl);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/layers/utils.ts

@@ -0,0 +1,263 @@
+import {
+	Container,
+	type IRenderer,
+	type DisplayObject,
+	RenderTexture,
+	Texture,
+	Sprite,
+	Filter
+} from "pixi.js";
+
+/**
+ * GLSL Shader that takes two textures and erases the second texture from the first.
+ */
+export const erase_shader = `
+precision highp float;
+
+uniform sampler2D uDrawingTexture;
+uniform sampler2D uEraserTexture;
+
+varying vec2 vTextureCoord;
+
+void main(void) {
+	vec4 drawingColor = texture2D(uDrawingTexture,vTextureCoord);
+	vec4 eraserColor = texture2D(uEraserTexture, vTextureCoord);
+
+	// Use the alpha of the eraser to determine how much to "erase" from the drawing
+	float alpha = 1.0 - eraserColor.a;
+	gl_FragColor = vec4(drawingColor.rgb * alpha, drawingColor.a * alpha);
+}`;
+
+/**
+ * Interface holding data for a layer
+ */
+export interface LayerScene {
+	/**
+	 * The texture used for tracking brush strokes.
+	 */
+	draw_texture: RenderTexture;
+	/**
+	 * The texture used for tracking eraser strokes.
+	 */
+	erase_texture: RenderTexture;
+	/**
+	 * The sprite used for displaying the composite of the draw and erase textures.
+	 */
+	composite: Sprite;
+	/**
+	 * The filter used for combining the draw and erase textures into a composite texture.
+	 */
+	filter?: Filter;
+}
+
+/**
+ * Interface for managing layers.
+ */
+interface LayerManager {
+	/**
+	 * Adds a layer to the container.
+	 * @param layer The container to add the layer to.
+	 * @param renderer The renderer to use for the layer.
+	 * @param width the width of the layer
+	 * @param height the height of the layer
+	 */
+	add_layer(
+		container: Container,
+		renderer: IRenderer,
+		width: number,
+		height: number
+	): [LayerScene, LayerScene[]];
+	/**
+	 * Swaps the layer with the layer above or below it.
+	 * @param layer The index layer to swap.
+	 * @param direction The direction to swap the layer.
+	 */
+	swap_layers(layer: number, direction: "up" | "down"): LayerScene;
+	/**
+	 * Changes the active layer.
+	 * @param layer The index of the layer to make active.
+	 */
+	change_active_layer(layer: number): LayerScene;
+	/**
+	 * Resizes the layers.
+	 * @param width The new width of the layers.
+	 * @param height The new height of the layers.
+	 */
+	reset(): void;
+	/**
+	 * Gets the layers.
+	 * @returns The layers.
+	 */
+	get_layers(): LayerScene[];
+
+	add_layer_from_blob(
+		container: Container,
+		renderer: IRenderer,
+		blob: Blob,
+		view: HTMLCanvasElement
+	): Promise<[LayerScene, LayerScene[]]>;
+}
+
+/**
+ * Swaps two adjacent elements in an array.
+ * @param array The array to swap elements in.
+ * @param index The index of the first element to swap.
+ */
+function swap_adjacent(array: any[], index: number): void {
+	if (index < 0 || index >= array.length - 1) {
+		throw new Error("Index out of bounds");
+	}
+
+	[array[index], array[index + 1]] = [array[index + 1], array[index]];
+}
+
+/**
+ * Creates a layer manager.
+ * @param canvas_resize a function to resize the canvas
+ * @returns a layer manager
+ */
+export function layer_manager(): LayerManager {
+	let _layers: LayerScene[] = [];
+	let current_layer = 0;
+	let position = 0;
+
+	return {
+		add_layer: function (
+			container: Container,
+			renderer: IRenderer,
+			width: number,
+			height: number
+		): [LayerScene, LayerScene[]] {
+			const layer_container = new Container() as Container & DisplayObject;
+			position++;
+			layer_container.zIndex = position;
+
+			const composite_texture = RenderTexture.create({
+				width,
+				height
+			});
+
+			const composite = new Sprite(composite_texture) as Sprite & DisplayObject;
+
+			layer_container.addChild(composite);
+
+			composite.zIndex = position;
+
+			const layer_scene: LayerScene = {
+				draw_texture: RenderTexture.create({
+					width,
+					height
+				}),
+				erase_texture: RenderTexture.create({
+					width,
+					height
+				}),
+				composite
+			};
+
+			const erase_filter = new Filter(undefined, erase_shader, {
+				uEraserTexture: layer_scene.erase_texture,
+				uDrawingTexture: layer_scene.draw_texture
+			});
+
+			composite.filters = [erase_filter];
+
+			container.addChild(layer_container);
+
+			_layers.push(layer_scene);
+
+			return [layer_scene, _layers];
+		},
+
+		swap_layers: function (
+			layer: number,
+			direction: "up" | "down"
+		): LayerScene {
+			if (direction === "up") {
+				swap_adjacent(_layers, layer);
+			} else {
+				swap_adjacent(_layers, layer - 1);
+			}
+			return _layers[layer];
+		},
+
+		change_active_layer: function (layer: number): LayerScene {
+			current_layer = layer;
+			return _layers[layer];
+		},
+		reset() {
+			_layers.forEach((layer) => {
+				layer.draw_texture.destroy(true);
+				layer.erase_texture.destroy(true);
+				layer.composite.destroy(true);
+			});
+			_layers = [];
+			current_layer = 0;
+			position = 0;
+		},
+		async add_layer_from_blob(
+			container: Container,
+			renderer: IRenderer,
+			blob: Blob,
+			view: HTMLCanvasElement
+		) {
+			const img = await createImageBitmap(blob);
+			const bitmap_texture = Texture.from(img);
+
+			const [w, h] = resize_to_fit(
+				bitmap_texture.width,
+				bitmap_texture.height,
+				view.width,
+				view.height
+			);
+
+			const sprite = new Sprite(bitmap_texture) as Sprite & DisplayObject;
+			sprite.zIndex = 0;
+
+			sprite.width = w;
+			sprite.height = h;
+
+			const [layer, layers] = this.add_layer(
+				container,
+				renderer,
+				view.width,
+				view.height
+			);
+
+			renderer.render(sprite, {
+				renderTexture: layer.draw_texture
+			});
+
+			return [layer, layers];
+		},
+		get_layers() {
+			return _layers;
+		}
+	};
+}
+
+function resize_to_fit(
+	inner_width: number,
+	inner_height: number,
+	outer_width: number,
+	outer_height: number
+): [number, number] {
+	if (inner_width <= outer_width && inner_height <= outer_height) {
+		return [inner_width, inner_height];
+	}
+
+	const inner_aspect = inner_width / inner_height;
+	const outer_aspect = outer_width / outer_height;
+
+	let new_width, new_height;
+
+	if (inner_aspect > outer_aspect) {
+		new_width = outer_width;
+		new_height = outer_width / inner_aspect;
+	} else {
+		new_height = outer_height;
+		new_width = outer_height * inner_aspect;
+	}
+
+	return [new_width, new_height];
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/Brush.svelte

@@ -0,0 +1,278 @@
+<script lang="ts" context="module">
+	import { type ColorInput } from "tinycolor2";
+
+	export interface Eraser {
+		/**
+		 * The default size of the eraser.
+		 */
+		default_size: number | "auto";
+	}
+
+	export interface Brush extends Eraser {
+		/**
+		 * The default color of the brush.
+		 */
+		default_color: ColorInput;
+		/**
+		 * The colors to show in the color swatch
+		 */
+		colors: ColorInput[];
+		/**
+		 * Whether to show _only_ the color swatches specified in `colors`, or to show the color swatches specified in `colors` along with the colorpicker.
+		 */
+		color_mode: "fixed" | "defaults";
+	}
+
+	type brush_option_type = boolean;
+</script>
+
+<script lang="ts">
+	import tinycolor from "tinycolor2";
+	import { clamp } from "../utils/pixi";
+
+	import { getContext, onMount, tick } from "svelte";
+	import { type ToolContext, TOOL_KEY } from "./Tools.svelte";
+	import { type EditorContext, EDITOR_KEY } from "../ImageEditor.svelte";
+	import { draw_path, type DrawCommand } from "./brush";
+	import BrushOptions from "./BrushOptions.svelte";
+	import type { FederatedPointerEvent } from "pixi.js";
+
+	export let default_size: Brush["default_size"];
+	export let default_color: Brush["default_color"] | undefined = undefined;
+	export let colors: Brush["colors"] | undefined = undefined;
+	export let color_mode: Brush["color_mode"] | undefined = undefined;
+	export let mode: "erase" | "draw";
+
+	$: processed_colors = colors
+		? colors.map(process_color).filter((_, i) => i < 4)
+		: [];
+
+	$: selected_color =
+		default_color === "auto"
+			? processed_colors[0]
+			: !default_color
+				? "black"
+				: process_color(default_color);
+
+	let brush_options: brush_option_type = false;
+
+	const {
+		pixi,
+		dimensions,
+		current_layer,
+		command_manager,
+		register_context,
+		editor_box,
+		crop,
+		toolbar_box
+	} = getContext<EditorContext>(EDITOR_KEY);
+
+	const { active_tool, register_tool, current_color } =
+		getContext<ToolContext>(TOOL_KEY);
+
+	let drawing = false;
+	let draw: DrawCommand;
+
+	function generate_sizes(x: number, y: number): number {
+		const min = clamp(Math.min(x, y), 500, 1000);
+
+		return Math.round((min * 2) / 100);
+	}
+
+	$: mode === "draw" && current_color.set(selected_color);
+
+	let selected_size =
+		default_size === "auto" ? generate_sizes(...$dimensions) : default_size;
+
+	function pointer_down_handler(event: FederatedPointerEvent): void {
+		if ($active_tool !== mode) {
+			return;
+		}
+		drawing = true;
+
+		if (!$pixi || !$current_layer) {
+			return;
+		}
+
+		draw = draw_path(
+			$pixi.renderer!,
+			$pixi.layer_container,
+			$current_layer,
+			mode
+		);
+
+		draw.start({
+			x: event.screen.x,
+			y: event.screen.y,
+			color: selected_color || undefined,
+			size: selected_size,
+			opacity: 1
+		});
+	}
+
+	function pointer_up_handler(event: FederatedPointerEvent): void {
+		if (!$pixi || !$current_layer) {
+			return;
+		}
+		if ($active_tool !== mode) {
+			return;
+		}
+		draw.stop();
+		command_manager.execute(draw);
+		drawing = false;
+	}
+
+	function pointer_move_handler(event: FederatedPointerEvent): void {
+		if ($active_tool !== mode) {
+			return;
+		}
+		if (drawing) {
+			draw.continue({
+				x: event.screen.x,
+				y: event.screen.y
+			});
+		}
+
+		const x_bound = $crop[0] * $dimensions[0];
+		const y_bound = $crop[1] * $dimensions[1];
+
+		if (
+			x_bound > event.screen.x ||
+			y_bound > event.screen.y ||
+			event.screen.x > x_bound + $crop[2] * $dimensions[0] ||
+			event.screen.y > y_bound + $crop[3] * $dimensions[1]
+		) {
+			brush_cursor = false;
+			document.body.style.cursor = "auto";
+		} else {
+			brush_cursor = true;
+			document.body.style.cursor = "none";
+		}
+		if (brush_cursor) {
+			pos = {
+				x: event.clientX - $editor_box.child_left,
+				y: event.clientY - $editor_box.child_top
+			};
+		}
+	}
+
+	let brush_cursor = false;
+
+	async function toggle_listeners(on_off: "on" | "off"): Promise<void> {
+		$pixi?.layer_container[on_off]("pointerdown", pointer_down_handler);
+
+		$pixi?.layer_container[on_off]("pointerup", pointer_up_handler);
+
+		$pixi?.layer_container[on_off]("pointermove", pointer_move_handler);
+		$pixi?.layer_container[on_off](
+			"pointerenter",
+			(event: FederatedPointerEvent) => {
+				if ($active_tool === mode) {
+					brush_cursor = true;
+					document.body.style.cursor = "none";
+				}
+			}
+		);
+		$pixi?.layer_container[on_off](
+			"pointerleave",
+			() => ((brush_cursor = false), (document.body.style.cursor = "auto"))
+		);
+	}
+
+	register_context(mode, {
+		init_fn: () => {
+			toggle_listeners("on");
+		},
+		reset_fn: () => {
+			toggle_listeners("off");
+		}
+	});
+	const toggle_options = debounce_toggle();
+
+	const unregister = register_tool(mode, {
+		cb: toggle_options
+	});
+	onMount(() => {
+		return () => {
+			unregister();
+			toggle_listeners("off");
+		};
+	});
+
+	let recent_colors: (string | null)[] = [null, null, null];
+
+	function process_color(color: ColorInput): string {
+		return tinycolor(color).toRgbString();
+	}
+
+	let pos = { x: 0, y: 0 };
+	$: brush_size =
+		(selected_size / $dimensions[0]) * $editor_box.child_width * 2;
+
+	function debounce_toggle(): (should_close?: boolean) => void {
+		let timeout: NodeJS.Timeout | null = null;
+
+		return function executedFunction(should_close?: boolean) {
+			const later = (): void => {
+				if (timeout) {
+					clearTimeout(timeout);
+				}
+				if (should_close !== undefined) {
+					brush_options = should_close;
+					return;
+				}
+				brush_options = !brush_options;
+			};
+
+			if (timeout) {
+				clearTimeout(timeout);
+			}
+			timeout = setTimeout(later, 100);
+		};
+	}
+</script>
+
+<svelte:window
+	on:keydown={({ key }) => key === "Escape" && toggle_options(false)}
+/>
+
+<span
+	style:transform="translate({pos.x}px, {pos.y}px)"
+	style:top="{$editor_box.child_top -
+		$editor_box.parent_top -
+		brush_size / 2}px"
+	style:left="{$editor_box.child_left -
+		$editor_box.parent_left -
+		brush_size / 2}px"
+	style:width="{brush_size}px"
+	style:height="{brush_size}px"
+	style:opacity={brush_cursor ? 1 : 0}
+/>
+
+{#if brush_options}
+	<div>
+		<BrushOptions
+			show_swatch={mode === "draw"}
+			on:click_outside={() => toggle_options()}
+			colors={processed_colors}
+			bind:selected_color
+			{color_mode}
+			bind:recent_colors
+			bind:selected_size
+			dimensions={$dimensions}
+			parent_width={$editor_box.parent_width}
+			parent_height={$editor_box.parent_height}
+			parent_left={$editor_box.parent_left}
+			toolbar_box={$toolbar_box}
+		/>
+	</div>
+{/if}
+
+<style>
+	span {
+		position: absolute;
+		background: rgba(0, 0, 0, 0.5);
+		pointer-events: none;
+		border-radius: 50%;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/BrushOptions.svelte

@@ -0,0 +1,180 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { click_outside } from "../utils/events";
+
+	import { type Brush } from "./Brush.svelte";
+	import ColorPicker from "./ColorPicker.svelte";
+	import ColorSwatch from "./ColorSwatch.svelte";
+	import ColorField from "./ColorField.svelte";
+	import BrushSize from "./BrushSize.svelte";
+
+	export let colors: string[];
+	export let selected_color: string;
+	export let color_mode: Brush["color_mode"] | undefined = undefined;
+	export let recent_colors: (string | null)[] = [];
+	export let selected_size: number;
+	export let dimensions: [number, number];
+	export let parent_width: number;
+	export let parent_height: number;
+	export let parent_left: number;
+	export let toolbar_box: DOMRect | Record<string, never>;
+	export let show_swatch: boolean;
+
+	let color_picker = false;
+	let current_mode: "hex" | "rgb" | "hsl" = "hex";
+	let editing_index: number | null = null;
+
+	const dispatch = createEventDispatcher<{
+		click_outside: void;
+	}>();
+
+	function handle_color_selection(
+		{
+			index,
+			color
+		}: {
+			index: number | null;
+			color: string | null;
+		},
+		type: "core" | "user"
+	): void {
+		if (type === "user" && !color) {
+			editing_index = index;
+			color_picker = true;
+		}
+
+		if (!color) return;
+		selected_color = color;
+
+		if (type === "core") {
+			color_picker = false;
+		}
+	}
+
+	function handle_color_change(color: string): void {
+		if (editing_index === null) return;
+		recent_colors[editing_index] = color;
+	}
+
+	$: handle_color_change(selected_color);
+	let width = 0;
+	let height = 0;
+	let c_width = 0;
+	let c_height = 0;
+	let wrap_el: HTMLDivElement;
+	let full_screen = false;
+	let anchor: "default" | "center" | "top" = "default";
+	let left_anchor = 0;
+	let top_anchor = null;
+	$: {
+		if (wrap_el && (width || height || c_height || c_width)) {
+			const box = wrap_el.getBoundingClientRect();
+			color_picker;
+
+			if (box.width > parent_width) {
+				full_screen = true;
+			} else if (parent_width > box.width + 230 * 2 + 25) {
+				anchor = "default";
+
+				left_anchor = toolbar_box.right - parent_left + 24;
+			} else {
+				anchor = "center";
+			}
+
+			if (box.height + 50 > parent_height) {
+				anchor = "top";
+				top_anchor = true;
+			}
+		}
+	}
+</script>
+
+<svelte:window bind:innerHeight={height} bind:innerWidth={width} />
+
+<div
+	class="wrap"
+	class:padded={!color_picker}
+	use:click_outside={() => dispatch("click_outside")}
+	class:anchor_default={anchor === "default"}
+	class:anchor_center={anchor === "center"}
+	class:anchor_top={anchor === "top"}
+	bind:this={wrap_el}
+	bind:clientWidth={c_width}
+	bind:clientHeight={c_height}
+	class:anchor={`${left_anchor}px`}
+>
+	{#if color_mode === "defaults"}
+		{#if color_picker}
+			<ColorPicker bind:color={selected_color} />
+			<ColorField
+				bind:current_mode
+				color={selected_color}
+				on:close={() => (color_picker = false)}
+				on:selected={({ detail }) => (selected_color = detail)}
+			/>
+		{/if}
+	{/if}
+	{#if show_swatch}
+		<ColorSwatch
+			bind:color_picker
+			{colors}
+			on:select={({ detail }) => handle_color_selection(detail, "core")}
+			on:edit={({ detail }) => handle_color_selection(detail, "user")}
+			user_colors={color_mode === "defaults" ? recent_colors : null}
+			{selected_color}
+			{current_mode}
+		/>
+	{/if}
+
+	{#if color_picker || show_swatch}
+		<div class="sep"></div>
+	{/if}
+
+	<BrushSize max={dimensions[0] / 10} min={1} bind:selected_size />
+</div>
+
+<style>
+	.wrap {
+		max-width: 230px;
+		width: 90%;
+		position: absolute;
+		display: flex;
+		flex-direction: column;
+		gap: 5px;
+		background: var(--background-fill-secondary);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--radius-md);
+		box-shadow: 0px 0px 5px 0px rgba(0, 0, 0, 0.1);
+		padding-bottom: var(--size-2);
+		pointer-events: all;
+		cursor: default;
+		z-index: var(--layer-top);
+		overflow: hidden;
+	}
+
+	.anchor_default {
+		position: absolute;
+		left: var(--left-anchor);
+		bottom: 8px;
+	}
+	.anchor_center {
+		position: absolute;
+		bottom: 50px;
+		left: 50%;
+		transform: translateX(-50%);
+	}
+
+	.anchor_top {
+		position: absolute;
+		top: 1px;
+		left: 50%;
+		transform: translateX(-50%);
+	}
+
+	.sep {
+		height: 1px;
+		background-color: var(--block-border-color);
+		margin: 0 var(--size-3);
+		margin-top: var(--size-1);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/BrushSize.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+	import { click_outside } from "../utils/events";
+	import { createEventDispatcher } from "svelte";
+	import { BrushSize } from "@gradio/icons";
+
+	export let selected_size: number;
+	export let min: number;
+	export let max: number;
+
+	const dispatch = createEventDispatcher<{
+		click_outside: void;
+	}>();
+
+	let width = 0;
+	let height = 0;
+	let c_width = 0;
+	let c_height = 0;
+	let wrap_el: HTMLDivElement;
+	let anchor_right = false;
+	let anchor_top = false;
+
+	$: {
+		if (wrap_el && (width || height || c_height || c_width)) {
+			const box = wrap_el.getBoundingClientRect();
+
+			anchor_right = box.width + 30 > width / 2;
+			anchor_top = box.y < 80;
+		}
+	}
+</script>
+
+<svelte:window bind:innerHeight={height} bind:innerWidth={width} />
+
+<div
+	class="wrap"
+	use:click_outside={() => dispatch("click_outside")}
+	bind:this={wrap_el}
+	bind:clientWidth={c_width}
+	bind:clientHeight={c_height}
+	class:right={anchor_right}
+	class:top={anchor_top}
+	class:bottom={!anchor_top}
+>
+	<span>
+		<BrushSize />
+	</span>
+	<input type="range" bind:value={selected_size} {min} {max} step={1} />
+</div>
+
+<style>
+	.wrap {
+		width: 100%;
+		display: flex;
+		gap: var(--size-4);
+		background: var(--background-fill-secondary);
+		padding: 0 var(--size-4);
+		cursor: default;
+		padding-top: var(--size-2-5);
+	}
+
+	input {
+		width: 100%;
+	}
+	span {
+		width: 26px;
+		color: var(--body-text-color);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/ColorField.svelte

@@ -0,0 +1,172 @@
+<script lang="ts">
+	import { Eyedropper } from "@gradio/icons";
+	import { createEventDispatcher } from "svelte";
+
+	import tinycolor from "tinycolor2";
+	export let color: string;
+
+	export let current_mode: "hex" | "rgb" | "hsl" = "hex";
+
+	const dispatch = createEventDispatcher<{
+		selected: string;
+		close: void;
+	}>();
+	const modes = [
+		["Hex", "hex"],
+		["RGB", "rgb"],
+		["HSL", "hsl"]
+	] as const;
+
+	function format_color(color: string, mode: "hex" | "rgb" | "hsl"): string {
+		if (mode === "hex") {
+			return tinycolor(color).toHexString();
+		} else if (mode === "rgb") {
+			return tinycolor(color).toRgbString();
+		}
+		return tinycolor(color).toHslString();
+	}
+
+	$: color_string = format_color(color, current_mode);
+	$: color_string && dispatch("selected", color_string);
+
+	function request_eyedropper(): void {
+		// @ts-ignore
+		const eyeDropper = new EyeDropper();
+
+		eyeDropper.open().then((result: { sRGBHex: string }) => {
+			color = result.sRGBHex;
+		});
+	}
+
+	//@ts-ignore
+	const eyedropper_supported = !!window.EyeDropper;
+
+	function handle_click(): void {
+		dispatch("selected", color_string);
+		dispatch("close");
+	}
+</script>
+
+<div class="input">
+	<button class="swatch" style:background={color} on:click={handle_click}
+	></button>
+	<div>
+		<div class="input-wrap">
+			<input
+				type="text"
+				value={color_string}
+				on:change={(e) => (color = e.currentTarget.value)}
+			/>
+
+			<button class="eyedropper" on:click={request_eyedropper}>
+				{#if eyedropper_supported}
+					<Eyedropper />
+				{/if}
+			</button>
+		</div>
+		<div class="buttons">
+			{#each modes as [label, value]}
+				<button
+					class="button"
+					class:active={current_mode === value}
+					on:click={() => (current_mode = value)}>{label}</button
+				>
+			{/each}
+		</div>
+	</div>
+</div>
+
+<style>
+	.input {
+		display: flex;
+		align-items: center;
+		padding: 0 10px 15px;
+	}
+
+	.input input {
+		height: 30px;
+		width: 100%;
+		flex-shrink: 1;
+		border-bottom-left-radius: 0;
+		border: 1px solid var(--block-border-color);
+		letter-spacing: -0.05rem;
+		border-left: none;
+		border-right: none;
+		font-family: var(--font-mono);
+		font-size: var(--scale-000);
+		padding-left: 15px;
+		padding-right: 0;
+		background-color: var(--background-fill-secondary);
+		color: var(--block-label-text-color);
+	}
+
+	.swatch {
+		width: 50px;
+		height: 50px;
+		border-top-left-radius: 15px;
+		border-bottom-left-radius: 15px;
+		flex-shrink: 0;
+		border: 1px solid var(--block-border-color);
+	}
+
+	.buttons button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		border: 1px solid var(--block-border-color);
+		background: var(--background-fill-secondary);
+		padding: 3px 6px;
+		font-size: var(--scale-000);
+		cursor: pointer;
+		border-right: none;
+		width: 100%;
+		border-top: none;
+	}
+
+	.buttons button:first-child {
+		border-left: none;
+	}
+
+	.buttons button:last-child {
+		border-bottom-right-radius: 15px;
+		border-right: 1px solid var(--block-border-color);
+	}
+
+	.buttons button:hover {
+		background: var(--background-fill-secondary-hover);
+		font-weight: var(--weight-bold);
+	}
+
+	.buttons button.active {
+		background: var(--background-fill-secondary);
+		font-weight: var(--weight-bold);
+	}
+
+	.buttons {
+		height: 20px;
+
+		display: flex;
+		justify-content: stretch;
+		gap: 0px;
+		/* padding: 0 10px; */
+	}
+
+	.input-wrap {
+		display: flex;
+	}
+
+	.eyedropper {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 25px;
+		height: 30px;
+		border-top-right-radius: 15px;
+		border: 1px solid var(--block-border-color);
+		border-left: none;
+		background: var(--background-fill-secondary);
+		height: 30px;
+		padding: 7px 7px 5px 0px;
+		cursor: pointer;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/ColorPicker.svelte

@@ -0,0 +1,205 @@
+<script lang="ts">
+	import { tick } from "svelte";
+	import tinycolor from "tinycolor2";
+	import { clamp } from "../utils/pixi";
+
+	export let color = "rgb(255, 255, 255)";
+
+	let name = "world";
+	let sl_marker_pos = [0, 0];
+	let sl_rect: DOMRect | null = null;
+	let sl_moving = false;
+	let sl = [0, 0];
+
+	let hue = 0;
+	let hue_marker_pos = 0;
+	let hue_rect: DOMRect | null = null;
+	let hue_moving = false;
+
+	function handle_hue_down(
+		event: MouseEvent & { currentTarget: HTMLDivElement }
+	): void {
+		hue_rect = event.currentTarget.getBoundingClientRect();
+
+		hue_moving = true;
+		update_hue_from_mouse(event.clientX);
+	}
+
+	function update_hue_from_mouse(x: number): void {
+		if (!hue_rect) return;
+		const _x = clamp(x - hue_rect.left, 0, hue_rect.width); // Get the x-coordinate relative to the box
+		hue_marker_pos = _x;
+		const _hue = (_x / hue_rect.width) * 360; // Scale the x position to a hue value (0-360)
+
+		hue = _hue;
+
+		color = hsva_to_rgba({ h: _hue, s: sl[0], v: sl[1], a: 1 });
+	}
+
+	function hsva_to_rgba(hsva: {
+		h: number;
+		s: number;
+		v: number;
+		a: number;
+	}): string {
+		const saturation = hsva.s;
+		const value = hsva.v;
+		let chroma = saturation * value;
+		const hue_by_60 = hsva.h / 60;
+		let x = chroma * (1 - Math.abs((hue_by_60 % 2) - 1));
+		const m = value - chroma;
+
+		chroma = chroma + m;
+		x = x + m;
+
+		const index = Math.floor(hue_by_60) % 6;
+		const red = [chroma, x, m, m, x, chroma][index];
+		const green = [x, chroma, chroma, x, m, m][index];
+		const blue = [m, m, x, chroma, chroma, x][index];
+
+		return `rgba(${red * 255}, ${green * 255}, ${blue * 255}, ${hsva.a})`;
+	}
+
+	function update_color_from_mouse(x: number, y: number): void {
+		if (!sl_rect) return;
+		const _x = clamp(x - sl_rect.left, 0, sl_rect.width);
+		const _y = clamp(y - sl_rect.top, 0, sl_rect.height);
+		sl_marker_pos = [_x, _y];
+		const _hsva = {
+			h: hue * 1,
+			s: _x / sl_rect.width,
+			v: 1 - _y / sl_rect.height,
+			a: 1
+		};
+
+		sl = [_hsva.s, _hsva.v];
+
+		color = hsva_to_rgba(_hsva);
+	}
+
+	function handle_sl_down(
+		event: MouseEvent & { currentTarget: HTMLDivElement }
+	): void {
+		sl_moving = true;
+		sl_rect = event.currentTarget.getBoundingClientRect();
+		update_color_from_mouse(event.clientX, event.clientY);
+	}
+
+	function handle_move(
+		event: MouseEvent & { currentTarget: EventTarget & Window }
+	): void {
+		if (sl_moving) update_color_from_mouse(event.clientX, event.clientY);
+		if (hue_moving) update_hue_from_mouse(event.clientX);
+	}
+
+	function handle_end(): void {
+		if (sl_moving) sl_moving = false;
+		if (hue_moving) hue_moving = false;
+	}
+
+	async function update_mouse_from_color(color: string): Promise<void> {
+		if (sl_moving || hue_moving) return;
+		await tick();
+		if (!color) return;
+		if (!sl_rect) {
+			sl_rect = sl_wrap.getBoundingClientRect();
+		}
+
+		if (!hue_rect) {
+			hue_rect = hue_wrap.getBoundingClientRect();
+		}
+
+		const hsva = tinycolor(color).toHsv();
+		const _x = hsva.s * sl_rect!.width;
+		const _y = (1 - hsva.v) * sl_rect!.height;
+		sl_marker_pos = [_x, _y];
+		sl = [hsva.s, hsva.v];
+		hue = hsva.h;
+		hue_marker_pos = (hsva.h / 360) * hue_rect!.width;
+	}
+
+	$: update_mouse_from_color(color);
+
+	let sl_wrap: HTMLDivElement;
+	let hue_wrap: HTMLDivElement;
+</script>
+
+<svelte:window on:mousemove={handle_move} on:mouseup={handle_end} />
+
+<!-- svelte-ignore a11y-no-static-element-interactions -->
+<div
+	class="color-gradient"
+	on:mousedown={handle_sl_down}
+	style="--hue:{hue}"
+	bind:this={sl_wrap}
+>
+	<div
+		class="marker"
+		style:transform="translate({sl_marker_pos[0]}px,{sl_marker_pos[1]}px)"
+		style:background={color}
+	/>
+</div>
+<!-- svelte-ignore a11y-no-static-element-interactions -->
+<div class="hue-slider" on:mousedown={handle_hue_down} bind:this={hue_wrap}>
+	<div
+		class="marker"
+		style:background={"hsl(" + hue + ", 100%, 50%)"}
+		style:transform="translateX({hue_marker_pos}px)"
+	/>
+</div>
+
+<style>
+	.hue-slider {
+		position: relative;
+		width: 90%;
+		margin: 10px auto;
+		height: 10px;
+		border-radius: 5px;
+		background: linear-gradient(
+			to right,
+			hsl(0, 100%, 50%) 0%,
+			#ff0 17%,
+			lime 33%,
+			cyan 50%,
+			blue 67%,
+			magenta 83%,
+			red 100%
+		);
+		border-top: none;
+	}
+
+	.color-gradient {
+		position: relative;
+		--hue: white;
+
+		background: linear-gradient(rgba(0, 0, 0, 0), #000),
+			linear-gradient(90deg, #fff, hsl(var(--hue), 100%, 50%));
+		width: 100%;
+		height: 150px;
+		border-top-left-radius: 4px;
+		border-top-right-radius: 4px;
+	}
+
+	.marker {
+		position: absolute;
+		width: 14px;
+		height: 14px;
+		border-radius: 50%;
+		border: 2px solid white;
+
+		top: -7px;
+		left: -7px;
+		box-shadow: 0 1px 5px rgba(0, 0, 0, 0.1);
+		pointer-events: none;
+	}
+
+	.hue-slider > .marker {
+		box-shadow: 0 0 1px #888;
+		top: -3px;
+		margin: auto;
+		height: 16px;
+		width: 16px;
+		left: -8px;
+		border: 2px solid white;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/ColorSwatch.svelte

@@ -0,0 +1,203 @@
+<script lang="ts">
+	import tinycolor from "tinycolor2";
+	import { createEventDispatcher } from "svelte";
+	export let selected_color: string;
+	export let colors: string[];
+	export let user_colors: (string | null)[] | null = [];
+	import { Palette } from "@gradio/icons";
+
+	export let show_empty = false;
+	export let current_mode: "hex" | "rgb" | "hsl" = "hex";
+	export let color_picker = false;
+	const dispatch = createEventDispatcher<{
+		select: { index: number | null; color: string | null };
+		edit: { index: number; color: string | null };
+	}>();
+
+	$: _colors = show_empty ? colors : colors.filter((c) => c);
+
+	function get_formatted_color(
+		color: string,
+		mode: "hex" | "rgb" | "hsl"
+	): string {
+		if (mode === "hex") {
+			return tinycolor(color).toHexString();
+		} else if (mode === "rgb") {
+			return tinycolor(color).toRgbString();
+		}
+		return tinycolor(color).toHslString();
+	}
+
+	let current_index = `select-${colors.findIndex(
+		(c) =>
+			get_formatted_color(c, current_mode) ===
+			get_formatted_color(selected_color, current_mode)
+	)}`;
+
+	function handle_select(
+		type: "edit" | "select",
+		detail: {
+			index: number;
+			color: string | null;
+		}
+	): void {
+		current_index = `${type}-${detail.index}`;
+		dispatch(type, detail);
+	}
+
+	function handle_picker_click(): void {
+		dispatch("select", { index: null, color: selected_color });
+		color_picker = !color_picker;
+	}
+</script>
+
+{#if !color_picker}
+	<span class:lg={user_colors}></span>
+{/if}
+
+<div class="swatch-wrap">
+	<span class="icon-wrap">
+		<Palette />
+	</span>
+	<div>
+		{#if user_colors}
+			<div class="swatch">
+				{#each user_colors as color, i}
+					<button
+						on:click={() => handle_select("edit", { index: i, color })}
+						class="color"
+						class:empty={color === null}
+						style="background-color: {color}"
+						class:selected={`edit-${i}` === current_index}
+					></button>
+				{/each}
+
+				<button
+					on:click={handle_picker_click}
+					class="color colorpicker"
+					class:hidden={!color_picker}
+				></button>
+			</div>
+		{/if}
+		<menu class="swatch">
+			{#each _colors as color, i}
+				<button
+					on:click={() => handle_select("select", { index: i, color })}
+					class="color"
+					class:empty={color === null}
+					style="background-color: {color}"
+					class:selected={`select-${i}` === current_index}
+				></button>
+			{/each}
+		</menu>
+	</div>
+</div>
+
+<style>
+	.icon-wrap {
+		width: 18px;
+		margin-top: 6px;
+
+		margin-left: var(--size-4);
+	}
+
+	.swatch-wrap {
+		display: flex;
+		justify-content: space-between;
+		align-items: flex-start;
+	}
+	span {
+		margin-top: 0px;
+	}
+
+	span.lg {
+		margin-top: var(--spacing-xl);
+	}
+	.swatch {
+		display: flex;
+		gap: var(--size-2-5);
+		justify-content: space-around;
+		margin-bottom: var(--size-2);
+		margin-right: var(--size-6);
+		padding-left: var(--size-2);
+	}
+
+	.empty {
+		border: 1px solid var(--block-border-color);
+		font-weight: var(--weight-bold);
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		padding-top: 4px;
+		text-align: center;
+		font-size: var(--scale-0);
+		cursor: pointer;
+	}
+
+	.empty::after {
+		content: "+";
+		margin-bottom: var(--size-1);
+	}
+
+	.color {
+		width: 30px;
+		height: 30px;
+		border-radius: 50%;
+	}
+
+	.empty.selected,
+	.color.selected {
+		border: 2px solid var(--color-accent);
+	}
+
+	.colorpicker {
+		border: 1px solid var(--block-border-color);
+
+		background: conic-gradient(
+			red,
+			#ff0 60deg,
+			lime 120deg,
+			cyan 180deg,
+			blue 240deg,
+			magenta 300deg,
+			red 360deg
+		);
+		overflow: hidden;
+		position: relative;
+		color: white;
+		cursor: pointer;
+	}
+
+	.colorpicker::before {
+		content: "";
+		position: absolute;
+		width: 100%;
+		height: 100%;
+		background: rgba(0, 0, 0, 0.6);
+		opacity: 1;
+		transition: 0.1s;
+		top: 0;
+		left: 0;
+	}
+
+	.colorpicker::after {
+		display: flex;
+		justify-content: center;
+		align-content: center;
+		content: "⨯";
+		color: white;
+		font-size: var(--scale-5);
+		position: absolute;
+		width: 100%;
+		height: 100%;
+		transform: translateY(-17px);
+		opacity: 1;
+		transition: 0.1s;
+		top: 0;
+	}
+
+	.colorpicker.hidden::after,
+	.colorpicker.hidden::before {
+		opacity: 0;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/Crop.svelte

@@ -0,0 +1,189 @@
+<script lang="ts">
+	import { getContext, onDestroy, onMount, tick } from "svelte";
+
+	import { type ToolContext, TOOL_KEY } from "./Tools.svelte";
+	import { type EditorContext, EDITOR_KEY } from "../ImageEditor.svelte";
+	import { crop_canvas, resize_and_reposition, type CropCommand } from "./crop";
+
+	import Cropper from "./Cropper.svelte";
+
+	const { active_tool, register_tool } = getContext<ToolContext>(TOOL_KEY);
+	const {
+		dimensions,
+		editor_box,
+		pixi,
+		crop,
+		command_manager,
+		current_history
+	} = getContext<EditorContext>(EDITOR_KEY);
+
+	let cropper: CropCommand | null;
+
+	export let crop_constraint: [number, number] | `${string}:${string}` | null;
+
+	let _crop_constraint: number | null = null;
+	$: {
+		if (typeof crop_constraint === "string") {
+			const [w, h] = crop_constraint.split(":");
+			_crop_constraint = parseInt(w) / parseInt(h);
+		} else if (Array.isArray(crop_constraint)) {
+			_crop_constraint = crop_constraint[0] / crop_constraint[1];
+		}
+	}
+
+	let w_p = 1;
+	let h_p = 1;
+	let l_p = 0;
+	let t_p = 0;
+
+	let current_opacity = 0;
+
+	let manually_cropped = false;
+
+	$: {
+		if (!manually_cropped && _crop_constraint && $pixi && $active_tool) {
+			requestAnimationFrame(() => {
+				initial_crop();
+			});
+		}
+	}
+
+	let c: CropCommand | null = null;
+
+	async function initial_crop(): Promise<void> {
+		if (c || $current_history.previous) return;
+		const { new_height, new_width, x_offset, y_offset } = resize_and_reposition(
+			$editor_box.child_width,
+			$editor_box.child_height,
+			"c",
+			_crop_constraint!,
+
+			$editor_box.child_width,
+			$editor_box.child_height
+		);
+
+		w_p = new_width / $editor_box.child_width;
+		h_p = new_height / $editor_box.child_height;
+		l_p = x_offset / $editor_box.child_width;
+		t_p = y_offset / $editor_box.child_height;
+
+		c = crop_canvas($pixi!.renderer, $pixi!.mask_container, crop, 0.2);
+		c.start(...$dimensions, current_crop, false);
+
+		c.continue(
+			[
+				l_p * $dimensions[0],
+				t_p * $dimensions[1],
+				w_p * $dimensions[0],
+				h_p * $dimensions[1]
+			],
+			false
+		);
+		c.stop();
+
+		c.execute();
+		c = null;
+		current_opacity = 0;
+	}
+
+	function handle_crop(
+		type: "start" | "stop" | "continue",
+
+		{
+			x,
+			y,
+			width,
+			height
+		}: {
+			x: number;
+			y: number;
+			width: number;
+			height: number;
+		}
+	): void {
+		if (!$pixi) return;
+
+		if (type === "start") {
+			if (cropper) {
+				current_opacity = cropper.stop();
+				cropper = null;
+			}
+
+			cropper = crop_canvas(
+				$pixi?.renderer,
+				$pixi.mask_container,
+				crop,
+				current_opacity
+			);
+			cropper.start(...$dimensions, current_crop);
+		} else if (type === "continue") {
+			if (!cropper) return;
+			cropper.continue([
+				x * $dimensions[0],
+				y * $dimensions[1],
+				width * $dimensions[0],
+				height * $dimensions[1]
+			]);
+		} else if (type === "stop") {
+			if (!cropper) return;
+			command_manager.execute(cropper);
+		}
+		manually_cropped = true;
+	}
+
+	let measured = false;
+
+	function get_measurements(): void {
+		if (measured) return;
+		if (!$editor_box.child_height) return;
+		const _height = $editor_box.child_height;
+		const _width = $editor_box.child_width;
+		const _top = $editor_box.child_top - $editor_box.parent_top;
+		const _left = $editor_box.child_left - $editor_box.parent_left;
+
+		w_p = _width / $editor_box.child_width;
+		h_p = _height / $editor_box.child_height;
+		l_p =
+			(_left - $editor_box.child_left + $editor_box.parent_left) /
+			$editor_box.child_width;
+		t_p =
+			(_top - $editor_box.child_top + $editor_box.parent_top) /
+			$editor_box.child_height;
+
+		measured = true;
+	}
+
+	let current_crop: [number, number, number, number];
+	$: current_crop = [
+		l_p * $dimensions[0],
+		t_p * $dimensions[1],
+		w_p * $dimensions[0],
+		h_p * $dimensions[1]
+	];
+
+	$: {
+		l_p = $crop[0];
+		t_p = $crop[1];
+		w_p = $crop[2];
+		h_p = $crop[3];
+	}
+
+	$: $editor_box && get_measurements();
+
+	const unregister = register_tool("crop");
+	onDestroy(unregister);
+</script>
+
+{#if $active_tool === "crop" && measured}
+	<Cropper
+		crop_constraint={_crop_constraint}
+		{w_p}
+		{h_p}
+		{l_p}
+		{t_p}
+		{editor_box}
+		on:crop_start={({ detail }) => handle_crop("start", detail)}
+		on:crop_continue={({ detail }) => handle_crop("continue", detail)}
+		on:crop_end={({ detail }) => handle_crop("stop", detail)}
+	/>
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/Handle.svelte

@@ -0,0 +1,289 @@
+<script lang="ts">
+	import { tick, createEventDispatcher } from "svelte";
+
+	export let type = "corner";
+	export let location: "tl" | "tr" | "bl" | "br" | "t" | "b" | "l" | "r";
+
+	export let x1 = 0;
+	export let y1 = 0;
+	export let x2 = 0;
+	export let y2 = 0;
+
+	let box: DOMRect;
+	let y_offset = 0;
+	let x_offset = 0;
+	const min = 100;
+
+	let active = false;
+
+	const dispatch = createEventDispatcher<{
+		change: {
+			top: number | undefined;
+			bottom: number | undefined;
+			left: number | undefined;
+			right: number | undefined;
+		};
+	}>();
+	export let dragging = false;
+
+	let el: HTMLDivElement;
+
+	function handle_mousedown(e: MouseEvent): void {
+		box = el.getBoundingClientRect();
+		active = true;
+		dragging = true;
+
+		if (["tl", "bl", "l"].includes(location)) x_offset = e.clientX - box.right;
+		if (["tl", "tr", "t"].includes(location)) y_offset = e.clientY - box.bottom;
+		if (["tr", "r", "br"].includes(location)) x_offset = e.clientX - box.left;
+		if (["br", "b", "bl"].includes(location)) y_offset = e.clientY - box.top;
+	}
+
+	function handle_mousemove(e: MouseEvent): void {
+		if (!active) return;
+		const top_pos = e.clientY - y_offset;
+		const bottom_pos = e.clientY - y_offset;
+		const left_pos = e.clientX - x_offset;
+		const right_pos = e.clientX - x_offset;
+
+		if (["tl", "bl", "l"].includes(location)) {
+			x1 = left_pos;
+		}
+
+		if (["tl", "tr", "t"].includes(location)) {
+			y1 = top_pos;
+		}
+
+		if (["tr", "r", "br"].includes(location)) {
+			x2 = right_pos;
+		}
+
+		if (["br", "b", "bl"].includes(location)) {
+			y2 = bottom_pos;
+		}
+	}
+
+	async function handle_mouseup(e: MouseEvent): Promise<void> {
+		await tick();
+		active = false;
+		dragging = false;
+	}
+
+	function make_transform(
+		_location: typeof location,
+		x1: number,
+		x2: number,
+		y1: number,
+		y2: number
+	): string {
+		let t = undefined;
+		let l = undefined;
+		let r = undefined;
+		let b = undefined;
+
+		if (box) {
+			if (["tl", "l", "bl"].includes(_location)) {
+				l = x1;
+			}
+
+			if (["tl", "t", "tr"].includes(_location)) {
+				t = y1;
+			}
+
+			if (["tr", "r", "br"].includes(_location)) {
+				r = x2;
+			}
+
+			if (["br", "b", "bl"].includes(_location)) {
+				b = y2;
+			}
+		}
+
+		dispatch("change", { top: t, bottom: b, left: l, right: r });
+		return "";
+	}
+
+	$: transform = make_transform(location, x1, x2, y1, y2);
+</script>
+
+<svelte:window on:mousemove={handle_mousemove} on:mouseup={handle_mouseup} />
+
+<!--	svelte-ignore a11y-no-static-element-interactions -->
+<div class="hitbox {location}" on:mousedown={handle_mousedown} style:transform>
+	<div class="handle {type} {location}" bind:this={el}></div>
+</div>
+
+<style>
+	.hitbox {
+		position: absolute;
+		width: 50px;
+		height: 50px;
+		--hitbox-mid-offset: calc(50% - 25px);
+		--hitbox-corner-offset: -25px;
+		--handle-corner-offset: calc(50% - 5px);
+		--handle-mid-offset: calc(50% - 2px);
+		z-index: var(--layer-top);
+	}
+
+	/* hitbox positions  */
+	.hitbox.tl,
+	.hitbox.bl,
+	.hitbox.l {
+		left: var(--hitbox-corner-offset);
+	}
+
+	.hitbox.tr,
+	.hitbox.br,
+	.hitbox.r {
+		right: var(--hitbox-corner-offset);
+	}
+
+	.hitbox.t,
+	.hitbox.tr,
+	.hitbox.tl {
+		top: var(--hitbox-corner-offset);
+	}
+
+	.hitbox.t,
+	.hitbox.b {
+		left: var(--hitbox-mid-offset);
+	}
+
+	.hitbox.l,
+	.hitbox.r {
+		top: var(--hitbox-mid-offset);
+	}
+
+	.hitbox.b,
+	.hitbox.br,
+	.hitbox.bl {
+		bottom: var(--hitbox-corner-offset);
+	}
+
+	/* hitbox cursors */
+
+	.hitbox.tl,
+	.hitbox.br {
+		cursor: nwse-resize;
+	}
+
+	.hitbox.bl,
+	.hitbox.tr {
+		cursor: nesw-resize;
+	}
+
+	.hitbox.l,
+	.hitbox.r {
+		cursor: ew-resize;
+	}
+
+	.hitbox.t,
+	.hitbox.b {
+		cursor: ns-resize;
+	}
+
+	/* Visual handles  */
+	.handle {
+		position: absolute;
+	}
+
+	/* square to fill in corners */
+	.corner {
+		width: 4px;
+		height: 4px;
+		background: black;
+	}
+
+	/* handle segment positions  */
+	.handle.tl,
+	.handle.bl,
+	.handle.l {
+		left: var(--handle-corner-offset);
+	}
+
+	.handle.tr,
+	.handle.r,
+	.handle.br {
+		right: var(--handle-corner-offset);
+	}
+
+	.handle.tr,
+	.handle.t,
+	.handle.tl {
+		top: var(--handle-corner-offset);
+	}
+
+	.handle.br,
+	.handle.b,
+	.handle.bl {
+		bottom: var(--handle-corner-offset);
+	}
+
+	.handle.l,
+	.handle.r {
+		bottom: var(--handle-mid-offset);
+	}
+
+	.handle.t,
+	.handle.b {
+		left: var(--handle-mid-offset);
+	}
+
+	.handle::before {
+		position: absolute;
+		content: "";
+		width: 20px;
+		height: 4px;
+		background: black;
+	}
+
+	.handle::after {
+		position: absolute;
+		content: "";
+		width: 4px;
+		height: 20px;
+		background: black;
+	}
+
+	.handle.t::before,
+	.handle.b::before {
+		width: 30px;
+		left: -14px;
+	}
+
+	.handle.r::after,
+	.handle.l::after {
+		height: 30px;
+		top: -13px;
+	}
+
+	.handle.l::before,
+	.handle.r::before {
+		content: none;
+	}
+
+	.handle.t::after,
+	.handle.b::after {
+		content: none;
+	}
+
+	.handle.tr::before,
+	.handle.br::before {
+		right: 4px;
+	}
+
+	.handle.tl::before,
+	.handle.bl::before {
+		left: 4px;
+	}
+
+	.handle.tl::after,
+	.handle.tr::after {
+		top: 4px;
+	}
+
+	.handle.bl::after,
+	.handle.br::after {
+		bottom: 4px;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/IconButton.svelte

@@ -0,0 +1,133 @@
+<script lang="ts">
+	import { type ComponentType } from "svelte";
+	export let Icon: ComponentType;
+	export let label = "";
+	export let show_label = false;
+	export let pending = false;
+	export let size: "small" | "large" | "medium" = "small";
+	export let padded = true;
+	export let highlight = false;
+	export let disabled = false;
+	export let hasPopup = false;
+	export let color = "var(--block-label-text-color)";
+	export let transparent = false;
+	export let background = "var(--background-fill-primary)";
+	export let offset = 0;
+	$: _color = highlight ? "var(--color-accent)" : color;
+</script>
+
+<button
+	{disabled}
+	on:click
+	aria-label={label}
+	aria-haspopup={hasPopup}
+	title={label}
+	class:pending
+	class:padded
+	class:highlight
+	class:transparent
+	style:color={!disabled && _color ? _color : "var(--block-label-text-color)"}
+	style:--bg-color={!disabled ? background : "auto"}
+	style:margin-left={offset + "px"}
+>
+	{#if show_label}<span>{label}</span>{/if}
+	<div
+		class:small={size === "small"}
+		class:large={size === "large"}
+		class:medium={size === "medium"}
+	>
+		<Icon />
+	</div>
+</button>
+
+<style>
+	button {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		gap: 1px;
+		z-index: var(--layer-2);
+		/* background: var(--background-fill-primary); */
+		border-radius: var(--radius-sm);
+		color: var(--block-label-text-color);
+		border: 1px solid transparent;
+	}
+
+	button[disabled] {
+		opacity: 0.5;
+		box-shadow: none;
+	}
+
+	button[disabled]:hover {
+		cursor: not-allowed;
+		/* border: 1px solid var(--button-secondary-border-color); */
+		/* padding: 2px; */
+	}
+
+	.padded {
+		padding: 2px;
+		background: var(--bg-color);
+		box-shadow: var(--shadow-drop);
+		border: 1px solid var(--button-secondary-border-color);
+	}
+
+	button:hover,
+	button.highlight {
+		cursor: pointer;
+		color: var(--color-accent);
+	}
+
+	.padded:hover {
+		border: 2px solid var(--button-secondary-border-color-hover);
+		padding: 1px;
+		color: var(--block-label-text-color);
+	}
+
+	span {
+		padding: 0px 1px;
+		font-size: 10px;
+	}
+
+	div {
+		padding: 2px;
+		display: flex;
+		align-items: flex-end;
+	}
+
+	.small {
+		width: 14px;
+		height: 14px;
+	}
+
+	.medium {
+		width: 20px;
+		height: 20px;
+	}
+
+	.large {
+		width: 22px;
+		height: 22px;
+	}
+
+	.pending {
+		animation: flash 0.5s infinite;
+	}
+
+	@keyframes flash {
+		0% {
+			opacity: 0.5;
+		}
+		50% {
+			opacity: 1;
+		}
+		100% {
+			opacity: 0.5;
+		}
+	}
+
+	.transparent {
+		background: transparent;
+		border: none;
+		box-shadow: none;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/Sources.svelte

@@ -0,0 +1,276 @@
+<script lang="ts">
+	import { getContext, onMount, tick, createEventDispatcher } from "svelte";
+	import { type ToolContext, TOOL_KEY } from "./Tools.svelte";
+	import { type EditorContext, EDITOR_KEY } from "../ImageEditor.svelte";
+	import {
+		Image as ImageIcon,
+		Webcam as WebcamIcon,
+		ImagePaste
+	} from "@gradio/icons";
+	import { Upload } from "@gradio/upload";
+	import { Webcam } from "@gradio/image";
+	import { type I18nFormatter } from "@gradio/utils";
+	import { default as IconButton } from "./IconButton.svelte";
+	import { type Client } from "@gradio/client";
+
+	import { add_bg_color, add_bg_image } from "./sources";
+	import type { FileData } from "@gradio/client";
+
+	export let background_file: FileData | null;
+	export let root: string;
+	export let sources: ("upload" | "webcam" | "clipboard")[] = [
+		"upload",
+		"webcam",
+		"clipboard"
+	];
+	export let mirror_webcam = true;
+	export let i18n: I18nFormatter;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let dragging: boolean;
+
+	const { active_tool } = getContext<ToolContext>(TOOL_KEY);
+	const { pixi, dimensions, register_context, reset, editor_box } =
+		getContext<EditorContext>(EDITOR_KEY);
+
+	export let active_mode: "webcam" | "color" | null = null;
+	let background: Blob | File | null;
+
+	const dispatch = createEventDispatcher<{
+		upload: never;
+	}>();
+
+	const sources_meta = {
+		upload: {
+			icon: ImageIcon,
+			label: "Upload",
+			order: 0,
+			id: "bg_upload",
+			cb() {
+				upload_component.open_file_upload();
+
+				$active_tool = "bg";
+			}
+		},
+		webcam: {
+			icon: WebcamIcon,
+			label: "Webcam",
+			order: 1,
+			id: "bg_webcam",
+			cb() {
+				active_mode = "webcam";
+				$active_tool = "bg";
+			}
+		},
+		clipboard: {
+			icon: ImagePaste,
+			label: "Paste",
+			order: 2,
+			id: "bg_clipboard",
+			cb() {
+				process_clipboard();
+				$active_tool = null;
+			}
+		}
+	} as const;
+
+	$: sources_list = sources
+		.map((src) => sources_meta[src])
+		.sort((a, b) => a.order - b.order);
+
+	let upload_component: Upload;
+
+	async function process_clipboard(): Promise<void> {
+		const items = await navigator.clipboard.read();
+
+		for (let i = 0; i < items.length; i++) {
+			const type = items[i].types.find((t) => t.startsWith("image/"));
+			if (type) {
+				const blob = await items[i].getType(type);
+
+				background = blob || null;
+			}
+		}
+	}
+
+	function handle_upload(e: CustomEvent<Blob | any>): void {
+		const file_data = e.detail;
+		background = file_data;
+		active_mode = null;
+	}
+
+	let should_reset = true;
+
+	async function set_background(): Promise<void> {
+		if (!$pixi) return;
+		if (background) {
+			const add_image = add_bg_image(
+				$pixi.background_container,
+				$pixi.renderer,
+				background,
+				$pixi.resize
+			);
+			$dimensions = await add_image.start();
+
+			if (should_reset) {
+				reset(false, $dimensions);
+			}
+
+			add_image.execute();
+
+			should_reset = true;
+
+			await tick();
+			bg = true;
+		}
+	}
+
+	async function process_bg_file(file: FileData | null): Promise<void> {
+		if (!file || !file.url) return;
+		should_reset = false;
+
+		const blob_res = await fetch(file.url);
+		const blob = await blob_res.blob();
+		background = blob;
+	}
+
+	function handle_key(e: KeyboardEvent): void {
+		if (e.key === "Escape") {
+			active_mode = null;
+		}
+	}
+
+	$: background && set_background();
+	$: process_bg_file(background_file);
+
+	export let bg = false;
+
+	register_context("bg", {
+		init_fn: () => {
+			if (!$pixi) return;
+
+			const add_image = add_bg_color(
+				$pixi.background_container,
+				$pixi.renderer,
+				"black",
+				...$dimensions,
+				$pixi.resize
+			);
+			$dimensions = add_image.start();
+			add_image.execute();
+		},
+		reset_fn: () => {}
+	});
+</script>
+
+<svelte:window on:keydown={handle_key} />
+
+{#if sources.length}
+	<div class="source-wrap">
+		{#each sources_list as { icon, label, id, cb } (id)}
+			<IconButton
+				Icon={icon}
+				size="medium"
+				padded={false}
+				label={label + " button"}
+				hasPopup={true}
+				transparent={true}
+				on:click={cb}
+			/>
+		{/each}
+		<span class="sep"></span>
+	</div>
+	<div
+		class="upload-container"
+		class:click-disabled={!!bg ||
+			active_mode === "webcam" ||
+			$active_tool !== "bg"}
+		style:height="{$editor_box.child_height +
+			($editor_box.child_top - $editor_box.parent_top)}px"
+	>
+		<Upload
+			hidden={bg || active_mode === "webcam" || $active_tool !== "bg"}
+			bind:this={upload_component}
+			filetype="image/*"
+			on:load={handle_upload}
+			on:error
+			bind:dragging
+			{root}
+			disable_click={!sources.includes("upload")}
+			format="blob"
+			{upload}
+			{stream_handler}
+		></Upload>
+		{#if active_mode === "webcam"}
+			<div
+				class="modal"
+				style:max-width="{$editor_box.child_width}px"
+				style:max-height="{$editor_box.child_height}px"
+				style:top="{$editor_box.child_top - $editor_box.parent_top}px"
+			>
+				<div class="modal-inner">
+					<Webcam
+						{upload}
+						{root}
+						on:capture={handle_upload}
+						on:error
+						on:drag
+						{mirror_webcam}
+						streaming={false}
+						mode="image"
+						include_audio={false}
+						{i18n}
+					/>
+				</div>
+			</div>
+		{/if}
+	</div>
+{/if}
+
+<style>
+	.modal {
+		position: absolute;
+		height: 100%;
+		width: 100%;
+		left: 0;
+		right: 0;
+		margin: auto;
+		z-index: var(--layer-top);
+		display: flex;
+		align-items: center;
+	}
+
+	.modal-inner {
+		width: 100%;
+	}
+
+	.sep {
+		height: 12px;
+		background-color: var(--block-border-color);
+		width: 1px;
+		display: block;
+		margin-left: var(--spacing-xl);
+	}
+
+	.source-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		margin-left: var(--spacing-lg);
+		height: 100%;
+	}
+
+	.upload-container {
+		position: absolute;
+		height: 100%;
+		flex-shrink: 1;
+		max-height: 100%;
+		width: 100%;
+		left: 0;
+		top: 0;
+	}
+
+	.upload-container.click-disabled {
+		pointer-events: none;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/Tools.svelte

@@ -0,0 +1,162 @@
+<script lang="ts" context="module">
+	import type {
+		Subscriber,
+		Invalidator,
+		Unsubscriber,
+		Writable
+	} from "svelte/store";
+	import type { tool } from "../tools/";
+
+	export const TOOL_KEY = Symbol("tool");
+
+	type upload_tool = "bg_webcam" | "bg_upload" | "bg_clipboard" | "bg_color";
+	type transform_tool = "crop" | "rotate";
+	type brush_tool = "brush_color" | "brush_size";
+	type eraser_tool = "eraser_size";
+
+	export interface ToolOptions {
+		order: number;
+		label: string;
+		icon: typeof Image;
+		cb: (...args: any[]) => void;
+		id: upload_tool | transform_tool | brush_tool | eraser_tool;
+	}
+
+	export interface ToolMeta {
+		default: upload_tool | transform_tool | brush_tool | eraser_tool | null;
+		options: ToolOptions[];
+	}
+
+	export interface ToolContext {
+		register_tool: (type: tool, opts?: { cb: () => void }) => () => void;
+		active_tool: {
+			set: (tool: tool) => void;
+			subscribe(
+				this: void,
+				run: Subscriber<tool | null>,
+				invalidate?: Invalidator<tool | null>
+			): Unsubscriber;
+		};
+
+		current_color: Writable<string>;
+	}
+</script>
+
+<script lang="ts">
+	import { Toolbar } from "@gradio/atoms";
+	import { default as IconButton } from "./IconButton.svelte";
+	import { getContext, setContext } from "svelte";
+	import { writable } from "svelte/store";
+	import { EDITOR_KEY, type EditorContext } from "../ImageEditor.svelte";
+	import { Image, Crop, Brush, Erase } from "@gradio/icons";
+	import { type I18nFormatter } from "@gradio/utils";
+
+	const { active_tool, toolbar_box, editor_box } =
+		getContext<EditorContext>(EDITOR_KEY);
+
+	export let i18n: I18nFormatter;
+
+	let tools: tool[] = [];
+
+	const cbs: Record<string, () => void> = {};
+	let current_color = writable("#000000");
+	const tool_context: ToolContext = {
+		current_color,
+		register_tool: (type: tool, opts?: { cb: () => void }) => {
+			tools = [...tools, type];
+			if (opts?.cb) {
+				cbs[type] = opts.cb;
+			}
+
+			return () => {
+				tools = tools.filter((tool) => tool !== type);
+			};
+		},
+
+		active_tool: {
+			subscribe: active_tool.subscribe,
+			set: active_tool.set
+		}
+	};
+
+	setContext<ToolContext>(TOOL_KEY, tool_context);
+
+	const tools_meta: Record<
+		tool,
+		{
+			order: number;
+			label: string;
+			icon: typeof Image;
+		}
+	> = {
+		crop: {
+			order: 1,
+			label: i18n("Transform"),
+			icon: Crop
+		},
+		draw: {
+			order: 2,
+			label: i18n("Draw"),
+			icon: Brush
+		},
+		erase: {
+			order: 2,
+			label: i18n("Erase"),
+			icon: Erase
+		},
+		bg: {
+			order: 0,
+			label: i18n("Background"),
+			icon: Image
+		}
+	} as const;
+
+	let toolbar_width: number;
+	let toolbar_wrap: HTMLDivElement;
+
+	$: toolbar_width, $editor_box, get_dimensions();
+
+	function get_dimensions(): void {
+		if (!toolbar_wrap) return;
+		$toolbar_box = toolbar_wrap.getBoundingClientRect();
+	}
+
+	function handle_click(e: Event, tool: tool): void {
+		e.stopPropagation();
+		$active_tool = tool;
+		cbs[tool] && cbs[tool]();
+	}
+</script>
+
+<slot />
+
+<div
+	class="toolbar-wrap"
+	bind:clientWidth={toolbar_width}
+	bind:this={toolbar_wrap}
+>
+	<Toolbar show_border={false}>
+		{#each tools as tool (tool)}
+			<IconButton
+				highlight={$active_tool === tool}
+				on:click={(e) => handle_click(e, tool)}
+				Icon={tools_meta[tool].icon}
+				size="medium"
+				padded={false}
+				label={tools_meta[tool].label + " button"}
+				transparent={true}
+				offset={tool === "draw" ? -2 : tool === "erase" ? -6 : 0}
+			/>
+		{/each}
+	</Toolbar>
+</div>
+
+<style>
+	.toolbar-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		margin-left: var(--spacing-xl);
+		height: 100%;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/brush.ts

@@ -0,0 +1,247 @@
+import {
+	Container,
+	Graphics,
+	Color,
+	type ColorSource,
+	type IRenderer,
+	RenderTexture,
+	Sprite
+} from "pixi.js";
+
+import type { LayerScene } from "../layers/utils";
+import { type Command } from "../utils/commands";
+import { make_graphics } from "../utils/pixi";
+
+export interface DrawCommand extends Command {
+	/**
+	 * sets the initial state to begin drawing
+	 * @param options the options for drawing
+	 * @returns
+	 */
+	start: (options: DrawOptions) => void;
+	/**
+	 * continues drawing, smoothly interpolating between points where necessary
+	 * @param options the options for drawing
+	 * @returns
+	 */
+	continue: (options: Points) => void;
+	/**
+	 * stops drawing
+	 * @returns
+	 */
+	stop: () => void;
+	/**
+	 * Whether or not the user is currently drawing.
+	 */
+	drawing: boolean;
+}
+
+/**
+ * Coordinates for a draw or erase path.
+ */
+interface Points {
+	/**
+	 * The x coordinate of the path.
+	 */
+	x: number;
+	/**
+	 * The y coordinate of the path.
+	 */
+	y: number;
+}
+
+/**
+ * Options for drawing a path.
+ */
+interface DrawOptions extends Points {
+	/**
+	 * The size of the brush.
+	 */
+	size: number;
+	/**
+	 * The color of the brush.
+	 */
+	color?: ColorSource;
+	/**
+	 * The opacity of the brush.
+	 */
+	opacity: number;
+	/**
+	 * Whether or not to set the initial texture.
+	 */
+	set_initial_texture?: boolean;
+}
+
+/**
+ * Draws a circle on the given graphics object.
+ * @param graphics the graphics object to draw on
+ * @param x the x coordinate of the circle
+ * @param y the y coordinate of the circle
+ * @param brush_color the color of the circle
+ * @param brush_size the radius of the circle
+ */
+function drawCircle(
+	graphics: Graphics,
+	x: number,
+	y: number,
+	brush_color: ColorSource = new Color("black"),
+	brush_size: number
+): void {
+	const color = new Color(brush_color);
+	graphics.beginFill(color);
+	graphics.drawCircle(x, y, brush_size);
+	graphics.endFill();
+}
+
+/**
+ * Interpolates between two points.
+ * @param point1 the first point
+ * @param point2 the second point
+ * @returns an array of points between the two points
+ */
+function interpolate(
+	point1: { x: number; y: number },
+	point2: { x: number; y: number }
+): Points[] {
+	let points: Points[] = [];
+	const dx = point2.x - point1.x;
+	const dy = point2.y - point1.y;
+	const distance = Math.sqrt(dx * dx + dy * dy);
+	const steps = Math.ceil(distance / 2);
+	const stepX = dx / steps;
+	const stepY = dy / steps;
+
+	for (let j = 0; j < steps; j++) {
+		const x = point1.x + j * stepX;
+		const y = point1.y + j * stepY;
+		points.push({ x, y });
+	}
+
+	return points;
+}
+
+export function draw_path(
+	renderer: IRenderer,
+	stage: Container,
+	layer: LayerScene,
+	mode: "draw" | "erase"
+): DrawCommand {
+	const paths: Points[] = [];
+	let initial_path: DrawOptions;
+	let graphics: Graphics;
+	let InitialTexture: RenderTexture;
+
+	let has_drawn = false;
+	let id = 0;
+
+	return {
+		drawing: false,
+		start: function ({
+			x,
+			y,
+			size,
+			color = new Color("black"),
+			opacity,
+			set_initial_texture = true
+		}: DrawOptions) {
+			if (set_initial_texture) {
+				InitialTexture = RenderTexture.create({
+					width: layer.draw_texture.width,
+					height: layer.draw_texture.height
+				});
+				renderer.render(layer.composite, {
+					renderTexture: InitialTexture
+				});
+			}
+			initial_path = { x, y, size, color, opacity };
+			paths.push({ x, y });
+			graphics = make_graphics(id++);
+
+			drawCircle(graphics, x, y, color, size);
+
+			renderer.render(graphics, {
+				renderTexture:
+					mode === "draw" ? layer.draw_texture : layer.erase_texture,
+				clear: false
+			});
+
+			this.drawing = true;
+		},
+		continue: function ({ x, y }: Points) {
+			const last_point = paths[paths.length - 1];
+			const new_points = interpolate(last_point, { x, y });
+
+			for (let i = 0; i < new_points.length; i++) {
+				const { x, y } = new_points[i];
+				drawCircle(graphics, x, y, initial_path.color, initial_path.size);
+				paths.push({ x, y });
+			}
+
+			renderer.render(graphics, {
+				renderTexture:
+					mode === "draw" ? layer.draw_texture : layer.erase_texture,
+				clear: false
+			});
+			graphics.clear();
+		},
+		stop: function () {
+			const current_sketch = RenderTexture.create({
+				width: layer.draw_texture.width,
+				height: layer.draw_texture.height
+			});
+
+			renderer.render(layer.composite, {
+				renderTexture: current_sketch
+			});
+
+			renderer.render(new Sprite(current_sketch), {
+				renderTexture: layer.draw_texture
+			});
+
+			const clear_graphics = new Graphics()
+				.beginFill(0x000000, 0) // Use a fill color with 0 alpha for transparency
+				.drawRect(0, 0, layer.erase_texture.width, layer.erase_texture.height)
+				.endFill();
+
+			renderer.render(clear_graphics, {
+				renderTexture: layer.erase_texture,
+				clear: true
+			});
+
+			has_drawn = true;
+			this.drawing = false;
+		},
+		execute: function () {
+			if (!has_drawn) {
+				for (let i = 1; i < paths.length; i++) {
+					const { x, y } = paths[i];
+					drawCircle(graphics, x, y, initial_path.color, initial_path.size);
+				}
+
+				renderer.render(graphics, {
+					renderTexture:
+						mode === "draw" ? layer.draw_texture : layer.erase_texture,
+					clear: false
+				});
+
+				this.stop!();
+			}
+		},
+		undo: function () {
+			const clear_graphics = new Graphics()
+				.beginFill(0x000000, 0)
+				.drawRect(0, 0, layer.erase_texture.width, layer.erase_texture.height)
+				.endFill();
+			renderer.render(new Sprite(InitialTexture), {
+				renderTexture: layer.draw_texture
+			});
+			renderer.render(clear_graphics, {
+				renderTexture: layer.erase_texture,
+				clear: true
+			});
+
+			this.stop!();
+			has_drawn = false;
+		}
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/crop.ts

@@ -0,0 +1,215 @@
+import {
+	Graphics,
+	type IRenderer,
+	type Container,
+	Sprite,
+	RenderTexture
+} from "pixi.js";
+import { type Command } from "../utils/commands";
+import { spring } from "svelte/motion";
+import type { Writable } from "svelte/store";
+
+export interface CropCommand extends Command {
+	start: (
+		width: number,
+		height: number,
+		previous_crop: [number, number, number, number],
+		preview?: boolean,
+		set_previous?: boolean
+	) => void;
+	stop: () => number;
+	continue: (
+		crop_size: [number, number, number, number],
+		preview?: boolean
+	) => void;
+}
+
+export function crop_canvas(
+	renderer: IRenderer,
+	mask_container: Container,
+	crop: Writable<[number, number, number, number]>,
+	current_opacity = 0
+): CropCommand {
+	let text: RenderTexture;
+	let sprite: Sprite;
+	const mask_graphics = new Graphics();
+	let previous_crop: [number, number, number, number];
+	let final_crop: [number, number, number, number];
+	let width: number;
+	let height: number;
+	let alpha_spring = spring(current_opacity, {
+		stiffness: 0.1,
+		damping: 0.5
+	});
+
+	let spring_value = current_opacity;
+	alpha_spring.subscribe((value) => {
+		if (!final_crop) return;
+		spring_value = value;
+		crop_mask(width, height, final_crop, true);
+	});
+
+	function crop_mask(
+		width: number,
+		height: number,
+		crop_size: [number, number, number, number],
+		preview: boolean
+	): void {
+		mask_graphics.clear();
+		if (preview) {
+			mask_graphics.beginFill(0xffffff, spring_value);
+			mask_graphics.drawRect(0, 0, width, height);
+			mask_graphics.endFill();
+		}
+		mask_graphics.beginFill(0xffffff, 1);
+		mask_graphics.drawRect(...crop_size);
+		mask_graphics.endFill();
+
+		renderer.render(mask_graphics, {
+			renderTexture: text
+		});
+	}
+
+	let clean = true;
+	let stopped = false;
+
+	return {
+		start: (
+			_width: number,
+			_height: number,
+			_previous_crop: [number, number, number, number],
+			_preview = true,
+			set_previous = true
+		) => {
+			clean = false;
+			text = RenderTexture.create({
+				width: _width,
+				height: _height
+			});
+
+			crop_mask(_width, _height, _previous_crop, _preview);
+			sprite = new Sprite(text);
+			mask_container.mask = sprite;
+			width = _width;
+			height = _height;
+			if (set_previous)
+				previous_crop = JSON.parse(JSON.stringify(_previous_crop));
+		},
+		continue: (crop_size: [number, number, number, number], preview = true) => {
+			final_crop = JSON.parse(JSON.stringify(crop_size));
+			if (spring_value === 0.2) {
+				crop_mask(width, height, final_crop, preview);
+			} else {
+				alpha_spring.set(0.2);
+			}
+		},
+
+		undo() {
+			this.start(width, height, previous_crop, false);
+			crop.set([
+				previous_crop[0] / width,
+				previous_crop[1] / height,
+				previous_crop[2] / width,
+				previous_crop[3] / height
+			]);
+			clean = true;
+		},
+		stop() {
+			stopped = true;
+			return spring_value;
+		},
+		execute() {
+			if (clean) {
+				this.start(width, height, final_crop, false);
+
+				crop.set([
+					final_crop[0] / width,
+					final_crop[1] / height,
+					final_crop[2] / width,
+					final_crop[3] / height
+				]);
+				clean = true;
+			} else {
+				if (!stopped) {
+					alpha_spring.set(0);
+				}
+
+				crop.set([
+					final_crop[0] / width,
+					final_crop[1] / height,
+					final_crop[2] / width,
+					final_crop[3] / height
+				]);
+
+				clean = true;
+			}
+		}
+	};
+}
+
+export function resize_and_reposition(
+	original_width: number,
+	original_height: number,
+	anchor: "t" | "r" | "l" | "b" | "tl" | "tr" | "bl" | "br" | "c",
+	aspect_ratio: number,
+	max_width: number,
+	max_height: number
+): {
+	new_width: number;
+	new_height: number;
+	x_offset: number;
+	y_offset: number;
+} {
+	let new_width = original_width;
+	let new_height = original_height;
+
+	// Calculate new dimensions based on aspect ratio
+	if (anchor.includes("t") || anchor.includes("b") || anchor == "c") {
+		new_width = original_height * aspect_ratio;
+	}
+	if (anchor.includes("l") || anchor.includes("r") || anchor == "c") {
+		new_height = original_width / aspect_ratio;
+	}
+
+	// Ensure aspect ratio is maintained
+	new_height = new_height || new_width / aspect_ratio;
+	new_width = new_width || new_height * aspect_ratio;
+
+	// Apply max width/height constraints and adjust dimensions
+	if (new_width > max_width) {
+		new_width = max_width;
+		new_height = new_width / aspect_ratio;
+	}
+	if (new_height > max_height) {
+		new_height = max_height;
+		new_width = new_height * aspect_ratio;
+	}
+
+	// Calculate offsets to ensure anchor position is maintained
+	let x_offset = 0;
+	let y_offset = 0;
+	if (anchor.includes("r")) {
+		x_offset = original_width - new_width;
+	} else if (anchor.includes("l")) {
+		x_offset = 0;
+	} else {
+		// Center or top/bottom center
+		x_offset = (original_width - new_width) / 2;
+	}
+
+	if (anchor.includes("b")) {
+		y_offset = original_height - new_height;
+	} else if (anchor.includes("t")) {
+		y_offset = 0;
+	} else {
+		// Center or left/right center
+		y_offset = (original_height - new_height) / 2;
+	}
+
+	return {
+		new_width: new_width,
+		new_height: new_height,
+		x_offset: x_offset,
+		y_offset: y_offset
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/index.ts

@@ -0,0 +1,5 @@
+export { default as Tools } from "./Tools.svelte";
+export { default as Brush } from "./Brush.svelte";
+export { default as Crop } from "./Crop.svelte";
+export { default as Sources } from "./Sources.svelte";
+export * from "./types";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/sources.ts

@@ -0,0 +1,114 @@
+import {
+	type Container,
+	type IRenderer,
+	Sprite,
+	Texture,
+	DisplayObject,
+	type ColorSource,
+	Color,
+	RenderTexture
+} from "pixi.js";
+
+import { type Command } from "../utils/commands";
+import { make_graphics } from "../utils/pixi";
+
+interface BgImageCommand extends Command {
+	/**
+	 * Initial setup for the bg command
+	 * @returns
+	 */
+	start: () => Promise<[number, number]>;
+}
+
+/**
+ * Adds a background image to the canvas.
+ * @param container The container to add the image to.
+ * @param renderer The renderer to use for the image.
+ * @param background The background image to add.
+ * @param resize The function to resize the canvas.
+ * @returns A command that can be used to undo the action.
+ */
+
+export function add_bg_image(
+	container: Container,
+	renderer: IRenderer,
+	background: Blob | File,
+	resize: (width: number, height: number) => void
+): BgImageCommand {
+	let sprite: Sprite & DisplayObject;
+	return {
+		async start() {
+			container.removeChildren();
+			const img = await createImageBitmap(background);
+			const bitmap_texture = Texture.from(img);
+			sprite = new Sprite(bitmap_texture) as Sprite & DisplayObject;
+			return [sprite.width, sprite.height];
+		},
+		async execute() {
+			// renderer.resize(sprite.width, sprite.height);
+			resize(sprite.width, sprite.height);
+
+			sprite.zIndex = 0;
+			container.addChild(sprite);
+		},
+		undo() {
+			container.removeChildAt(0);
+		}
+	};
+}
+
+/**
+ * Command that sets a background
+ */
+interface BgColorCommand extends Command {
+	/**
+	 * Initial setup for the bg command
+	 * @returns
+	 */
+	start: () => [number, number];
+}
+
+/**
+ * Adds a background color to the canvas.
+ * @param container The container to add the image to.
+ * @param renderer The renderer to use for the image.
+ * @param color The background color to add.
+ * @param width The width of the background.
+ * @param height The height of the background.
+ * @param resize The function to resize the canvas.
+ * @returns A command that can be used to undo the action.
+ */
+export function add_bg_color(
+	container: Container,
+	renderer: IRenderer,
+	color: ColorSource,
+	width: number,
+	height: number,
+	resize: (width: number, height: number) => void
+): BgColorCommand {
+	let sprite: Sprite & DisplayObject;
+	return {
+		start() {
+			container.removeChildren();
+			const graphics = make_graphics(1);
+			const texture = RenderTexture.create({
+				width,
+				height
+			});
+			graphics.beginFill(new Color(color));
+			graphics.drawRect(0, 0, width, height);
+			graphics.endFill();
+			renderer.render(graphics, { renderTexture: texture });
+			sprite = new Sprite(texture) as Sprite & DisplayObject;
+			return [sprite.width, sprite.height];
+		},
+		async execute() {
+			resize(sprite.width, sprite.height);
+			sprite.zIndex = 1;
+			container.addChild(sprite);
+		},
+		undo() {
+			container.removeChildren();
+		}
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/tools/types.ts

@@ -0,0 +1 @@
+export type tool = "draw" | "erase" | "crop" | "bg";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/utils/commands.ts

@@ -0,0 +1,162 @@
+import { writable, type Writable } from "svelte/store";
+
+/**
+ * Base command interface that is added to the command_managers history
+ */
+export interface Command {
+	/**
+	 * Optionally called when the command is first executed for multi-step commands
+	 * @param args arguments to pass to the command
+	 */
+	start?: (...args: any) => any | Promise<any>;
+	/**
+	 * Optionally called when the command is continued for multi-step commands
+	 * @param args arguments to pass to the command
+	 */
+	continue?: (...args: any) => any | Promise<any>;
+	/**
+	 * Optionally called when the command is stopped for multi-step commands
+	 * @param args arguments to pass to the command
+	 */
+	stop?: (...args: any) => any | Promise<any>;
+	/**
+	 * Called by the command manager to execute the command, can act as a no-op if the work has already been done
+	 * This function must be able to recreate the command if the command is undone and redone (`stop`/`start`/`continue` will not be called again)
+	 */
+	execute(): any | Promise<any>;
+	/**
+	 * Called by the command manager to undo the command
+	 * This function must be able to undo the work done by the execute function
+	 */
+	undo(): any | Promise<any>;
+}
+
+/**
+ * Command manager interface that handles the undo/redo history
+ */
+export interface CommandManager {
+	/**
+	 * Undo the last command
+	 */
+	undo(): void;
+	/**
+	 * Redo the last undone command
+	 */
+	redo(): void;
+	/**
+	 * Execute a command and add it to the history
+	 * @param command command to execute
+	 */
+	execute(command: Command): void;
+	/**
+	 * Whether or not there are commands that can be undone
+	 * Observable store that you can subscribe to for updates
+	 */
+	readonly can_undo: Writable<boolean>;
+	/**
+	 * Whether or not there are commands that can be redone
+	 * Observable store that you can subscribe to for updates
+	 */
+	readonly can_redo: Writable<boolean>;
+	/**
+	 * Resets the history
+	 */
+	reset(): void;
+	/**
+	 * The current history node
+	 * Observable store that you can subscribe to for updates
+	 */
+	readonly current_history: Writable<CommandNode>;
+}
+
+/**
+ * Command node interface that is used to create the undo/redo history
+ */
+interface CommandNode {
+	/**
+	 * Command that the node holds
+	 */
+	command: Command | null;
+	/**
+	 * Next command in the history
+	 */
+	next: CommandNode | null;
+	/**
+	 * Previous command in the history
+	 */
+	previous: CommandNode | null;
+	/**
+	 * Push a command onto the history
+	 * @param command command to push onto the history
+	 */
+	push(command: Command): void;
+}
+
+/**
+ * Creates a command node
+ * @param command command to add to the node
+ * @returns a command node
+ */
+function command_node(command?: Command): CommandNode {
+	return {
+		command: command || null,
+		next: null,
+		previous: null,
+		push: function (command: Command) {
+			const node = command_node(command);
+			node.previous = this;
+			this.next = node;
+		}
+	};
+}
+
+/**
+ * Creates a command manager
+ * @returns a command manager
+ */
+export function command_manager(): CommandManager {
+	let history: CommandNode = command_node();
+	const can_undo = writable(false);
+	const can_redo = writable(false);
+	const current_history = writable(history);
+	return {
+		undo: function () {
+			if (history.previous) {
+				history.command?.undo();
+				history = history.previous;
+			}
+			can_undo.set(!!history.previous);
+			can_redo.set(!!history.next);
+			current_history.set(history);
+		},
+		redo: function () {
+			if (history.next) {
+				history.next.command?.execute();
+				history = history.next;
+			}
+
+			can_undo.set(!!history.previous);
+			can_redo.set(!!history.next);
+			current_history.set(history);
+		},
+		execute: function (command: Command) {
+			command.execute();
+			history.push(command);
+			history = history.next!;
+			can_undo.set(!!history.previous);
+			can_redo.set(!!history.next);
+			current_history.set(history);
+		},
+
+		can_undo,
+		can_redo,
+		current_history,
+
+		reset: function () {
+			history = command_node();
+			can_undo.set(false);
+			can_redo.set(false);
+			current_history.set(history);
+		}
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/utils/events.ts

@@ -0,0 +1,30 @@
+import { tick } from "svelte";
+
+/**
+ * Svelte action to handle clicks outside of a DOM node
+ * @param node DOM node to check the click is outside of
+ * @param callback callback function to call if click is outside
+ * @returns svelte action return object with destroy method to remove event listener
+ */
+export function click_outside(
+	node: Node,
+	callback: (arg: MouseEvent) => void
+): any {
+	const handle_click = (event: MouseEvent): void => {
+		if (
+			node &&
+			!node.contains(event.target as Node) &&
+			!event.defaultPrevented
+		) {
+			callback(event);
+		}
+	};
+
+	document.addEventListener("mousedown", handle_click, true);
+
+	return {
+		destroy() {
+			document.removeEventListener("mousedown", handle_click, true);
+		}
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/utils/parse_placeholder.ts

@@ -0,0 +1,27 @@
+const RE_HEADING = /^(#\s*)(.+)$/m;
+
+export function inject(text: string): [string | false, string | false] {
+	const trimmed_text = text.trim();
+
+	const heading_match = trimmed_text.match(RE_HEADING);
+	if (!heading_match) {
+		return [false, trimmed_text || false];
+	}
+
+	const [full_match, , heading_content] = heading_match;
+	const _heading = heading_content.trim();
+
+	if (trimmed_text === full_match) {
+		return [_heading, false];
+	}
+
+	const heading_end_index =
+		heading_match.index !== undefined
+			? heading_match.index + full_match.length
+			: 0;
+	const remaining_text = trimmed_text.substring(heading_end_index).trim();
+
+	const _paragraph = remaining_text || false;
+
+	return [_heading, _paragraph];
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/imageeditor/shared/utils/pixi.ts

@@ -0,0 +1,298 @@
+import {
+	Application,
+	Container,
+	Graphics,
+	Sprite,
+	Rectangle,
+	RenderTexture,
+	type IRenderer,
+	type DisplayObject,
+	type ICanvas
+} from "pixi.js";
+
+import { type LayerScene } from "../layers/utils";
+
+/**
+ * interface holding references to pixi app components
+ */
+export interface PixiApp {
+	/**
+	 * The pixi container for layers
+	 */
+	layer_container: Container;
+	/**
+	 * The pixi container for background images and colors
+	 */
+	background_container: Container;
+	/**
+	 * The pixi renderer
+	 */
+	renderer: IRenderer;
+	/**
+	 * The pixi canvas
+	 */
+	view: HTMLCanvasElement & ICanvas;
+	/**
+	 * The pixi container for masking
+	 */
+	mask_container: Container;
+	destroy(): void;
+	/**
+	 * Resizes the pixi app
+	 * @param width the new width
+	 * @param height the new height
+	 */
+	resize(width: number, height: number): void;
+	/**
+	 * Gets the blobs for the background, layers, and composite
+	 * @param bounds the bounds of the canvas
+	 * @returns a promise with the blobs
+	 */
+	get_blobs(
+		layers: LayerScene[],
+		bounds: Rectangle,
+		dimensions: [number, number]
+	): Promise<ImageBlobs>;
+	// /**
+	//  * Resets the mask
+	//  */
+	// reset?: () => void;
+
+	/**
+	 * Gets the layers
+	 */
+	get_layers?: () => LayerScene[];
+}
+
+/**
+ * Creates a PIXI app and attaches it to a DOM element
+ * @param target DOM element to attach PIXI app to
+ * @param width Width of the PIXI app
+ * @param height Height of the PIXI app
+ * @param antialias Whether to use antialiasing
+ * @returns object with pixi container and renderer
+ */
+export function create_pixi_app({
+	target,
+	dimensions: [width, height],
+	antialias
+}: {
+	target: HTMLElement;
+	dimensions: [number, number];
+	antialias: boolean;
+}): PixiApp {
+	const ratio = window.devicePixelRatio || 1;
+	const app = new Application({
+		width,
+		height,
+		antialias: antialias,
+		backgroundAlpha: 0,
+		eventMode: "static"
+	});
+	const view = app.view as HTMLCanvasElement;
+	// ensure that we can sort the background and layer containers
+	app.stage.sortableChildren = true;
+	view.style.maxWidth = `${width / ratio}px`;
+	view.style.maxHeight = `${height / ratio}px`;
+	view.style.width = "100%";
+	view.style.height = "100%";
+
+	target.appendChild(app.view as HTMLCanvasElement);
+
+	// we need a separate container for the background so that we can
+	// clear its content without knowing too much about its children
+	const background_container = new Container() as Container & DisplayObject;
+	background_container.zIndex = 0;
+	const layer_container = new Container() as Container & DisplayObject;
+	layer_container.zIndex = 1;
+
+	// ensure we can reorder  layers via zIndex
+	layer_container.sortableChildren = true;
+
+	const mask_container = new Container() as Container & DisplayObject;
+	mask_container.zIndex = 1;
+	const composite_container = new Container() as Container & DisplayObject;
+	composite_container.zIndex = 0;
+
+	mask_container.addChild(background_container);
+	mask_container.addChild(layer_container);
+
+	app.stage.addChild(mask_container);
+	app.stage.addChild(composite_container);
+	const mask = new Graphics();
+	let text = RenderTexture.create({
+		width,
+		height
+	});
+	const sprite = new Sprite(text);
+
+	mask_container.mask = sprite;
+
+	app.render();
+
+	function reset_mask(width: number, height: number): void {
+		background_container.removeChildren();
+		mask.beginFill(0xffffff, 1);
+		mask.drawRect(0, 0, width, height);
+		mask.endFill();
+		text = RenderTexture.create({
+			width,
+			height
+		});
+		app.renderer.render(mask, {
+			renderTexture: text
+		});
+
+		const sprite = new Sprite(text);
+
+		mask_container.mask = sprite;
+	}
+
+	function resize(width: number, height: number): void {
+		app.renderer.resize(width, height);
+		view.style.maxWidth = `${width / ratio}px`;
+		view.style.maxHeight = `${height / ratio}px`;
+		reset_mask(width, height);
+	}
+
+	async function get_blobs(
+		_layers: LayerScene[],
+		bounds: Rectangle,
+		[w, h]: [number, number]
+	): Promise<ImageBlobs> {
+		const background = await get_canvas_blob(
+			app.renderer,
+			background_container,
+			bounds,
+			w,
+			h
+		);
+
+		const layers = await Promise.all(
+			_layers.map((layer) =>
+				get_canvas_blob(
+					app.renderer,
+					layer.composite as DisplayObject,
+					bounds,
+					w,
+					h
+				)
+			)
+		);
+
+		const composite = await get_canvas_blob(
+			app.renderer,
+			mask_container,
+			bounds,
+			w,
+			h
+		);
+
+		return {
+			background,
+			layers,
+			composite
+		};
+	}
+
+	return {
+		layer_container,
+		renderer: app.renderer,
+		destroy: () => app.destroy(true),
+		view: app.view as HTMLCanvasElement & ICanvas,
+		background_container,
+		mask_container,
+		resize,
+		get_blobs
+	};
+}
+
+/**
+ * Creates a pixi graphics object.
+ * @param z_index the z index of the graphics object
+ * @returns a graphics object
+ */
+export function make_graphics(z_index: number): Graphics {
+	const graphics = new Graphics();
+	graphics.eventMode = "none";
+	graphics.zIndex = z_index;
+
+	return graphics;
+}
+
+/**
+ * Clamps a number between a min and max value.
+ * @param n The number to clamp.
+ * @param min The minimum value.
+ * @param max The maximum value.
+ * @returns The clamped number.
+ */
+export function clamp(n: number, min: number, max: number): number {
+	return n < min ? min : n > max ? max : n;
+}
+
+/**
+ * Generates a blob from a pixi object.
+ * @param renderer The pixi renderer.
+ * @param obj The pixi object to generate a blob from.
+ * @param bounds The bounds of the canvas that we wish to extract
+ * @param width The full width of the canvas
+ * @param height The full height of the canvas
+ * @returns A promise with the blob.
+ */
+function get_canvas_blob(
+	renderer: IRenderer,
+	obj: DisplayObject,
+	bounds: Rectangle,
+	width: number,
+	height: number
+): Promise<Blob | null> {
+	return new Promise((resolve) => {
+		// for some reason pixi won't extract a cropped canvas without distorting it
+		// so we have to extract the whole canvas and crop it manually
+		const src_canvas = renderer.extract.canvas(
+			obj,
+			new Rectangle(0, 0, width, height)
+		);
+
+		// Create a new canvas for the cropped area with the appropriate size
+		let dest_canvas = document.createElement("canvas");
+		dest_canvas.width = bounds.width;
+		dest_canvas.height = bounds.height;
+		let dest_ctx = dest_canvas.getContext("2d");
+
+		if (!dest_ctx) {
+			resolve(null);
+			throw new Error("Could not create canvas context");
+		}
+
+		// Draw the cropped area onto the destination canvas
+		dest_ctx.drawImage(
+			src_canvas as HTMLCanvasElement,
+			// this is the area of the source that we want to copy (the crop box)
+			bounds.x,
+			bounds.y,
+			bounds.width,
+			bounds.height,
+			// this is where we want to draw the crop box on the destination canvas
+			0,
+			0,
+			bounds.width,
+			bounds.height
+		);
+
+		// we grab a blob here so we can upload it
+		dest_canvas.toBlob?.((blob) => {
+			if (!blob) {
+				resolve(null);
+			}
+			resolve(blob);
+		});
+	});
+}
+
+export interface ImageBlobs {
+	background: Blob | null;
+	layers: (Blob | null)[];
+	composite: Blob | null;
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/label/shared/Label.svelte

@@ -0,0 +1,158 @@
+<script lang="ts">
+	import type { SelectData } from "@gradio/utils";
+	import { createEventDispatcher } from "svelte";
+
+	export let value: {
+		label?: string;
+		confidences?: { label: string; confidence: number }[];
+	};
+
+	const dispatch = createEventDispatcher<{ select: SelectData }>();
+
+	export let color: string | undefined = undefined;
+	export let selectable = false;
+
+	function get_aria_referenceable_id(elem_id: string): string {
+		// `aria-labelledby` interprets the value as a space-separated id reference list,
+		// so each single id should not contain any spaces.
+		// Ref: https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-labelledby#benefits_and_drawbacks
+		return elem_id.replace(/\s/g, "-");
+	}
+</script>
+
+<div class="container">
+	<h2
+		class="output-class"
+		data-testid="label-output-value"
+		class:no-confidence={!("confidences" in value)}
+		style:background-color={color || "transparent"}
+	>
+		{value.label}
+	</h2>
+
+	{#if typeof value === "object" && value.confidences}
+		{#each value.confidences as confidence_set, i}
+			<button
+				class="confidence-set group"
+				data-testid={`${confidence_set.label}-confidence-set`}
+				class:selectable
+				on:click={() => {
+					dispatch("select", { index: i, value: confidence_set.label });
+				}}
+			>
+				<div class="inner-wrap">
+					<meter
+						aria-labelledby={get_aria_referenceable_id(
+							`meter-text-${confidence_set.label}`
+						)}
+						aria-label={confidence_set.label}
+						aria-valuenow={Math.round(confidence_set.confidence * 100)}
+						aria-valuemin="0"
+						aria-valuemax="100"
+						class="bar"
+						min="0"
+						max="1"
+						value={confidence_set.confidence}
+						style="width: {confidence_set.confidence *
+							100}%; background: var(--stat-background-fill);
+						"
+					/>
+
+					<dl class="label">
+						<dt
+							id={get_aria_referenceable_id(
+								`meter-text-${confidence_set.label}`
+							)}
+							class="text"
+						>
+							{confidence_set.label}
+						</dt>
+						<div class="line" />
+						<dd class="confidence">
+							{Math.round(confidence_set.confidence * 100)}%
+						</dd>
+					</dl>
+				</div>
+			</button>
+		{/each}
+	{/if}
+</div>
+
+<style>
+	.container {
+		padding: var(--block-padding);
+	}
+	.output-class {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		padding: var(--size-6) var(--size-4);
+		color: var(--body-text-color);
+		font-weight: var(--weight-bold);
+		font-size: var(--text-xxl);
+	}
+
+	.confidence-set {
+		display: flex;
+		justify-content: space-between;
+		align-items: flex-start;
+		margin-bottom: var(--size-2);
+		color: var(--body-text-color);
+		line-height: var(--line-none);
+		font-family: var(--font-mono);
+		width: 100%;
+	}
+
+	.confidence-set:last-child {
+		margin-bottom: 0;
+	}
+
+	.inner-wrap {
+		flex: 1 1 0%;
+		display: flex;
+		flex-direction: column;
+	}
+
+	.bar {
+		appearance: none;
+		align-self: flex-start;
+		margin-bottom: var(--size-1);
+		border-radius: var(--radius-md);
+		background: var(--stat-background-fill);
+		height: var(--size-1);
+	}
+
+	.label {
+		display: flex;
+		align-items: baseline;
+	}
+
+	.label > * + * {
+		margin-left: var(--size-2);
+	}
+
+	.confidence-set:hover .label {
+		color: var(--color-accent);
+	}
+
+	.confidence-set:focus .label {
+		color: var(--color-accent);
+	}
+
+	.text {
+		line-height: var(--line-md);
+		text-align: left;
+	}
+
+	.line {
+		flex: 1 1 0%;
+		border: 1px dashed var(--border-color-primary);
+		padding-right: var(--size-4);
+		padding-left: var(--size-4);
+	}
+
+	.confidence {
+		margin-left: auto;
+		text-align: right;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/model3D/Example.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export let value: string | null;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</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>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/model3D/shared/Canvas3DGS.svelte

@@ -0,0 +1,130 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import * as SPLAT from "gsplat";
+	import type { FileData } from "@gradio/client";
+	import { resolve_wasm_src } from "@gradio/wasm/svelte";
+
+	export let value: FileData;
+	export let zoom_speed: number;
+	export let pan_speed: number;
+
+	$: url = value.url;
+
+	/* URL resolution for the Wasm mode. */
+	export let resolved_url: typeof url = undefined; // Exposed to be bound to the download link in the parent component.
+	// The prop can be updated before the Promise from `resolve_wasm_src` is resolved.
+	// In such a case, the resolved url for the old `url` has to be discarded,
+	// This variable `latest_url` is used to pick up only the value resolved for the latest `url`.
+	let latest_url: typeof url;
+	$: {
+		// In normal (non-Wasm) Gradio, the original `url` should be used immediately
+		// without waiting for `resolve_wasm_src()` to resolve.
+		// If it waits, a blank element is displayed until the async task finishes
+		// and it leads to undesirable flickering.
+		// So set `resolved_url` immediately above, and update it with the resolved values below later.
+		resolved_url = url;
+
+		if (url) {
+			latest_url = url;
+			const resolving_url = url;
+			resolve_wasm_src(url).then((resolved) => {
+				if (latest_url === resolving_url) {
+					resolved_url = resolved ?? undefined;
+				} else {
+					resolved && URL.revokeObjectURL(resolved);
+				}
+			});
+		}
+	}
+
+	let canvas: HTMLCanvasElement;
+	let scene: SPLAT.Scene;
+	let camera: SPLAT.Camera;
+	let renderer: SPLAT.WebGLRenderer | null = null;
+	let controls: SPLAT.OrbitControls;
+	let mounted = false;
+	let frameId: number | null = null;
+
+	function reset_scene(): void {
+		if (frameId !== null) {
+			cancelAnimationFrame(frameId);
+			frameId = null;
+		}
+
+		if (renderer !== null) {
+			renderer.dispose();
+			renderer = null;
+		}
+
+		scene = new SPLAT.Scene();
+		camera = new SPLAT.Camera();
+		renderer = new SPLAT.WebGLRenderer(canvas);
+		controls = new SPLAT.OrbitControls(camera, canvas);
+		controls.zoomSpeed = zoom_speed;
+		controls.panSpeed = pan_speed;
+
+		if (!value) {
+			return;
+		}
+
+		let loading = false;
+		const load = async (): Promise<void> => {
+			if (loading) {
+				console.error("Already loading");
+				return;
+			}
+			if (!resolved_url) {
+				throw new Error("No resolved URL");
+			}
+			loading = true;
+			if (resolved_url.endsWith(".ply")) {
+				await SPLAT.PLYLoader.LoadAsync(resolved_url, scene, undefined);
+			} else if (resolved_url.endsWith(".splat")) {
+				await SPLAT.Loader.LoadAsync(resolved_url, scene, undefined);
+			} else {
+				throw new Error("Unsupported file type");
+			}
+			loading = false;
+		};
+
+		const frame = (): void => {
+			if (!renderer) {
+				return;
+			}
+
+			if (loading) {
+				frameId = requestAnimationFrame(frame);
+				return;
+			}
+
+			controls.update();
+			renderer.render(scene, camera);
+
+			frameId = requestAnimationFrame(frame);
+		};
+
+		load();
+		frameId = requestAnimationFrame(frame);
+	}
+
+	onMount(() => {
+		if (value != null) {
+			reset_scene();
+		}
+		mounted = true;
+
+		return () => {
+			if (renderer) {
+				renderer.dispose();
+			}
+		};
+	});
+
+	$: ({ path } = value || {
+		path: undefined
+	});
+
+	$: canvas && mounted && path && reset_scene();
+</script>
+
+<canvas bind:this={canvas}></canvas>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/model3D/shared/Model3D.svelte

@@ -0,0 +1,136 @@
+<script lang="ts">
+	import type { FileData } from "@gradio/client";
+	import { BlockLabel, IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import { File, Download, Undo } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { dequal } from "dequal";
+	import type Canvas3DGS from "./Canvas3DGS.svelte";
+	import type Canvas3D from "./Canvas3D.svelte";
+
+	export let value: FileData | null;
+	export let display_mode: "solid" | "point_cloud" | "wireframe" = "solid";
+	export let clear_color: [number, number, number, number] = [0, 0, 0, 0];
+	export let label = "";
+	export let show_label: boolean;
+	export let i18n: I18nFormatter;
+	export let zoom_speed = 1;
+	export let pan_speed = 1;
+	// alpha, beta, radius
+	export let camera_position: [number | null, number | null, number | null] = [
+		null,
+		null,
+		null
+	];
+	export let has_change_history = false;
+
+	let current_settings = { camera_position, zoom_speed, pan_speed };
+
+	let use_3dgs = false;
+	let Canvas3DGSComponent: typeof Canvas3DGS;
+	let Canvas3DComponent: typeof Canvas3D;
+	async function loadCanvas3D(): Promise<typeof Canvas3D> {
+		const module = await import("./Canvas3D.svelte");
+		return module.default;
+	}
+	async function loadCanvas3DGS(): Promise<typeof Canvas3DGS> {
+		const module = await import("./Canvas3DGS.svelte");
+		return module.default;
+	}
+	$: if (value) {
+		use_3dgs = value.path.endsWith(".splat") || value.path.endsWith(".ply");
+		if (use_3dgs) {
+			loadCanvas3DGS().then((component) => {
+				Canvas3DGSComponent = component;
+			});
+		} else {
+			loadCanvas3D().then((component) => {
+				Canvas3DComponent = component;
+			});
+		}
+	}
+
+	let canvas3d: Canvas3D | undefined;
+	function handle_undo(): void {
+		canvas3d?.reset_camera_position(camera_position, zoom_speed, pan_speed);
+	}
+
+	$: {
+		if (
+			!dequal(current_settings.camera_position, camera_position) ||
+			current_settings.zoom_speed !== zoom_speed ||
+			current_settings.pan_speed !== pan_speed
+		) {
+			canvas3d?.reset_camera_position(camera_position, zoom_speed, pan_speed);
+			current_settings = { camera_position, zoom_speed, pan_speed };
+		}
+	}
+
+	let resolved_url: string | undefined;
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={File}
+	label={label || i18n("3D_model.3d_model")}
+/>
+{#if value}
+	<div class="model3D">
+		<IconButtonWrapper>
+			{#if !use_3dgs}
+				<!-- Canvas3DGS doesn't implement the undo method (reset_camera_position) -->
+				<IconButton
+					Icon={Undo}
+					label="Undo"
+					on:click={() => handle_undo()}
+					disabled={!has_change_history}
+				/>
+			{/if}
+			<a
+				href={resolved_url}
+				target={window.__is_colab__ ? "_blank" : null}
+				download={window.__is_colab__ ? null : value.orig_name || value.path}
+			>
+				<IconButton Icon={Download} label={i18n("common.download")} />
+			</a>
+		</IconButtonWrapper>
+
+		{#if use_3dgs}
+			<svelte:component
+				this={Canvas3DGSComponent}
+				bind:resolved_url
+				{value}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{:else}
+			<svelte:component
+				this={Canvas3DComponent}
+				bind:this={canvas3d}
+				bind:resolved_url
+				{value}
+				{display_mode}
+				{clear_color}
+				{camera_position}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{/if}
+	</div>
+{/if}
+
+<style>
+	.model3D {
+		display: flex;
+		position: relative;
+		width: var(--size-full);
+		height: var(--size-full);
+		border-radius: var(--block-radius);
+		overflow: hidden;
+	}
+	.model3D :global(canvas) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+		overflow: hidden;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/model3D/shared/Model3DUpload.svelte

@@ -0,0 +1,154 @@
+<script lang="ts">
+	import { createEventDispatcher, tick } from "svelte";
+	import { Upload, ModifyUpload } from "@gradio/upload";
+	import type { FileData, Client } from "@gradio/client";
+	import { BlockLabel } from "@gradio/atoms";
+	import { File } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import type Canvas3DGS from "./Canvas3DGS.svelte";
+	import type Canvas3D from "./Canvas3D.svelte";
+
+	export let value: null | FileData;
+	export let display_mode: "solid" | "point_cloud" | "wireframe" = "solid";
+	export let clear_color: [number, number, number, number] = [0, 0, 0, 0];
+	export let label = "";
+	export let show_label: boolean;
+	export let root: string;
+	export let i18n: I18nFormatter;
+	export let zoom_speed = 1;
+	export let pan_speed = 1;
+	export let max_file_size: number | null = null;
+	export let uploading = false;
+
+	// alpha, beta, radius
+	export let camera_position: [number | null, number | null, number | null] = [
+		null,
+		null,
+		null
+	];
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+
+	async function handle_upload({
+		detail
+	}: CustomEvent<FileData>): Promise<void> {
+		value = detail;
+		await tick();
+		dispatch("change", value);
+		dispatch("load", value);
+	}
+
+	async function handle_clear(): Promise<void> {
+		value = null;
+		await tick();
+		dispatch("clear");
+		dispatch("change");
+	}
+
+	let use_3dgs = false;
+	let Canvas3DGSComponent: typeof Canvas3DGS;
+	let Canvas3DComponent: typeof Canvas3D;
+	async function loadCanvas3D(): Promise<typeof Canvas3D> {
+		const module = await import("./Canvas3D.svelte");
+		return module.default;
+	}
+	async function loadCanvas3DGS(): Promise<typeof Canvas3DGS> {
+		const module = await import("./Canvas3DGS.svelte");
+		return module.default;
+	}
+	$: if (value) {
+		use_3dgs = value.path.endsWith(".splat") || value.path.endsWith(".ply");
+		if (use_3dgs) {
+			loadCanvas3DGS().then((component) => {
+				Canvas3DGSComponent = component;
+			});
+		} else {
+			loadCanvas3D().then((component) => {
+				Canvas3DComponent = component;
+			});
+		}
+	}
+
+	let canvas3d: Canvas3D | undefined;
+	async function handle_undo(): Promise<void> {
+		canvas3d?.reset_camera_position(camera_position, zoom_speed, pan_speed);
+	}
+
+	const dispatch = createEventDispatcher<{
+		change: FileData | null;
+		clear: undefined;
+		drag: boolean;
+		load: FileData;
+	}>();
+
+	let dragging = false;
+
+	$: dispatch("drag", dragging);
+</script>
+
+<BlockLabel {show_label} Icon={File} label={label || "3D Model"} />
+
+{#if value === null}
+	<Upload
+		{upload}
+		{stream_handler}
+		on:load={handle_upload}
+		{root}
+		{max_file_size}
+		filetype={[".stl", ".obj", ".gltf", ".glb", "model/obj", ".splat", ".ply"]}
+		bind:dragging
+		bind:uploading
+		on:error
+	>
+		<slot />
+	</Upload>
+{:else}
+	<div class="input-model">
+		<ModifyUpload
+			undoable={!use_3dgs}
+			on:clear={handle_clear}
+			{i18n}
+			on:undo={handle_undo}
+		/>
+
+		{#if use_3dgs}
+			<svelte:component
+				this={Canvas3DGSComponent}
+				{value}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{:else}
+			<svelte:component
+				this={Canvas3DComponent}
+				bind:this={canvas3d}
+				{value}
+				{display_mode}
+				{clear_color}
+				{camera_position}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{/if}
+	</div>
+{/if}
+
+<style>
+	.input-model {
+		display: flex;
+		position: relative;
+		justify-content: center;
+		align-items: center;
+		width: var(--size-full);
+		height: var(--size-full);
+		border-radius: var(--block-radius);
+		overflow: hidden;
+	}
+
+	.input-model :global(canvas) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+		overflow: hidden;
+	}
+</style>