Upload folder using huggingface_hub

6.9.1/preview/package.json

@@ -0,0 +1,36 @@
+{
+	"name": "@gradio/preview",
+	"version": "0.16.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"main": "dist/index.js",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"scripts": {
+		"build": "vite build --ssr"
+	},
+	"dependencies": {
+		"@sveltejs/vite-plugin-svelte": "^6.2.1",
+		"@types/which": "^3.0.4",
+		"rollup": "^4.59.0",
+		"vite": "^7.1.9",
+		"svelte-preprocess": "^6.0.3",
+		"typescript": "^5.9.3"
+	},
+	"exports": {
+		".": {
+			"default": "./dist/index.js",
+			"import": "./dist/index.js",
+			"gradio": "./src/index.ts",
+			"svelte": "./dist/src/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/preview"
+	}
+}

6.9.1/preview/src/_deepmerge_internal.ts

@@ -0,0 +1,133 @@
+// this is a copy of the deepemerge source code but with an esm interface rather than commonjs
+
+export const deepmerge = `
+function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+}
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value)
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+var defaultIsMergeableObject = isMergeableObject;
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key)
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function getEnumerableOwnPropertySymbols(target) {
+	return Object.getOwnPropertySymbols
+		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return Object.propertyIsEnumerable.call(target, symbol)
+		})
+		: []
+}
+
+function getKeys(target) {
+	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+}
+
+function propertyIsOnObject(object, property) {
+	try {
+		return property in object
+	} catch(_) {
+		return false
+	}
+}
+
+// Protects from prototype poisoning and unexpected merging up the prototype chain.
+function propertyIsUnsafe(target, key) {
+	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
+}
+
+function mergeObject(target, source, options) {
+	var destination = {}
+	if (options.isMergeableObject(target)) {
+		getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options)
+		})
+	}
+	getKeys(source).forEach(function(key) {
+		if (propertyIsUnsafe(target, key)) {
+			return
+		}
+
+		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options)
+		} else {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options)
+		}
+	})
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {}
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge
+	options.isMergeableObject = options.isMergeableObject || defaultIsMergeableObject
+	
+	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified
+
+	var sourceIsArray = Array.isArray(source)
+	var targetIsArray = Array.isArray(target)
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+}
+
+export default deepmerge;
+`;

6.9.1/preview/src/build.ts

@@ -0,0 +1,131 @@
+import * as fs from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+import { build } from "vite";
+import type { PreRenderedChunk } from "rollup";
+
+import { plugins, make_gradio_plugin } from "./plugins";
+import { examine_module } from "./index";
+
+interface BuildOptions {
+	component_dir: string;
+	root_dir: string;
+	python_path: string;
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export async function make_build({
+	component_dir,
+	root_dir,
+	python_path
+}: BuildOptions): Promise<void> {
+	process.env.gradio_mode = "dev";
+	const svelte_dir = join(root_dir, "assets", "svelte");
+
+	const module_meta = examine_module(
+		component_dir,
+		root_dir,
+		python_path,
+		"build"
+	);
+	try {
+		for (const comp of module_meta) {
+			const template_dir = comp.template_dir;
+			const source_dir = comp.frontend_dir;
+
+			const pkg = JSON.parse(
+				fs.readFileSync(join(source_dir, "package.json"), "utf-8")
+			);
+			let component_config = {
+				plugins: [],
+				svelte: {
+					preprocess: []
+				},
+				build: {
+					target: []
+				},
+				optimizeDeps: {
+					exclude: ["svelte", "svelte/*"]
+				}
+			};
+
+			if (
+				comp.frontend_dir &&
+				fs.existsSync(join(comp.frontend_dir, "gradio.config.js"))
+			) {
+				const m = await import(
+					join("file://" + comp.frontend_dir, "gradio.config.js")
+				);
+
+				component_config.plugins = m.default.plugins || [];
+				component_config.svelte.preprocess = m.default.svelte?.preprocess || [];
+				component_config.build.target = m.default.build?.target || "modules";
+				component_config.optimizeDeps =
+					m.default.optimizeDeps || component_config.optimizeDeps;
+			}
+
+			const exports: (string | any)[][] = [
+				[
+					join(template_dir, "component"),
+					[
+						join(__dirname, "svelte_runtime_entry.js"),
+						join(source_dir, pkg.exports["."].gradio)
+					]
+				],
+				[
+					join(template_dir, "example"),
+					[
+						join(__dirname, "svelte_runtime_entry.js"),
+						join(source_dir, pkg.exports["./example"].gradio)
+					]
+				]
+			].filter(([_, path]) => !!path);
+
+			for (const [out_path, entry_path] of exports) {
+				try {
+					const x = await build({
+						root: source_dir,
+						configFile: false,
+						plugins: [
+							...plugins(component_config),
+							make_gradio_plugin({ svelte_dir, component_dir })
+						],
+						build: {
+							emptyOutDir: true,
+							outDir: out_path,
+							lib: {
+								entry: entry_path,
+								fileName: "index.js",
+								formats: ["es"]
+							},
+							minify: true,
+							rollupOptions: {
+								output: {
+									assetFileNames: (chunkInfo) => {
+										if (chunkInfo.names[0].endsWith(".css")) {
+											return `style.css`;
+										}
+
+										return chunkInfo.names[0];
+									},
+									entryFileNames: (chunkInfo: PreRenderedChunk) => {
+										if (chunkInfo.isEntry) {
+											return chunkInfo.name.toLocaleLowerCase() + ".js";
+										}
+										return `${chunkInfo.name.toLocaleLowerCase()}.js`;
+									}
+								}
+							}
+						}
+					});
+				} catch (e) {
+					throw e;
+				}
+			}
+		}
+	} catch (e) {
+		throw e;
+	}
+}

6.9.1/preview/src/dev.ts

@@ -0,0 +1,220 @@
+import { join } from "path";
+import * as fs from "fs";
+
+import { createServer, createLogger } from "vite";
+import type { PreprocessorGroup } from "svelte/compiler";
+
+import { plugins, make_gradio_plugin } from "./plugins";
+import { examine_module } from "./index";
+
+const vite_messages_to_ignore = [
+	"Default and named imports from CSS files are deprecated.",
+	"The above dynamic import cannot be analyzed by Vite."
+];
+
+const logger = createLogger();
+const originalWarning = logger.warn;
+logger.warn = (msg, options) => {
+	if (vite_messages_to_ignore.some((m) => msg.includes(m))) return;
+
+	originalWarning(msg, options);
+};
+
+const originalError = logger.error;
+
+logger.error = (msg, options) => {
+	if (msg && msg.includes("Pre-transform error")) return;
+	originalError(msg, options);
+};
+
+interface ServerOptions {
+	component_dir: string;
+	root_dir: string;
+	frontend_port: number;
+	backend_port: number;
+	host: string;
+	python_path: string;
+}
+
+export async function create_server({
+	component_dir,
+	root_dir,
+	frontend_port,
+	backend_port,
+	host,
+	python_path
+}: ServerOptions): Promise<void> {
+	process.env.gradio_mode = "dev";
+	const [imports, config, runtimes] = await generate_imports(
+		component_dir,
+		root_dir,
+		python_path
+	);
+
+	const svelte_dir = join(root_dir, "assets", "svelte");
+
+	try {
+		const server = await createServer({
+			customLogger: logger,
+			mode: "development",
+			configFile: false,
+			root: root_dir,
+			server: {
+				port: frontend_port,
+				host: host,
+				fs: {
+					allow: [root_dir, component_dir]
+				}
+			},
+			optimizeDeps: config.optimizeDeps,
+			cacheDir: join(component_dir, "frontend", "node_modules", ".vite"),
+			plugins: [
+				...plugins(config),
+				make_gradio_plugin({
+					backend_port,
+					svelte_dir,
+					component_dir,
+					imports,
+					runtimes
+				})
+			]
+		});
+
+		await server.listen();
+
+		console.info(
+			`[orange3]Frontend Server[/] (Go here): ${server.resolvedUrls?.local}`
+		);
+	} catch (e) {
+		console.error(e);
+	}
+}
+
+function find_frontend_folders(start_path: string): string[] {
+	if (!fs.existsSync(start_path)) {
+		console.warn("No directory found at:", start_path);
+		return [];
+	}
+
+	if (fs.existsSync(join(start_path, "pyproject.toml"))) return [start_path];
+
+	const results: string[] = [];
+	const dir = fs.readdirSync(start_path);
+	dir.forEach((dir) => {
+		const filepath = join(start_path, dir);
+		if (fs.existsSync(filepath)) {
+			if (fs.existsSync(join(filepath, "pyproject.toml")))
+				results.push(filepath);
+		}
+	});
+
+	return results;
+}
+
+function to_posix(_path: string): string {
+	const isExtendedLengthPath = /^\\\\\?\\/.test(_path);
+	const hasNonAscii = /[^\u0000-\u0080]+/.test(_path);
+
+	if (isExtendedLengthPath || hasNonAscii) {
+		return _path;
+	}
+
+	return _path.replace(/\\/g, "/");
+}
+
+export interface ComponentConfig {
+	plugins: any[];
+	svelte: {
+		preprocess: PreprocessorGroup[];
+		extensions?: string[];
+	};
+	build: {
+		target: string | string[];
+	};
+	optimizeDeps: object;
+}
+
+async function generate_imports(
+	component_dir: string,
+	root: string,
+	python_path: string
+): Promise<[string, ComponentConfig, string]> {
+	const components = find_frontend_folders(component_dir);
+
+	const component_entries = components.flatMap((component) => {
+		return examine_module(component, root, python_path, "dev");
+	});
+	if (component_entries.length === 0) {
+		console.info(
+			`No custom components were found in ${component_dir}. It is likely that dev mode does not work properly. Please pass the --gradio-path and --python-path CLI arguments so that gradio uses the right executables.`
+		);
+	}
+
+	let component_config: ComponentConfig = {
+		plugins: [],
+		svelte: {
+			preprocess: []
+		},
+		build: {
+			target: []
+		},
+		optimizeDeps: {
+			exclude: ["svelte", "svelte/*"]
+		}
+	};
+
+	await Promise.all(
+		component_entries.map(async (component) => {
+			if (
+				component.frontend_dir &&
+				fs.existsSync(join(component.frontend_dir, "gradio.config.js"))
+			) {
+				const m = await import(
+					join("file://" + component.frontend_dir, "gradio.config.js")
+				);
+
+				component_config.plugins = m.default.plugins || [];
+				component_config.svelte.preprocess = m.default.svelte?.preprocess || [];
+				component_config.build.target = m.default.build?.target || "modules";
+				component_config.optimizeDeps =
+					m.default.optimizeDeps || component_config.optimizeDeps;
+			} else {
+			}
+		})
+	);
+
+	const imports = component_entries.reduce((acc, component) => {
+		const pkg = JSON.parse(
+			fs.readFileSync(join(component.frontend_dir, "package.json"), "utf-8")
+		);
+
+		const exports: Record<string, any | undefined> = {
+			component: pkg.exports["."],
+			example: pkg.exports["./example"]
+		};
+
+		if (!exports.component)
+			throw new Error(
+				"Could not find component entry point. Please check the exports field of your package.json."
+			);
+
+		const example = exports.example
+			? `example: () => import("/@fs/${to_posix(
+					join(component.frontend_dir, exports.example.gradio)
+				)}"),\n`
+			: "";
+		return `${acc}"${component.component_class_id}": {
+			${example}
+			component: () => import("/@fs/${to_posix(
+				join(component.frontend_dir, exports.component.gradio)
+			)}"),
+
+			},\n`;
+	}, "");
+
+	const runtimes = component_entries.reduce((acc, component) => {
+		return `${acc}"${component.component_class_id}": import("svelte"),\n`;
+	}, "");
+
+	return [`{${imports}}`, component_config, `{${runtimes}}`];
+}

6.9.1/preview/src/index.ts

@@ -0,0 +1,202 @@
+import { type ChildProcess, spawn, spawnSync } from "node:child_process";
+import * as net from "net";
+
+import { create_server, type ComponentConfig } from "./dev";
+import { make_build } from "./build";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export interface ComponentMeta {
+	name: string;
+	template_dir: string;
+	frontend_dir: string;
+	component_class_id: string;
+}
+
+const args = process.argv.slice(2);
+// get individual args as `--arg value` or `value`
+
+function parse_args(args: string[]): Record<string, string> {
+	const arg_map: Record<string, string> = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const name = arg.slice(2);
+			const value = args[i + 1];
+			arg_map[name] = value;
+			i++;
+		}
+	}
+	return arg_map;
+}
+
+const parsed_args = parse_args(args);
+
+async function run(): Promise<void> {
+	if (parsed_args.mode === "build") {
+		await make_build({
+			component_dir: parsed_args["component-directory"],
+			root_dir: parsed_args.root,
+			python_path: parsed_args["python-path"]
+		});
+	} else {
+		const [backend_port, frontend_port] = await find_free_ports(7860, 8860);
+		const options = {
+			component_dir: parsed_args["component-directory"],
+			root_dir: parsed_args.root,
+			frontend_port,
+			backend_port,
+			host: parsed_args.host,
+			...parsed_args
+		};
+		process.env.GRADIO_BACKEND_PORT = backend_port.toString();
+		const _process = spawn(
+			parsed_args["gradio-path"],
+			[parsed_args.app, "--watch-dirs", options.component_dir],
+			{
+				shell: false,
+				stdio: "pipe",
+				cwd: process.cwd(),
+				env: {
+					...process.env,
+					GRADIO_SERVER_PORT: backend_port.toString(),
+					PYTHONUNBUFFERED: "true"
+				}
+			}
+		);
+
+		_process.stdout.setEncoding("utf8");
+		_process.stderr.setEncoding("utf8");
+
+		function std_out(mode: "stdout" | "stderr") {
+			return function (data: Buffer): void {
+				const _data = data.toString();
+
+				if (_data.includes("Running on")) {
+					create_server({
+						component_dir: options.component_dir,
+						root_dir: options.root_dir,
+						frontend_port,
+						backend_port,
+						host: options.host,
+						python_path: parsed_args["python-path"]
+					});
+				}
+
+				process[mode].write(_data);
+			};
+		}
+
+		_process.stdout.on("data", std_out("stdout"));
+		_process.stderr.on("data", std_out("stderr"));
+		_process.on("exit", () => kill_process(_process));
+		_process.on("close", () => kill_process(_process));
+		_process.on("disconnect", () => kill_process(_process));
+	}
+}
+
+function kill_process(process: ChildProcess): void {
+	process.kill("SIGKILL");
+}
+
+export { create_server };
+
+run();
+
+export async function find_free_ports(
+	start_port: number,
+	end_port: number
+): Promise<[number, number]> {
+	let found_ports: number[] = [];
+
+	for (let port = start_port; port < end_port; port++) {
+		if (await is_free_port(port)) {
+			found_ports.push(port);
+			if (found_ports.length === 2) {
+				return [found_ports[0], found_ports[1]];
+			}
+		}
+	}
+
+	throw new Error(
+		`Could not find free ports: there were not enough ports available.`
+	);
+}
+
+export function is_free_port(port: number): Promise<boolean> {
+	return new Promise((accept, reject) => {
+		const sock = net.createConnection(port, "127.0.0.1");
+		setTimeout(() => {
+			sock.destroy();
+			reject(
+				new Error(`Timeout while detecting free port with 127.0.0.1:${port} `)
+			);
+		}, 3000);
+		sock.once("connect", () => {
+			sock.end();
+			accept(false);
+		});
+		sock.once("error", (e) => {
+			sock.destroy();
+			//@ts-ignore
+			if (e.code === "ECONNREFUSED") {
+				accept(true);
+			} else {
+				reject(e);
+			}
+		});
+	});
+}
+
+function is_truthy<T>(value: T | null | undefined | false): value is T {
+	return value !== null && value !== undefined && value !== false;
+}
+
+export function examine_module(
+	component_dir: string,
+	root: string,
+	python_path: string,
+	mode: "build" | "dev"
+): ComponentMeta[] {
+	const _process = spawnSync(
+		python_path,
+		[join(__dirname, "examine.py"), "-m", mode],
+		{
+			cwd: join(component_dir, "backend"),
+			stdio: "pipe"
+		}
+	);
+	const exceptions: string[] = [];
+
+	const components = _process.stdout
+		.toString()
+		.trim()
+		.split("\n")
+		.map((line) => {
+			if (line.startsWith("|EXCEPTION|")) {
+				exceptions.push(line.slice("|EXCEPTION|:".length));
+			}
+			const [name, template_dir, frontend_dir, component_class_id] =
+				line.split("~|~|~|~");
+			if (name && template_dir && frontend_dir && component_class_id) {
+				return {
+					name: name.trim(),
+					template_dir: template_dir.trim(),
+					frontend_dir: frontend_dir.trim(),
+					component_class_id: component_class_id.trim()
+				};
+			}
+			return false;
+		})
+		.filter(is_truthy);
+	if (exceptions.length > 0) {
+		console.info(
+			`While searching for gradio custom component source directories in ${component_dir}, the following exceptions were raised. If dev mode does not work properly please pass the --gradio-path and --python-path CLI arguments so that gradio uses the right executables: ${exceptions.join(
+				"\n"
+			)}`
+		);
+	}
+	return components;
+}

6.9.1/preview/src/placeholder.ts

@@ -0,0 +1 @@
+export default {};

6.9.1/preview/src/plugins.ts

@@ -0,0 +1,155 @@
+import type { Plugin, PluginOption } from "vite";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+import { join, dirname } from "path";
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+import { type ComponentConfig } from "./dev";
+import type { PreprocessorGroup } from "svelte/compiler";
+import { sveltePreprocess } from "svelte-preprocess";
+
+const svelte_codes_to_ignore: Record<string, string> = {
+	"reactive-component": "Icon"
+};
+
+export function plugins(config: ComponentConfig): PluginOption[] {
+	const _additional_plugins = config.plugins || [];
+	const _additional_svelte_preprocess = config.svelte?.preprocess || [];
+	const _svelte_extensions = (config.svelte?.extensions || [".svelte"]).map(
+		(ext) => {
+			if (ext.trim().startsWith(".")) {
+				return ext;
+			}
+			return `.${ext.trim()}`;
+		}
+	);
+
+	if (!_svelte_extensions.includes(".svelte")) {
+		_svelte_extensions.push(".svelte");
+	}
+
+	return [
+		svelte({
+			inspector: false,
+			onwarn(warning, handler) {
+				if (
+					svelte_codes_to_ignore.hasOwnProperty(warning.code) &&
+					svelte_codes_to_ignore[warning.code] &&
+					warning.message.includes(svelte_codes_to_ignore[warning.code])
+				) {
+					return;
+				}
+				handler!(warning);
+			},
+			prebundleSvelteLibraries: false,
+			compilerOptions: {
+				discloseVersion: false,
+				hmr: true
+			},
+			extensions: _svelte_extensions,
+			preprocess: [
+				sveltePreprocess({
+					typescript: {
+						compilerOptions: {
+							declaration: false,
+							declarationMap: false
+						}
+					}
+				}),
+				...(_additional_svelte_preprocess as PreprocessorGroup[])
+			]
+		}),
+		..._additional_plugins
+	];
+}
+
+function resolve_svelte_entry(id: string, base_dir: string): string | null {
+	const require_fn = createRequire(join(base_dir, "frontend", "_"));
+	try {
+		const svelte_pkg_path = require_fn.resolve("svelte/package.json");
+		const svelte_dir = dirname(svelte_pkg_path);
+		const pkg = JSON.parse(readFileSync(svelte_pkg_path, "utf-8"));
+
+		const subpath = id === "svelte" ? "." : "./" + id.slice("svelte/".length);
+
+		if (pkg.exports && pkg.exports[subpath]) {
+			const entry = pkg.exports[subpath];
+			const resolved =
+				typeof entry === "string" ? entry : entry.browser || entry.default;
+			if (resolved) {
+				return join(svelte_dir, resolved);
+			}
+		}
+	} catch {
+		return null;
+	}
+	return null;
+}
+
+interface GradioPluginOptions {
+	svelte_dir: string;
+	component_dir: string;
+	backend_port?: number;
+	imports?: string;
+	runtimes?: string;
+}
+
+export function make_gradio_plugin({
+	backend_port,
+	component_dir,
+	imports,
+	runtimes
+}: GradioPluginOptions): Plugin {
+	const v_id = "virtual:component-loader";
+	const v_id_2 = "virtual:cc-init";
+	const resolved_v_id = "\0" + v_id;
+	const resolved_v_id_2 = "\0" + v_id_2;
+	return {
+		name: "gradio",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === v_id) {
+				return resolved_v_id;
+			}
+			if (id === v_id_2) {
+				return resolved_v_id_2;
+			}
+
+			if (id.startsWith("svelte")) {
+				const resolved = resolve_svelte_entry(id, component_dir);
+				if (resolved) {
+					return resolved;
+				}
+			}
+		},
+		load(id) {
+			if (id === resolved_v_id) {
+				return `export default {};`;
+			}
+
+			if (id === resolved_v_id_2) {
+				return `window.__GRADIO_DEV__ = "dev";
+      window.__GRADIO__SERVER_PORT__ = ${backend_port};
+      window.__GRADIO__CC__ = ${imports};
+      window.__GRADIO__CC__RUNTIMES__ = ${runtimes};`;
+			}
+		},
+		transform(code, id) {
+			return code.replace('"_NORMAL_"', '"_CC_"');
+		}
+	};
+}
+
+// export const deepmerge_plugin: Plugin = {
+//   name: "deepmerge",
+//   enforce: "pre",
+//   resolveId(id) {
+//     if (id === "deepmerge") {
+//       return "deepmerge_internal";
+//     }
+//   },
+//   load(id) {
+//     if (id === "deepmerge_internal") {
+//       return deepmerge;
+//     }
+//   },
+// };

6.9.1/preview/test/test/frontend/Example.svelte

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

6.9.1/preview/test/test/frontend/Index.svelte

@@ -0,0 +1,113 @@
+<script lang="ts">
+	import "./main.css";
+	import { JsonView } from "@zerodevx/svelte-json-view";
+
+	import type { Gradio } from "@gradio/utils";
+	import { Block, Info } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { SelectData } from "@gradio/utils";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible: boolean | "hidden" = true;
+	export let value = false;
+	// export let value_is_output = false;
+	// export let label = "Checkbox";
+	// export let info: string | undefined = undefined;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let gradio: Gradio<{
+		change: never;
+		select: SelectData;
+		input: never;
+	}>;
+</script>
+
+<div class="relative flex min-h-screen flex-col justify-center overflow-hidden">
+	<div
+		class="relative bg-white px-6 pt-10 pb-8 shadow-xl ring-1 ring-gray-900/5 sm:mx-auto sm:max-w-lg sm:rounded-lg sm:px-10"
+	>
+		<div class="mx-auto max-w-md">
+			<h1 class="text-xl! font-bold! text-gray-900">
+				<span class="text-blue-500">Tailwind</span> in Gradio
+			</h1>
+			<h2><em>(i hope you're happy now)</em></h2>
+			<div class="divide-y divide-gray-300/50">
+				<div class="space-y-6 py-8 text-base leading-7 text-gray-600">
+					<p>
+						An advanced online playground for Tailwind CSS, including support
+						for things like:
+					</p>
+					<ul class="space-y-4 my-4!">
+						<li class="flex items-center">
+							<svg
+								class="h-6 w-6 flex-none fill-sky-100 stroke-sky-500 stroke-2 mr-4"
+								stroke-linecap="round"
+								stroke-linejoin="round"
+							>
+								<circle cx="12" cy="12" r="11" />
+								<path
+									d="m8 13 2.165 2.165a1 1 0 0 0 1.521-.126L16 9"
+									fill="none"
+								/>
+							</svg>
+							<p class="ml-4">
+								Customizing your
+								<code class="text-sm font-bold text-gray-900"
+									>tailwind.config.js</code
+								> file
+							</p>
+						</li>
+						<li class="flex items-center">
+							<svg
+								class="h-6 w-6 flex-none fill-sky-100 stroke-sky-500 stroke-2 mr-4"
+								stroke-linecap="round"
+								stroke-linejoin="round"
+							>
+								<circle cx="12" cy="12" r="11" />
+								<path
+									d="m8 13 2.165 2.165a1 1 0 0 0 1.521-.126L16 9"
+									fill="none"
+								/>
+							</svg>
+							<p class="ml-4">
+								Extracting classes with
+								<code class="text-sm font-bold text-gray-900">@apply</code>
+							</p>
+						</li>
+						<li class="flex items-center">
+							<svg
+								class="h-6 w-6 flex-none fill-sky-100 stroke-sky-500 stroke-2 mr-4"
+								stroke-linecap="round"
+								stroke-linejoin="round"
+							>
+								<circle cx="12" cy="12" r="11" />
+								<path
+									d="m8 13 2.165 2.165a1 1 0 0 0 1.521-.126L16 9"
+									fill="none"
+								/>
+							</svg>
+							<p class="ml-4">Code completion with instant preview</p>
+						</li>
+					</ul>
+					<p>
+						Perfect for learning how the framework works, prototyping a new
+						idea, or creating a demo to share online.
+					</p>
+				</div>
+				<div class="pt-8 text-base font-semibold leading-7">
+					<p class="text-gray-900">Want to dig deeper into Tailwind?</p>
+					<p>
+						<a
+							href="https://tailwindcss.com/docs"
+							class="text-sky-500 hover:text-sky-600">Read the docs &rarr;</a
+						>
+					</p>
+				</div>
+			</div>
+		</div>
+	</div>
+</div>

6.9.1/preview/test/test/frontend/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "gradio_test",
+	"version": "0.5.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": true,
+	"main_changeset": true,
+	"exports": {
+		".": "./Index.svelte",
+		"./example": "./Example.svelte",
+		"./package.json": "./package.json"
+	},
+	"dependencies": {},
+	"devDependencies": {},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/preview/test/test/frontend"
+	}
+}

6.9.1/preview/vite.config.ts

@@ -0,0 +1,35 @@
+import { defineConfig } from "vite";
+import { cpSync, write } from "fs";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const dir = require.resolve("./package.json");
+
+const template_dir = join(dir, "..", "..", "..", "gradio", "templates");
+
+export default defineConfig({
+	build: {
+		lib: {
+			entry: "./src/index.ts",
+			formats: ["es"]
+		},
+		outDir: "dist",
+		rollupOptions: {
+			external: ["fsevents", "vite", "@sveltejs/vite-plugin-svelte"]
+		}
+	},
+	plugins: [copy_files()]
+});
+
+export function copy_files() {
+	return {
+		name: "copy_files",
+		writeBundle() {
+			cpSync("./src/examine.py", "dist/examine.py");
+			cpSync("./src/svelte_runtime_entry.js", "dist/svelte_runtime_entry.js");
+			cpSync("./src/register.mjs", join(template_dir, "register.mjs"));
+			cpSync("./src/hooks.mjs", join(template_dir, "hooks.mjs"));
+		}
+	};
+}