Upload folder using huggingface_hub

6.0.0-dev.5/imageeditor/Example.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">
+	import { BaseImage as Image } from "@gradio/image";
+	import type { EditorData } from "./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>

6.0.0-dev.5/imageeditor/Index.svelte

@@ -0,0 +1,213 @@
+<svelte:options accessors={true} immutable={true} />
+
+<script lang="ts">
+	import type { ImageBlobs } from "./InteractiveImageEditor.svelte";
+
+	import { FileData } from "@gradio/client";
+
+	import { BaseStaticImage as StaticImage } from "@gradio/image";
+	import InteractiveImageEditor from "./InteractiveImageEditor.svelte";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+
+	import { Gradio } from "@gradio/utils";
+	import type { ImageEditorEvents, ImageEditorProps } from "./types";
+
+	let props = $props();
+
+	class ImageEditorGradio extends Gradio<ImageEditorEvents, ImageEditorProps> {
+		async get_data() {
+			const data = await super.get_data();
+			const value = await _get_value();
+			return { ...data, value: value };
+		}
+	}
+	const gradio = new ImageEditorGradio(props, {
+		server: { accept_blobs: () => {} },
+		buttons: [],
+		height: 350,
+		border_region: 0
+	});
+
+	let editor_instance: InteractiveImageEditor;
+	let image_id: null | string = $state(null);
+
+	let has_run_change = false;
+	let has_run_input = false;
+
+	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 is_dragging: boolean;
+
+	const is_browser = typeof window !== "undefined";
+
+	// function handle_change(): void {
+	// 	if (gradio.props.value) gradio.dispatch("change");
+	// }
+
+	function handle_save(): void {
+		gradio.dispatch("apply");
+	}
+
+	// function handle_history_change(): void {
+	// 	gradio.dispatch("change");
+
+	// 	gradio.dispatch("input");
+	// }
+
+	let has_value = $derived(
+		gradio.props.value?.background ||
+			gradio.props.value?.layers?.length ||
+			gradio.props.value?.composite
+	);
+
+	let normalised_background = $derived(
+		gradio.props.value?.background
+			? new FileData(gradio.props.value.background)
+			: null
+	);
+	let normalised_composite = $derived(
+		gradio.props.value?.composite
+			? new FileData(gradio.props.value.composite)
+			: null
+	);
+	let normalised_layers = $derived(
+		gradio.props.value?.layers?.map((layer) => new FileData(layer)) || []
+	);
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		visible={gradio.shared.visible}
+		variant={"solid"}
+		border_mode={is_dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height}
+		width={gradio.props.width}
+		allow_overflow={true}
+		overflow_behavior="visible"
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on:clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+		<StaticImage
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => gradio.dispatch("error", detail)}
+			value={gradio.props.value?.composite || null}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			buttons={gradio.props.buttons}
+			selectable={gradio.props._selectable}
+			i18n={gradio.i18n}
+		/>
+	</Block>
+{:else}
+	<Block
+		visible={gradio.shared.visible}
+		variant={has_value ? "solid" : "dashed"}
+		border_mode={is_dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height}
+		width={gradio.props.width}
+		allow_overflow={true}
+		overflow_behavior="visible"
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on:clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<InteractiveImageEditor
+			border_region={gradio.props.border_region}
+			bind:is_dragging
+			canvas_size={gradio.props.canvas_size}
+			bind:image_id
+			layers={normalised_layers}
+			composite={normalised_composite}
+			background={normalised_background}
+			bind:this={editor_instance}
+			root={gradio.shared.root}
+			sources={gradio.props.sources}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			fixed_canvas={gradio.props.fixed_canvas}
+			on:input={() => {
+				if (!has_run_input) {
+					has_run_input = true;
+				} else {
+					gradio.dispatch("input");
+				}
+			}}
+			on:save={(e) => handle_save()}
+			on:edit={() => gradio.dispatch("edit")}
+			on:clear={() => gradio.dispatch("clear")}
+			on:drag={({ detail }) => (is_dragging = detail)}
+			on:upload={() => gradio.dispatch("upload")}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => {
+				gradio.shared.loading_status = gradio.shared.loading_status || {};
+				gradio.shared.loading_status.status = "error";
+				gradio.dispatch("error", detail);
+			}}
+			on:receive_null={() =>
+				(gradio.props.value = {
+					background: null,
+					layers: [],
+					composite: null
+				})}
+			on:change={() => {
+				if (!has_run_change) {
+					has_run_change = true;
+				} else {
+					gradio.dispatch("change");
+				}
+			}}
+			on:error
+			brush={gradio.props.brush}
+			eraser={gradio.props.eraser}
+			changeable={gradio.shared.attached_events.includes("apply")}
+			realtime={gradio.shared.attached_events.includes("change") ||
+				gradio.shared.attached_events.includes("input")}
+			i18n={gradio.i18n}
+			transforms={gradio.props.transforms}
+			accept_blobs={gradio.shared.server.accept_blobs}
+			layer_options={gradio.props.layers}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			placeholder={gradio.props.placeholder}
+			webcam_options={gradio.props.webcam_options}
+			show_download_button={gradio.props.buttons === null
+				? true
+				: gradio.props.buttons.includes("download")}
+			theme_mode={gradio.shared.theme_mode}
+			on:download_error={(e) => gradio.dispatch("error", e.detail)}
+		></InteractiveImageEditor>
+	</Block>
+{/if}

6.0.0-dev.5/imageeditor/InteractiveImageEditor.svelte

@@ -0,0 +1,309 @@
+<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 { type CommandNode } from "./shared/core/commands";
+	import ImageEditor from "./shared/ImageEditor.svelte";
+	import { type Brush as IBrush, type Eraser } from "./shared/brush/types";
+	import { type Tool as ToolbarTool } from "./shared/Toolbar.svelte";
+
+	import { BlockLabel } from "@gradio/atoms";
+	import { Image as ImageIcon } from "@gradio/icons";
+	import { inject } from "./shared/utils/parse_placeholder";
+	import {
+		type LayerOptions,
+		type Transform,
+		type Source,
+		type WebcamOptions
+	} from "./shared/types";
+
+	export let brush: IBrush;
+	export let eraser: Eraser;
+	export let sources: Source[];
+	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 theme_mode: "dark" | "light";
+
+	export let layers: FileData[];
+	export let composite: FileData | null;
+	export let background: FileData | null;
+
+	export let layer_options: LayerOptions;
+	export let transforms: Transform[];
+	export let accept_blobs: (a: any) => void;
+
+	export let canvas_size: [number, number];
+	export let fixed_canvas = false;
+	export let realtime: boolean;
+	export let upload: Client["upload"];
+	export let is_dragging: boolean;
+	export let placeholder: string | undefined = undefined;
+	export let border_region: number;
+	export let full_history: CommandNode | null = null;
+	export let webcam_options: WebcamOptions;
+	export let show_download_button = false;
+
+	const dispatch = createEventDispatcher<{
+		clear?: never;
+		upload?: never;
+		change?: never;
+		receive_null?: never;
+	}>();
+
+	let editor: ImageEditor;
+	let has_drawn = false;
+
+	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 (background_image) dispatch("upload");
+
+	export async function get_data(): Promise<ImageBlobs> {
+		let blobs;
+		try {
+			blobs = await editor.get_blobs();
+		} catch (e) {
+			return { background: null, layers: [], composite: null };
+		}
+
+		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();
+			dispatch("receive_null");
+		}
+	}
+
+	$: handle_value({ layers, composite, background });
+
+	let background_image = false;
+	let can_undo: boolean;
+
+	export let image_id: null | string = null;
+
+	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);
+		}
+	}
+
+	$: [heading, paragraph] = placeholder ? inject(placeholder) : [false, false];
+
+	let current_tool: ToolbarTool;
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={ImageIcon}
+	label={label || i18n("image.image")}
+/>
+<ImageEditor
+	{transforms}
+	{composite}
+	{layers}
+	{background}
+	on:history
+	{canvas_size}
+	bind:this={editor}
+	{changeable}
+	on:save
+	on:input
+	on:change={handle_change}
+	on:clear={() => dispatch("clear")}
+	on:download_error
+	{sources}
+	bind:background_image
+	bind:current_tool
+	brush_options={brush}
+	eraser_options={eraser}
+	{fixed_canvas}
+	{border_region}
+	{layer_options}
+	{i18n}
+	{root}
+	{upload}
+	bind:is_dragging
+	bind:has_drawn
+	{webcam_options}
+	{show_download_button}
+	{theme_mode}
+	bind:can_undo
+	bind:full_history
+>
+	{#if current_tool === "image" && !can_undo}
+		<div class="empty wrap">
+			{#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-1);
+		text-align: center;
+		color: var(--color-grey-500) !important;
+		cursor: pointer;
+	}
+
+	.wrap {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		line-height: var(--line-md);
+		font-size: var(--text-md);
+	}
+
+	.or {
+		color: var(--body-text-color-subdued);
+	}
+</style>

6.0.0-dev.5/imageeditor/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@gradio/imageeditor",
+	"version": "0.18.2-dev.1",
+	"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:^",
+		"@types/tinycolor2": "^1.4.6",
+		"pixi-filters": "^6.1.4",
+		"pixi.js": "^8.14.0",
+		"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": "^5.43.4"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/imageeditor"
+	}
+}

6.0.0-dev.5/imageeditor/shared/Anchor.svelte

@@ -0,0 +1,384 @@
+<script lang="ts">
+	import { spring } from "svelte/motion";
+	import { Image } from "@gradio/icons";
+	import { onMount, createEventDispatcher } from "svelte";
+
+	const positions = [
+		"top-left",
+		"top",
+		"top-right",
+		"left",
+		"center",
+		"right",
+		"bottom-left",
+		"bottom",
+		"bottom-right"
+	] as const;
+	const dispatch = createEventDispatcher<{
+		position: (typeof positions)[number];
+	}>();
+
+	const spring_opt = {
+		stiffness: 0.1,
+		precision: 0.5
+	};
+	const pos = spring([5, 5], spring_opt);
+	const init = [(120 - 10) / 3, (120 - 10) / 3];
+	const dimensions = spring(init, spring_opt);
+	type Arrow = {
+		x: number;
+		y: number;
+		x_dir: number;
+		y_dir: number;
+		rotation: number;
+		type: number;
+	};
+	const arrow_spring = spring<Arrow[]>([], spring_opt);
+
+	let last_i = 0;
+	let expanded = true;
+	const box_size = (120 - 5 * 2) / 3;
+
+	async function handle_box_hover(i: number): Promise<void> {
+		expanded = false;
+		last_i = i;
+		const y = Math.floor(i / 3);
+		const x = i % 3;
+		pos.set([x * box_size + 5 * x + 5, y * box_size + 5 * y + 5]);
+
+		dimensions.set(init);
+	}
+
+	let last_pos = 0;
+	async function handle_box_click(i: number, stagger = false): Promise<void> {
+		if (expanded && stagger) return;
+
+		const y = Math.floor(i / 3);
+		const x = i % 3;
+
+		const [initial_arrows, eventual_arrows] = get_valid_offsets({
+			x: x,
+			y: y
+		});
+
+		if (stagger && last_i !== i) {
+			await Promise.all([
+				pos.set([x * box_size + 5 * x + 5, y * box_size + 5 * y + 5]),
+				arrow_spring.set(initial_arrows, { hard: true }),
+				dimensions.set(init)
+			]);
+		} else {
+			await arrow_spring.set(initial_arrows, { hard: true });
+		}
+		last_pos = i;
+		expanded = true;
+
+		pos.set([0, 0]);
+		dimensions.set([120 + 10, 120 + 10]);
+		arrow_spring.set(eventual_arrows);
+
+		dispatch("position", positions[i]);
+	}
+
+	function get_valid_offsets(anchorPoint: {
+		x: number;
+		y: number;
+	}): [Arrow[], Arrow[]] {
+		const destination_points: { x: number; y: number }[] = [
+			{ x: 0, y: 0 },
+			{ x: 1, y: 0 },
+			{ x: 2, y: 0 },
+			{ x: 0, y: 1 },
+			{ x: 1, y: 1 },
+			{ x: 2, y: 1 },
+			{ x: 0, y: 2 },
+			{ x: 1, y: 2 },
+			{ x: 2, y: 2 }
+		];
+
+		const offsets = destination_points
+			.map((dest) => ({
+				x: dest.x - anchorPoint.x,
+				y: dest.y - anchorPoint.y,
+				dest
+			}))
+			.filter((offset) => !(offset.x === 0 && offset.y === 0));
+
+		const normalized_offsets = offsets
+			.map((offset) => {
+				// cardinal
+				if (offset.x === 0 || offset.y === 0) {
+					const magnitude = Math.max(Math.abs(offset.x), Math.abs(offset.y));
+					return {
+						magnitude,
+						x: offset.x / magnitude,
+						y: offset.y / magnitude,
+						dest: offset.dest,
+						original: offset,
+						type: "cardinal" as const
+					};
+				}
+
+				// ordinal
+				if (Math.abs(offset.x) === Math.abs(offset.y)) {
+					const magnitude = Math.abs(offset.x);
+					return {
+						magnitude,
+						x: offset.x / magnitude,
+						y: offset.y / magnitude,
+						dest: offset.dest,
+						original: offset,
+						type: "ordinal" as const
+					};
+				}
+
+				// skip the rest
+				return null;
+			})
+			.filter((offset) => offset !== null);
+
+		const directions = new Map<
+			string,
+			{
+				x: number;
+				y: number;
+				dest: { x: number; y: number };
+				original: { x: number; y: number };
+				magnitude: number;
+				type: "cardinal" | "ordinal";
+			}[]
+		>();
+
+		normalized_offsets.forEach((offset) => {
+			if (directions.has(`${offset.x}-${offset.y}`)) {
+				directions.get(`${offset.x}-${offset.y}`)?.push(offset);
+			} else {
+				directions.set(`${offset.x}-${offset.y}`, [offset]);
+			}
+		});
+
+		const unique_directions = Array.from(directions.values()).map(
+			(direction) => {
+				return direction.sort((a, b) => b.magnitude - a.magnitude)[0];
+			}
+		);
+
+		const eventual_arrows = unique_directions.map((arrow) => ({
+			x:
+				arrow.dest.x * box_size +
+				14 * arrow.dest.x +
+				14 +
+				10 +
+				(arrow.type === "ordinal" ? 0 : 12 * arrow.x),
+			y:
+				arrow.dest.y * box_size +
+				14 * arrow.dest.y +
+				14 +
+				10 +
+				(arrow.type === "ordinal" ? 0 : 12 * arrow.y),
+			x_dir: arrow.x,
+			y_dir: arrow.y,
+			rotation:
+				Math.atan2(arrow.original.y, arrow.original.x) * (180 / Math.PI) + 180,
+			type: arrow.type === "ordinal" ? 1 : 2
+		}));
+
+		const initial_arrows = eventual_arrows.map((arrow) => ({
+			...arrow,
+			x:
+				anchorPoint.x * box_size +
+				14 * anchorPoint.x + // gaps
+				14 + // padding
+				10 + // arrow head
+				(arrow.x_dir * box_size) / 2 +
+				arrow.x_dir * (arrow.type === 1 ? 0 : 10), // offset based on direction
+
+			y:
+				anchorPoint.y * box_size +
+				14 * anchorPoint.y +
+				14 +
+				10 +
+				(arrow.y_dir * box_size) / 2 +
+				arrow.y_dir * (arrow.type === 1 ? 0 : 10)
+		}));
+
+		return [initial_arrows, eventual_arrows];
+	}
+
+	onMount(() => {
+		handle_box_click(0);
+	});
+</script>
+
+<div class="wrap" class:expanded>
+	<div
+		class="box-wrap"
+		role="grid"
+		tabindex="0"
+		on:mouseleave={() => handle_box_click(last_pos, true)}
+	>
+		{#each { length: 9 } as _, i}
+			<button
+				class="box"
+				class:active-box={last_pos === i}
+				on:mouseenter={() => handle_box_hover(i)}
+				on:click={() => handle_box_click(i)}
+			>
+				<span class:active={last_pos === i} class="icon-wrap">
+					<Image />
+				</span>
+			</button>
+		{/each}
+	</div>
+	<div
+		class="expanding-box"
+		style:width="{$dimensions[0]}px"
+		style:height="{$dimensions[1]}px"
+		style:transform="translate({$pos[0]}px, {$pos[1]}px)"
+	></div>
+	<svg viewBox="0 0 150 150">
+		{#each $arrow_spring as arrow}
+			<line
+				x1={(last_pos % 3) * box_size +
+					14 * (last_pos % 3) +
+					14 +
+					10 +
+					(arrow.x_dir * box_size) / 2 +
+					arrow.x_dir * (arrow.type === 1 ? 0 : 10)}
+				x2={arrow.x}
+				y1={Math.floor(last_pos / 3) * box_size +
+					14 * Math.floor(last_pos / 3) +
+					14 +
+					10 +
+					(arrow.y_dir * box_size) / 2 +
+					arrow.y_dir * (arrow.type === 1 ? 0 : 10)}
+				y2={arrow.y}
+			/>
+		{/each}
+		{#each $arrow_spring as arrow}
+			<g style:transform="translate(-75px, -75px)">
+				<g style:transform="translate({arrow.x}px, {arrow.y}px)">
+					<path
+						d="M 70,75 80,69 80,81 Z"
+						style:transform="rotate({arrow.rotation}deg)"
+						style:transform-origin="75 75"
+					/>
+				</g>
+			</g>
+		{/each}
+	</svg>
+</div>
+
+<style>
+	.wrap {
+		position: relative;
+		margin: 10px 0;
+		height: 130px;
+		width: 130px;
+		padding: 5px;
+	}
+
+	.box-wrap {
+		width: 100%;
+		height: 100%;
+		display: grid;
+		grid-template-columns: repeat(3, 1fr);
+		grid-template-rows: repeat(3, 1fr);
+		gap: 5px;
+
+		background-color: var(--block-background-fill);
+	}
+
+	.box {
+		cursor: pointer;
+		border: none;
+		border: #ccc dashed 1px;
+		border-radius: 4px;
+		transition: 0.1s;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+
+	.box::after {
+		background: none !important;
+	}
+
+	.expanding-box {
+		--mod: 3;
+		--border: 2;
+		border: orange solid 2px;
+		border-radius: 4px;
+		position: absolute;
+		top: 0px;
+		left: 0px;
+		width: 100%;
+		height: 100%;
+		pointer-events: none;
+
+		width: calc(100% / var(--mod));
+		height: calc(100% / var(--mod));
+		transform-origin: 50% 0;
+		box-sizing: border-box;
+	}
+
+	svg {
+		position: absolute;
+		top: 0px;
+		left: 0px;
+		width: 100%;
+		height: 100%;
+
+		pointer-events: none;
+	}
+
+	.icon-wrap {
+		opacity: 0.2;
+		height: 50%;
+		width: 50%;
+
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		border-color: #ccc;
+		transition: 0.1s;
+		padding-top: 1px;
+	}
+
+	.wrap.expanded .icon-wrap {
+		opacity: 0;
+	}
+
+	.wrap.expanded .box {
+		border-color: #fff;
+	}
+
+	.icon-wrap.active {
+		opacity: 1 !important;
+	}
+
+	svg {
+		opacity: 0;
+		padding: 5px;
+		transition: 0.1s;
+	}
+	.expanded svg {
+		opacity: 1;
+	}
+
+	svg line {
+		stroke: #999;
+		stroke-width: 3px;
+		stroke-linecap: round;
+	}
+
+	svg path {
+		stroke-width: 3;
+		stroke: #999;
+		stroke-linejoin: round;
+		stroke-linecap: round;
+		fill: #999;
+		/* transition: 0.5s; */
+		transform-origin: 75px 75px;
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/Controls.svelte

@@ -0,0 +1,251 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import {
+		Check,
+		Trash,
+		ZoomIn,
+		ZoomOut,
+		Pan,
+		Download,
+		Undo,
+		Redo
+	} from "@gradio/icons";
+	import type { Writable } from "svelte/store";
+
+	export let can_save = false;
+	export let changeable = false;
+	export let current_zoom = 1;
+	export let tool: string;
+	export let min_zoom = true;
+	export let enable_download = false;
+	export let can_undo: boolean;
+	export let can_redo: boolean;
+
+	const dispatch = createEventDispatcher<{
+		remove_image: void;
+		undo: void;
+		redo: void;
+		save: void;
+		zoom_in: void;
+		zoom_out: void;
+		set_zoom: number | "fit";
+		pan: void;
+		download: void;
+	}>();
+
+	let show_zoom_popup = false;
+
+	function handle_zoom_click(e: MouseEvent): void {
+		e.stopPropagation();
+		show_zoom_popup = !show_zoom_popup;
+	}
+
+	function handle_zoom_change(zoom: number | "fit"): void {
+		dispatch("set_zoom", zoom);
+		show_zoom_popup = false;
+	}
+
+	function handle_zoom_keydown(e: KeyboardEvent): void {
+		if (e.key === "Enter") {
+			handle_zoom_change(current_zoom);
+		}
+	}
+
+	$: formatted_zoom = Math.round(current_zoom * 100);
+</script>
+
+<IconButtonWrapper>
+	{#if enable_download}
+		<IconButton
+			Icon={Download}
+			label="Download"
+			on:click={(event) => {
+				dispatch("download");
+				event.stopPropagation();
+			}}
+		/>
+	{/if}
+
+	<IconButton
+		Icon={Pan}
+		label="Pan"
+		on:click={(e) => {
+			e.stopPropagation();
+			dispatch("pan");
+		}}
+		highlight={tool === "pan"}
+		size="small"
+		padded={false}
+		transparent={true}
+		disabled={min_zoom}
+	/>
+
+	<IconButton
+		Icon={ZoomOut}
+		label="Zoom out"
+		on:click={(event) => {
+			dispatch("zoom_out");
+			event.stopPropagation();
+		}}
+	/>
+	<IconButton
+		Icon={ZoomIn}
+		label="Zoom in"
+		on:click={(event) => {
+			dispatch("zoom_in");
+			event.stopPropagation();
+		}}
+	/>
+
+	<div class="zoom-number">
+		<span
+			role="button"
+			tabindex="0"
+			on:click={handle_zoom_click}
+			on:keydown={handle_zoom_keydown}>{formatted_zoom}%</span
+		>
+		{#if show_zoom_popup}
+			<div class="zoom-controls">
+				<ul>
+					<li>
+						<button on:click|stopPropagation={() => handle_zoom_change("fit")}>
+							Fit to screen
+						</button>
+					</li>
+					{#each [0.25, 0.5, 1, 2, 4] as zoom}
+						<li>
+							<button on:click|stopPropagation={() => handle_zoom_change(zoom)}>
+								{zoom * 100}%
+							</button>
+						</li>
+					{/each}
+				</ul>
+			</div>
+		{/if}
+	</div>
+	<div class="separator"></div>
+
+	<IconButton
+		Icon={Undo}
+		label="Undo"
+		on:click={(event) => {
+			dispatch("undo");
+			event.stopPropagation();
+		}}
+		disabled={!can_undo}
+	/>
+
+	<IconButton
+		Icon={Redo}
+		label="Redo"
+		on:click={(event) => {
+			dispatch("redo");
+			event.stopPropagation();
+		}}
+		disabled={!can_redo}
+	/>
+
+	{#if changeable}
+		<IconButton
+			disabled={!can_save}
+			Icon={Check}
+			label="Save changes"
+			on:click={(event) => {
+				dispatch("save");
+				event.stopPropagation();
+			}}
+			color="var(--color-accent)"
+		/>
+	{/if}
+
+	<IconButton
+		Icon={Trash}
+		label="Clear canvas"
+		on:click={(event) => {
+			dispatch("remove_image");
+			event.stopPropagation();
+		}}
+	/>
+</IconButtonWrapper>
+
+<style>
+	.separator {
+		width: 1px;
+		height: 10px;
+		background-color: var(--border-color-primary);
+	}
+
+	.zoom-number {
+		position: relative;
+		width: 30px;
+		padding-left: 4px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.zoom-number span {
+		cursor: pointer;
+		font-size: var(--text-sm);
+		transition: color 0.15s ease;
+	}
+
+	.zoom-number span:hover {
+		color: var(--color-accent);
+	}
+
+	.zoom-controls {
+		position: absolute;
+		top: calc(100% + var(--spacing-xxs) + 3px);
+		left: -2px;
+		background: var(--block-background-fill);
+		border: 1px solid var(--color-gray-200);
+		border-radius: var(--radius-sm);
+		padding: var(--spacing-xxs);
+		box-shadow: var(--shadow-drop);
+		font-size: 12px;
+		z-index: var(--layer-2);
+		width: max-content;
+		color: var(--block-label-text-color);
+		border: 1px solid var(--block-border-color);
+		border-top-left-radius: 0;
+		border-top-right-radius: 0;
+	}
+
+	.zoom-controls ul {
+		list-style: none;
+		margin: 0;
+		padding: 0;
+	}
+
+	.zoom-controls li {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		transition: background-color 0.15s ease;
+		border-bottom: 1px solid var(--border-color-primary);
+	}
+
+	.zoom-controls li:last-child {
+		border-bottom: none;
+	}
+
+	.zoom-controls li:hover {
+		background-color: var(--background-fill-secondary);
+	}
+
+	.zoom-controls button {
+		width: 100%;
+		text-align: left;
+		padding: var(--spacing-sm) var(--spacing-md);
+		font-size: var(--text-sm);
+		line-height: var(--line-sm);
+		transition: all 0.15s ease;
+		border-radius: var(--radius-sm);
+	}
+
+	.zoom-controls button:hover {
+		color: var(--color-accent);
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/IconButton.svelte

@@ -0,0 +1,150 @@
+<script lang="ts">
+	import { type ComponentType } from "svelte";
+	import type { ColorInput } from "tinycolor2";
+	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: string | ColorInput = "var(--block-label-text-color)";
+	export let transparent = false;
+	export let background = "var(--background-fill-primary)";
+	export let offset = 0;
+	export let label_position: "left" | "right" = "left";
+	export let roundedness: "quite" | "very" = "quite";
+	$: _color = highlight ? "var(--color-accent)" : color.toString();
+</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"}
+	class="{roundedness}-round"
+>
+	{#if show_label && label_position === "left"}
+		<span style="margin-left: 4px;">{label}</span>
+	{/if}
+	<div
+		class:small={size === "small"}
+		class:large={size === "large"}
+		class:medium={size === "medium"}
+	>
+		<Icon />
+	</div>
+	{#if show_label && label_position === "right"}
+		<span style="margin-right: 4px;">{label}</span>
+	{/if}
+</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;
+	}
+
+	.quite-round {
+		border-radius: var(--radius-sm);
+	}
+
+	.very-round {
+		border-radius: var(--radius-md);
+	}
+
+	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>

6.0.0-dev.5/imageeditor/shared/ImageEditor.svelte

@@ -0,0 +1,904 @@
+<script lang="ts" context="module">
+	import type { Tool, Subtool } from "./Toolbar.svelte";
+
+	export const EDITOR_KEY = Symbol("editor");
+	export type context_type = "bg" | "layers" | "crop" | "draw" | "erase";
+</script>
+
+<script lang="ts">
+	import { onMount, createEventDispatcher, tick } from "svelte";
+	import { get } from "svelte/store";
+	import Toolbar, { type Tool as ToolbarTool } from "./Toolbar.svelte";
+	import { CropTool } from "./crop/crop";
+	import { ResizeTool } from "./resize/resize";
+	import { Webcam } from "@gradio/image";
+	import type { I18nFormatter } from "@gradio/utils";
+	import type { Client, FileData } from "@gradio/client";
+	import tinycolor, { type ColorInput } from "tinycolor2";
+	import { ZoomTool } from "./zoom/zoom";
+	import { type CommandManager, type CommandNode } from "./core/commands";
+	import { ImageEditor } from "./core/editor";
+	import { type Brush, type Eraser } from "./brush/types";
+	import { BrushTool } from "./brush/brush";
+	import { create_drag } from "@gradio/upload";
+	import SecondaryToolbar from "./SecondaryToolbar.svelte";
+	import { Check } from "@gradio/icons";
+	import type { LayerOptions, Source, Transform, WebcamOptions } from "./types";
+
+	import { type ImageBlobs } from "./types";
+	import Controls from "./Controls.svelte";
+	import IconButton from "./IconButton.svelte";
+
+	const { drag, open_file_upload } = create_drag();
+	const dispatch = createEventDispatcher<{
+		clear?: never;
+		save: void;
+		change: void;
+		upload: void;
+		input: void;
+		download_error: string;
+	}>();
+
+	export const antialias = true;
+
+	export let changeable = false;
+	export let sources: Source[] = ["upload", "webcam", "clipboard"];
+	export let transforms: Transform[] = ["crop", "resize"];
+	export let canvas_size: [number, number];
+	export let is_dragging = false;
+	export let background_image = false;
+	export let brush_options: Brush;
+	export let eraser_options: Eraser;
+	export let fixed_canvas = false;
+	export let root: string;
+	export let i18n: I18nFormatter;
+	export let upload: Client["upload"];
+	export let composite: FileData | null;
+	export let layers: FileData[];
+	export let background: FileData | null;
+	export let border_region = 0;
+	export let layer_options: LayerOptions;
+	export let current_tool: ToolbarTool;
+	export let webcam_options: WebcamOptions;
+	export let show_download_button = false;
+	export let theme_mode: "dark" | "light";
+	export let full_history: CommandNode | null = null;
+
+	let pixi_target: HTMLDivElement;
+	let pixi_target_crop: HTMLDivElement;
+
+	$: if (layer_options) {
+		if (check_if_should_init()) {
+			editor.set_layer_options(layer_options);
+			refresh_tools();
+		}
+	}
+
+	function refresh_tools(): void {
+		if (!editor || !ready) return;
+		editor.set_tool(current_tool);
+		editor.set_subtool(current_subtool);
+	}
+
+	$: if (editor && ready && editor.layers) {
+		const current_layers = get(editor.layers);
+
+		if (current_layers.layers.length > 0 && !current_layers.active_layer) {
+			refresh_tools_for_layer_changes(current_layers);
+		}
+	}
+
+	/**
+	 * Refreshes tools when layer state changes
+	 */
+	function refresh_tools_for_layer_changes(current_layers: any): void {
+		if (!editor || !ready) return;
+
+		if (current_layers.layers.length > 0 && !current_layers.active_layer) {
+			editor.set_layer(current_layers.layers[0].id);
+		}
+
+		// reapply current tool to ensure it targets the correct layer
+		if (current_tool) {
+			editor.set_tool(current_tool);
+			if (current_subtool) {
+				editor.set_subtool(current_subtool);
+			}
+		}
+
+		if (brush && (current_tool === "draw" || current_tool === "erase")) {
+			brush.set_tool(current_tool, current_subtool);
+		}
+	}
+
+	function check_if_should_init(): boolean {
+		return layer_options && editor && ready;
+	}
+
+	export let has_drawn = false;
+
+	/**
+	 * Gets the image blobs from the editor
+	 * @returns {Promise<ImageBlobs>} Object containing background, layers, and composite image blobs
+	 */
+	export async function get_blobs(): Promise<ImageBlobs> {
+		if (!editor) return { background: null, layers: [], composite: null };
+		if (!background_image && !has_drawn && !layers.length)
+			return { background: null, layers: [], composite: null };
+		const blobs = await editor.get_blobs();
+		return blobs;
+	}
+
+	let editor: ImageEditor;
+
+	/**
+	 * Adds an image to the editor
+	 * @param {Blob | File} image - The image to add
+	 */
+	export function add_image(image: Blob | File): void {
+		editor.add_image({ image });
+	}
+
+	let pending_bg: Promise<void>;
+	/**
+	 * Adds an image to the editor from a URL
+	 * @param {string | FileData} source - The URL of the image or a FileData object
+	 * @returns {Promise<void>}
+	 */
+	export async function add_image_from_url(
+		source:
+			| string
+			| {
+					url: string;
+					meta: {
+						_type: string;
+					};
+			  }
+			| any
+	): Promise<void> {
+		if (!editor || !source || !check_if_should_init()) return;
+		let url: string;
+
+		if (typeof source === "string") {
+			url = source;
+		} else if (source?.meta?._type === "gradio.FileData" && source?.url) {
+			url = source.url;
+		} else {
+			console.warn("Invalid source provided to add_image_from_url:", source);
+			return;
+		}
+
+		try {
+			pending_bg = editor.add_image_from_url(url);
+			let pending_crop = crop.add_image_from_url(url);
+			await Promise.all([pending_bg, pending_crop]);
+			crop.set_tool("image");
+			crop.set_subtool("crop");
+			background_image = true;
+			zoom.set_zoom("fit");
+			dispatch("upload");
+			dispatch("input");
+		} catch (error) {
+			console.error("Error adding image from URL:", error);
+		}
+	}
+
+	/**
+	 * Adds a new layer with an image loaded from a URL
+	 * @param {string | FileData} source - The URL of the image or a FileData object
+	 * @returns {Promise<string | null>} - The ID of the created layer, or null if failed
+	 */
+	export async function add_layers_from_url(
+		source: FileData[] | any
+	): Promise<void> {
+		if (!editor || !source.length || !check_if_should_init()) return;
+
+		if (
+			Array.isArray(source) &&
+			source.every((item) => item?.meta?._type === "gradio.FileData")
+		) {
+			try {
+				await pending_bg;
+				await editor.add_layers_from_url(source.map((item) => item.url));
+				dispatch("change");
+				dispatch("input");
+			} catch (error) {
+				console.error("Error adding layer from URL:", error);
+			}
+		}
+	}
+
+	let brush: BrushTool;
+	let zoom: ZoomTool;
+	let zoom_level = 1;
+	let ready = false;
+	let mounted = false;
+	let min_zoom = true;
+
+	let last_dimensions = { width: 0, height: 0 };
+
+	/**
+	 * Handles visibility changes and resets zoom if dimensions have changed
+	 */
+	async function handle_visibility_change(): Promise<void> {
+		if (!editor || !ready || !zoom) return;
+		await tick();
+
+		const is_visible = pixi_target.offsetParent !== null;
+
+		if (is_visible) {
+			const current_dimensions = pixi_target.getBoundingClientRect();
+
+			if (
+				current_dimensions.width !== last_dimensions.width ||
+				current_dimensions.height !== last_dimensions.height
+			) {
+				zoom.set_zoom("fit");
+
+				last_dimensions = {
+					width: current_dimensions.width,
+					height: current_dimensions.height
+				};
+			}
+		}
+	}
+
+	onMount(() => {
+		let intersection_observer: IntersectionObserver;
+		let resize_observer: ResizeObserver;
+
+		init_image_editor().then(() => {
+			mounted = true;
+			intersection_observer = new IntersectionObserver(() => {
+				handle_visibility_change();
+			});
+
+			resize_observer = new ResizeObserver(() => {
+				handle_visibility_change();
+			});
+
+			intersection_observer.observe(pixi_target);
+			resize_observer.observe(pixi_target);
+
+			setTimeout(() => {
+				if (full_history && editor) {
+					editor.command_manager
+						.replay(full_history, editor.context)
+						.then(() => {
+							refresh_tools_after_history();
+						});
+				}
+			}, 0);
+		});
+
+		if (typeof window !== "undefined") {
+			(window as any).editor = editor;
+		}
+
+		return () => {
+			if (intersection_observer) {
+				intersection_observer.disconnect();
+			}
+			if (resize_observer) {
+				resize_observer.disconnect();
+			}
+			if (editor) {
+				editor.destroy();
+			}
+		};
+	});
+
+	/**
+	 * Refreshes tool state after history replay to ensure proper layer targeting
+	 */
+	function refresh_tools_after_history(): void {
+		if (!editor || !ready) return;
+
+		const current_layers = get(editor.layers);
+
+		if (current_layers.layers.length > 0 && !current_layers.active_layer) {
+			editor.set_layer(current_layers.layers[0].id);
+		}
+
+		if (current_tool) {
+			editor.set_tool(current_tool);
+			if (current_subtool) {
+				editor.set_subtool(current_subtool);
+			}
+		}
+
+		if (brush && (current_tool === "draw" || current_tool === "erase")) {
+			brush.set_tool(current_tool, current_subtool);
+		}
+
+		full_history = editor.command_manager.history;
+	}
+
+	let crop: ImageEditor;
+	let crop_zoom: ZoomTool;
+	export let can_undo = false;
+	let can_redo = false;
+	async function init_image_editor(): Promise<void> {
+		brush = new BrushTool();
+		zoom = new ZoomTool();
+		editor = new ImageEditor({
+			target_element: pixi_target,
+			width: canvas_size[0],
+			height: canvas_size[1],
+			tools: ["image", zoom, new ResizeTool(), brush],
+			fixed_canvas,
+			border_region,
+			layer_options,
+			theme_mode
+		});
+
+		brush.on("change", () => {
+			has_drawn = true;
+		});
+
+		crop_zoom = new ZoomTool();
+
+		crop = new ImageEditor({
+			target_element: pixi_target_crop,
+			width: canvas_size[0],
+			height: canvas_size[1],
+			tools: ["image", crop_zoom, new CropTool()],
+			dark: true,
+			fixed_canvas: false,
+			border_region: 0,
+			pad_bottom: 40
+		});
+
+		editor.scale.subscribe((_scale) => {
+			zoom_level = _scale;
+		});
+
+		editor.min_zoom.subscribe((is_min_zoom) => {
+			min_zoom = is_min_zoom;
+		});
+
+		editor.dimensions.subscribe((dimensions) => {
+			last_dimensions = { ...dimensions };
+		});
+
+		editor.command_manager.current_history.subscribe((history) => {
+			can_undo = history.previous !== null;
+			can_redo = history.next !== null;
+		});
+
+		await Promise.all([editor.ready, crop.ready]).then(() => {
+			handle_tool_change({ tool: "image" });
+			ready = true;
+			if (sources.length > 0) {
+				handle_tool_change({ tool: "image" });
+			} else {
+				handle_tool_change({ tool: "draw" });
+			}
+			crop.set_subtool("crop");
+		});
+
+		editor.on("change", () => {
+			dispatch("change");
+			dispatch("input");
+			full_history = editor.command_manager.history;
+		});
+
+		if (background || layers.length > 0) {
+			if (background) {
+				await add_image_from_url(background);
+			}
+			if (layers.length > 0) {
+				await add_layers_from_url(layers);
+			}
+			handle_tool_change({ tool: "draw" });
+		} else if (composite) {
+			await add_image_from_url(composite);
+			handle_tool_change({ tool: "draw" });
+		}
+
+		refresh_tools();
+	}
+
+	$: if (
+		background == null &&
+		layers.length == 0 &&
+		composite == null &&
+		editor &&
+		ready
+	) {
+		editor.reset_canvas();
+		zoom.set_zoom("fit");
+		handle_tool_change({ tool: "image" });
+		background_image = false;
+		has_drawn = false;
+	}
+
+	$: current_tool === "image" &&
+		current_subtool === "crop" &&
+		crop_zoom.set_zoom("fit");
+
+	/**
+	 * Handles file uploads
+	 * @param {File[]} files - The uploaded files
+	 */
+	async function handle_files(
+		files: File[] | Blob[] | File | Blob | null
+	): Promise<void> {
+		if (files == null) return;
+		if (!sources.includes("upload")) return;
+		editor.reset_canvas();
+		const _file = Array.isArray(files) ? files[0] : files;
+		await editor.add_image({ image: _file });
+		await crop.add_image({ image: _file });
+		crop.reset();
+
+		background_image = true;
+		zoom.set_zoom("fit");
+		handle_tool_change({ tool: "draw" });
+		dispatch("upload");
+	}
+
+	$: background_image = can_undo && editor.command_manager.contains("AddImage");
+
+	/**
+	 * Handles tool change events
+	 * @param {{ tool: ToolbarTool }} param0 - Object containing the selected tool
+	 */
+	function handle_tool_change({ tool }: { tool: ToolbarTool }): void {
+		editor.set_tool(tool);
+		current_tool = tool;
+
+		if (tool === "image") {
+			crop.set_tool("image");
+			crop.set_subtool("crop");
+		}
+	}
+
+	/**
+	 * Handles subtool change events
+	 * @param {{ tool: ToolbarTool, subtool: Subtool }} param0 - Object containing the selected tool and subtool
+	 */
+	function handle_subtool_change({
+		tool,
+		subtool
+	}: {
+		tool: ToolbarTool;
+		subtool: Subtool | null;
+	}): void {
+		editor.set_subtool(subtool);
+		current_subtool = subtool;
+
+		if (subtool === null) {
+			return;
+		}
+
+		if (tool === "draw") {
+			if (subtool === "size") {
+				brush_size_visible = true;
+			} else if (subtool === "color") {
+				brush_color_visible = true;
+			}
+		}
+
+		if (tool === "erase" && subtool === "size") {
+			eraser_size_visible = true;
+		}
+
+		if (tool === "image" && subtool === "paste") {
+			process_clipboard();
+		}
+
+		if (tool === "image" && subtool === "upload") {
+			tick().then(() => {
+				disable_click = false;
+				open_file_upload();
+			});
+		}
+	}
+
+	let eraser_size_visible = false;
+	let selected_color: ColorInput | string;
+	let selected_size: number;
+	let selected_opacity = 1;
+	let selected_eraser_size: number;
+
+	$: {
+		if (brush_options) {
+			update_brush_options();
+		}
+
+		if (eraser_options) {
+			update_eraser_options();
+		}
+	}
+
+	function update_brush_options(): void {
+		const default_color =
+			brush_options.default_color === "auto"
+				? brush_options.colors[0]
+				: brush_options.default_color;
+
+		// color is already a tuple [color, opacity]
+		if (Array.isArray(default_color)) {
+			selected_color = default_color[0];
+			selected_opacity = default_color[1];
+		} else {
+			selected_color = default_color;
+
+			// color is a string, check if it has opacity info
+			const color = tinycolor(default_color);
+			if (color.getAlpha() < 1) {
+				selected_opacity = color.getAlpha();
+			} else {
+				selected_opacity = 1;
+			}
+		}
+
+		selected_size =
+			typeof brush_options.default_size === "number"
+				? brush_options.default_size
+				: 25;
+	}
+
+	function update_eraser_options(): void {
+		selected_eraser_size =
+			eraser_options.default_size === "auto" ? 25 : eraser_options.default_size;
+	}
+
+	let brush_size_visible = false;
+
+	let brush_color_visible = false;
+
+	$: brush?.set_brush_color(
+		(() => {
+			let color_value;
+			if (selected_color === "auto") {
+				const default_color =
+					brush_options.colors.find((color) =>
+						Array.isArray(color)
+							? color[0] === brush_options.default_color
+							: color === brush_options.default_color
+					) || brush_options.colors[0];
+
+				color_value = Array.isArray(default_color)
+					? default_color[0]
+					: default_color;
+			} else {
+				color_value = selected_color;
+			}
+			return color_value;
+		})()
+	);
+
+	$: brush?.set_brush_size(
+		typeof selected_size === "number" ? selected_size : 25
+	);
+
+	$: brush?.set_eraser_size(
+		typeof selected_eraser_size === "number" ? selected_eraser_size : 25
+	);
+
+	$: disable_click =
+		current_tool !== "image" ||
+		(current_tool === "image" && background_image) ||
+		(current_tool === "image" && current_subtool === "webcam") ||
+		!sources.includes("upload");
+
+	let current_subtool: Subtool | null = null;
+	let preview = false;
+	$: brush?.preview_brush(preview);
+	$: brush?.set_brush_opacity(selected_opacity);
+
+	function handle_zoom_change(zoom_level: number | "fit"): void {
+		zoom.set_zoom(zoom_level);
+	}
+
+	function zoom_in_out(direction: "in" | "out"): void {
+		zoom.set_zoom(
+			direction === "in"
+				? zoom_level + (zoom_level < 1 ? 0.1 : zoom_level * 0.1)
+				: zoom_level - (zoom_level < 1 ? 0.1 : zoom_level * 0.1)
+		);
+	}
+
+	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);
+
+				handle_files(blob);
+			}
+		}
+	}
+
+	function handle_capture(e: CustomEvent): void {
+		if (e.detail !== null) {
+			handle_files(e.detail as Blob);
+		}
+		handle_subtool_change({ tool: current_tool, subtool: null });
+	}
+
+	function handle_save(): void {
+		dispatch("save");
+	}
+
+	$: add_image_from_url(composite || background);
+	$: add_layers_from_url(layers);
+
+	async function handle_crop_confirm(): Promise<void> {
+		const { image } = await crop.get_crop_bounds();
+		if (!image) return;
+
+		await editor.add_image({
+			image,
+			resize: false
+		});
+		handle_subtool_change({ tool: "image", subtool: null });
+		dispatch("change");
+		dispatch("input");
+	}
+
+	async function handle_download(): Promise<void> {
+		const blobs = await editor.get_blobs();
+
+		const blob = blobs.composite;
+		if (!blob) {
+			dispatch("download_error", "Unable to generate image to download.");
+			return;
+		}
+		const url = URL.createObjectURL(blob);
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = "image.png";
+		link.click();
+		URL.revokeObjectURL(url);
+	}
+
+	function handle_undo(): void {
+		editor.undo();
+	}
+
+	function handle_redo(): void {
+		editor.redo();
+	}
+
+	let old_background = background;
+
+	$: if (old_background !== background) {
+		handle_tool_change({ tool: "draw" });
+		handle_subtool_change({ tool: "draw", subtool: null });
+		current_tool = "draw";
+		old_background = background;
+	}
+</script>
+
+<div
+	data-testid="image"
+	class="image-container"
+	class:dark-bg={current_subtool === "crop"}
+	use:drag={{
+		on_drag_change: (dragging) => (is_dragging = dragging),
+		on_files: handle_files,
+		accepted_types: "image/*",
+		disable_click: disable_click
+	}}
+	aria-label={"Click to upload or drop files"}
+	aria-dropeffect="copy"
+>
+	{#if ready}
+		{#if current_subtool !== "crop"}
+			<Controls
+				{changeable}
+				on:set_zoom={(e) => handle_zoom_change(e.detail)}
+				on:zoom_in={() => zoom_in_out("in")}
+				on:zoom_out={() => zoom_in_out("out")}
+				{min_zoom}
+				current_zoom={zoom_level}
+				on:remove_image={() => {
+					dispatch("clear");
+					editor.reset_canvas();
+					handle_tool_change({ tool: "image" });
+					background_image = false;
+					has_drawn = false;
+				}}
+				tool={current_tool}
+				can_save={true}
+				on:save={handle_save}
+				on:pan={(e) => {
+					handle_tool_change({ tool: "pan" });
+				}}
+				enable_download={show_download_button}
+				on:download={() => handle_download()}
+				{can_undo}
+				{can_redo}
+				on:undo={handle_undo}
+				on:redo={handle_redo}
+			/>
+		{/if}
+
+		{#if current_subtool !== "crop"}
+			<Toolbar
+				{sources}
+				{transforms}
+				background={background_image}
+				on:tool_change={(e) => handle_tool_change(e.detail)}
+				on:subtool_change={(e) => handle_subtool_change(e.detail)}
+				show_brush_size={brush_size_visible}
+				show_brush_color={brush_color_visible}
+				show_eraser_size={eraser_size_visible}
+				{brush_options}
+				{eraser_options}
+				bind:selected_color
+				bind:selected_size
+				bind:selected_eraser_size
+				bind:selected_opacity
+				bind:preview
+				tool={current_tool}
+				subtool={current_subtool}
+			/>
+		{/if}
+
+		{#if current_tool === "image" && current_subtool === "webcam"}
+			<div class="modal">
+				<div class="modal-inner">
+					<Webcam
+						{upload}
+						{root}
+						on:capture={handle_capture}
+						on:error
+						on:drag
+						streaming={false}
+						mode="image"
+						include_audio={false}
+						{i18n}
+						mirror_webcam={webcam_options.mirror}
+						webcam_constraints={webcam_options.constraints}
+					/>
+				</div>
+			</div>
+		{/if}
+
+		{#if current_subtool !== "crop" && !layer_options.disabled}
+			<SecondaryToolbar
+				enable_additional_layers={layer_options.allow_additional_layers}
+				layers={editor.layers}
+				on:new_layer={() => {
+					editor.add_layer();
+				}}
+				on:change_layer={(e) => {
+					editor.set_layer(e.detail);
+					if (current_tool === "draw") {
+						handle_tool_change({ tool: "draw" });
+					}
+				}}
+				on:move_layer={(e) => {
+					editor.move_layer(e.detail.id, e.detail.direction);
+				}}
+				on:delete_layer={(e) => {
+					editor.delete_layer(e.detail);
+				}}
+				on:toggle_layer_visibility={(e) => {
+					editor.toggle_layer_visibility(e.detail);
+				}}
+			/>
+		{/if}
+	{/if}
+	<div
+		class="pixi-target"
+		class:visible={current_subtool !== "crop"}
+		bind:this={pixi_target}
+	></div>
+	<div
+		class="pixi-target-crop"
+		class:visible={current_subtool === "crop"}
+		bind:this={pixi_target_crop}
+	></div>
+
+	{#if current_subtool === "crop"}
+		<div class="crop-confirm-button">
+			<IconButton
+				Icon={Check}
+				label="Confirm crop"
+				show_label={true}
+				size="large"
+				padded={true}
+				color="white"
+				background="var(--color-green-500)"
+				label_position="right"
+				on:click={handle_crop_confirm}
+			/>
+		</div>
+	{/if}
+	<slot></slot>
+</div>
+
+<style>
+	.image-container {
+		display: flex;
+		height: 100%;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		max-height: 100%;
+		border-radius: var(--radius-sm);
+	}
+
+	.pixi-target {
+		width: 100%;
+		height: 100%;
+		position: absolute;
+		top: 0;
+		left: 0;
+		z-index: 1;
+		display: block;
+		opacity: 0;
+		pointer-events: none;
+		border-radius: var(--radius-sm);
+	}
+
+	.pixi-target-crop {
+		width: 100%;
+		height: 100%;
+		position: absolute;
+		top: 0;
+		left: 0;
+		z-index: 2;
+		display: block;
+		opacity: 0;
+		pointer-events: none;
+		border-radius: var(--radius-sm);
+	}
+
+	.visible {
+		opacity: 1;
+		pointer-events: auto;
+	}
+
+	.pixi-target {
+		width: 100%;
+		height: 100%;
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+		overflow: hidden;
+	}
+
+	.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 {
+		height: 100%;
+		width: 100%;
+		background: var(--block-background-fill);
+	}
+
+	.dark-bg {
+		background: #333;
+	}
+
+	.crop-confirm-button {
+		position: absolute;
+		bottom: 8px;
+		left: 0;
+		right: 0;
+		margin: auto;
+		z-index: var(--layer-top);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/Layers.svelte

@@ -0,0 +1,282 @@
+<script lang="ts">
+	import { click_outside } from "./utils/events";
+	import {
+		Layers,
+		Clear,
+		ArrowUp,
+		ArrowDown,
+		Plus,
+		Visibility,
+		VisibilityOff
+	} from "@gradio/icons";
+	import { IconButton } from "@gradio/atoms";
+	import { createEventDispatcher } from "svelte";
+	import type { Writable } from "svelte/store";
+
+	const dispatch = createEventDispatcher<{
+		new_layer: void;
+		change_layer: string;
+		move_layer: { id: string; direction: "up" | "down" };
+		delete_layer: string;
+		toggle_layer_visibility: string;
+	}>();
+
+	export let layers: Writable<{
+		active_layer: string;
+		layers: {
+			name: string;
+			id: string;
+			user_created: boolean;
+			visible: boolean;
+		}[];
+	}>;
+	export let enable_additional_layers = true;
+	export let enable_layers = true;
+	export let show_layers = false;
+
+	function new_layer(): void {
+		dispatch("new_layer");
+	}
+
+	function change_layer(id: string): void {
+		dispatch("change_layer", id);
+		show_layers = false;
+	}
+
+	function move_layer(id: string, direction: "up" | "down"): void {
+		dispatch("move_layer", { id, direction });
+	}
+
+	function delete_layer(id: string): void {
+		dispatch("delete_layer", id);
+	}
+</script>
+
+{#if enable_layers}
+	<div
+		class="layer-wrap"
+		class:closed={!show_layers}
+		use:click_outside={() => (show_layers = false)}
+	>
+		<button
+			class="layer-title-button"
+			aria-label="Show Layers"
+			on:click|stopPropagation={() => (show_layers = !show_layers)}
+		>
+			{show_layers
+				? "Layers"
+				: $layers.layers.find((l) => l.id === $layers.active_layer)?.name}
+			<span class="icon"><Layers /></span>
+		</button>
+		{#if show_layers}
+			<ul>
+				{#each $layers.layers as { id, name, user_created, visible }, i (i)}
+					<li>
+						{#if !visible}
+							<IconButton
+								Icon={VisibilityOff}
+								size="small"
+								on:click={(e) => {
+									e.stopPropagation();
+									dispatch("toggle_layer_visibility", id);
+								}}
+							/>
+						{:else}
+							<IconButton
+								Icon={Visibility}
+								size="small"
+								on:click={(e) => {
+									e.stopPropagation();
+									dispatch("toggle_layer_visibility", id);
+								}}
+							/>
+						{/if}
+						<button
+							class:selected_layer={$layers.active_layer === id}
+							aria-label={`layer-${i + 1}`}
+							on:click|stopPropagation={() => change_layer(id)}>{name}</button
+						>
+						{#if $layers.layers.length > 1}
+							<div>
+								{#if i > 0}
+									<IconButton
+										on:click={(e) => {
+											e.stopPropagation();
+											move_layer(id, "up");
+										}}
+										Icon={ArrowUp}
+										size="x-small"
+									/>
+								{/if}
+								{#if i < $layers.layers.length - 1}
+									<IconButton
+										on:click={(e) => {
+											e.stopPropagation();
+											move_layer(id, "down");
+										}}
+										Icon={ArrowDown}
+										size="x-small"
+									/>
+								{/if}
+								{#if $layers.layers.length > 1 && user_created}
+									<IconButton
+										on:click={(e) => {
+											e.stopPropagation();
+											delete_layer(id);
+										}}
+										Icon={Clear}
+										size="x-small"
+									/>
+								{/if}
+							</div>
+						{/if}
+					</li>
+				{/each}
+				{#if enable_additional_layers}
+					<li class="add-layer">
+						<IconButton
+							Icon={Plus}
+							label="Add Layer"
+							on:click={(e) => {
+								e.stopPropagation();
+								new_layer();
+							}}
+							size="x-small"
+						/>
+					</li>
+				{/if}
+			</ul>
+		{/if}
+	</div>
+{/if}
+
+<style>
+	.add-layer {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		margin: var(--spacing-sm) 0 0 0;
+	}
+
+	.add-layer :global(button) {
+		width: 100%;
+	}
+	.icon {
+		width: 14px;
+		color: var(--body-text-color);
+		transition: color 0.15s ease;
+	}
+
+	.layer-wrap {
+		/* position: absolute; */
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		/* border: 1px solid var(--border-color-primary); */
+		/* z-index: var(--layer-1); */
+		/* border-radius: var(--radius-sm); */
+		/* background-color: var(--block-background-fill); */
+		width: 100%;
+		flex-direction: column;
+		/* bottom: 5px; */
+		/* right: 5px; */
+		/* border-bottom: 0;
+		border-right: 0; */
+		/* box-shadow: var(--shadow-drop); */
+	}
+
+	.layer-wrap button {
+		justify-content: space-between;
+		align-items: center;
+		width: 100%;
+		display: flex;
+		font-size: var(--text-sm);
+		line-height: var(--line-sm);
+		transition: all 0.15s ease;
+		padding: var(--spacing-md) var(--spacing-lg);
+		/* padding-right: var(--spacing-lg); */
+		border-radius: var(--radius-sm);
+		/* padding-left: 30px; */
+	}
+
+	button.layer-title-button {
+		width: 100%;
+		/* padding-left: 30px; */
+	}
+
+	.layer-wrap button:hover .icon {
+		color: var(--color-accent);
+	}
+
+	.selected_layer {
+		color: var(--color-accent);
+		font-weight: var(--weight-semibold);
+	}
+
+	ul {
+		/* position: absolute; */
+		bottom: 0;
+		right: 0;
+		/* background: var(--block-background-fill); */
+		width: 100%;
+		/* min-width: 100%; */
+		list-style: none;
+		z-index: var(--layer-top);
+		/* border: 1px solid var(--border-color-primary); */
+		/* border-radius: var(--radius-sm); */
+		/* box-shadow: var(--shadow-drop-lg); */
+		padding: var(--spacing-sm);
+		/* transform: translate(-1px, 1px); */
+		border-top: 1px solid var(--border-color-primary);
+	}
+
+	/* .sep {
+		height: 12px;
+		background-color: var(--block-border-color);
+		width: 1px;
+		display: block;
+		margin-left: var(--spacing-xl);
+	} */
+
+	li {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		/* border-radius: var(--radius-sm); */
+		transition: background-color 0.15s ease;
+		border-bottom: 1px solid var(--border-color-primary);
+	}
+
+	.layer-wrap ul > li > button {
+		padding-left: calc(var(--spacing-md));
+	}
+
+	li:hover {
+		background-color: var(--background-fill-secondary);
+	}
+
+	li:last-child {
+		border-bottom: none;
+	}
+	li:last-child:hover {
+		background-color: unset;
+	}
+
+	li div {
+		display: flex;
+		gap: var(--spacing-sm);
+		padding: var(--spacing-sm);
+	}
+	li > button {
+		padding: var(--spacing-sm) var(--spacing-md);
+	}
+
+	/* li > div > button {
+		opacity: 0.7;
+		transition: opacity 0.15s ease;
+	}
+
+	li > div > button:hover {
+		opacity: 1;
+	} */
+</style>

6.0.0-dev.5/imageeditor/shared/Resize.svelte

@@ -0,0 +1,239 @@
+<script lang="ts" context="module">
+	export type Position =
+		| "top-left"
+		| "top"
+		| "top-right"
+		| "left"
+		| "center"
+		| "right"
+		| "bottom-left"
+		| "bottom"
+		| "bottom-right";
+</script>
+
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import type { Spring } from "svelte/motion";
+	import Anchor from "./Anchor.svelte";
+
+	export let dimensions: Spring<{ width: number; height: number }>;
+
+	const dispatch = createEventDispatcher<{
+		change: { anchor: Position; scale: boolean; width: number; height: number };
+	}>();
+
+	let selected_anchor: Position = "center";
+	let scale = false;
+
+	let new_width = $dimensions?.width;
+	let new_height = $dimensions?.height;
+
+	function handle_click(): void {
+		dispatch("change", {
+			anchor: selected_anchor,
+			scale,
+			width: new_width,
+			height: new_height
+		});
+	}
+
+	function set_anchor(position: Position): void {
+		selected_anchor = position;
+	}
+</script>
+
+<!-- svelte-ignore a11y-click-events-have-key-events -->
+<!-- svelte-ignore a11y-no-static-element-interactions -->
+<div class="wrap" on:click|stopPropagation>
+	<div class="size-wrap">
+		<div class="size-input">
+			<label for="width">Width</label><input
+				type="number"
+				id="width"
+				bind:value={new_width}
+			/>
+		</div>
+		<div class="size-input">
+			<label for="height">Height </label><input
+				type="number"
+				id="height"
+				bind:value={new_height}
+			/>
+		</div>
+	</div>
+
+	<div class="scale-wrap">
+		<h2 class="image-will-label">Image will:</h2>
+		<div class="toggle-container">
+			<label class="radio-label">
+				<input
+					type="radio"
+					name="resize_mode"
+					value={true}
+					bind:group={scale}
+				/>
+				<span class="radio-button">rescale</span>
+			</label>
+			<label class="radio-label">
+				<input
+					type="radio"
+					name="resize_mode"
+					value={false}
+					bind:group={scale}
+				/>
+				<span class="radio-button">anchor</span>
+			</label>
+		</div>
+	</div>
+	<div class="anchor-wrap">
+		<Anchor on:position={(e) => set_anchor(e.detail)} />
+	</div>
+	<button class="apply-button" on:click={() => handle_click()}
+		>Resize Canvas</button
+	>
+</div>
+
+<!-- </div> -->
+
+<style>
+	.wrap {
+		padding: var(--spacing-xl) var(--spacing-lg);
+		color: var(--block-label-text-color);
+	}
+
+	.size-wrap {
+		display: flex;
+		flex-direction: row;
+		gap: 10px;
+	}
+
+	.size-input {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-xxs);
+	}
+
+	label,
+	h2 {
+		display: flex;
+		align-items: center;
+		gap: 15px;
+
+		cursor: pointer;
+		color: var(--checkbox-label-text-color);
+		font-weight: var(--checkbox-label-text-weight);
+		font-size: var(--text-sm);
+		line-height: var(--line-md);
+	}
+
+	.scale-wrap {
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-sm);
+		margin-top: var(--spacing-md);
+	}
+
+	input[type="number"] {
+		border: 1px solid var(--border-color-primary);
+		width: 60px;
+		border-radius: var(--radius-sm);
+		background-color: var(--checkbox-background-color-focus);
+		color: var(--body-text-color);
+		font-size: var(--text-sm);
+		transition: border-color 0.15s ease;
+		padding: var(--spacing-xs);
+		line-height: 1rem;
+	}
+
+	input[type="number"]:hover {
+		border-color: var(--color-accent-soft);
+	}
+
+	input[type="number"]:focus {
+		border-color: var(--color-accent);
+		outline: none;
+		box-shadow: 0 0 0 1px var(--color-accent-soft);
+	}
+
+	.image-will-label {
+		grid-column: 1;
+	}
+
+	.toggle-container {
+		display: flex;
+		grid-column: 2;
+		border-radius: var(--radius-sm);
+		border: 1px solid var(--border-color-primary);
+		overflow: hidden;
+	}
+
+	.toggle-container {
+		display: flex;
+		grid-column: 2;
+		border-radius: var(--radius-sm);
+		border: 1px solid var(--border-color-primary);
+		overflow: hidden;
+	}
+
+	.radio-label {
+		flex: 1;
+		margin: 0;
+		padding: 0;
+		position: relative;
+		cursor: pointer;
+	}
+
+	.radio-button {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		padding: var(--spacing-sm);
+		background: var(--checkbox-background-color);
+		color: var(--body-text-color);
+		font-size: var(--text-sm);
+		transition: background-color 0.15s ease;
+		width: 100%;
+		height: 100%;
+	}
+
+	input[type="radio"] {
+		position: absolute;
+		opacity: 0;
+		width: 0;
+		height: 0;
+	}
+
+	input[type="radio"]:not(:checked) + .radio-button:hover {
+		background: var(--checkbox-background-color-hover);
+	}
+
+	input[type="radio"]:checked + .radio-button {
+		background: var(--color-accent);
+		color: white;
+	}
+
+	.apply-button {
+		width: 100%;
+		margin-top: var(--spacing-md);
+		padding: var(--spacing-sm) var(--spacing-md);
+		background: var(--color-accent);
+		color: white;
+		border: none;
+		border-radius: var(--radius-sm);
+		font-size: var(--text-sm);
+		font-weight: var(--weight-semibold);
+		transition: all 0.15s ease;
+	}
+
+	.apply-button:hover {
+		background: var(--button-primary-background-fill-hover);
+	}
+
+	.anchor-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		flex-direction: column;
+		gap: 10px;
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/SecondaryToolbar.svelte

@@ -0,0 +1,67 @@
+<script lang="ts">
+	import Layers from "./Layers.svelte";
+	import type { Writable } from "svelte/store";
+
+	export let layers: Writable<{
+		active_layer: string;
+		layers: {
+			name: string;
+			id: string;
+			user_created: boolean;
+			visible: boolean;
+		}[];
+	}>;
+
+	export let enable_additional_layers = true;
+	export let enable_layers = true;
+	export let show_layers = false;
+</script>
+
+<div class="toolbar-wrap-wrap">
+	<div class="toolbar-wrap">
+		{#if enable_layers}
+			<Layers
+				{layers}
+				{enable_additional_layers}
+				{enable_layers}
+				{show_layers}
+				on:new_layer
+				on:change_layer
+				on:move_layer
+				on:delete_layer
+				on:toggle_layer_visibility
+			/>
+		{/if}
+	</div>
+</div>
+
+<style>
+	.toolbar-wrap-wrap {
+		position: absolute;
+		right: 0;
+		bottom: 0;
+		width: fit-content;
+		max-height: 100%;
+		overflow-y: auto;
+		display: flex;
+		flex-direction: column-reverse;
+	}
+
+	.toolbar-wrap {
+		min-width: 110px;
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		position: relative;
+		right: 0;
+		bottom: 0;
+		border: 1px solid var(--block-border-color);
+		border-radius: 0;
+		border-top-left-radius: var(--radius-md);
+		border-right: none;
+		border-bottom: none;
+		z-index: 1000;
+		background-color: var(--block-background-fill);
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/Toolbar.svelte

@@ -0,0 +1,383 @@
+<script lang="ts" context="module">
+	export type Tool = "image" | "draw" | "erase" | "pan";
+	export type Subtool =
+		| "upload"
+		| "paste"
+		| "webcam"
+		| "color"
+		| "size"
+		| "crop"
+		| "remove_background"
+		| null;
+</script>
+
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import IconButton from "./IconButton.svelte";
+	import {
+		Image,
+		Brush,
+		Erase,
+		Crop,
+		Upload,
+		ImagePaste,
+		Webcam,
+		Circle,
+		Resize,
+		ColorPickerSolid
+	} from "@gradio/icons";
+	import BrushOptions from "./brush/BrushOptions.svelte";
+	import type { Source, Transform } from "./types";
+	import {
+		type Brush as BrushType,
+		type Eraser as EraserType
+	} from "./brush/types";
+	import tinycolor from "tinycolor2";
+
+	export let tool: Tool = "image";
+	export let subtool: Subtool = null;
+
+	export let background = false;
+	export let brush_options: BrushType | false;
+	export let selected_size =
+		brush_options && typeof brush_options.default_size === "number"
+			? brush_options.default_size
+			: 25;
+	export let eraser_options: EraserType;
+	export let selected_eraser_size =
+		eraser_options && typeof eraser_options.default_size === "number"
+			? eraser_options.default_size
+			: 25;
+
+	// Handle default_color including potential color-opacity tuple
+	export let selected_color =
+		brush_options &&
+		(() => {
+			const default_color = brush_options.default_color;
+			if (Array.isArray(default_color)) {
+				return default_color[0];
+			}
+			return default_color;
+		})();
+
+	// Set default opacity based on default_color if it's a tuple
+	export let selected_opacity =
+		brush_options &&
+		(() => {
+			const default_color = brush_options.default_color;
+			if (Array.isArray(default_color)) {
+				return default_color[1];
+			}
+			// Check if color string has opacity
+			const color = tinycolor(default_color);
+			if (color.getAlpha() < 1) {
+				return color.getAlpha();
+			}
+			return 1;
+		})();
+
+	export let preview = false;
+	export let show_brush_color = false;
+	export let show_brush_size = false;
+	export let show_eraser_size = false;
+	export let sources: Source[];
+	export let transforms: Transform[];
+	let recent_colors: string[] = [];
+
+	let enable_layers = true;
+	const dispatch = createEventDispatcher<{
+		tool_change: { tool: Tool };
+		subtool_change: {
+			tool: Tool;
+			subtool: Subtool;
+		};
+	}>();
+
+	/**
+	 * Handles tool click events
+	 * @param {Tool} _tool - The selected tool
+	 */
+	function handle_tool_click(e: Event, _tool: Tool): void {
+		e.stopPropagation();
+		dispatch("tool_change", { tool: _tool });
+	}
+
+	/**
+	 * Handles subtool click events
+	 * @param {Event} e - The click event
+	 * @param {Subtool} _subtool - The selected subtool
+	 */
+	function handle_subtool_click(e: Event, _subtool: typeof subtool): void {
+		e.stopPropagation();
+
+		dispatch("subtool_change", { tool, subtool: _subtool });
+	}
+
+	$: show_brush_size = tool === "draw" && subtool === "size";
+	$: show_brush_color = tool === "draw" && subtool === "color";
+	$: show_eraser_size = tool === "erase" && subtool === "size";
+
+	$: can_crop = transforms.includes("crop");
+	$: can_resize = transforms.includes("resize");
+	$: can_upload = sources.includes("upload");
+	$: can_webcam = sources.includes("webcam");
+	$: can_paste = sources.includes("clipboard");
+</script>
+
+<div class="toolbar-wrap">
+	<div class="half-container">
+		{#if sources.length > 0}
+			<IconButton
+				Icon={Image}
+				label="Image"
+				highlight={tool === "image"}
+				on:click={(e) => handle_tool_click(e, "image")}
+				size="medium"
+				padded={false}
+				transparent={true}
+			/>
+		{/if}
+		{#if brush_options}
+			<IconButton
+				Icon={Brush}
+				label="Brush"
+				on:click={(e) => handle_tool_click(e, "draw")}
+				highlight={tool === "draw"}
+				size="medium"
+				padded={false}
+				transparent={true}
+			/>
+		{/if}
+		{#if eraser_options}
+			<IconButton
+				Icon={Erase}
+				label="Erase"
+				on:click={(e) => handle_tool_click(e, "erase")}
+				highlight={tool === "erase"}
+				size="medium"
+				padded={false}
+				transparent={true}
+			/>
+		{/if}
+	</div>
+	<div
+		class="half-container right"
+		class:hide={tool === "pan" ||
+			(tool === "image" && !background && sources.length === 0) ||
+			(tool === "image" && background && transforms.length === 0)}
+	>
+		{#if tool === "image"}
+			{#if background}
+				{#if can_crop}
+					<IconButton
+						Icon={Crop}
+						label="Crop"
+						on:click={(e) => handle_subtool_click(e, "crop")}
+						highlight={subtool === "crop"}
+						size="medium"
+						padded={false}
+						transparent={true}
+						offset={0}
+					/>
+				{/if}
+				{#if can_resize}
+					<IconButton
+						Icon={Resize}
+						label="Resize"
+						on:click={(e) => handle_subtool_click(e, "size")}
+						highlight={subtool === "size"}
+						size="medium"
+						padded={false}
+						transparent={true}
+						offset={0}
+					/>
+				{/if}
+			{:else}
+				{#if can_upload}
+					<IconButton
+						Icon={Upload}
+						label="Upload"
+						on:click={(e) => handle_subtool_click(e, "upload")}
+						highlight={subtool === "upload"}
+						size="medium"
+						padded={false}
+						transparent={true}
+						offset={0}
+					/>
+				{/if}
+				{#if can_paste}
+					<IconButton
+						Icon={ImagePaste}
+						label="Paste"
+						on:click={(e) => handle_subtool_click(e, "paste")}
+						highlight={subtool === "paste"}
+						size="large"
+						padded={false}
+						transparent={true}
+						offset={0}
+					/>
+				{/if}
+				{#if can_webcam}
+					<IconButton
+						Icon={Webcam}
+						label="Webcam"
+						on:click={(e) => handle_subtool_click(e, "webcam")}
+						highlight={subtool === "webcam"}
+						size="medium"
+						padded={false}
+						transparent={true}
+						offset={0}
+					/>
+				{/if}
+			{/if}
+		{/if}
+
+		{#if tool === "draw" && brush_options}
+			<IconButton
+				Icon={ColorPickerSolid}
+				label="Color"
+				color={selected_color}
+				on:click={(e) => handle_subtool_click(e, "color")}
+				size="medium"
+				padded={false}
+				transparent={true}
+				offset={0}
+			/>
+			<IconButton
+				Icon={Circle}
+				label="Brush Size"
+				on:click={(e) => handle_subtool_click(e, "size")}
+				highlight={subtool === "size"}
+				size="medium"
+				padded={false}
+				transparent={true}
+				offset={0}
+			/>
+
+			{#if show_brush_color || show_brush_size}
+				<BrushOptions
+					colors={brush_options.colors}
+					color_mode={brush_options.color_mode}
+					{recent_colors}
+					show_swatch={show_brush_color}
+					show_size={show_brush_size}
+					bind:selected_size
+					bind:selected_color
+					bind:selected_opacity
+					bind:preview
+					on:click_outside={(e) => {
+						e.stopPropagation();
+						preview = false;
+						show_brush_color = false;
+						show_brush_size = false;
+						handle_subtool_click(e, null);
+					}}
+					mode="brush"
+				/>
+			{/if}
+		{/if}
+
+		{#if tool === "erase" && eraser_options}
+			<IconButton
+				Icon={Circle}
+				label="Eraser Size"
+				on:click={(e) => handle_subtool_click(e, "size")}
+				highlight={subtool === "size"}
+				size="medium"
+				padded={false}
+				transparent={true}
+				offset={0}
+			/>
+		{/if}
+		{#if show_eraser_size}
+			<BrushOptions
+				colors={[]}
+				show_swatch={false}
+				show_size={true}
+				bind:selected_size={selected_eraser_size}
+				bind:selected_color
+				bind:selected_opacity
+				bind:preview
+				on:click_outside={(e) => {
+					e.stopPropagation();
+					preview = false;
+					show_eraser_size = false;
+					handle_subtool_click(e, null);
+				}}
+				mode="eraser"
+			/>
+		{/if}
+	</div>
+</div>
+
+<style>
+	.toolbar-wrap {
+		display: inline-flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		position: absolute;
+		left: 15px;
+		right: 0;
+		top: 30%;
+		/* transform: translateY(-50%); */
+		width: 30px;
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--radius-md);
+
+		gap: var(--spacing-sm);
+		z-index: 1000;
+		background-color: var(--block-background-fill);
+	}
+
+	.half-container {
+		flex: 1;
+		display: flex;
+		flex-direction: column;
+		gap: var(--spacing-sm);
+		position: relative;
+	}
+
+	.half-container {
+		width: 100%;
+		padding: var(--spacing-sm) 0;
+	}
+
+	.half-container:last-child {
+		border-top: 1px solid var(--block-border-color);
+	}
+
+	.hide {
+		display: none;
+	}
+
+	/* .toolbar-left,
+	.toolbar-right {
+		display: flex;
+		flex-direction: row;
+		align-items: center;
+		gap: var(--spacing-sm);
+		display: flex;
+		z-index: 1000;
+		border-radius: var(--radius-sm);
+		background-color: #fff;
+		padding: var(--spacing-sm) 0.3rem;
+		width: auto;
+	}
+
+	.toolbar-right {
+		border-left: 0;
+		border-top-left-radius: 0;
+		border-bottom-left-radius: 0;
+	}
+
+	.toolbar-left {
+		border-top-right-radius: 0;
+		border-bottom-right-radius: 0;
+	}
+
+	.toolbar-layers {
+		border-top-left-radius: 0;
+		border-bottom-left-radius: 0;
+	} */
+</style>

6.0.0-dev.5/imageeditor/shared/brush/BrushOptions.svelte

@@ -0,0 +1,197 @@
+<script lang="ts">
+	import { createEventDispatcher, tick } from "svelte";
+	import { click_outside } from "../utils/events";
+
+	import { type Brush, type ColorTuple } from "./types";
+	import ColorPicker from "./ColorPicker.svelte";
+	import ColorSwatch from "./ColorSwatch.svelte";
+	import ColorField from "./ColorField.svelte";
+	import BrushSize from "./BrushSize.svelte";
+	import type { ColorInput } from "tinycolor2";
+
+	export let colors: (ColorInput | ColorTuple)[];
+	export let selected_color: any;
+	export let color_mode: Brush["color_mode"] | undefined = undefined;
+	export let recent_colors: (ColorInput | ColorTuple)[] = [];
+	export let selected_size: number;
+	export let selected_opacity: number;
+	export let show_swatch: boolean;
+	export let show_size: boolean;
+	export let mode: "brush" | "eraser" = "brush";
+
+	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,
+			opacity
+		}: {
+			index: number | null;
+			color: string | null;
+			opacity?: number;
+		},
+		type: "core" | "user"
+	): void {
+		if (type === "user" && !color) {
+			editing_index = index;
+			color_picker = true;
+		}
+
+		if (!color) return;
+		selected_color = color;
+
+		if (opacity !== undefined) {
+			selected_opacity = opacity;
+		}
+
+		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;
+
+	function debounce(
+		func: (...args: any[]) => void,
+		delay: number
+	): (...args: any[]) => void {
+		let timeout: NodeJS.Timeout;
+		return function (...args: any[]): void {
+			clearTimeout(timeout);
+			timeout = setTimeout(() => func(...args), delay);
+		};
+	}
+
+	export let preview = false;
+	function handle_preview(): void {
+		if (!preview) {
+			preview = true;
+			debounced_close_preview();
+		} else {
+			debounced_close_preview();
+		}
+	}
+
+	function handle_close_preview(): void {
+		preview = false;
+	}
+
+	const debounced_close_preview = debounce(handle_close_preview, 1000);
+
+	$: (selected_size, selected_color, handle_preview());
+
+	function handle_select(color: string): void {
+		selected_color = color;
+	}
+
+	function handle_add_color(): void {
+		// limit to 5
+		if (recent_colors.length >= 5) {
+			recent_colors.pop();
+		}
+		// check if the color is already in the array
+		if (
+			recent_colors.some((color) => {
+				if (Array.isArray(color)) {
+					return color[0] === selected_color && color[1] === selected_opacity;
+				}
+				return color === selected_color;
+			})
+		) {
+			return;
+		}
+		recent_colors.push([selected_color, selected_opacity]);
+		recent_colors = recent_colors;
+	}
+</script>
+
+<svelte:window bind:innerHeight={height} bind:innerWidth={width} />
+
+<div
+	class="wrap"
+	class:padded={!color_picker}
+	use:click_outside={() => dispatch("click_outside")}
+	class:color_picker
+	class:size_picker={show_size && mode === "brush"}
+	class:eraser_picker={mode === "eraser"}
+>
+	{#if color_mode === "defaults"}
+		{#if color_picker}
+			<ColorPicker
+				bind:color={selected_color}
+				bind:opacity={selected_opacity}
+			/>
+			<ColorField
+				bind:current_mode
+				color={selected_color}
+				on:close={() => (color_picker = false)}
+				on:selected={({ detail }) => handle_select(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}
+			on:add_color={handle_add_color}
+		/>
+	{/if}
+
+	{#if show_size}
+		<BrushSize max={100} min={1} bind:selected_size />
+	{/if}
+</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;
+		top: 0;
+
+		transform: translate(35px, -12px);
+	}
+
+	.color_picker {
+		transform: translate(35px, -50%);
+	}
+
+	.size_picker {
+		transform: translate(35px, 18px);
+	}
+
+	.eraser_picker {
+		transform: translate(35px, -7px);
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/brush/BrushSize.svelte

@@ -0,0 +1,40 @@
+<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;
+	}>();
+</script>
+
+<div class="wrap" use:click_outside={() => dispatch("click_outside")}>
+	<span>
+		<BrushSize />
+	</span>
+	<input type="range" bind:value={selected_size} {min} {max} step={1} />
+</div>
+
+<style>
+	.wrap {
+		width: 230px;
+		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>

6.0.0-dev.5/imageeditor/shared/brush/ColorField.svelte

@@ -0,0 +1,174 @@
+<script lang="ts">
+	import { Eyedropper, Plus } from "@gradio/icons";
+	import { createEventDispatcher } from "svelte";
+
+	import tinycolor from "tinycolor2";
+	import IconButton from "../IconButton.svelte";
+	export let color: string;
+
+	export let current_mode: "hex" | "rgb" | "hsl" = "hex";
+
+	const dispatch = createEventDispatcher<{
+		selected: string;
+		close: void;
+		add_color: 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>

6.0.0-dev.5/imageeditor/shared/brush/ColorPicker.svelte

@@ -0,0 +1,283 @@
+<script lang="ts">
+	import { onMount, tick } from "svelte";
+	import tinycolor from "tinycolor2";
+	import { clamp } from "../utils/pixi";
+
+	export let color = "rgb(255, 255, 255)";
+
+	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;
+
+	let opacity_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);
+		if (opacity_moving) update_opacity_from_mouse(event.clientX);
+	}
+
+	function handle_end(): void {
+		if (sl_moving) sl_moving = false;
+		if (hue_moving) hue_moving = false;
+		if (opacity_moving) opacity_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;
+
+	export let opacity = 1;
+
+	let opacity_wrap: HTMLDivElement;
+
+	function handle_opacity_down(
+		event: MouseEvent & { currentTarget: HTMLDivElement }
+	): void {
+		opacity_rect = event.currentTarget.getBoundingClientRect();
+		opacity_moving = true;
+		update_opacity_from_mouse(event.clientX);
+	}
+	let opacity_rect: DOMRect | null = null;
+
+	function update_opacity_from_mouse(x: number): void {
+		if (!opacity_rect) return;
+		const _x = clamp(x - opacity_rect.left, 0, opacity_rect.width);
+		opacity = _x / opacity_rect.width;
+	}
+
+	onMount(() => {
+		opacity_rect = opacity_wrap.getBoundingClientRect();
+	});
+</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="opacity-slider"
+	on:mousedown={handle_opacity_down}
+	style="--color:{color === 'auto' ? 'transparent' : color}"
+	bind:this={opacity_wrap}
+>
+	<div
+		class="opacity-marker"
+		style:background="white"
+		style:transform="translateX({opacity * (opacity_rect?.width ?? 1)}px)"
+	/>
+</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: 0px auto 10px auto;
+		height: 12px;
+		border-radius: 2px;
+		border: 1px solid var(--block-border-color);
+		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;
+	}
+
+	.opacity-slider {
+		position: relative;
+		width: 90%;
+		margin: 10px auto 5px auto;
+		height: 12px;
+		border-radius: 2px;
+		border: 1px solid var(--block-border-color);
+		/* background: linear-gradient(45deg, #808080 25%, transparent 25%),
+			linear-gradient(-45deg, #808080 25%, transparent 25%),
+			linear-gradient(45deg, transparent 75%, #808080 75%),
+			linear-gradient(-45deg, transparent 75%, #808080 75%); */
+		background:
+			linear-gradient(to right, transparent, var(--color)),
+			repeating-conic-gradient(#808080 0% 25%, transparent 0% 50%) 0 0 / 10px
+				10px;
+	}
+
+	.opacity-marker {
+		position: absolute;
+		width: 16px;
+		height: 16px;
+		border-radius: 50%;
+	}
+
+	.opacity-slider > .opacity-marker {
+		box-shadow: 0 0 1px #888;
+		top: -4px;
+		margin: auto;
+		height: 18px;
+		width: 18px;
+		left: -9px;
+		margin: auto;
+		border: 1px solid var(--block-border-color);
+	}
+
+	.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;
+		border: 1px solid var(--block-border-color);
+	}
+
+	.hue-slider > .marker {
+		box-shadow: 0 0 1px #888;
+		top: -3px;
+		margin: auto;
+		height: 18px;
+		width: 18px;
+		left: -9px;
+
+		border: 1px solid var(--block-border-color);
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/brush/ColorSwatch.svelte

@@ -0,0 +1,253 @@
+<script lang="ts">
+	import tinycolor from "tinycolor2";
+	import { createEventDispatcher } from "svelte";
+	import type { ColorTuple } from "./types";
+	import type { ColorInput } from "tinycolor2";
+	import IconButton from "../IconButton.svelte";
+	import { Plus } from "@gradio/icons";
+
+	export let selected_color: string;
+	export let colors: (ColorInput | ColorTuple)[];
+	export let user_colors: (ColorInput | ColorTuple)[] | null = [];
+
+	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; opacity?: number };
+		edit: { index: number; color: string | null };
+		add_color: void;
+	}>();
+
+	$: _colors = show_empty ? colors : colors.filter((c) => c);
+
+	function get_color(color_input: ColorInput | ColorTuple): string {
+		if (Array.isArray(color_input)) {
+			return color_input[0] as string;
+		}
+		return color_input as string;
+	}
+
+	function get_opacity(
+		color_input: ColorInput | ColorTuple
+	): number | undefined {
+		if (Array.isArray(color_input)) {
+			return color_input[1];
+		}
+
+		const color = tinycolor(color_input);
+		return color.getAlpha();
+	}
+
+	function get_formatted_color(
+		color: ColorInput | ColorTuple,
+		mode: "hex" | "rgb" | "hsl"
+	): string {
+		const color_value = get_color(color);
+		if (mode === "hex") {
+			return tinycolor(color_value).toHexString();
+		} else if (mode === "rgb") {
+			return tinycolor(color_value).toRgbString();
+		}
+		return tinycolor(color_value).toHslString();
+	}
+
+	let current_index = `select-${colors.findIndex(
+		(c) =>
+			get_formatted_color(c, current_mode) ===
+			get_formatted_color(selected_color, current_mode)
+	)}`;
+
+	$: selected_opacity = get_opacity(selected_color);
+
+	function handle_select(
+		type: "edit" | "select",
+		detail: {
+			index: number;
+			color: string | null;
+			opacity?: number;
+		}
+	): 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">
+	<div class="swatch-container">
+		{#if user_colors}
+			<div class="swatch">
+				{#if color_picker}
+					<IconButton
+						Icon={Plus}
+						on:click={() => dispatch("add_color")}
+						roundedness="very"
+						background={get_color(selected_color)}
+						color="white"
+					/>
+				{/if}
+				{#each user_colors as color, i}
+					{@const color_string = get_color(color)}
+					{@const opacity = get_opacity(color)}
+					<button
+						on:click={() =>
+							handle_select("edit", {
+								index: i,
+								color: color_string,
+								opacity: opacity
+							})}
+						class="color"
+						class:empty={color === null}
+						style="background-color: {color_string}"
+						style:opacity
+						class:selected={`${color_string}-${opacity}` ===
+							`${selected_color}-${selected_opacity}`}
+					></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_item, i}
+				{@const color_string = get_color(color_item)}
+				{@const opacity = get_opacity(color_item)}
+				<button
+					on:click={() =>
+						handle_select("select", {
+							index: i,
+							color: color_string,
+							opacity: opacity
+						})}
+					class="color"
+					class:empty={color_item === null}
+					style="background-color: {color_string}"
+					style:opacity
+					class:selected={`${color_string}-${opacity}` ===
+						`${selected_color}-${selected_opacity}`}
+				></button>
+			{/each}
+		</menu>
+	</div>
+</div>
+
+<style>
+	.swatch-wrap {
+		display: flex;
+		justify-content: space-between;
+		align-items: flex-start;
+		/* max-width: 200px; */
+		width: 205px;
+	}
+
+	span.lg {
+		margin-top: var(--spacing-sm);
+	}
+	.swatch-container {
+		display: flex;
+		flex-direction: column;
+		gap: 10px;
+		width: 100%;
+	}
+	.swatch {
+		display: grid;
+		grid-template-columns: repeat(auto-fill, 25px);
+		gap: 8px;
+		justify-content: flex-start;
+
+		overflow: hidden;
+		justify-content: center;
+	}
+
+	.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: 25px;
+		height: 25px;
+		border-radius: var(--radius-md);
+	}
+
+	.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-items: center;
+		content: "⨯";
+		color: white;
+		font-size: var(--scale-5);
+		position: absolute;
+		width: 100%;
+		height: 100%;
+		transform: translateY(-7px);
+		opacity: 1;
+		transition: 0.1s;
+		top: 0;
+	}
+
+	.colorpicker.hidden::after,
+	.colorpicker.hidden::before {
+		opacity: 0;
+	}
+</style>

6.0.0-dev.5/imageeditor/shared/brush/brush-cursor.ts

@@ -0,0 +1,366 @@
+import {
+	Container,
+	Graphics,
+	Sprite,
+	type FederatedPointerEvent
+} from "pixi.js";
+import { type ImageEditorContext } from "../core/editor";
+import { type BrushState } from "./types";
+import tinycolor from "tinycolor2";
+import { clear_timeout } from "./brush-utils";
+
+/**
+ * Class to handle all cursor preview-related functionality for the brush tool.
+ */
+export class BrushCursor {
+	private cursor_graphics: Graphics | null = null;
+	private cursor_container: Container | null = null;
+	private brush_preview_container: Container | null = null;
+	private brush_preview_graphics: Graphics | null = null;
+	private is_preview_visible = false;
+	private is_cursor_over_image = false;
+	private cursor_position_check_timeout: number | null = null;
+	private is_brush_or_erase_active = false;
+
+	private _bound_update_cursor:
+		| ((event: FederatedPointerEvent) => void)
+		| null = null;
+	private _bound_check_cursor_over_image:
+		| ((event: FederatedPointerEvent) => void)
+		| null = null;
+
+	constructor(
+		private image_editor_context: ImageEditorContext,
+		private state: BrushState,
+		private scale: number
+	) {
+		this.initialize_cursor();
+		this.initialize_brush_preview();
+	}
+
+	/**
+	 * Returns whether the cursor is currently over the image.
+	 */
+	is_over_image(): boolean {
+		return this.is_cursor_over_image;
+	}
+
+	/**
+	 * Sets up cursor-related event listeners.
+	 */
+	setup_event_listeners(): void {
+		this.cleanup_event_listeners();
+
+		this._bound_update_cursor = this.update_cursor_position.bind(this);
+		this._bound_check_cursor_over_image =
+			this.check_cursor_over_image.bind(this);
+
+		const stage = this.image_editor_context.app.stage;
+		stage.on("pointermove", this._bound_update_cursor);
+		stage.on("pointermove", this._bound_check_cursor_over_image);
+
+		this.image_editor_context.image_container.on(
+			"pointerenter",
+			this.on_image_container_pointer_enter.bind(this)
+		);
+		this.image_editor_context.image_container.on(
+			"pointerleave",
+			this.on_image_container_pointer_leave.bind(this)
+		);
+	}
+
+	/**
+	 * Removes all cursor-related event listeners.
+	 */
+	cleanup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+
+		if (this._bound_update_cursor) {
+			stage.off("pointermove", this._bound_update_cursor);
+			this._bound_update_cursor = null;
+		}
+
+		if (this._bound_check_cursor_over_image) {
+			stage.off("pointermove", this._bound_check_cursor_over_image);
+			this._bound_check_cursor_over_image = null;
+		}
+
+		this.image_editor_context.image_container.off("pointerenter");
+		this.image_editor_context.image_container.off("pointerleave");
+
+		this.cursor_position_check_timeout = clear_timeout(
+			this.cursor_position_check_timeout
+		);
+	}
+
+	/**
+	 * initializes the cursor for the brush tool.
+	 */
+	initialize_cursor(): void {
+		if (this.cursor_container) {
+			if (this.cursor_container.parent) {
+				this.cursor_container.parent.removeChild(this.cursor_container);
+			}
+			this.cursor_container.destroy({ children: true });
+			this.cursor_container = null;
+		}
+
+		this.cursor_container = new Container();
+		this.image_editor_context.ui_container.addChild(this.cursor_container);
+
+		this.cursor_graphics = new Graphics();
+		this.cursor_container.addChild(this.cursor_graphics);
+
+		this.update_cursor_appearance();
+	}
+
+	/**
+	 * updates the appearance of the cursor.
+	 */
+	update_cursor_appearance(): void {
+		if (!this.cursor_graphics) return;
+
+		this.cursor_graphics.clear();
+
+		const cursor_color =
+			this.state.mode === "draw"
+				? tinycolor(this.state.color).toString()
+				: 0xffffff;
+
+		this.cursor_graphics
+			.circle(0, 0, this.state.brush_size * this.scale)
+			.stroke({
+				width: 1.5,
+				color: cursor_color,
+				alpha: 0.8
+			});
+
+		this.cursor_graphics.circle(0, 0, 1).fill({
+			color: cursor_color,
+			alpha: 0.8
+		});
+	}
+
+	/**
+	 * updates the position of the cursor.
+	 * @param {FederatedPointerEvent} event - The pointer event.
+	 */
+	update_cursor_position(event: FederatedPointerEvent): void {
+		if (!this.cursor_container) return;
+
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+
+		const ui_pos = this.image_editor_context.ui_container.toLocal(
+			this.image_editor_context.image_container.toGlobal(local_pos)
+		);
+
+		this.cursor_container.position.set(ui_pos.x, ui_pos.y);
+	}
+
+	/**
+	 * checks if the cursor is over the image container.
+	 * @param {FederatedPointerEvent} event - The pointer event.
+	 */
+	check_cursor_over_image(event: FederatedPointerEvent): void {
+		if (this.cursor_position_check_timeout !== null) {
+			window.clearTimeout(this.cursor_position_check_timeout);
+			this.cursor_position_check_timeout = null;
+		}
+
+		const image_container = this.image_editor_context.image_container;
+		const bounds = image_container.getBounds();
+
+		const was_over_image = this.is_cursor_over_image;
+		this.is_cursor_over_image =
+			event.global.x >= bounds.x &&
+			event.global.x <= bounds.x + bounds.width &&
+			event.global.y >= bounds.y &&
+			event.global.y <= bounds.y + bounds.height;
+
+		if (was_over_image !== this.is_cursor_over_image) {
+			this.update_cursor_and_preview_visibility();
+		}
+	}
+
+	/**
+	 * updates the size of the cursor.
+	 */
+	update_cursor_size(): void {
+		this.update_cursor_appearance();
+	}
+
+	/**
+	 * Updates whether brush or erase tool is active
+	 */
+	set_active(is_active: boolean): void {
+		this.is_brush_or_erase_active = is_active;
+		this.update_cursor_and_preview_visibility();
+	}
+
+	/**
+	 * updates the visibility of the cursor.
+	 */
+	update_cursor_visibility(): void {
+		if (this.cursor_container) {
+			this.cursor_container.visible =
+				this.is_cursor_over_image && this.is_brush_or_erase_active;
+		}
+	}
+
+	/**
+	 * Shows or hides the brush preview.
+	 * @param {boolean} show - Whether to show the preview.
+	 */
+	preview_brush(show: boolean): void {
+		this.is_preview_visible = show;
+
+		if (this.brush_preview_container) {
+			this.brush_preview_container.visible =
+				show && this.is_brush_or_erase_active;
+		}
+
+		if (show) {
+			this.update_brush_preview();
+			this.update_brush_preview_position();
+		}
+	}
+
+	/**
+	 * initializes the brush preview.
+	 */
+	initialize_brush_preview(): void {
+		if (this.brush_preview_container) {
+			if (this.brush_preview_container.parent) {
+				this.brush_preview_container.parent.removeChild(
+					this.brush_preview_container
+				);
+			}
+			this.brush_preview_container.destroy({ children: true });
+			this.brush_preview_container = null;
+		}
+
+		this.brush_preview_container = new Container();
+		this.image_editor_context.ui_container.addChild(
+			this.brush_preview_container
+		);
+
+		this.brush_preview_graphics = new Graphics();
+		this.brush_preview_container.addChild(this.brush_preview_graphics);
+
+		this.brush_preview_container.visible = false;
+	}
+
+	/**
+	 * updates the brush preview appearance.
+	 */
+	update_brush_preview(): void {
+		if (!this.brush_preview_graphics) return;
+
+		this.brush_preview_graphics.clear();
+
+		const preview_size = this.state.brush_size * this.scale;
+		const preview_color =
+			this.state.mode === "draw"
+				? tinycolor(this.state.color).setAlpha(this.state.opacity).toString()
+				: 0xffffff;
+
+		this.brush_preview_graphics.circle(0, 0, preview_size).fill({
+			color: preview_color,
+			alpha: this.state.mode === "draw" ? this.state.opacity : 0.3
+		});
+
+		this.brush_preview_graphics.circle(0, 0, preview_size + 1).stroke({
+			width: 1,
+			color: 0x000000,
+			alpha: 0.5
+		});
+	}
+
+	/**
+	 * updates the position of the brush preview to center of canvas.
+	 */
+	update_brush_preview_position(): void {
+		if (!this.brush_preview_container) return;
+
+		const image_container = this.image_editor_context.image_container;
+		const center_x = image_container.width / 2;
+		const center_y = image_container.height / 2;
+
+		const global_pos = image_container.toGlobal({ x: center_x, y: center_y });
+
+		const ui_pos = this.image_editor_context.ui_container.toLocal(global_pos);
+
+		this.brush_preview_container.position.set(ui_pos.x, ui_pos.y);
+	}
+
+	/**
+	 * Called when the pointer enters the image container.
+	 */
+	on_image_container_pointer_enter(): void {
+		this.is_cursor_over_image = true;
+		this.update_cursor_and_preview_visibility();
+	}
+
+	/**
+	 * Called when the pointer leaves the image container.
+	 */
+	on_image_container_pointer_leave(): void {
+		this.is_cursor_over_image = false;
+		this.update_cursor_and_preview_visibility();
+	}
+
+	/**
+	 * Updates both cursor and preview visibility based on cursor position.
+	 */
+	update_cursor_and_preview_visibility(): void {
+		this.update_cursor_visibility();
+		if (this.brush_preview_container) {
+			this.brush_preview_container.visible =
+				this.is_preview_visible && this.is_brush_or_erase_active;
+		}
+	}
+
+	/**
+	 * Cleans up all cursor resources.
+	 */
+	cleanup(): void {
+		this.is_brush_or_erase_active = false;
+
+		if (this.cursor_container) {
+			if (this.cursor_container.parent) {
+				this.cursor_container.parent.removeChild(this.cursor_container);
+			}
+			this.cursor_container.destroy({ children: true });
+			this.cursor_container = null;
+		}
+
+		if (this.brush_preview_container) {
+			if (this.brush_preview_container.parent) {
+				this.brush_preview_container.parent.removeChild(
+					this.brush_preview_container
+				);
+			}
+			this.brush_preview_container.destroy({ children: true });
+			this.brush_preview_container = null;
+		}
+
+		if (this.cursor_position_check_timeout !== null) {
+			window.clearTimeout(this.cursor_position_check_timeout);
+			this.cursor_position_check_timeout = null;
+		}
+	}
+
+	/**
+	 * Updates the brush state.
+	 */
+	update_state(state: BrushState, scale: number): void {
+		this.state = state;
+		this.scale = scale;
+		this.update_cursor_appearance();
+		if (this.is_preview_visible) {
+			this.update_brush_preview();
+		}
+	}
+}

6.0.0-dev.5/imageeditor/shared/brush/brush-textures.ts

@@ -0,0 +1,757 @@
+import {
+	Container,
+	RenderTexture,
+	Sprite,
+	Graphics,
+	Application,
+	Texture
+} from "pixi.js";
+import { type ImageEditorContext } from "../core/editor";
+import { type Command } from "../core/commands";
+
+/**
+ * Represents a single drawing segment with all its parameters
+ */
+interface BrushSegment {
+	from_x: number;
+	from_y: number;
+	to_x: number;
+	to_y: number;
+	size: number;
+	color: string;
+	opacity: number;
+	mode: "draw" | "erase";
+}
+
+/**
+ * Represents a complete brush stroke containing multiple segments
+ */
+interface BrushStroke {
+	segments: BrushSegment[];
+	layer_id: string;
+}
+
+export class BrushCommand implements Command {
+	private stroke_data: BrushStroke;
+	private context: ImageEditorContext;
+	private original_texture: Texture | null = null;
+
+	name: string;
+
+	constructor(
+		context: ImageEditorContext,
+		stroke_data: BrushStroke,
+		original_texture?: Texture
+	) {
+		this.name = "Draw";
+		this.stroke_data = stroke_data;
+		this.context = context;
+		if (original_texture) {
+			this.original_texture = this.create_texture_from(original_texture);
+		}
+	}
+
+	/**
+	 * Creates a new texture with the same content as the source texture
+	 */
+	private create_texture_from(source: Texture): Texture {
+		const texture = RenderTexture.create({
+			width: source.width,
+			height: source.height,
+			resolution: window.devicePixelRatio || 1
+		});
+
+		const sprite = new Sprite(source);
+		const container = new Container();
+		container.addChild(sprite);
+
+		this.context.app.renderer.render(container, {
+			renderTexture: texture
+		});
+
+		container.destroy({ children: true });
+		return texture;
+	}
+
+	/**
+	 * Recreates the stroke by rendering all segments from the stored parameters
+	 * Preserves the exact order of draw/erase operations
+	 */
+	private render_stroke_from_data(
+		stroke_data: BrushStroke,
+		target_texture: RenderTexture
+	): void {
+		const draw_segments = stroke_data.segments.filter((s) => s.mode === "draw");
+		const erase_segments = stroke_data.segments.filter(
+			(s) => s.mode === "erase"
+		);
+
+		if (draw_segments.length > 0) {
+			const graphics = new Graphics();
+			const container = new Container();
+			container.addChild(graphics);
+			let alpha = 1;
+
+			for (const segment of draw_segments) {
+				if (segment.opacity < alpha) {
+					alpha = segment.opacity;
+				}
+				let colorValue = 0xffffff;
+				if (segment.color.startsWith("#")) {
+					colorValue = parseInt(segment.color.replace("#", "0x"), 16);
+				}
+
+				graphics.setFillStyle({
+					color: colorValue,
+					alpha: 1
+				});
+
+				this.render_segment_to_graphics(graphics, segment);
+			}
+
+			// we need a sprite in order to set the alpha and for that we need a texture
+			// i'm not entirely sure why other approaches didn't work
+			const alpha_sprite_texture = RenderTexture.create({
+				width: target_texture.width,
+				height: target_texture.height,
+				resolution: window.devicePixelRatio || 1
+			});
+
+			const alpha_sprite = new Sprite(alpha_sprite_texture);
+			this.context.app.renderer.render({
+				container: container,
+				target: alpha_sprite_texture
+			});
+
+			alpha_sprite.alpha = alpha;
+
+			this.context.app.renderer.render({
+				container: alpha_sprite,
+				target: target_texture,
+				clear: false
+			});
+
+			container.destroy({ children: true });
+			alpha_sprite.destroy();
+			alpha_sprite_texture.destroy();
+		}
+
+		if (erase_segments.length > 0) {
+			// create a temp texture to work with
+			const temp_content_texture = RenderTexture.create({
+				width: target_texture.width,
+				height: target_texture.height,
+				resolution: window.devicePixelRatio || 1
+			});
+
+			const copy_sprite = new Sprite(target_texture);
+			const copy_container = new Container();
+			copy_container.addChild(copy_sprite);
+
+			this.context.app.renderer.render({
+				container: copy_container,
+				target: temp_content_texture,
+				clear: true
+			});
+
+			// create a graphics object to draw the erase segments
+			const erase_graphics = new Graphics();
+			const erase_container = new Container();
+			erase_container.addChild(erase_graphics);
+
+			erase_graphics.setFillStyle({
+				color: 0xffffff,
+				alpha: 1.0
+			});
+
+			for (const segment of erase_segments) {
+				this.render_segment_to_graphics(erase_graphics, segment);
+			}
+
+			// create a separate texture to hold the mask
+			const mask_texture = RenderTexture.create({
+				width: target_texture.width,
+				height: target_texture.height,
+				resolution: window.devicePixelRatio || 1
+			});
+
+			this.context.app.renderer.render({
+				container: erase_container,
+				target: mask_texture,
+				clear: true
+			});
+
+			const content_sprite = new Sprite(temp_content_texture);
+			const mask_sprite = new Sprite(mask_texture);
+
+			// only now do we create a sprite from the original texture and add the mask
+			const masked_container = new Container();
+			masked_container.addChild(content_sprite);
+			masked_container.setMask({ mask: mask_sprite, inverse: true }); // inverse mask = erase
+
+			// now we can render the masked content back to the target texture
+			this.context.app.renderer.render({
+				container: masked_container,
+				target: target_texture,
+				clear: true
+			});
+
+			copy_container.destroy({ children: true });
+			erase_container.destroy({ children: true });
+			masked_container.destroy({ children: true });
+			temp_content_texture.destroy();
+			mask_texture.destroy();
+		}
+	}
+
+	/**
+	 * Renders a segment to a graphics object (extracted from renderSegment)
+	 */
+	private render_segment_to_graphics(
+		graphics: Graphics,
+		segment: BrushSegment
+	): void {
+		const distance = Math.sqrt(
+			Math.pow(segment.to_x - segment.from_x, 2) +
+				Math.pow(segment.to_y - segment.from_y, 2)
+		);
+
+		if (distance < 0.1) {
+			graphics.circle(segment.from_x, segment.from_y, segment.size).fill();
+		} else {
+			const spacing = Math.max(segment.size / 3, 2);
+			const steps = Math.max(Math.ceil(distance / spacing), 2);
+
+			for (let i = 0; i < steps; i++) {
+				const t = i / (steps - 1);
+				const x = segment.from_x + (segment.to_x - segment.from_x) * t;
+				const y = segment.from_y + (segment.to_y - segment.from_y) * t;
+
+				graphics.circle(x, y, segment.size).fill();
+			}
+		}
+	}
+
+	async execute(context: ImageEditorContext): Promise<void> {
+		if (context) {
+			this.context = context;
+		}
+
+		let layer_textures = this.context.layer_manager.get_layer_textures(
+			this.stroke_data.layer_id
+		);
+
+		if (!layer_textures) {
+			const all_layers = this.context.layer_manager.get_layers();
+			const top_layer = all_layers[all_layers.length - 1];
+			layer_textures = this.context.layer_manager.get_layer_textures(
+				top_layer.id
+			);
+		}
+
+		if (!layer_textures) return;
+
+		// create a temporary texture to render the stroke
+		const temp_texture = RenderTexture.create({
+			width: layer_textures.draw.width,
+			height: layer_textures.draw.height,
+			resolution: window.devicePixelRatio || 1
+		});
+
+		// copy current layer content to temp texture
+		const current_sprite = new Sprite(layer_textures.draw);
+		const temp_container = new Container();
+		temp_container.addChild(current_sprite);
+
+		this.context.app.renderer.render({
+			container: temp_container,
+			target: temp_texture,
+			clear: true
+		});
+
+		temp_container.destroy({ children: true });
+
+		this.render_stroke_from_data(this.stroke_data, temp_texture);
+
+		// copy final result back to layer texture
+		const final_sprite = new Sprite(temp_texture);
+		const final_container = new Container();
+		final_container.addChild(final_sprite);
+
+		this.context.app.renderer.render({
+			container: final_container,
+			target: layer_textures.draw,
+			clear: true
+		});
+
+		final_container.destroy({ children: true });
+		temp_texture.destroy();
+	}
+
+	async undo(): Promise<void> {
+		if (!this.original_texture) return;
+
+		const layer_textures = this.context.layer_manager.get_layer_textures(
+			this.stroke_data.layer_id
+		);
+		if (!layer_textures) return;
+
+		const temp_sprite = new Sprite(this.original_texture);
+		const temp_container = new Container();
+		temp_container.addChild(temp_sprite);
+
+		this.context.app.renderer.render({
+			container: temp_container,
+			target: layer_textures.draw,
+			clear: true
+		});
+
+		temp_container.destroy({ children: true });
+	}
+}
+
+/**
+ * Class to handle texture operations for the brush tool.
+ * Simplified to work directly with layer textures.
+ */
+export class BrushTextures {
+	private stroke_texture: RenderTexture | null = null;
+	private erase_texture: RenderTexture | null = null;
+	private display_container: Container | null = null;
+	private stroke_container: Container | null = null;
+	private stroke_graphics: Graphics | null = null;
+	private preview_sprite: Sprite | null = null;
+	private erase_graphics: Graphics | null = null;
+	private dimensions: { width: number; height: number };
+	private image_editor_context: ImageEditorContext;
+	private app: Application;
+	private is_new_stroke = true;
+
+	private current_opacity = 1.0;
+	private original_layer_texture: Texture | null = null;
+	private active_layer_id: string | null = null;
+	private current_stroke_segments: BrushSegment[] = [];
+
+	constructor(image_editor_context: ImageEditorContext, app: Application) {
+		this.image_editor_context = image_editor_context;
+		this.app = app;
+
+		this.dimensions = {
+			width: this.image_editor_context.image_container.width,
+			height: this.image_editor_context.image_container.height
+		};
+	}
+
+	/**
+	 * Initializes textures needed for the brush tool.
+	 */
+	initialize_textures(): void {
+		this.cleanup_textures();
+
+		const local_bounds =
+			this.image_editor_context.image_container.getLocalBounds();
+
+		this.dimensions = {
+			width: local_bounds.width,
+			height: local_bounds.height
+		};
+
+		this.stroke_texture = RenderTexture.create({
+			width: this.dimensions.width,
+			height: this.dimensions.height,
+			resolution: window.devicePixelRatio || 1
+		});
+
+		this.erase_texture = RenderTexture.create({
+			width: this.dimensions.width,
+			height: this.dimensions.height,
+			resolution: window.devicePixelRatio || 1
+		});
+
+		this.display_container = new Container();
+
+		this.image_editor_context.image_container.addChild(this.display_container);
+
+		this.stroke_container = new Container();
+		this.stroke_graphics = new Graphics();
+		this.stroke_container.addChild(this.stroke_graphics);
+
+		this.erase_graphics = new Graphics();
+
+		this.preview_sprite = new Sprite(this.stroke_texture);
+		this.preview_sprite.alpha = 0;
+		this.display_container.addChild(this.preview_sprite);
+
+		const clear_container = new Container();
+		this.app.renderer.render(clear_container, {
+			renderTexture: this.stroke_texture
+		});
+		this.app.renderer.render(clear_container, {
+			renderTexture: this.erase_texture
+		});
+		clear_container.destroy();
+
+		this.is_new_stroke = true;
+		this.current_opacity = 1.0;
+	}
+
+	/**
+	 * Reinitializes textures when needed (e.g., after resizing).
+	 */
+	reinitialize(): void {
+		if (
+			this.image_editor_context.image_container.width !==
+				this.dimensions.width ||
+			this.image_editor_context.image_container.height !==
+				this.dimensions.height
+		) {
+			this.initialize_textures();
+		}
+	}
+
+	/**
+	 * Cleans up texture resources.
+	 */
+	cleanup_textures(): void {
+		if (this.stroke_texture) {
+			this.stroke_texture.destroy();
+			this.stroke_texture = null;
+		}
+
+		if (this.erase_texture) {
+			this.erase_texture.destroy();
+			this.erase_texture = null;
+		}
+
+		if (this.display_container) {
+			if (this.display_container.parent) {
+				this.display_container.parent.removeChild(this.display_container);
+			}
+			this.display_container.destroy({ children: true });
+			this.display_container = null;
+		}
+
+		if (this.original_layer_texture) {
+			this.original_layer_texture.destroy();
+			this.original_layer_texture = null;
+		}
+
+		this.stroke_container = null;
+		this.stroke_graphics = null;
+		this.preview_sprite = null;
+		this.erase_graphics = null;
+		this.active_layer_id = null;
+	}
+
+	/**
+	 * Preserve the canvas state when starting a new stroke.
+	 */
+	preserve_canvas_state(): void {
+		const active_layer =
+			this.image_editor_context.layer_manager.get_active_layer();
+		if (!active_layer) return;
+
+		const layers = this.image_editor_context.layer_manager.get_layers();
+		const layer = layers.find((l) => l.container === active_layer);
+		if (!layer) return;
+
+		this.active_layer_id = layer.id;
+
+		const layer_textures =
+			this.image_editor_context.layer_manager.get_layer_textures(layer.id);
+		if (!layer_textures) return;
+
+		if (this.original_layer_texture) {
+			this.original_layer_texture.destroy();
+		}
+
+		this.original_layer_texture = RenderTexture.create({
+			width: this.dimensions.width,
+			height: this.dimensions.height,
+			resolution: window.devicePixelRatio || 1
+		});
+
+		const temp_sprite = new Sprite(layer_textures.draw);
+		const temp_container = new Container();
+		temp_container.addChild(temp_sprite);
+
+		this.app.renderer.render(temp_container, {
+			renderTexture: this.original_layer_texture
+		});
+
+		temp_container.destroy({ children: true });
+
+		this.is_new_stroke = true;
+	}
+
+	/**
+	 * Resets the eraser mask.
+	 */
+	reset_eraser_mask(): void {
+		if (!this.erase_graphics || !this.erase_texture) return;
+
+		this.erase_graphics.clear();
+		this.erase_graphics.setFillStyle({ color: 0xffffff, alpha: 1.0 });
+		this.erase_graphics
+			.rect(0, 0, this.dimensions.width, this.dimensions.height)
+			.fill();
+		this.erase_graphics.endFill();
+
+		this.app.renderer.render(this.erase_graphics, {
+			renderTexture: this.erase_texture
+		});
+	}
+
+	/**
+	 * Commits the current stroke to the active layer and returns a command for undo/redo.
+	 */
+	commit_stroke(): void {
+		if (
+			!this.stroke_texture ||
+			!this.preview_sprite ||
+			!this.stroke_graphics ||
+			!this.original_layer_texture ||
+			!this.active_layer_id
+		)
+			return;
+
+		this.preview_sprite.visible = false;
+
+		const active_layer =
+			this.image_editor_context.layer_manager.get_active_layer();
+
+		if (!active_layer) return;
+
+		const layers = this.image_editor_context.layer_manager.get_layers();
+		const layer = layers.find((l) => l.container === active_layer);
+		if (!layer) return;
+
+		if (layer.id !== this.active_layer_id) return;
+
+		const layer_textures =
+			this.image_editor_context.layer_manager.get_layer_textures(layer.id);
+		if (!layer_textures) return;
+
+		const stroke_data: BrushStroke = {
+			segments: [...this.current_stroke_segments],
+			layer_id: this.active_layer_id
+		};
+
+		const brush_command = new BrushCommand(
+			this.image_editor_context,
+			stroke_data,
+			this.original_layer_texture
+		);
+
+		if (this.stroke_graphics) {
+			this.stroke_graphics.clear();
+		}
+		const clear_container = new Container();
+		this.app.renderer.render(clear_container, {
+			renderTexture: this.stroke_texture
+		});
+		clear_container.destroy();
+
+		this.is_new_stroke = true;
+		this.original_layer_texture = null;
+		this.active_layer_id = null;
+		this.current_stroke_segments = [];
+
+		this.image_editor_context.command_manager.execute(
+			brush_command,
+			this.image_editor_context
+		);
+	}
+
+	/**
+	 * Calculates the distance between two points.
+	 */
+	private calculate_distance(
+		x1: number,
+		y1: number,
+		x2: number,
+		y2: number
+	): number {
+		return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+	}
+
+	/**
+	 * Draws a segment for the current stroke using a simple "stamp" approach.
+	 */
+	draw_segment(
+		from_x: number,
+		from_y: number,
+		to_x: number,
+		to_y: number,
+		size: number,
+		color: string,
+		opacity: number,
+		mode: "draw" | "erase"
+	): void {
+		if (
+			!this.stroke_graphics ||
+			!this.stroke_texture ||
+			!this.stroke_container ||
+			!this.preview_sprite
+		)
+			return;
+
+		if (this.is_new_stroke && !this.original_layer_texture) {
+			this.preserve_canvas_state();
+		}
+
+		this.current_opacity =
+			mode === "draw" ? Math.min(Math.max(opacity, 0), 1) : 0.5;
+
+		const scaled_size = size;
+
+		if (this.is_new_stroke) {
+			this.stroke_graphics.clear();
+			this.current_stroke_segments = [];
+
+			const clear_container = new Container();
+			this.app.renderer.render(clear_container, {
+				renderTexture: this.stroke_texture
+			});
+			clear_container.destroy();
+
+			this.is_new_stroke = false;
+		}
+
+		this.current_stroke_segments.push({
+			from_x,
+			from_y,
+			to_x,
+			to_y,
+			size: scaled_size,
+			color,
+			opacity: this.current_opacity,
+			mode
+		});
+
+		if (mode === "draw") {
+			let colorValue = 0xffffff;
+			try {
+				if (color.startsWith("#")) {
+					colorValue = parseInt(color.replace("#", "0x"), 16);
+				}
+			} catch (e) {
+				colorValue = 0xffffff;
+			}
+			this.stroke_graphics.setFillStyle({
+				color: colorValue,
+				alpha: 1.0
+			});
+		} else {
+			this.stroke_graphics.setFillStyle({
+				color: 0xffffff,
+				alpha: 1.0
+			});
+		}
+
+		const distance = this.calculate_distance(from_x, from_y, to_x, to_y);
+
+		if (distance < 0.1) {
+			this.stroke_graphics.circle(from_x, from_y, scaled_size).fill();
+		} else {
+			const spacing = Math.max(scaled_size / 3, 2);
+			const steps = Math.max(Math.ceil(distance / spacing), 2);
+
+			for (let i = 0; i < steps; i++) {
+				const t = i / (steps - 1);
+				const x = from_x + (to_x - from_x) * t;
+				const y = from_y + (to_y - from_y) * t;
+
+				this.stroke_graphics.circle(x, y, scaled_size).fill();
+			}
+		}
+
+		this.stroke_graphics.endFill();
+
+		this.app.renderer.render(this.stroke_container, {
+			renderTexture: this.stroke_texture
+		});
+
+		if (mode === "draw") {
+			this.preview_sprite.texture = this.stroke_texture;
+			this.preview_sprite.alpha = this.current_opacity;
+
+			this.preview_sprite.tint = 0xffffff;
+		} else {
+			const active_layer =
+				this.image_editor_context.layer_manager.get_active_layer();
+			if (!active_layer) return;
+
+			const layers = this.image_editor_context.layer_manager.get_layers();
+			const layer = layers.find((l) => l.container === active_layer);
+			if (!layer) return;
+
+			const layer_textures =
+				this.image_editor_context.layer_manager.get_layer_textures(layer.id);
+			if (!layer_textures) return;
+
+			const preview_texture = RenderTexture.create({
+				width: this.dimensions.width,
+				height: this.dimensions.height,
+				resolution: window.devicePixelRatio || 1
+			});
+
+			const base_container = new Container();
+			const content_sprite = new Sprite(layer_textures.draw);
+			base_container.addChild(content_sprite);
+			this.app.renderer.render(base_container, {
+				renderTexture: preview_texture
+			});
+			base_container.destroy({ children: true });
+
+			const preview_container = new Container();
+
+			const mask_sprite = new Sprite(this.stroke_texture);
+
+			const overlay = new Graphics();
+			overlay.setFillStyle({ color: 0xffffff, alpha: 0.5 });
+			overlay.rect(0, 0, this.dimensions.width, this.dimensions.height).fill();
+
+			overlay.setMask({ mask: mask_sprite, inverse: false });
+
+			preview_container.addChild(overlay);
+
+			this.app.renderer.render(preview_container, {
+				renderTexture: preview_texture
+			});
+
+			this.preview_sprite.texture = preview_texture;
+			this.preview_sprite.alpha = 1.0;
+
+			preview_container.destroy({ children: true });
+			preview_texture.destroy();
+		}
+
+		this.preview_sprite.visible = true;
+	}
+
+	/**
+	 * Gets current dimensions of the texture.
+	 */
+	get_dimensions(): { width: number; height: number } {
+		return this.dimensions;
+	}
+
+	/**
+	 * Checks if textures are properly initialized.
+	 */
+	get textures_initialized(): boolean {
+		return !!(
+			this.stroke_texture &&
+			this.display_container &&
+			this.preview_sprite
+		);
+	}
+
+	/**
+	 * Cleanup all resources.
+	 */
+	cleanup(): void {
+		this.cleanup_textures();
+	}
+}

6.0.0-dev.5/imageeditor/shared/brush/brush-utils.ts

@@ -0,0 +1,76 @@
+import { Container, Sprite, Graphics } from "pixi.js";
+
+/**
+ * Sets the cursor style for a single PIXI object.
+ * @param child - The PIXI object to set the cursor for.
+ * @param cursor - The cursor style to set.
+ */
+export function set_cursor(
+	child: Container | Sprite | Graphics,
+	cursor: "unset" | "none"
+): void {
+	if (child instanceof Container) {
+		child.cursor = cursor;
+	} else if ("cursor" in child) {
+		(child as any).cursor = cursor;
+	}
+}
+
+/**
+ * Recursively sets the cursor style for PIXI objects.
+ * @param children - The PIXI objects to set the cursor for.
+ * @param cursor - The cursor style to set.
+ */
+export function recurse_set_cursor(
+	children: (Container | Sprite | Graphics)[],
+	cursor: "unset" | "none"
+): void {
+	for (const child of children) {
+		set_cursor(child, cursor);
+		if (child instanceof Container && child.children.length > 0) {
+			recurse_set_cursor(
+				child.children as (Container | Sprite | Graphics)[],
+				cursor
+			);
+		}
+	}
+}
+
+/**
+ * Safely removes a child from its parent.
+ * @param child - The child to remove.
+ */
+export function safe_remove_child(
+	child: Container | Sprite | Graphics | null
+): void {
+	if (child && child.parent) {
+		child.parent.removeChild(child);
+	}
+}
+
+/**
+ * Safely destroys a PIXI object and nullifies it.
+ * @param obj - The object to destroy.
+ * @returns null to assist with nullifying the reference.
+ */
+export function safe_destroy<T extends { destroy: (options?: any) => void }>(
+	obj: T | null
+): null {
+	if (obj) {
+		safe_remove_child(obj as any);
+		obj.destroy({ children: true });
+	}
+	return null;
+}
+
+/**
+ * Clears a timeout safely and nullifies the reference.
+ * @param timeout - The timeout to clear.
+ * @returns null to assist with nullifying the reference.
+ */
+export function clear_timeout(timeout: number | null): null {
+	if (timeout !== null) {
+		window.clearTimeout(timeout);
+	}
+	return null;
+}

6.0.0-dev.5/imageeditor/shared/brush/brush.ts

@@ -0,0 +1,468 @@
+import { Container, type FederatedPointerEvent } from "pixi.js";
+import { type ImageEditorContext, type Tool } from "../core/editor";
+import { type Tool as ToolbarTool, type Subtool } from "../Toolbar.svelte";
+import type { ColorInput } from "tinycolor2";
+import tinycolor from "tinycolor2";
+import { BrushCursor } from "./brush-cursor";
+import { BrushTextures } from "./brush-textures";
+import { recurse_set_cursor } from "./brush-utils";
+import { type BrushState } from "./types";
+
+/**
+ * BrushTool class implements the Tool interface for drawing and erasing.
+ * @class
+ * @implements {Tool}
+ */
+export class BrushTool implements Tool {
+	/**
+	 * The name of the tool.
+	 * @type {string}
+	 */
+	name = "brush" as const;
+
+	/**
+	 * The context of the image editor.
+	 * @private
+	 */
+	private image_editor_context!: ImageEditorContext;
+
+	/**
+	 * The current tool selected in the toolbar.
+	 * @private
+	 */
+	private current_tool!: ToolbarTool;
+
+	/**
+	 * The current subtool selected in the toolbar.
+	 * @private
+	 */
+	private current_subtool!: Subtool;
+
+	/**
+	 * The state of the brush tool.
+	 * @private
+	 */
+	private state: BrushState = {
+		opacity: 1,
+		brush_size: 10,
+		color: "#000000",
+		mode: "draw"
+	};
+
+	/**
+	 * Size settings for brush and eraser
+	 * @private
+	 */
+	private brush_size = 10;
+	private eraser_size = 20;
+
+	/**
+	 * Drawing state
+	 * @private
+	 */
+	private is_drawing = false;
+	private last_x = 0;
+	private last_y = 0;
+	private scale = 1;
+
+	/**
+	 * Event listeners
+	 * @private
+	 */
+	private _bound_pointer_down: ((event: FederatedPointerEvent) => void) | null =
+		null;
+	private _bound_pointer_move: ((event: FederatedPointerEvent) => void) | null =
+		null;
+	private _bound_pointer_up: (() => void) | null = null;
+	private event_callbacks: Map<string, (() => void)[]> = new Map();
+	/**
+	 * Utility modules
+	 * @private
+	 */
+	private brush_cursor: BrushCursor | null = null;
+	private brush_textures: BrushTextures | null = null;
+
+	/**
+	 * Sets up the brush tool with the given context, tool, and subtool.
+	 * @param {ImageEditorContext} context - The image editor context.
+	 * @param {ToolbarTool} tool - The tool from the toolbar.
+	 * @param {Subtool} subtool - The subtool from the toolbar.
+	 * @returns {Promise<void>}
+	 */
+	async setup(
+		context: ImageEditorContext,
+		tool: ToolbarTool,
+		subtool: Subtool
+	): Promise<void> {
+		this.image_editor_context = context;
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+
+		this.state.mode = tool === "erase" ? "erase" : "draw";
+
+		if (this.state.mode === "draw") {
+			this.state.brush_size = this.brush_size;
+		} else {
+			this.state.brush_size = this.eraser_size;
+		}
+
+		context.scale.subscribe((scale) => {
+			this.scale = scale;
+			if (this.brush_cursor) {
+				this.brush_cursor.update_state(this.state, this.scale);
+			}
+		});
+
+		this.brush_cursor = new BrushCursor(
+			this.image_editor_context,
+			this.state,
+			this.scale
+		);
+
+		this.brush_cursor.set_active(tool === "draw" || tool === "erase");
+
+		this.brush_textures = new BrushTextures(
+			this.image_editor_context,
+			context.app
+		);
+		this.brush_textures.initialize_textures();
+
+		this.setup_event_listeners();
+
+		this.handle_cursors(tool);
+	}
+
+	/**
+	 * Handles cursor styles for the brush tool.
+	 * @param {ToolbarTool} tool - The current tool.
+	 * @private
+	 */
+	private handle_cursors(tool: ToolbarTool): void {
+		recurse_set_cursor(
+			this.image_editor_context.image_container.children as Container[],
+			"none"
+		);
+	}
+
+	/**
+	 * Sets the current tool and subtool.
+	 * @param {ToolbarTool} tool - The current tool.
+	 * @param {Subtool} subtool - The current subtool.
+	 */
+	set_tool(tool: ToolbarTool, subtool: Subtool): void {
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+
+		if (this.current_tool !== "erase" && this.current_tool !== "draw") {
+			this.commit_pending_changes();
+		}
+
+		if (this.brush_cursor) {
+			const should_be_active = tool === "draw" || tool === "erase";
+
+			this.brush_cursor.set_active(should_be_active);
+		}
+
+		const new_mode = tool === "erase" ? "erase" : "draw";
+		const mode_changed = this.state.mode !== new_mode;
+		const needs_brush_tool = tool === "erase" || tool === "draw";
+		const textures_initialized =
+			this.brush_textures?.textures_initialized ?? false;
+
+		if (needs_brush_tool && (mode_changed || !textures_initialized)) {
+			this.brush_textures?.initialize_textures();
+		}
+
+		if (this.state.mode !== new_mode) {
+			this.state.mode = new_mode;
+
+			if (this.state.mode === "draw") {
+				this.state.brush_size = this.brush_size;
+			} else {
+				this.state.brush_size = this.eraser_size;
+			}
+
+			if (this.brush_cursor) {
+				this.brush_cursor.update_state(this.state, this.scale);
+			}
+		}
+	}
+
+	/**
+	 * Commits any pending changes to the canvas.
+	 * @private
+	 */
+	private commit_pending_changes(): void {
+		if (this.is_drawing) {
+			this.on_pointer_up();
+		}
+	}
+
+	/**
+	 * Called when the user presses the mouse button.
+	 * @param {FederatedPointerEvent} event - The pointer event.
+	 * @private
+	 */
+	private on_pointer_down(event: FederatedPointerEvent): void {
+		const current_layer =
+			this.image_editor_context.layer_manager.get_active_layer();
+
+		if (
+			!current_layer?.visible ||
+			(this.current_tool !== "erase" && this.current_tool !== "draw")
+		) {
+			return;
+		}
+
+		if (this.brush_cursor && !this.brush_cursor.is_over_image()) {
+			return;
+		}
+
+		if (this.brush_textures) {
+			this.brush_textures.preserve_canvas_state();
+		}
+
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+
+		this.is_drawing = true;
+		this.last_x = local_pos.x;
+		this.last_y = local_pos.y;
+
+		if (this.brush_textures) {
+			this.brush_textures.draw_segment(
+				local_pos.x,
+				local_pos.y,
+				local_pos.x,
+				local_pos.y,
+				this.state.brush_size,
+				this.state.color,
+				this.state.opacity,
+				this.state.mode
+			);
+		}
+	}
+
+	/**
+	 * Called when the user moves the mouse while drawing.
+	 * @param {FederatedPointerEvent} event - The pointer event.
+	 * @private
+	 */
+	private on_pointer_move(event: FederatedPointerEvent): void {
+		if (this.brush_cursor) {
+			this.brush_cursor.update_cursor_position(event);
+		}
+
+		if (!this.is_drawing) return;
+
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+
+		if (this.brush_textures) {
+			this.brush_textures.draw_segment(
+				this.last_x,
+				this.last_y,
+				local_pos.x,
+				local_pos.y,
+				this.state.brush_size,
+				this.state.color,
+				this.state.opacity,
+				this.state.mode
+			);
+		}
+
+		this.last_x = local_pos.x;
+		this.last_y = local_pos.y;
+	}
+
+	/**
+	 * Called when the user releases the mouse button.
+	 * @private
+	 */
+	private on_pointer_up(): void {
+		if (!this.is_drawing) return;
+
+		this.is_drawing = false;
+
+		if (this.brush_textures) {
+			this.brush_textures.commit_stroke();
+		}
+
+		this.notify("change");
+	}
+
+	/**
+	 * Sets up event listeners for drawing.
+	 * @private
+	 */
+	private setup_event_listeners(): void {
+		this.cleanup_event_listeners();
+
+		this._bound_pointer_down = this.on_pointer_down.bind(this);
+		this._bound_pointer_move = this.on_pointer_move.bind(this);
+		this._bound_pointer_up = this.on_pointer_up.bind(this);
+
+		const image_container = this.image_editor_context.image_container;
+		image_container.eventMode = "static";
+		image_container.interactiveChildren = true;
+
+		const stage = this.image_editor_context.app.stage;
+		stage.eventMode = "static";
+
+		stage.on("pointerdown", this._bound_pointer_down);
+		stage.on("pointermove", this._bound_pointer_move);
+		stage.on("pointerup", this._bound_pointer_up);
+		stage.on("pointerupoutside", this._bound_pointer_up);
+
+		if (this.brush_cursor) {
+			this.brush_cursor.setup_event_listeners();
+		}
+	}
+
+	/**
+	 * Cleans up event listeners.
+	 * @private
+	 */
+	private cleanup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+
+		if (this._bound_pointer_down) {
+			stage.off("pointerdown", this._bound_pointer_down);
+			this._bound_pointer_down = null;
+		}
+
+		if (this._bound_pointer_move) {
+			stage.off("pointermove", this._bound_pointer_move);
+			this._bound_pointer_move = null;
+		}
+
+		if (this._bound_pointer_up) {
+			stage.off("pointerup", this._bound_pointer_up);
+			stage.off("pointerupoutside", this._bound_pointer_up);
+			this._bound_pointer_up = null;
+		}
+
+		if (this.brush_cursor) {
+			this.brush_cursor.cleanup_event_listeners();
+		}
+	}
+
+	/**
+	 * Sets the brush size.
+	 * @param {number} size - The new brush size.
+	 */
+	set_brush_size(size: number): void {
+		this.brush_size = size;
+
+		if (this.state.mode === "draw") {
+			this.state.brush_size = size;
+
+			if (this.brush_cursor) {
+				this.brush_cursor.update_state(this.state, this.scale);
+			}
+		}
+	}
+
+	/**
+	 * Sets the brush color.
+	 * @param {string|ColorInput} color - The new brush color.
+	 */
+	set_brush_color(color: string | ColorInput): void {
+		const color_string = tinycolor(color).toHexString();
+
+		this.state.color = color_string;
+
+		if (this.brush_cursor) {
+			this.brush_cursor.update_state(this.state, this.scale);
+		}
+	}
+
+	/**
+	 * Sets the brush opacity.
+	 * @param {number} opacity - The new brush opacity.
+	 */
+	set_brush_opacity(opacity: number): void {
+		const clamped_opacity = Math.max(0, Math.min(1, opacity));
+
+		this.state.opacity = clamped_opacity;
+
+		if (this.brush_cursor) {
+			this.brush_cursor.update_state(this.state, this.scale);
+		}
+	}
+
+	/**
+	 * Sets the eraser size.
+	 * @param {number} size - The new eraser size.
+	 */
+	set_eraser_size(size: number): void {
+		this.eraser_size = size;
+
+		if (this.state.mode === "erase") {
+			this.state.brush_size = size;
+
+			if (this.brush_cursor) {
+				this.brush_cursor.update_state(this.state, this.scale);
+			}
+		}
+	}
+
+	/**
+	 * Gets the current size based on mode (brush or eraser).
+	 * @returns {number} The current size.
+	 */
+	get_current_size(): number {
+		return this.state.mode === "draw" ? this.brush_size : this.eraser_size;
+	}
+
+	/**
+	 * Shows or hides the brush preview.
+	 * @param {boolean} show - Whether to show the preview.
+	 */
+	preview_brush(show: boolean): void {
+		if (this.brush_cursor) {
+			this.brush_cursor.preview_brush(show);
+		}
+	}
+
+	/**
+	 * Cleans up resources used by the brush tool.
+	 */
+	cleanup(): void {
+		this.commit_pending_changes();
+
+		this.cleanup_event_listeners();
+
+		if (this.brush_textures) {
+			this.brush_textures.cleanup();
+			this.brush_textures = null;
+		}
+
+		if (this.brush_cursor) {
+			this.brush_cursor.cleanup();
+			this.brush_cursor = null;
+		}
+	}
+
+	on<T extends string>(event: T, callback: () => void): void {
+		this.event_callbacks.set(event, [
+			...(this.event_callbacks.get(event) || []),
+			callback
+		]);
+	}
+
+	off<T extends string>(event: T, callback: () => void): void {
+		this.event_callbacks.set(
+			event,
+			this.event_callbacks.get(event)?.filter((cb) => cb !== callback) || []
+		);
+	}
+
+	private notify<T extends string>(event: T): void {
+		for (const callback of this.event_callbacks.get(event) || []) {
+			callback();
+		}
+	}
+}

6.0.0-dev.5/imageeditor/shared/brush/types.ts

@@ -0,0 +1,41 @@
+import { type ColorInput } from "tinycolor2";
+
+/**
+ * Represents the state of the brush tool.
+ * @interface BrushState
+ * @property {number} opacity - The opacity of the brush.
+ * @property {number} brush_size - The size of the brush.
+ * @property {string} color - The color of the brush in hex format.
+ * @property {"draw"|"erase"} mode - The mode of the brush, either draw or erase.
+ */
+export interface BrushState {
+	opacity: number;
+	brush_size: number;
+	color: string;
+	mode: "draw" | "erase";
+}
+
+export interface Eraser {
+	/**
+	 * The default size of the eraser.
+	 */
+	default_size: number | "auto";
+}
+
+export type ColorTuple = [ColorInput, number]; // [color, opacity]
+
+export interface Brush extends Eraser {
+	/**
+	 * The default color of the brush.
+	 */
+	default_color: ColorInput;
+	/**
+	 * The colors to show in the color swatch.
+	 * Can be either simple color strings or [color, opacity] tuples.
+	 */
+	colors: (ColorInput | ColorTuple)[];
+	/**
+	 * 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";
+}

6.0.0-dev.5/imageeditor/shared/core/commands.ts

@@ -0,0 +1,134 @@
+import { writable } from "svelte/store";
+import type { ImageEditorContext } from "./editor";
+
+/**
+ * Base command interface that is added to the command_managers history
+ */
+export interface Command {
+	/**
+	 * The name of the command
+	 */
+	name: string;
+	/**
+	 * 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(context?: ImageEditorContext): 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>;
+}
+
+/**
+ * Creates a command node
+ * @param command command to add to the node
+ * @returns a command node
+ */
+export class CommandNode {
+	command: Command | null;
+	next: CommandNode | null;
+	previous: CommandNode | null;
+
+	constructor(command?: Command) {
+		this.command = command || null;
+		this.next = null;
+		this.previous = null;
+	}
+
+	push(command: Command): void {
+		this.next = null;
+
+		const node = new CommandNode(command);
+		node.previous = this;
+		this.next = node;
+	}
+}
+
+/**
+ * Creates a command manager
+ * @returns a command manager
+ */
+export class CommandManager {
+	history: CommandNode = new CommandNode();
+	current_history = writable(this.history);
+
+	undo(): void {
+		if (this.history.previous) {
+			this.history.command?.undo();
+			this.history = this.history.previous;
+
+			this.current_history.update(() => this.history);
+		}
+	}
+	redo(context?: ImageEditorContext): void {
+		if (this.history.next) {
+			this.history = this.history.next;
+			this.history.command?.execute(context);
+			this.current_history.update(() => this.history);
+		}
+	}
+
+	async execute(command: Command, context: ImageEditorContext): Promise<void> {
+		await command.execute(context);
+		this.history.push(command);
+		this.history = this.history.next!;
+
+		this.current_history.update(() => this.history);
+	}
+
+	async wait_for_next_frame(): Promise<void> {
+		return new Promise((resolve) => {
+			requestAnimationFrame(() => {
+				resolve();
+			});
+		});
+	}
+
+	async replay(
+		full_history: CommandNode,
+		context: ImageEditorContext
+	): Promise<void> {
+		while (full_history.previous) {
+			full_history = full_history.previous;
+		}
+
+		while (full_history.next) {
+			await full_history.next.command!.execute(context);
+			full_history = full_history.next;
+		}
+
+		this.history = full_history;
+		this.current_history.update(() => this.history);
+	}
+
+	contains(command_name: string): boolean {
+		let current: CommandNode | null = this.history;
+		while (current) {
+			if (current.command?.name === command_name) return true;
+			current = current.next;
+		}
+		return false;
+	}
+
+	reset(): void {
+		this.history = new CommandNode();
+		this.current_history.update(() => this.history);
+	}
+}

6.0.0-dev.5/imageeditor/shared/core/editor.ts

@@ -0,0 +1,885 @@
+import { Application, Container, Graphics, Sprite, Assets } from "pixi.js";
+
+import { DropShadowFilter as BlurFilter } from "pixi-filters/drop-shadow";
+
+import { ImageTool } from "../image/image";
+
+import { ZoomTool } from "../zoom/zoom";
+import type { Subtool, Tool as ToolbarTool } from "../Toolbar.svelte";
+import type { Readable, Writable } from "svelte/store";
+import { spring, type Spring } from "svelte/motion";
+import { writable } from "svelte/store";
+import { type ImageBlobs, type LayerOptions } from "../types";
+import type { BrushTool } from "../brush/brush";
+import type { CropTool } from "../crop/crop";
+import { CommandManager, type Command } from "./commands";
+import {
+	LayerManager,
+	AddLayerCommand,
+	RemoveLayerCommand,
+	ReorderLayerCommand
+} from "./layers";
+
+export interface Tool {
+	name: string;
+	setup(
+		context: ImageEditorContext,
+		tool: ToolbarTool,
+		subtool: Subtool
+	): Promise<void>;
+	cleanup(): void;
+	set_tool(tool: ToolbarTool, subtool: Subtool): void;
+	on?: (event: string, callback: () => void) => void;
+	off?: (event: string, callback: () => void) => void;
+}
+
+const core_tools = ["image", "zoom"] as const;
+
+interface ImageEditorOptions {
+	target_element: HTMLElement;
+	width: number;
+	height: number;
+	tools: ((typeof core_tools)[number] | Tool)[];
+	fixed_canvas?: boolean;
+	dark?: boolean;
+	border_region?: number;
+	layer_options?: LayerOptions;
+	pad_bottom?: number;
+	theme_mode?: "dark" | "light";
+}
+
+const core_tool_map = {
+	image: () => new ImageTool(),
+	zoom: () => new ZoomTool()
+} as const;
+
+export interface ImageEditorContext {
+	app: Application;
+	ui_container: Container;
+	image_container: Container;
+	background_image?: Sprite;
+	command_manager: CommandManager;
+	layer_manager: LayerManager;
+	dimensions: Readable<{ width: number; height: number }>;
+	scale: Readable<number>;
+	position: Readable<{ x: number; y: number }>;
+	set_image_properties: (properties: {
+		width?: number;
+		height?: number;
+		scale?: number;
+		position?: { x: number; y: number };
+		animate?: boolean;
+	}) => Promise<void>;
+	execute_command: (command: Command) => Promise<void> | void;
+	resize_canvas: (width: number, height: number) => void;
+	reset: () => void;
+	set_background_image: (image: Sprite) => void;
+	pad_bottom: number;
+}
+
+const spring_config = {
+	stiffness: 0.45,
+	damping: 0.8
+};
+
+interface EditorStatePublic {
+	position: { x: number; y: number };
+	scale: number;
+	subscribe: (callback: (value: any) => void) => () => void;
+	current_tool: ToolbarTool;
+	current_subtool: Subtool;
+}
+
+class EditorState {
+	state: EditorStatePublic;
+	private scale: number;
+	private position: { x: number; y: number };
+	private subscribers: Set<(value: any) => void>;
+	constructor(editor: ImageEditor) {
+		if (!(editor instanceof ImageEditor)) {
+			throw new Error("EditorState must be created by ImageEditor");
+		}
+
+		this.scale = 1.0;
+		this.position = { x: 0, y: 0 };
+		this.subscribers = new Set();
+		// @ts-ignore
+		this.state = Object.freeze({
+			get position() {
+				return { ...this.position };
+			},
+			get scale() {
+				return this.scale;
+			},
+			get current_tool() {
+				return this.current_tool;
+			},
+			get current_subtool() {
+				return this.current_subtool;
+			},
+			subscribe: this.subscribe.bind(this)
+		});
+	}
+
+	_set_position(x: number, y: number): void {
+		const oldPosition = { ...this.position };
+		this.position = { x, y };
+		this._notify_subscribers("position", oldPosition, this.position);
+	}
+
+	_set_scale(scale: number): void {
+		const oldScale = this.scale;
+		this.scale = scale;
+		this._notify_subscribers("scale", oldScale, scale);
+	}
+
+	_notify_subscribers(property: string, oldValue: any, newValue: any): void {
+		this.subscribers.forEach((callback) => {
+			callback({
+				property,
+				oldValue,
+				newValue,
+				timestamp: Date.now()
+			});
+		});
+	}
+
+	subscribe(callback: (value: any) => void): () => void {
+		this.subscribers.add(callback);
+		return () => this.subscribers.delete(callback);
+	}
+}
+
+export class ImageEditor {
+	public ready: Promise<void>;
+	public background_image_present = writable(false);
+	public min_zoom = writable(true);
+
+	private app!: Application;
+	private ui_container!: Container;
+	private image_container!: Container;
+	command_manager: CommandManager;
+
+	private layer_manager!: LayerManager;
+	private tools: Map<string, Tool> = new Map<string, Tool>();
+	private current_tool!: ToolbarTool;
+	private current_subtool!: Subtool;
+	private target_element: HTMLElement;
+	private width: number;
+	private height: number;
+	private original_width: number;
+	private original_height: number;
+	dimensions: Spring<{ width: number; height: number }>;
+	scale: Spring<number>;
+	private position: Spring<{ x: number; y: number }>;
+	private state: EditorState;
+	private scale_value = 1;
+	private position_value: { x: number; y: number } = { x: 0, y: 0 };
+	private dimensions_value: { width: number; height: number } = {
+		width: 0,
+		height: 0
+	};
+	layers: Writable<{
+		active_layer: string;
+		layers: {
+			name: string;
+			id: string;
+			user_created: boolean;
+			visible: boolean;
+		}[];
+	}> = writable({
+		active_layer: "",
+		layers: []
+	});
+	private outline_container!: Container;
+	private outline_graphics!: Graphics;
+	private background_image?: Sprite;
+	private ready_resolve!: (value: void | PromiseLike<void>) => void;
+	private event_callbacks: Map<string, (() => void)[]> = new Map();
+	private fixed_canvas: boolean;
+	private dark: boolean;
+	private border_region: number;
+	private layer_options: LayerOptions;
+	private overlay_container!: Container;
+	private overlay_graphics!: Graphics;
+	private pad_bottom: number;
+	private theme_mode: "dark" | "light";
+	constructor(options: ImageEditorOptions) {
+		this.pad_bottom = options.pad_bottom || 0;
+		this.dark = options.dark || false;
+		this.theme_mode = options.theme_mode || "dark";
+		this.target_element = options.target_element;
+		this.width = options.width;
+		this.height = options.height;
+		this.original_width = options.width;
+		this.original_height = options.height;
+		this.command_manager = new CommandManager();
+
+		this.ready = new Promise((resolve) => {
+			this.ready_resolve = resolve;
+		});
+		this.fixed_canvas = options.fixed_canvas || false;
+		this.tools = new Map<string, Tool>(
+			options.tools.map((tool) => {
+				if (typeof tool === "string") {
+					return [tool, core_tool_map[tool]()];
+				}
+
+				return [tool.name, tool];
+			})
+		);
+
+		for (const tool of this.tools.values()) {
+			if (tool?.on) {
+				tool.on("change", () => {
+					this.notify("change");
+				});
+			}
+		}
+
+		this.dimensions = spring(
+			{ width: this.width, height: this.height },
+			spring_config
+		);
+		this.scale = spring(1, spring_config);
+		this.position = spring({ x: 0, y: 0 }, spring_config);
+		this.state = new EditorState(this);
+		this.border_region = options.border_region || 0;
+		this.layer_options = options.layer_options || {
+			allow_additional_layers: true,
+			layers: ["Layer 1"],
+			disabled: false
+		};
+		this.scale.subscribe((scale) => {
+			this.state._set_scale(scale);
+		});
+		this.position.subscribe((position) => {
+			this.state._set_position(position.x, position.y);
+		});
+		this.init();
+	}
+
+	get context(): ImageEditorContext {
+		const editor = this;
+		return {
+			app: this.app,
+			ui_container: this.ui_container,
+			image_container: this.image_container,
+			get background_image() {
+				return editor.background_image;
+			},
+			pad_bottom: this.pad_bottom,
+			command_manager: this.command_manager,
+			layer_manager: this.layer_manager,
+			dimensions: { subscribe: this.dimensions.subscribe },
+			scale: { subscribe: this.scale.subscribe },
+			position: { subscribe: this.position.subscribe },
+			set_image_properties: this.set_image_properties.bind(this),
+			execute_command: this.execute_command.bind(this),
+			resize_canvas: this.resize_canvas.bind(this),
+			reset: this.reset.bind(this),
+			set_background_image: this.set_background_image.bind(this)
+		};
+	}
+
+	async init(): Promise<void> {
+		const container_box = this.target_element.getBoundingClientRect();
+		new ResizeObserver((entries) => {
+			entries.forEach((entry) => {
+				this.resize_canvas(
+					entry.contentBoxSize[0].inlineSize,
+					entry.contentBoxSize[0].blockSize
+				);
+			});
+		}).observe(this.target_element);
+
+		this.app = new Application();
+
+		if (!this.dark) {
+			(globalThis as any).__PIXI_APP__ = this.app;
+		}
+		await this.app.init({
+			width: container_box.width,
+			height: container_box.height,
+			backgroundAlpha: this.dark ? 0 : 1,
+			backgroundColor: this.theme_mode === "dark" ? "#27272a" : "#ffffff",
+			resolution: window.devicePixelRatio,
+			autoDensity: true,
+			antialias: true,
+			powerPreference: "high-performance"
+		});
+
+		const canvas = this.app.canvas as HTMLCanvasElement;
+		canvas.style.background = "transparent";
+
+		this.setup_containers();
+
+		this.layer_manager.create_background_layer(this.width, this.height);
+
+		this.layer_manager.init_layers(this.width, this.height);
+
+		for (const tool of this.tools.values()) {
+			await tool.setup(this.context, this.current_tool, this.current_subtool);
+		}
+
+		const zoom = this.tools.get("zoom") as ZoomTool;
+		if (zoom) {
+			zoom.min_zoom.subscribe((is_min_zoom) => {
+				this.min_zoom.set(is_min_zoom);
+			});
+		}
+
+		this.target_element.appendChild(canvas);
+
+		this.target_element.style.background = "transparent";
+
+		this.dimensions.subscribe((dimensions) => {
+			this.dimensions_value = dimensions;
+			this.image_container.width = dimensions.width;
+			this.image_container.height = dimensions.height;
+		});
+
+		this.scale.subscribe((scale) => {
+			this.scale_value = scale;
+		});
+
+		this.position.subscribe((position) => {
+			this.position_value = position;
+		});
+
+		this.app.ticker.add(() => {
+			this.image_container.scale.set(this.scale_value);
+			this.image_container.position.set(
+				this.position_value.x,
+				this.position_value.y
+			);
+
+			const effective_width = this.dimensions_value.width * this.scale_value;
+			const effective_height = this.dimensions_value.height * this.scale_value;
+
+			const local_x = Math.round(
+				this.image_container.position.x - this.outline_container.position.x
+			);
+			const local_y = Math.round(
+				this.image_container.position.y - this.outline_container.position.y
+			);
+
+			this.overlay_container.position.set(
+				this.outline_container.position.x,
+				this.outline_container.position.y
+			);
+
+			this.outline_graphics.clear();
+			this.outline_graphics
+				.rect(local_x, local_y, effective_width, effective_height)
+				.fill({
+					color: this.dark ? 0x333333 : 0xffffff,
+					alpha: 1
+				});
+
+			if (this.border_region > 0) {
+				const scaled_border = this.border_region * this.scale_value;
+				const border_x = local_x + scaled_border - 1;
+				const border_y = local_y + scaled_border - 1;
+				const border_width = effective_width - scaled_border * 2 + 1;
+				const border_height = effective_height - scaled_border * 2 + 1;
+
+				this.overlay_graphics.clear();
+
+				this.overlay_graphics
+					.rect(border_x, border_y, border_width, border_height)
+					.stroke({
+						color: 0x999999,
+						width: 1,
+						alpha: 0,
+						pixelLine: true
+					});
+
+				const dashLength = 5;
+				const gapLength = 5;
+				const totalLength = dashLength + gapLength;
+				const lineColor = 0x999999;
+
+				for (let x = border_x; x < border_x + border_width; x += totalLength) {
+					this.overlay_graphics
+						.rect(
+							x,
+							border_y,
+							Math.min(dashLength, border_x + border_width - x),
+							1
+						)
+						.fill({ color: lineColor, alpha: 0.7 });
+
+					this.overlay_graphics
+						.rect(
+							x,
+							border_y + border_height,
+							Math.min(dashLength, border_x + border_width - x),
+							1
+						)
+						.fill({ color: lineColor, alpha: 0.7 });
+				}
+
+				for (let y = border_y; y < border_y + border_height; y += totalLength) {
+					this.overlay_graphics
+						.rect(
+							border_x,
+							y,
+							1,
+							Math.min(dashLength, border_y + border_height - y)
+						)
+						.fill({ color: lineColor, alpha: 0.7 });
+
+					this.overlay_graphics
+						.rect(
+							border_x + border_width,
+							y,
+							1,
+							Math.min(dashLength, border_y + border_height - y)
+						)
+						.fill({ color: lineColor, alpha: 0.7 });
+				}
+			} else {
+				this.overlay_graphics.clear();
+			}
+		});
+
+		this.ready_resolve();
+	}
+
+	private setup_containers(): void {
+		this.image_container = new Container({
+			eventMode: "static",
+			sortableChildren: true
+		});
+
+		this.image_container.width = this.width;
+		this.image_container.height = this.height;
+
+		this.app.stage.sortableChildren = true;
+		this.app.stage.alpha = 1;
+		this.app.stage.addChild(this.image_container);
+
+		this.image_container.scale.set(1);
+
+		this.ui_container = new Container({
+			eventMode: "static"
+		});
+		this.app.stage.addChild(this.ui_container);
+		this.ui_container.width = this.width;
+		this.ui_container.height = this.height;
+
+		this.outline_container = new Container();
+		this.outline_container.zIndex = -10;
+
+		this.outline_graphics = new Graphics();
+
+		this.outline_graphics.rect(0, 0, this.width, this.height).fill({
+			color: this.dark ? 0x333333 : 0xffffff,
+			alpha: 0
+		});
+
+		if (!this.dark) {
+			const blurFilter = new BlurFilter({
+				alpha: 0.1,
+				blur: 2,
+				color: 0x000000,
+				offset: { x: 0, y: 0 },
+				quality: 4,
+				shadowOnly: false
+			});
+
+			this.outline_graphics.filters = [blurFilter];
+		}
+
+		this.outline_container.addChild(this.outline_graphics);
+		this.app.stage.addChild(this.outline_container);
+
+		this.overlay_container = new Container();
+		this.app.stage.addChild(this.overlay_container);
+		this.overlay_container.width = this.width;
+		this.overlay_container.height = this.height;
+
+		this.overlay_container.zIndex = 999;
+		this.overlay_container.eventMode = "static";
+		this.overlay_container.interactiveChildren = true;
+		this.overlay_graphics = new Graphics();
+		this.overlay_container.addChild(this.overlay_graphics);
+
+		this.overlay_graphics.rect(0, 0, this.width, this.height).fill({
+			color: 0x000000,
+			alpha: 0
+		});
+
+		const app_center_x = this.app.screen.width / 2;
+		const app_center_y = this.app.screen.height / 2;
+
+		this.image_container.position.set(app_center_x, app_center_y);
+		this.outline_container.position.set(app_center_x, app_center_y);
+
+		this.layer_manager = new LayerManager(
+			this.image_container,
+			this.app,
+			this.fixed_canvas,
+			this.dark,
+			this.border_region,
+			this.layer_options
+		);
+		this.layers = this.layer_manager.layer_store;
+	}
+
+	resize_canvas(width: number, height: number): void {
+		if (this.app.renderer) {
+			this.app.renderer.resize(width, height);
+		}
+
+		const app_center_x = width / 2;
+		const app_center_y = height / 2;
+
+		if (this.image_container) {
+			this.image_container.position.set(app_center_x, app_center_y);
+		}
+		if (this.outline_container) {
+			this.outline_container.position.set(app_center_x, app_center_y);
+		}
+	}
+
+	reset(): void {
+		const zoom = this.tools.get("zoom");
+
+		if (zoom) {
+			zoom.cleanup();
+			zoom.setup(this.context, this.current_tool, this.current_subtool);
+		}
+
+		const brush = this.tools.get("brush") as BrushTool;
+
+		if (brush) {
+			this.set_tool("draw");
+		}
+	}
+
+	async set_image_properties(properties: {
+		width?: number;
+		height?: number;
+		scale?: number;
+		position?: { x: number; y: number };
+		animate?: boolean;
+	}): Promise<void> {
+		let hard =
+			typeof properties.animate !== "undefined" ? !properties.animate : true;
+		if (properties.position) {
+			const pos = this.position.set(properties.position, { hard });
+			if (hard) {
+				await pos;
+			}
+		}
+		if (properties.scale) {
+			const scale = this.scale.set(properties.scale, { hard });
+			if (hard) {
+				await scale;
+			}
+		}
+		if (properties.width && properties.height) {
+			this.width = properties.width;
+			this.height = properties.height;
+			const dimensions = this.dimensions.set(
+				{ width: properties.width, height: properties.height },
+				{ hard }
+			);
+			if (hard) {
+				await dimensions;
+			}
+		}
+	}
+
+	async execute_command(command: Command): Promise<void> {
+		await this.command_manager.execute(command, this.context);
+	}
+
+	undo(): void {
+		this.command_manager.undo();
+		this.notify("change");
+	}
+
+	redo(): void {
+		this.command_manager.redo(this.context);
+		this.notify("change");
+	}
+
+	async add_image({
+		image,
+		resize = true
+	}: {
+		image: Blob | File;
+		resize?: boolean;
+	}): Promise<void> {
+		const image_tool = this.tools.get("image") as ImageTool;
+		await image_tool.add_image({
+			image,
+			fixed_canvas: this.fixed_canvas,
+			border_region: this.border_region
+		});
+	}
+
+	/**
+	 * Adds an image from a URL as the background layer
+	 * @param url The URL of the image to add
+	 */
+	async add_image_from_url(url: string): Promise<void> {
+		const image_tool = this.tools.get("image") as ImageTool;
+		const texture = await Assets.load(url);
+		await image_tool.add_image({
+			image: texture,
+			fixed_canvas: this.fixed_canvas,
+			border_region: this.border_region
+		});
+
+		const resize_tool = this.tools.get("resize") as any;
+		if (resize_tool && typeof resize_tool.set_border_region === "function") {
+			resize_tool.set_border_region(this.border_region);
+		}
+	}
+
+	set_tool(tool: ToolbarTool): void {
+		this.current_tool = tool;
+
+		for (const tool of this.tools.values()) {
+			tool.set_tool(this.current_tool, this.current_subtool);
+		}
+	}
+
+	set_subtool(subtool: Subtool): void {
+		this.current_subtool = subtool;
+
+		for (const tool of this.tools.values()) {
+			tool.set_tool(this.current_tool, this.current_subtool);
+		}
+	}
+
+	set_background_image(image: Sprite): void {
+		this.background_image = image;
+	}
+
+	async reset_canvas(): Promise<void> {
+		this.width = this.original_width;
+		this.height = this.original_height;
+
+		this.layer_manager.reset_layers(this.width, this.height);
+		this.background_image = undefined;
+		this.background_image_present.set(false);
+		this.command_manager.reset();
+
+		await this.set_image_properties({
+			width: this.width,
+			height: this.height,
+			scale: 1,
+			position: { x: 0, y: 0 },
+			animate: false
+		});
+
+		this.layer_manager.create_background_layer(this.width, this.height);
+
+		for (const tool of this.tools.values()) {
+			tool.cleanup();
+			tool.setup(this.context, this.current_tool, this.current_subtool);
+		}
+
+		const zoom_tool = this.tools.get("zoom") as ZoomTool;
+		if (zoom_tool) {
+			zoom_tool.min_zoom.subscribe((is_min_zoom) => {
+				this.min_zoom.set(is_min_zoom);
+			});
+		}
+
+		this.notify("change");
+	}
+
+	add_layer(): void {
+		const add_layer_command = new AddLayerCommand(this.context, {
+			width: this.width,
+			height: this.height,
+			user_created: true,
+			make_active: true
+		});
+
+		this.execute_command(add_layer_command);
+		this.notify("change");
+	}
+
+	/**
+	 * Adds a new layer with an image loaded from a URL
+	 * @param layer_urls The URLs of the images to load
+	 * @returns A Promise that resolves when all layers are added
+	 */
+	async add_layers_from_url(layer_urls: string[] | undefined): Promise<void> {
+		this.command_manager.reset();
+		const _layers = this.layer_manager.get_layers();
+		_layers.forEach((l) => this.layer_manager.delete_layer(l.id));
+
+		if (layer_urls === undefined || layer_urls.length === 0) {
+			this.layer_manager.create_layer({
+				width: this.width,
+				height: this.height,
+				layer_name: undefined,
+				user_created: false
+			});
+			return;
+		}
+
+		const created_layer_ids: string[] = [];
+		for await (const url of layer_urls) {
+			const layer_id = await this.layer_manager.add_layer_from_url(url);
+			if (layer_id) {
+				created_layer_ids.push(layer_id);
+			}
+		}
+
+		if (created_layer_ids.length > 0) {
+			this.layer_manager.set_active_layer(created_layer_ids[0]);
+		}
+
+		const resize_tool = this.tools.get("resize") as any;
+		if (resize_tool && typeof resize_tool.set_border_region === "function") {
+			resize_tool.set_border_region(this.border_region);
+		}
+
+		this.notify("change");
+		this.notify("input");
+	}
+
+	set_layer(id: string): void {
+		this.layer_manager.set_active_layer(id);
+		this.notify("change");
+	}
+
+	move_layer(id: string, direction: "up" | "down"): void {
+		const reorder_layer_command = new ReorderLayerCommand(
+			this.context,
+			id,
+			direction
+		);
+		this.execute_command(reorder_layer_command);
+		this.notify("change");
+	}
+
+	delete_layer(id: string): void {
+		const remove_layer_command = new RemoveLayerCommand(this.context, id);
+		this.execute_command(remove_layer_command);
+		this.notify("change");
+	}
+
+	modify_canvas_size(
+		width: number,
+		height: number,
+		anchor:
+			| "top-left"
+			| "top"
+			| "top-right"
+			| "left"
+			| "center"
+			| "right"
+			| "bottom-left"
+			| "bottom"
+			| "bottom-right",
+		scale: boolean
+	): void {
+		const oldWidth = this.width;
+		const oldHeight = this.height;
+
+		this.layer_manager.resize_all_layers(
+			width,
+			height,
+			scale,
+			anchor,
+			oldWidth,
+			oldHeight
+		);
+
+		this.width = width;
+		this.height = height;
+
+		this.set_image_properties({
+			width,
+			height,
+			scale: 1,
+			position: { x: 0, y: 0 },
+			animate: false
+		});
+		this.notify("change");
+	}
+
+	async get_blobs(): Promise<ImageBlobs> {
+		const blobs = await this.layer_manager.get_blobs(this.width, this.height);
+		return blobs;
+	}
+
+	on(event: "change" | "input", callback: () => void): void {
+		this.event_callbacks.set(event, [
+			...(this.event_callbacks.get(event) || []),
+			callback
+		]);
+	}
+
+	off(event: "change", callback: () => void): void {
+		this.event_callbacks.set(
+			event,
+			this.event_callbacks.get(event)?.filter((cb) => cb !== callback) || []
+		);
+	}
+
+	private notify(event: "change" | "input"): void {
+		for (const callback of this.event_callbacks.get(event) || []) {
+			callback();
+		}
+	}
+
+	destroy(): void {
+		if (!this.app) return;
+
+		this.app?.destroy();
+	}
+
+	resize(width: number, height: number): void {
+		this.set_image_properties({
+			width,
+			height
+		});
+
+		this.reset();
+	}
+
+	async get_crop_bounds(): Promise<{
+		image: Blob | null;
+		crop_dimensions: { width: number; height: number };
+		image_dimensions: { width: number; height: number };
+		x: number;
+		y: number;
+	}> {
+		const crop_tool = this.tools.get("crop") as CropTool;
+		const crop_bounds = crop_tool.get_crop_bounds();
+		const image = await crop_tool.get_image();
+
+		return {
+			image,
+			...crop_bounds
+		};
+	}
+
+	get background_image_sprite(): Sprite | undefined {
+		return this.background_image;
+	}
+
+	set_layer_options(layer_options: LayerOptions): void {
+		this.layer_options = layer_options;
+		this.layer_manager.set_layer_options(
+			layer_options,
+			this.width,
+			this.height
+		);
+	}
+
+	toggle_layer_visibility(id: string): void {
+		this.layer_manager.toggle_layer_visibility(id);
+	}
+}

6.0.0-dev.5/imageeditor/shared/core/layers.ts

@@ -0,0 +1,1092 @@
+import {
+	Application,
+	Container,
+	Graphics,
+	Sprite,
+	RenderTexture,
+	SCALE_MODES,
+	Texture,
+	Assets
+} from "pixi.js";
+
+import { get_canvas_blob } from "../utils/pixi";
+import type { Writable } from "svelte/store";
+import { writable, get } from "svelte/store";
+import { type ImageBlobs, type LayerOptions } from "../types";
+import { type Command } from "./commands";
+import { type ImageEditorContext } from "./editor";
+
+export class LayerManager {
+	private layers: {
+		name: string;
+		id: string;
+		container: Container;
+		user_created: boolean;
+		visible: boolean;
+	}[] = [];
+	private active_layer: Container | null = null;
+	private active_layer_id: string | null = null;
+	private draw_textures: Map<Container, RenderTexture> = new Map();
+	layer_store: Writable<{
+		active_layer: string;
+		layers: {
+			name: string;
+			id: string;
+			user_created: boolean;
+			visible: boolean;
+		}[];
+	}> = writable({
+		active_layer: "",
+
+		layers: []
+	});
+	private background_layer: Container | null = null;
+	private image_container: Container;
+	private app: Application;
+	private fixed_canvas: boolean;
+	private dark: boolean;
+	private border_region: number;
+	private layer_options: LayerOptions;
+	constructor(
+		image_container: Container,
+		app: Application,
+		fixed_canvas: boolean,
+		dark: boolean,
+		border_region: number,
+		layer_options: LayerOptions
+	) {
+		this.image_container = image_container;
+		this.app = app;
+		this.fixed_canvas = fixed_canvas;
+		this.dark = dark;
+		this.border_region = border_region;
+		this.layer_options = layer_options;
+	}
+
+	toggle_layer_visibility(id: string): void {
+		const layer = this.layers.find((l) => l.id === id);
+		if (layer) {
+			layer.container.visible = !layer.container.visible;
+			layer.visible = layer.container.visible;
+			this.layer_store.update((state) => ({
+				active_layer: state.active_layer,
+				layers: this.layers
+			}));
+		}
+	}
+
+	create_background_layer(width: number, height: number): Container {
+		if (this.background_layer) {
+			this.background_layer.destroy();
+		}
+
+		const layer = new Container();
+
+		this.background_layer = layer;
+
+		const bg_texture = RenderTexture.create({
+			width,
+			height,
+			resolution: window.devicePixelRatio,
+			antialias: true,
+			scaleMode: SCALE_MODES.NEAREST
+		});
+
+		const bg_sprite = new Sprite(bg_texture);
+		layer.addChild(bg_sprite);
+
+		const clear_graphics = new Graphics();
+		clear_graphics.clear();
+
+		clear_graphics
+			.rect(0, 0, width, height)
+			.fill({ color: this.dark ? 0x333333 : 0xffffff, alpha: 1 });
+
+		this.app.renderer.render({
+			container: clear_graphics,
+			target: bg_texture,
+			clear: true
+		});
+
+		this.image_container.addChild(layer);
+
+		layer.zIndex = -1;
+
+		this.update_layer_order();
+		return layer;
+	}
+
+	set_layer_options(
+		layer_options: LayerOptions,
+		width: number,
+		height: number
+	): void {
+		this.layer_options = layer_options;
+		this.reset_layers(width, height);
+	}
+
+	/**
+	 * Creates a background layer from an image URL
+	 * @param url The URL of the image to use as background
+	 * @param width The width of the layer (if fixed_canvas is true)
+	 * @param height The height of the layer (if fixed_canvas is true)
+	 * @param borderRegion Minimum border region to add around the image for outpainting (in pixels)
+	 * @returns A Promise that resolves to the background Container when the image is loaded
+	 */
+	async create_background_layer_from_url(
+		url: string,
+		width?: number,
+		height?: number
+	): Promise<Container> {
+		const layer = this.create_background_layer(
+			width || this.image_container.width,
+			height || this.image_container.height
+		);
+
+		try {
+			const texture = await Texture.from(url);
+			const sprite = new Sprite(texture);
+
+			const imageWidth = sprite.texture.width;
+			const imageHeight = sprite.texture.height;
+
+			const containerWidth = width || this.image_container.width;
+			const containerHeight = height || this.image_container.height;
+
+			if (this.fixed_canvas) {
+				const effectiveContainerWidth = Math.max(
+					containerWidth - this.border_region * 2,
+					10
+				);
+				const effectiveContainerHeight = Math.max(
+					containerHeight - this.border_region * 2,
+					10
+				);
+
+				const imageAspectRatio = imageWidth / imageHeight;
+				const containerAspectRatio =
+					effectiveContainerWidth / effectiveContainerHeight;
+
+				let finalWidth, finalHeight;
+				let posX = this.border_region,
+					posY = this.border_region;
+
+				if (
+					imageWidth <= effectiveContainerWidth &&
+					imageHeight <= effectiveContainerHeight
+				) {
+					finalWidth = imageWidth;
+					finalHeight = imageHeight;
+				} else {
+					if (imageAspectRatio > containerAspectRatio) {
+						finalWidth = effectiveContainerWidth;
+						finalHeight = effectiveContainerWidth / imageAspectRatio;
+					} else {
+						finalHeight = effectiveContainerHeight;
+						finalWidth = effectiveContainerHeight * imageAspectRatio;
+					}
+				}
+
+				posX += Math.round((effectiveContainerWidth - finalWidth) / 2);
+				posY += Math.round((effectiveContainerHeight - finalHeight) / 2);
+				sprite.width = finalWidth;
+				sprite.height = finalHeight;
+				sprite.position.set(posX, posY);
+			} else {
+				sprite.position.set(this.border_region, this.border_region);
+
+				if (this.background_layer) {
+					this.background_layer.destroy();
+				}
+
+				const totalWidth = imageWidth + this.border_region * 2;
+				const totalHeight = imageHeight + this.border_region * 2;
+				const newLayer = this.create_background_layer(totalWidth, totalHeight);
+
+				sprite.width = imageWidth;
+				sprite.height = imageHeight;
+				newLayer.addChild(sprite);
+
+				return newLayer;
+			}
+
+			layer.addChild(sprite);
+
+			return layer;
+		} catch (error) {
+			console.error("Error loading image from URL:", error);
+			return layer;
+		}
+	}
+
+	create_layer({
+		width,
+		height,
+		layer_name,
+		user_created,
+		layer_id = undefined,
+		make_active = false
+	}: {
+		width: number;
+		height: number;
+		layer_name?: string;
+		user_created: boolean;
+		layer_id?: string;
+		make_active?: boolean;
+	}): Container {
+		const layer = new Container();
+		const _layer_id = layer_id || Math.random().toString(36).substring(2, 15);
+		const _layer_name = layer_name || `Layer ${this.layers.length + 1}`;
+
+		this.layers.push({
+			name: _layer_name,
+			id: _layer_id,
+			container: layer,
+			user_created,
+			visible: true
+		});
+
+		this.image_container.addChild(layer);
+
+		const draw_texture = RenderTexture.create({
+			width,
+			height,
+			resolution: window.devicePixelRatio,
+			antialias: true,
+			scaleMode: SCALE_MODES.NEAREST
+		});
+
+		const canvas_sprite = new Sprite(draw_texture);
+		layer.addChild(canvas_sprite);
+
+		const clear_graphics = new Graphics();
+		clear_graphics.clear();
+		clear_graphics.beginFill(0, 0);
+		clear_graphics.drawRect(0, 0, width, height);
+		clear_graphics.endFill();
+
+		this.app.renderer.render({
+			container: clear_graphics,
+			target: draw_texture,
+			clear: true
+		});
+
+		this.draw_textures.set(layer, draw_texture);
+
+		this.update_layer_order();
+		if (make_active) {
+			this.set_active_layer(_layer_id);
+		}
+
+		this.layer_store.set({
+			active_layer: this.active_layer_id || "",
+			layers: this.layers
+		});
+		return layer;
+	}
+
+	/**
+	 * Creates a new layer with an image loaded from a URL
+	 * @param url The URL of the image to load
+	 * @param borderRegion Minimum border region to add around the image for outpainting (in pixels)
+	 * @returns A Promise that resolves to the layer ID
+	 */
+	async add_layer_from_url(url: string): Promise<string> {
+		const { width, height } = this.image_container.getLocalBounds();
+		const layer = this.create_layer({
+			width,
+			height,
+			layer_name: "Layer 1",
+			user_created: true
+		});
+
+		const layerIndex = this.layers.findIndex((l) => l.container === layer);
+		if (layerIndex === -1) {
+			console.error("Could not find newly created layer");
+			return "";
+		}
+		const layerId = this.layers[layerIndex].id;
+
+		try {
+			const texture = await Assets.load(url);
+
+			const drawTexture = this.draw_textures.get(layer);
+			if (!drawTexture) {
+				console.error("No draw texture found for layer");
+				return layerId;
+			}
+
+			const sprite = new Sprite(texture);
+			const imageWidth = sprite.width;
+			const imageHeight = sprite.height;
+
+			let posX = this.border_region;
+			let posY = this.border_region;
+
+			const effectiveWidth = this.fixed_canvas
+				? width - this.border_region * 2
+				: width;
+			const effectiveHeight = this.fixed_canvas
+				? height - this.border_region * 2
+				: height;
+
+			if (imageWidth < effectiveWidth || imageHeight < effectiveHeight) {
+				posX = Math.floor((effectiveWidth - imageWidth) / 2);
+				posY = Math.floor((effectiveHeight - imageHeight) / 2);
+			}
+
+			sprite.position.set(posX, posY);
+
+			if (imageWidth > effectiveWidth || imageHeight > effectiveHeight) {
+				const imageAspectRatio = imageWidth / imageHeight;
+				const areaAspectRatio = effectiveWidth / effectiveHeight;
+
+				let finalWidth, finalHeight;
+
+				if (imageAspectRatio > areaAspectRatio) {
+					finalWidth = effectiveWidth;
+					finalHeight = effectiveWidth / imageAspectRatio;
+				} else {
+					finalHeight = effectiveHeight;
+					finalWidth = effectiveHeight * imageAspectRatio;
+				}
+
+				sprite.width = finalWidth;
+				sprite.height = finalHeight;
+
+				posX =
+					this.border_region + Math.floor((effectiveWidth - finalWidth) / 2);
+				posY =
+					this.border_region + Math.floor((effectiveHeight - finalHeight) / 2);
+				sprite.position.set(posX, posY);
+			}
+
+			this.app.renderer.render(sprite, { renderTexture: drawTexture });
+
+			this.set_active_layer(layerId);
+
+			return layerId;
+		} catch (error) {
+			console.error("Error loading image from URL:", error);
+			return layerId;
+		}
+	}
+
+	get_active_layer(): typeof this.active_layer {
+		return this.active_layer;
+	}
+
+	set_active_layer(id: string): void {
+		if (this.layers.some((l) => l.id === id)) {
+			this.active_layer =
+				this.layers.find((l) => l.id === id)?.container ||
+				this.layers[0]?.container ||
+				null;
+			this.active_layer_id = id;
+			this.layer_store.set({
+				active_layer: id,
+				layers: this.layers
+			});
+		}
+	}
+
+	get_layers(): typeof this.layers {
+		return this.layers;
+	}
+
+	get_layer_textures(id: string): { draw: RenderTexture } | null {
+		const layer = this.layers.find((l) => l.id === id);
+		if (layer) {
+			const draw = this.draw_textures.get(layer.container);
+			if (draw) {
+				return { draw };
+			}
+		}
+		return null;
+	}
+
+	delete_layer(id: string): void {
+		const index = this.layers.findIndex((l) => l.id === id);
+		if (index > -1) {
+			const draw_texture = this.draw_textures.get(this.layers[index].container);
+			if (draw_texture) {
+				draw_texture.destroy();
+				this.draw_textures.delete(this.layers[index].container);
+			}
+			this.layers[index].container.destroy();
+			if (this.active_layer === this.layers[index].container) {
+				const new_active_layer = this.layers[Math.max(0, index - 1)] || null;
+				this.active_layer = new_active_layer?.container || null;
+				this.active_layer_id = new_active_layer?.id || null;
+			}
+			this.layers = this.layers.filter((l) => l.id !== id);
+
+			this.layer_store.update((_layers) => ({
+				active_layer:
+					_layers.active_layer === id
+						? this.layers[this.layers.length - 1]?.id
+						: _layers.active_layer,
+				layers: this.layers
+			}));
+
+			this.update_layer_order();
+		}
+	}
+
+	private update_layer_order(): void {
+		if (this.background_layer) {
+			this.background_layer.zIndex = -1;
+		}
+		this.layers.forEach((layer, index) => {
+			layer.container.zIndex = index;
+		});
+	}
+
+	move_layer(id: string, direction: "up" | "down"): void {
+		const index = this.layers.findIndex((l) => l.id === id);
+		if (index > -1) {
+			const new_index = direction === "up" ? index - 1 : index + 1;
+
+			this.layers = this.layers.map((l, i) => {
+				if (i === index) {
+					return this.layers[new_index];
+				}
+				if (i === new_index) {
+					return this.layers[index];
+				}
+				return l;
+			});
+			this.update_layer_order();
+			this.layer_store.update((_layers) => ({
+				active_layer: id,
+				layers: this.layers
+			}));
+		}
+	}
+
+	/**
+	 * Resizes all layers to a new width and height
+	 * @param newWidth The new width of the layers
+	 * @param newHeight The new height of the layers
+	 * @param scale If true, scales the layer content to fit the new dimensions. If false, keeps the content size unchanged.
+	 * @param anchor The anchor point to position the content relative to the new size
+	 */
+	resize_all_layers(
+		newWidth: number,
+		newHeight: number,
+		scale: boolean,
+		anchor:
+			| "top-left"
+			| "top"
+			| "top-right"
+			| "left"
+			| "center"
+			| "right"
+			| "bottom-left"
+			| "bottom"
+			| "bottom-right",
+		oldCanvasWidth: number,
+		oldCanvasHeight: number
+	): void {
+		const oldLayersById = new Map(this.layers.map((l) => [l.id, l]));
+		const oldBackgroundLayer = this.background_layer;
+
+		const calculateOffset = (): { offsetX: number; offsetY: number } => {
+			let offsetX = 0;
+			let offsetY = 0;
+			const deltaWidth = newWidth - oldCanvasWidth;
+			const deltaHeight = newHeight - oldCanvasHeight;
+
+			if (anchor.includes("left")) {
+				offsetX = 0;
+			} else if (anchor.includes("right")) {
+				offsetX = deltaWidth;
+			} else {
+				offsetX = Math.floor(deltaWidth / 2);
+			}
+
+			if (anchor.includes("top")) {
+				offsetY = 0;
+			} else if (anchor.includes("bottom")) {
+				offsetY = deltaHeight;
+			} else {
+				offsetY = Math.floor(deltaHeight / 2);
+			}
+
+			return { offsetX, offsetY };
+		};
+
+		this.background_layer = this._resize_background_layer(
+			oldBackgroundLayer,
+			newWidth,
+			newHeight,
+			scale,
+			calculateOffset
+		);
+
+		const processedLayers: {
+			name: string;
+			id: string;
+			container: Container;
+			user_created: boolean;
+		}[] = [];
+
+		const oldLayerData = this.layers.map((oldLayer) => ({
+			id: oldLayer.id,
+			name: oldLayer.name,
+			user_created: oldLayer.user_created,
+			texture: this.draw_textures.get(oldLayer.container),
+			container: oldLayer.container
+		}));
+
+		this.layers = [];
+		this.draw_textures.clear();
+		for (const oldData of oldLayerData) {
+			const newLayer = this._resize_single_layer(
+				oldData,
+				newWidth,
+				newHeight,
+				scale,
+				calculateOffset
+			);
+			if (newLayer) {
+				processedLayers.push(newLayer);
+			}
+		}
+
+		const currentActiveId = get(this.layer_store).active_layer;
+		const activeLayerExists = processedLayers.some(
+			(l) => l.id === currentActiveId
+		);
+
+		if (!activeLayerExists && processedLayers.length > 0) {
+			this.set_active_layer(processedLayers[0].id);
+		} else if (processedLayers.length === 0) {
+			this.layer_store.update((s) => ({ ...s, active_layer: "" }));
+		} else {
+			this.layer_store.update((s) => ({ ...s }));
+		}
+
+		this.update_layer_order();
+
+		setTimeout(() => {
+			Assets.cache.reset();
+			this.app.renderer.textureGC.run();
+		}, 100);
+	}
+
+	/**
+	 * Helper method to resize the background layer.
+	 */
+	private _resize_background_layer(
+		oldBackgroundLayer: Container | null,
+		newWidth: number,
+		newHeight: number,
+		scale: boolean,
+		calculateOffset: () => { offsetX: number; offsetY: number }
+	): Container | null {
+		if (!oldBackgroundLayer) {
+			return this.create_background_layer(newWidth, newHeight);
+		}
+
+		let backgroundImage: Sprite | null = oldBackgroundLayer.children.find(
+			(child) =>
+				child instanceof Sprite &&
+				child.texture !== (oldBackgroundLayer.children[0] as Sprite)?.texture
+		) as Sprite | null;
+
+		const newBackgroundLayer = this.create_background_layer(
+			newWidth,
+			newHeight
+		);
+
+		if (backgroundImage) {
+			const newBgImage = new Sprite(backgroundImage.texture);
+			newBgImage.width = backgroundImage.width;
+			newBgImage.height = backgroundImage.height;
+
+			if (scale) {
+				newBgImage.width = newWidth;
+				newBgImage.height = newHeight;
+				newBgImage.position.set(0, 0);
+			} else {
+				const { offsetX, offsetY } = calculateOffset();
+				newBgImage.position.set(
+					backgroundImage.x + offsetX,
+					backgroundImage.y + offsetY
+				);
+			}
+			newBackgroundLayer.addChild(newBgImage);
+		}
+
+		return newBackgroundLayer;
+	}
+
+	/**
+	 * Helper method to resize a single regular layer.
+	 */
+	private _resize_single_layer(
+		oldData: {
+			id: string;
+			name: string;
+			user_created: boolean;
+			texture: RenderTexture | undefined;
+			container: Container;
+		},
+		newWidth: number,
+		newHeight: number,
+		scale: boolean,
+		calculateOffset: () => { offsetX: number; offsetY: number }
+	): {
+		name: string;
+		id: string;
+		container: Container;
+		user_created: boolean;
+	} | null {
+		if (!oldData.texture) {
+			console.warn(
+				`No texture found for layer ${oldData.id}, skipping cleanup.`
+			);
+			if (oldData.container && !oldData.container.destroyed) {
+				if (this.image_container.children.includes(oldData.container)) {
+					this.image_container.removeChild(oldData.container);
+				}
+				oldData.container.destroy({ children: true });
+			}
+			return null;
+		}
+
+		const newContainer = this.create_layer({
+			width: newWidth,
+			height: newHeight,
+			layer_name: oldData.name,
+			user_created: oldData.user_created
+		});
+
+		const newLayer = this.layers[this.layers.length - 1];
+		newLayer.id = oldData.id;
+		const newTexture = this.draw_textures.get(newContainer);
+
+		if (!newTexture) {
+			console.error(
+				`Failed to get texture for newly created layer ${newLayer.id}. Cleaning up.`
+			);
+			if (newContainer && !newContainer.destroyed) {
+				if (this.image_container.children.includes(newContainer)) {
+					this.image_container.removeChild(newContainer);
+				}
+				newContainer.destroy({ children: true });
+				const idx = this.layers.findIndex((l) => l.container === newContainer);
+				if (idx > -1) this.layers.splice(idx, 1);
+				this.draw_textures.delete(newContainer);
+			}
+			if (oldData.texture && !oldData.texture.destroyed)
+				oldData.texture.destroy(true);
+			if (oldData.container && !oldData.container.destroyed)
+				oldData.container.destroy({ children: true });
+			return null;
+		}
+
+		this.app.renderer.clear({ target: newTexture, clearColor: [0, 0, 0, 0] });
+
+		const sprite = new Sprite(oldData.texture);
+
+		if (scale) {
+			sprite.width = newWidth;
+			sprite.height = newHeight;
+			sprite.position.set(0, 0);
+		} else {
+			const { offsetX, offsetY } = calculateOffset();
+			sprite.position.set(offsetX, offsetY);
+		}
+
+		this.app.renderer.render(sprite, { renderTexture: newTexture });
+
+		sprite.destroy();
+		if (oldData.texture && !oldData.texture.destroyed) {
+			oldData.texture.destroy(true);
+		}
+		if (oldData.container && !oldData.container.destroyed) {
+			if (this.image_container.children.includes(oldData.container)) {
+				this.image_container.removeChild(oldData.container);
+			}
+			oldData.container.destroy({ children: true });
+		}
+
+		return newLayer;
+	}
+
+	async get_blobs(width: number, height: number): Promise<ImageBlobs> {
+		const blobs = {
+			background: await get_canvas_blob(
+				this.app.renderer,
+				this.background_layer,
+				{
+					width,
+					height,
+					x: 0,
+					y: 0
+				}
+			),
+			layers: await Promise.all(
+				this.layers.map(async (layer) => {
+					const blob = await get_canvas_blob(
+						this.app.renderer,
+						layer.container,
+						{
+							width,
+							height,
+							x: 0,
+							y: 0
+						}
+					);
+					if (blob) {
+						return blob;
+					}
+					return null;
+				})
+			),
+			composite: await get_canvas_blob(
+				this.app.renderer,
+				this.image_container,
+				{
+					width,
+					height,
+					x: 0,
+					y: 0
+				}
+			)
+		};
+
+		return blobs;
+	}
+
+	reset_layers(width: number, height: number, persist = false): void {
+		const _layers_to_recreate = persist
+			? this.layers.map((layer) => [layer.name, layer.id])
+			: this.layer_options.layers.map((layer) => [layer, undefined]);
+
+		this.layers.forEach((layer) => {
+			this.delete_layer(layer.id);
+		});
+
+		for (const [layer_name, layer_id] of _layers_to_recreate) {
+			this.create_layer({
+				width,
+				height,
+				layer_name: layer_name,
+				user_created: this.layer_options.layers.find((l) => l === layer_name)
+					? false
+					: true,
+				layer_id: layer_id
+			});
+		}
+
+		if (!persist) {
+			this.active_layer = this.layers[0].container;
+			this.active_layer_id = this.layers[0].id;
+		} else {
+			this.active_layer =
+				this.layers.find((l) => l.id === this.active_layer_id)?.container ||
+				this.layers[0]?.container;
+
+			if (!this.active_layer) return;
+		}
+
+		this.layer_store.update((state) => ({
+			active_layer: this.active_layer_id || this.layers[0].id,
+			layers: this.layers
+		}));
+	}
+
+	init_layers(width: number, height: number): void {
+		for (const layer of this.layers) {
+			this.delete_layer(layer.id);
+		}
+		let i = 0;
+		for (const layer of this.layer_options.layers) {
+			this.create_layer({
+				width,
+				height,
+				layer_name: layer,
+				user_created: false,
+				layer_id: `layer-${i}`
+			});
+			i++;
+		}
+
+		this.active_layer = this.layers[0].container;
+		this.active_layer_id = this.layers[0].id;
+		this.layer_store.update((_layers) => ({
+			active_layer: this.layers[0].id,
+			layers: this.layers
+		}));
+	}
+}
+
+/**
+ * Command to add a new layer
+ */
+export class AddLayerCommand implements Command {
+	private layer_id: string;
+	private layer_name: string;
+	private width: number;
+	private height: number;
+	private user_created: boolean;
+	private make_active: boolean;
+	private previous_active_layer: string | null = null;
+	name: string;
+	constructor(
+		private context: ImageEditorContext,
+		options: {
+			width: number;
+			height: number;
+			layer_name?: string;
+			user_created: boolean;
+			layer_id?: string;
+			make_active?: boolean;
+		}
+	) {
+		this.width = options.width;
+		this.height = options.height;
+		this.layer_name =
+			options.layer_name ||
+			`Layer ${this.context.layer_manager.get_layers().length + 1}`;
+		this.user_created = options.user_created;
+		this.layer_id =
+			options.layer_id || Math.random().toString(36).substring(2, 15);
+		this.make_active = options.make_active || false;
+		this.name = "AddLayer";
+		const current_layers = this.context.layer_manager.get_layers();
+		const current_active = current_layers.find(
+			(l) => l.container === this.context.layer_manager.get_active_layer()
+		);
+		this.previous_active_layer = current_active?.id || null;
+	}
+
+	async execute(context?: ImageEditorContext): Promise<void> {
+		if (context) {
+			this.context = context;
+		}
+
+		this.context.layer_manager.create_layer({
+			width: this.width,
+			height: this.height,
+			layer_name: this.layer_name,
+			user_created: this.user_created,
+			layer_id: this.layer_id,
+			make_active: this.make_active
+		});
+	}
+
+	async undo(): Promise<void> {
+		this.context.layer_manager.delete_layer(this.layer_id);
+
+		if (this.previous_active_layer) {
+			this.context.layer_manager.set_active_layer(this.previous_active_layer);
+		}
+	}
+}
+
+/**
+ * Command to remove a layer
+ */
+export class RemoveLayerCommand implements Command {
+	private layer_data: {
+		id: string;
+		name: string;
+		user_created: boolean;
+		visible: boolean;
+		was_active: boolean;
+	};
+	private previous_active_layer: string | null = null;
+	private texture_copy: RenderTexture | null = null;
+	name: string;
+
+	constructor(
+		private context: ImageEditorContext,
+		layer_id: string
+	) {
+		this.name = "RemoveLayer";
+		const layers = this.context.layer_manager.get_layers();
+		const layer_to_remove = layers.find((l) => l.id === layer_id);
+
+		if (!layer_to_remove) {
+			throw new Error(`Layer with ID ${layer_id} not found`);
+		}
+
+		const active_layer = this.context.layer_manager.get_active_layer();
+		const was_active = layer_to_remove.container === active_layer;
+
+		if (was_active) {
+			const layer_index = layers.findIndex((l) => l.id === layer_id);
+			const next_active = layers[Math.max(0, layer_index - 1)];
+			this.previous_active_layer = next_active?.id || null;
+		}
+
+		this.layer_data = {
+			id: layer_to_remove.id,
+			name: layer_to_remove.name,
+			user_created: layer_to_remove.user_created,
+			visible: layer_to_remove.visible,
+			was_active
+		};
+
+		this.captureTextureData(layer_id);
+	}
+
+	/**
+	 * Create a direct copy of the layer's texture
+	 */
+	private captureTextureData(layer_id: string): void {
+		const layer_textures =
+			this.context.layer_manager.get_layer_textures(layer_id);
+		if (!layer_textures) return;
+
+		try {
+			const original_texture = layer_textures.draw;
+
+			const texture_copy = RenderTexture.create({
+				width: original_texture.width,
+				height: original_texture.height,
+				resolution: window.devicePixelRatio || 1
+			});
+
+			const sprite = new Sprite(original_texture);
+
+			this.context.app.renderer.render(sprite, { renderTexture: texture_copy });
+
+			this.texture_copy = texture_copy;
+
+			sprite.destroy();
+		} catch (e) {
+			console.error("Failed to copy layer texture:", e);
+			this.texture_copy = null;
+		}
+	}
+
+	async execute(context?: ImageEditorContext): Promise<void> {
+		if (context) {
+			this.context = context;
+		}
+
+		this.context.layer_manager.delete_layer(this.layer_data.id);
+	}
+
+	async undo(): Promise<void> {
+		const dimensions = get(this.context.dimensions);
+
+		const container = this.context.layer_manager.create_layer({
+			width: dimensions.width,
+			height: dimensions.height,
+			layer_name: this.layer_data.name,
+			user_created: this.layer_data.user_created,
+			layer_id: this.layer_data.id,
+			make_active: this.layer_data.was_active
+		});
+
+		if (this.texture_copy) {
+			try {
+				const layer_textures = this.context.layer_manager.get_layer_textures(
+					this.layer_data.id
+				);
+				if (layer_textures) {
+					const sprite = new Sprite(this.texture_copy);
+
+					this.context.app.renderer.render(sprite, {
+						renderTexture: layer_textures.draw
+					});
+
+					sprite.destroy();
+				}
+			} catch (e) {
+				console.error("Failed to restore layer content:", e);
+			}
+		}
+
+		if (!this.layer_data.visible) {
+			this.context.layer_manager.toggle_layer_visibility(this.layer_data.id);
+		}
+
+		if (!this.layer_data.was_active && this.previous_active_layer) {
+			this.context.layer_manager.set_active_layer(this.previous_active_layer);
+		}
+	}
+
+	/**
+	 * Clean up resources when the command is no longer needed
+	 * This would need to be called by a garbage collection mechanism
+	 */
+	destroy(): void {
+		if (this.texture_copy) {
+			this.texture_copy.destroy();
+			this.texture_copy = null;
+		}
+	}
+}
+
+/**
+ * Command to reorder layers
+ */
+export class ReorderLayerCommand implements Command {
+	private original_order: string[];
+	private new_order: string[];
+	private layer_id: string;
+	private direction: "up" | "down";
+	name: string;
+
+	constructor(
+		private context: ImageEditorContext,
+		layer_id: string,
+		direction: "up" | "down"
+	) {
+		this.layer_id = layer_id;
+		this.direction = direction;
+		this.name = "ReorderLayer";
+		const layers = this.context.layer_manager.get_layers();
+		this.original_order = layers.map((l) => l.id);
+
+		const index = layers.findIndex((l) => l.id === layer_id);
+		if (index === -1) {
+			throw new Error(`Layer with ID ${layer_id} not found`);
+		}
+
+		const new_index = direction === "up" ? index - 1 : index + 1;
+		if (new_index < 0 || new_index >= layers.length) {
+			this.new_order = [...this.original_order];
+		} else {
+			this.new_order = [...this.original_order];
+			[this.new_order[index], this.new_order[new_index]] = [
+				this.new_order[new_index],
+				this.new_order[index]
+			];
+		}
+	}
+
+	async execute(context?: ImageEditorContext): Promise<void> {
+		if (context) {
+			this.context = context;
+		}
+
+		this.context.layer_manager.move_layer(this.layer_id, this.direction);
+	}
+
+	async undo(): Promise<void> {
+		const current_layers = this.context.layer_manager.get_layers();
+
+		if (
+			this.original_order.join(",") ===
+			current_layers.map((l) => l.id).join(",")
+		) {
+			return;
+		}
+
+		const layer_index = current_layers.findIndex((l) => l.id === this.layer_id);
+		if (layer_index === -1) return;
+
+		const original_index = this.original_order.indexOf(this.layer_id);
+		const move_direction = layer_index > original_index ? "up" : "down";
+
+		this.context.layer_manager.move_layer(this.layer_id, move_direction);
+	}
+}

6.0.0-dev.5/imageeditor/shared/crop/crop.ts

@@ -0,0 +1,1027 @@
+import {
+	Container,
+	Graphics,
+	Point,
+	Rectangle,
+	FederatedPointerEvent,
+	Sprite
+} from "pixi.js";
+import { type ImageEditorContext, type Tool } from "../core/editor";
+
+import { type Tool as ToolbarTool, type Subtool } from "../Toolbar.svelte";
+import { get_canvas_blob } from "../utils/pixi";
+
+/**
+ * @interface CropBounds
+ * @description Defines the bounds of a crop area
+ * @property {number} x - The x-coordinate of the crop area
+ * @property {number} y - The y-coordinate of the crop area
+ * @property {number} width - The width of the crop area
+ * @property {number} height - The height of the crop area
+ */
+interface CropBounds {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+/**
+ * @interface EditorState
+ * @description Defines the state of the editor
+ * @property {ToolbarTool} current_tool - The currently selected tool
+ * @property {Subtool} current_subtool - The currently selected subtool
+ */
+interface EditorState {
+	current_tool: ToolbarTool;
+	current_subtool: Subtool;
+}
+
+/**
+ * @class CropTool
+ * @implements {Tool}
+ * @description Implements the crop tool functionality for the image editor
+ */
+export class CropTool implements Tool {
+	name = "crop" as const;
+	private image_editor_context!: ImageEditorContext;
+	current_tool: ToolbarTool = "image";
+	current_subtool: Subtool = "crop";
+
+	// Constants
+	private readonly CORNER_SIZE = 25;
+	private readonly LINE_THICKNESS = 5;
+	private readonly HANDLE_COLOR = 0x000000;
+	private readonly HIT_AREA_SIZE = 40;
+
+	// State
+	private is_dragging = false;
+	private selected_handle: Container | null = null;
+	private active_corner_index = -1;
+	private active_edge_index = -1;
+	private last_pointer_position: Point | null = null;
+	crop_bounds: CropBounds = { x: 0, y: 0, width: 0, height: 0 };
+	private crop_ui_container: Container | null = null;
+	private crop_mask: Graphics | null = null;
+	private dimensions: { width: number; height: number } = {
+		width: 0,
+		height: 0
+	};
+	private position: { x: number; y: number } = { x: 0, y: 0 };
+	private scale = 1;
+	private is_dragging_window = false;
+	private drag_start_position: Point | null = null;
+	private drag_start_bounds: CropBounds | null = null;
+	private background_image_watcher: (() => void) | null = null;
+	private has_been_manually_changed = false;
+	private event_callbacks: Map<string, (() => void)[]> = new Map();
+	/**
+	 * @method setup
+	 * @async
+	 * @description Sets up the crop tool with the given context and state
+	 * @param {ImageEditorContext} context - The image editor context
+	 * @param {ToolbarTool} tool - The current tool
+	 * @param {Subtool} subtool - The current subtool
+	 * @returns {Promise<void>}
+	 */
+	async setup(
+		context: ImageEditorContext,
+		tool: ToolbarTool,
+		subtool: Subtool
+	): Promise<void> {
+		this.image_editor_context = context;
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+
+		context.dimensions.subscribe((dimensions) => {
+			this.dimensions = dimensions;
+
+			// Update crop bounds to match new dimensions
+			this.crop_bounds = {
+				x: 0,
+				y: 0,
+				width: dimensions.width,
+				height: dimensions.height
+			};
+
+			// Force UI update if it exists
+			if (this.crop_ui_container) {
+				this.update_crop_ui();
+			}
+
+			// Always update the mask when dimensions change
+			this.set_crop_mask();
+			this.update_crop_mask();
+		});
+
+		context.position.subscribe((position) => {
+			this.position = position;
+		});
+
+		context.scale.subscribe((scale) => {
+			this.scale = scale;
+		});
+
+		// Setup a background image watcher to ensure we always apply the mask to the current background image
+		this.background_image_watcher = () => {
+			// Only apply when crop tool is active and we have a mask
+			if (
+				this.crop_mask &&
+				this.current_tool === "image" &&
+				this.current_subtool === "crop"
+			) {
+				// Get a fresh reference to the background image and apply the mask
+				if (this.image_editor_context.background_image) {
+					this.image_editor_context.background_image.setMask(this.crop_mask);
+				}
+			}
+		};
+
+		// Add the watcher to the ticker to regularly check for background image changes
+		this.image_editor_context.app.ticker.add(this.background_image_watcher);
+
+		// Initialize crop UI
+		await this.init_crop_ui();
+
+		// Setup event listeners
+		this.setup_event_listeners();
+
+		// Ensure the crop UI visibility matches the current tool state
+		const isCropActive = tool === "image" && subtool === "crop";
+		if (this.crop_ui_container) {
+			this.crop_ui_container.visible = isCropActive;
+		}
+	}
+
+	/**
+	 * @method cleanup
+	 * @description Cleans up the crop tool resources and removes event listeners
+	 * @returns {void}
+	 */
+	cleanup(): void {
+		// Remove the crop UI container
+		if (this.crop_ui_container) {
+			this.image_editor_context.app.stage.removeChild(this.crop_ui_container);
+		}
+
+		// Remove the mask and reset the image container's mask property
+		if (this.crop_mask) {
+			if (this.crop_mask.parent) {
+				this.crop_mask.parent.removeChild(this.crop_mask);
+			}
+
+			// Clear mask from background_image if applied
+			if (
+				this.image_editor_context.background_image &&
+				this.image_editor_context.background_image.mask === this.crop_mask
+			) {
+				this.image_editor_context.background_image.mask = null;
+			}
+
+			// Clear mask from image_container if applied
+			if (this.image_editor_context.image_container.mask === this.crop_mask) {
+				this.image_editor_context.image_container.mask = null;
+			}
+		}
+
+		// Ensure all references to the crop mask are cleared
+		this.crop_mask = null;
+		this.crop_ui_container = null;
+
+		// Remove the background image watcher from the ticker
+		if (this.background_image_watcher) {
+			this.image_editor_context.app.ticker.remove(
+				this.background_image_watcher
+			);
+			this.background_image_watcher = null;
+		}
+
+		// Remove event listeners
+		this.cleanup_event_listeners();
+	}
+
+	/**
+	 * @method set_tool
+	 * @description Sets the current tool and subtool, updating UI visibility
+	 * @param {ToolbarTool} tool - The tool to set
+	 * @param {Subtool} subtool - The subtool to set
+	 * @returns {void}
+	 */
+	set_tool(tool: ToolbarTool, subtool: Subtool): void {
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+
+		// Show/hide crop UI based on tool and subtool
+		const isCropActive = tool === "image" && subtool === "crop";
+
+		// Only update the UI visibility, not the mask
+		if (this.crop_ui_container) {
+			this.crop_ui_container.visible = isCropActive;
+		}
+
+		// If crop tool is active, ensure the mask is up to date
+		if (isCropActive && this.crop_mask) {
+			this.update_crop_mask();
+		}
+	}
+
+	/**
+	 * @method set_crop_mask
+	 * @private
+	 * @description Sets up the crop mask for the image
+	 * @returns {void}
+	 */
+	private set_crop_mask(): void {
+		// Remove any existing mask to avoid duplicates
+		if (this.crop_mask) {
+			if (this.crop_mask.parent) {
+				this.crop_mask.parent.removeChild(this.crop_mask);
+			}
+
+			// Clear mask from image_container if it was applied there
+			if (this.image_editor_context.image_container.mask === this.crop_mask) {
+				this.image_editor_context.image_container.mask = null;
+			}
+
+			// Clear mask from background_image if it was applied there
+			if (
+				this.image_editor_context.background_image &&
+				this.image_editor_context.background_image.mask === this.crop_mask
+			) {
+				this.image_editor_context.background_image.mask = null;
+			}
+		}
+
+		// Create a new mask that will actually be used as an overlay
+		this.crop_mask = new Graphics();
+
+		// Add the mask/overlay to the display list
+		// This time it should be visible since we want to see the semi-transparent overlay
+		this.image_editor_context.image_container.addChild(this.crop_mask);
+	}
+
+	/**
+	 * @method init_crop_ui
+	 * @private
+	 * @async
+	 * @description Initializes the crop UI elements and sets up the update loop
+	 * @returns {Promise<void>}
+	 */
+	private async init_crop_ui(): Promise<void> {
+		// Create crop UI with scaled dimensions
+		const { width, height } =
+			this.image_editor_context.background_image?.getLocalBounds() || {
+				width: false,
+				height: false
+			};
+
+		this.crop_ui_container = this.make_crop_ui(
+			this.dimensions.width * this.scale,
+			this.dimensions.height * this.scale
+		);
+
+		// Position the crop UI container at the image position
+		this.crop_ui_container.position.set(this.position.x, this.position.y);
+
+		// Initially hide the crop UI until explicitly enabled by set_tool
+		this.crop_ui_container.visible = false;
+
+		this.image_editor_context.app.stage.addChild(this.crop_ui_container);
+
+		// Create and apply mask to the image container
+		this.set_crop_mask();
+
+		// Start the update loop for the UI
+		this.image_editor_context.app.ticker.add(this.update_crop_ui.bind(this));
+
+		// Initialize the mask with the current crop bounds
+		this.update_crop_mask();
+	}
+
+	/**
+	 * @method make_crop_ui
+	 * @private
+	 * @description Creates the crop UI with the specified dimensions
+	 * @param {number} width - Width of the crop area
+	 * @param {number} height - Height of the crop area
+	 * @returns {Container} The created crop UI container
+	 */
+	private make_crop_ui(width: number, height: number): Container {
+		const crop_container = new Container();
+		crop_container.eventMode = "static";
+		crop_container.interactiveChildren = true;
+
+		// Create crop outline with hit area for dragging
+		const crop_outline = new Graphics()
+			.rect(0, 0, width, height)
+			.stroke({ width: 1, color: 0x000000, alignment: 0, alpha: 0.5 });
+
+		// Make the outline interactive
+		crop_outline.eventMode = "static";
+		crop_outline.cursor = "move";
+
+		// Set hit area to match the outline's dimensions
+		crop_outline.hitArea = new Rectangle(0, 0, width, height);
+
+		// Add drag handlers to the outline
+		crop_outline.on("pointerdown", this.handle_window_drag_start.bind(this));
+
+		crop_container.addChild(crop_outline);
+
+		// Create corner handles
+		this.create_corner_handles(crop_container, width, height);
+
+		// Create edge handles
+		this.create_edge_handles(crop_container, width, height);
+
+		return crop_container;
+	}
+
+	/**
+	 * @method create_handle
+	 * @private
+	 * @description Creates a handle for the crop UI
+	 * @param {boolean} [is_edge=false] - Whether the handle is an edge handle
+	 * @returns {Container} The created handle container
+	 */
+	private create_handle(is_edge = false): Container {
+		const handle = new Container();
+		handle.eventMode = "static";
+
+		const handle_graphics = new Graphics();
+
+		if (is_edge) {
+			// Create a shorter bar for edge handles (2x instead of 3x)
+			handle_graphics
+				.rect(0, 0, this.CORNER_SIZE * 1.5, this.LINE_THICKNESS)
+				.fill(this.HANDLE_COLOR);
+		} else {
+			// Create L-shaped corner handles
+			handle_graphics
+				.rect(0, 0, this.CORNER_SIZE, this.LINE_THICKNESS)
+				.rect(0, 0, this.LINE_THICKNESS, this.CORNER_SIZE)
+				.fill(this.HANDLE_COLOR);
+		}
+
+		handle.addChild(handle_graphics);
+
+		// Adjust hit area based on handle type
+		const hit_size = is_edge ? this.HIT_AREA_SIZE * 1.5 : this.HIT_AREA_SIZE;
+		handle.hitArea = new Rectangle(
+			-hit_size / 2 + this.LINE_THICKNESS,
+			-hit_size / 2 + this.LINE_THICKNESS,
+			hit_size,
+			hit_size
+		);
+
+		return handle;
+	}
+
+	/**
+	 * @method create_edge_handles
+	 * @private
+	 * @description Creates edge handles for the crop UI
+	 * @param {Container} container - The container to add handles to
+	 * @param {number} width - Width of the crop area
+	 * @param {number} height - Height of the crop area
+	 * @returns {void}
+	 */
+	private create_edge_handles(
+		container: Container,
+		width: number,
+		height: number
+	): void {
+		// Horizontal handles at top and bottom
+		[-1, 1].forEach((i, index) => {
+			const handle = this.create_handle(true); // true for edge handle
+			handle.rotation = 0;
+
+			handle.on("pointerdown", (event: FederatedPointerEvent) => {
+				this.handle_pointer_down(event, handle, -1, index); // 0 for top, 1 for bottom
+			});
+
+			// Center the handle
+			handle.x = width / 2 - (this.CORNER_SIZE * 3) / 2;
+			handle.y = i < 0 ? -this.LINE_THICKNESS : height;
+			handle.cursor = "ns-resize";
+
+			container.addChild(handle);
+		});
+
+		// Vertical handles at left and right
+		[-1, 1].forEach((i, index) => {
+			const handle = this.create_handle(true); // true for edge handle
+			handle.rotation = Math.PI / 2; // Rotate 90 degrees
+
+			handle.on("pointerdown", (event: FederatedPointerEvent) => {
+				this.handle_pointer_down(event, handle, -1, index + 2); // 2 for left, 3 for right
+			});
+
+			// Center the handle
+			handle.x = i < 0 ? -this.LINE_THICKNESS : width;
+			handle.y = height / 2 - (this.CORNER_SIZE * 3) / 2;
+			handle.cursor = "ew-resize";
+
+			container.addChild(handle);
+		});
+	}
+
+	/**
+	 * @method create_corner_handles
+	 * @private
+	 * @description Creates corner handles for the crop UI
+	 * @param {Container} container - The container to add handles to
+	 * @param {number} width - Width of the crop area
+	 * @param {number} height - Height of the crop area
+	 * @returns {void}
+	 */
+	private create_corner_handles(
+		container: Container,
+		width: number,
+		height: number
+	): void {
+		const corners = [
+			{ x: 0, y: 0, xScale: 1, yScale: 1, cursor: "nwse-resize" }, // Top-left
+			{ x: width, y: 0, xScale: -1, yScale: 1, cursor: "nesw-resize" }, // Top-right
+			{ x: 0, y: height, xScale: 1, yScale: -1, cursor: "nesw-resize" }, // Bottom-left
+			{ x: width, y: height, xScale: -1, yScale: -1, cursor: "nwse-resize" } // Bottom-right
+		];
+
+		corners.forEach(({ x, y, xScale, yScale, cursor }, i) => {
+			const corner = this.create_handle(false); // false for corner handle
+			corner.x = x - (xScale < 0 ? -this.LINE_THICKNESS : this.LINE_THICKNESS);
+			corner.y = y - (yScale < 0 ? -this.LINE_THICKNESS : this.LINE_THICKNESS);
+			corner.scale.set(xScale, yScale);
+
+			corner.on("pointerdown", (event: FederatedPointerEvent) => {
+				this.handle_pointer_down(event, corner, i, -1);
+			});
+
+			corner.cursor = cursor;
+
+			container.addChild(corner);
+		});
+	}
+
+	/**
+	 * @method handle_pointer_down
+	 * @private
+	 * @description Handles pointer down events on handles
+	 * @param {FederatedPointerEvent} event - The pointer event
+	 * @param {Container} handle - The handle that was clicked
+	 * @param {number} corner_index - Index of the corner (-1 if not a corner)
+	 * @param {number} edge_index - Index of the edge (-1 if not an edge)
+	 * @returns {void}
+	 */
+	private handle_pointer_down(
+		event: FederatedPointerEvent,
+		handle: Container,
+		corner_index: number,
+		edge_index: number
+	): void {
+		// Only handle crop events if crop tool is active
+		if (this.current_subtool !== "crop") return;
+
+		event.stopPropagation();
+
+		this.is_dragging = true;
+		this.selected_handle = handle;
+		this.active_corner_index = corner_index;
+		this.active_edge_index = edge_index;
+
+		// Convert global position to the container's local coordinates.
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+
+		this.last_pointer_position = new Point(local_pos.x, local_pos.y);
+	}
+
+	/**
+	 * updates the crop bounds based on pointer movement
+	 * @param delta - the change in position
+	 */
+	private update_crop_bounds(delta: Point): void {
+		// Set flag indicating the crop has been manually changed
+		this.has_been_manually_changed = true;
+
+		// Scale the delta to match the image coordinates
+		const scaled_delta = new Point(delta.x, delta.y);
+
+		// Store original values to calculate actual changes
+		const original = {
+			x: this.crop_bounds.x,
+			y: this.crop_bounds.y,
+			width: this.crop_bounds.width,
+			height: this.crop_bounds.height
+		};
+
+		if (this.active_corner_index !== -1) {
+			// Handle corner dragging
+			switch (this.active_corner_index) {
+				case 0: // Top-left
+					// Update width and x position
+					const newWidth0 = Math.max(20, original.width - scaled_delta.x);
+					const widthDiff0 = original.width - newWidth0;
+					this.crop_bounds.width = newWidth0;
+					this.crop_bounds.x = original.x + widthDiff0;
+
+					// Update height and y position
+					const newHeight0 = Math.max(20, original.height - scaled_delta.y);
+					const heightDiff0 = original.height - newHeight0;
+					this.crop_bounds.height = newHeight0;
+					this.crop_bounds.y = original.y + heightDiff0;
+					break;
+
+				case 1: // Top-right
+					// Update width (right side)
+					this.crop_bounds.width = Math.max(
+						20,
+						original.width + scaled_delta.x
+					);
+
+					// Update height and y position (top side)
+					const newHeight1 = Math.max(20, original.height - scaled_delta.y);
+					const heightDiff1 = original.height - newHeight1;
+					this.crop_bounds.height = newHeight1;
+					this.crop_bounds.y = original.y + heightDiff1;
+					break;
+
+				case 2: // Bottom-left
+					// Update width and x position (left side)
+					const newWidth2 = Math.max(20, original.width - scaled_delta.x);
+					const widthDiff2 = original.width - newWidth2;
+					this.crop_bounds.width = newWidth2;
+					this.crop_bounds.x = original.x + widthDiff2;
+
+					// Update height (bottom side)
+					this.crop_bounds.height = Math.max(
+						20,
+						original.height + scaled_delta.y
+					);
+					break;
+
+				case 3: // Bottom-right
+					// Update width (right side)
+					this.crop_bounds.width = Math.max(
+						20,
+						original.width + scaled_delta.x
+					);
+
+					// Update height (bottom side)
+					this.crop_bounds.height = Math.max(
+						20,
+						original.height + scaled_delta.y
+					);
+					break;
+			}
+		} else if (this.active_edge_index !== -1) {
+			// Handle edge dragging
+			switch (this.active_edge_index) {
+				case 0: // Top
+					// Update height and y position
+					const newHeight = Math.max(20, original.height - scaled_delta.y);
+					const heightDiff = original.height - newHeight;
+					this.crop_bounds.height = newHeight;
+					this.crop_bounds.y = original.y + heightDiff;
+					break;
+
+				case 1: // Bottom
+					// Update height only
+					this.crop_bounds.height = Math.max(
+						20,
+						original.height + scaled_delta.y
+					);
+					break;
+
+				case 2: // Left
+					// Update width and x position
+					const newWidth = Math.max(20, original.width - scaled_delta.x);
+					const widthDiff = original.width - newWidth;
+					this.crop_bounds.width = newWidth;
+					this.crop_bounds.x = original.x + widthDiff;
+					break;
+
+				case 3: // Right
+					// Update width only
+					this.crop_bounds.width = Math.max(
+						20,
+						original.width + scaled_delta.x
+					);
+					break;
+			}
+		}
+
+		// Apply constraints
+		this.constrain_crop_bounds();
+
+		// Update the UI and mask
+		this.update_crop_ui();
+		this.update_crop_mask();
+
+		// Make sure to apply mask to the current background image
+		if (this.crop_mask && this.image_editor_context.background_image) {
+			this.image_editor_context.background_image.setMask(this.crop_mask);
+		}
+	}
+
+	/**
+	 * constrains the crop bounds to the image dimensions
+	 */
+	private constrain_crop_bounds(): void {
+		// Store original values
+		const original = {
+			x: this.crop_bounds.x,
+			y: this.crop_bounds.y,
+			width: this.crop_bounds.width,
+			height: this.crop_bounds.height
+		};
+
+		// First, constrain width and height to prevent exceeding image dimensions
+		// and ensure minimum size
+		this.crop_bounds.width = Math.max(
+			20,
+			Math.min(this.crop_bounds.width, this.dimensions.width)
+		);
+
+		this.crop_bounds.height = Math.max(
+			20,
+			Math.min(this.crop_bounds.height, this.dimensions.height)
+		);
+
+		// Then constrain x and y to keep the crop window within the image bounds
+		const oldX = this.crop_bounds.x;
+		this.crop_bounds.x = Math.max(
+			0,
+			Math.min(
+				this.crop_bounds.x,
+				this.dimensions.width - this.crop_bounds.width
+			)
+		);
+
+		// If x position was constrained, adjust width to prevent opposite handle drift
+		if (
+			(this.crop_bounds.x !== oldX && this.active_corner_index === 0) ||
+			this.active_edge_index === 2
+		) {
+			// Left side was constrained, adjust width to compensate
+			const xDiff = this.crop_bounds.x - oldX;
+			this.crop_bounds.width -= xDiff;
+		}
+
+		const oldY = this.crop_bounds.y;
+		this.crop_bounds.y = Math.max(
+			0,
+			Math.min(
+				this.crop_bounds.y,
+				this.dimensions.height - this.crop_bounds.height
+			)
+		);
+
+		// If y position was constrained, adjust height to prevent opposite handle drift
+		if (
+			this.crop_bounds.y !== oldY &&
+			(this.active_corner_index === 0 ||
+				this.active_corner_index === 1 ||
+				this.active_edge_index === 0)
+		) {
+			// Top side was constrained, adjust height to compensate
+			const yDiff = this.crop_bounds.y - oldY;
+			this.crop_bounds.height -= yDiff;
+		}
+
+		// Final check to ensure width and height don't exceed image dimensions from current position
+		this.crop_bounds.width = Math.max(
+			20,
+			Math.min(
+				this.crop_bounds.width,
+				this.dimensions.width - this.crop_bounds.x
+			)
+		);
+
+		this.crop_bounds.height = Math.max(
+			20,
+			Math.min(
+				this.crop_bounds.height,
+				this.dimensions.height - this.crop_bounds.y
+			)
+		);
+	}
+
+	/**
+	 * updates the crop mask graphics
+	 */
+	private update_crop_mask(): void {
+		if (!this.crop_mask) return;
+
+		// Clear the previous mask shape
+		this.crop_mask.clear();
+
+		const { width, height } =
+			this.image_editor_context.background_image?.getLocalBounds() ?? {
+				width: 0,
+				height: 0
+			};
+		this.crop_mask
+			.rect(0, 0, width, height)
+			.fill({ color: 0x000000, alpha: 0.4 })
+			.rect(
+				this.crop_bounds.x,
+				this.crop_bounds.y,
+				this.crop_bounds.width,
+				this.crop_bounds.height
+			)
+			.cut();
+
+		// Reset blend mode
+		// this.crop_mask.blendMode = "normal";
+
+		// Make the mask visible (previously we had alpha=0)
+		// this.crop_mask.alpha = 1;
+
+		// Since we're not using this as a mask anymore, but as an overlay,
+		// we should remove any existing mask assignment
+		if (this.image_editor_context.background_image) {
+			this.image_editor_context.background_image.mask = null;
+		}
+
+		// Make sure the mask is not applied to the image container
+		if (this.image_editor_context.image_container.mask === this.crop_mask) {
+			this.image_editor_context.image_container.mask = null;
+		}
+	}
+
+	/**
+	 * updates the crop ui position and dimensions
+	 */
+	private update_crop_ui(): void {
+		if (!this.crop_mask || !this.crop_ui_container) return;
+
+		// Move crop_ui_container so that (0,0) of its local space aligns with the crop_bounds on the stage
+		this.crop_ui_container.position.set(
+			this.position.x + this.crop_bounds.x * this.scale,
+			this.position.y + this.crop_bounds.y * this.scale
+		);
+
+		// Get the scaled dimensions
+		const scaled_width = this.crop_bounds.width * this.scale;
+		const scaled_height = this.crop_bounds.height * this.scale;
+
+		// Redraw the outline so it matches the crop_bounds size
+		const outline = this.crop_ui_container.getChildAt(0) as Graphics;
+		outline
+			.clear()
+			.rect(0, 0, scaled_width, scaled_height)
+			.stroke({ width: 1, color: 0x000000, alignment: 0, alpha: 0.5 });
+
+		// Update the hit area to match the new dimensions
+		outline.hitArea = new Rectangle(0, 0, scaled_width, scaled_height);
+
+		// Update handle positions to reflect the cropped area, not the full image
+		this.update_handle_positions(scaled_width, scaled_height);
+	}
+
+	/**
+	 * updates the positions of all handles
+	 * @param width - width of the crop area
+	 * @param height - height of the crop area
+	 */
+	private update_handle_positions(width: number, height: number): void {
+		if (!this.crop_ui_container) return;
+
+		// Skip the outline (index 0), get corner/edge handles
+		const handles = this.crop_ui_container.children.slice(1);
+
+		// First 4 are corners
+		const corners = handles.slice(0, 4);
+		const cornerPositions = [
+			{ x: 0, y: 0 }, // Top-left
+			{ x: width, y: 0 }, // Top-right
+			{ x: 0, y: height }, // Bottom-left
+			{ x: width, y: height } // Bottom-right
+		];
+
+		corners.forEach((handle, i) => {
+			const xScale = i % 2 === 0 ? 1 : -1;
+			const yScale = i < 2 ? 1 : -1;
+			handle.position.set(
+				cornerPositions[i].x -
+					(xScale < 0 ? -this.LINE_THICKNESS : this.LINE_THICKNESS),
+				cornerPositions[i].y -
+					(yScale < 0 ? -this.LINE_THICKNESS : this.LINE_THICKNESS)
+			);
+		});
+
+		// Remaining 4 are edges
+		const edges = handles.slice(4);
+		edges.forEach((handle, i) => {
+			if (i < 2) {
+				// Top/Bottom edges
+				handle.position.set(
+					width / 2 - (this.CORNER_SIZE * 1.5) / 2, // Changed from 3 to 2
+					i === 0 ? -this.LINE_THICKNESS : height
+				);
+			} else {
+				// Left/Right edges
+				handle.position.set(
+					i === 2 ? 0 : width + this.LINE_THICKNESS,
+					height / 2 - (this.CORNER_SIZE * 1.5) / 2 // Changed from 3 to 2
+				);
+			}
+		});
+	}
+
+	/**
+	 * sets up event listeners for the crop tool
+	 */
+	private setup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+		stage.eventMode = "static";
+		stage.on("pointermove", this.handle_pointer_move.bind(this));
+		stage.on("pointerup", this.handle_pointer_up.bind(this));
+		stage.on("pointerupoutside", this.handle_pointer_up.bind(this));
+	}
+
+	/**
+	 * removes event listeners for the crop tool
+	 */
+	private cleanup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+
+		stage.off("pointermove", this.handle_pointer_move.bind(this));
+		stage.off("pointerup", this.handle_pointer_up.bind(this));
+		stage.off("pointerupoutside", this.handle_pointer_up.bind(this));
+	}
+
+	/**
+	 * handles pointer move events
+	 * @param event - the pointer event
+	 */
+	private handle_pointer_move(event: FederatedPointerEvent): void {
+		if (this.current_subtool !== "crop") return;
+
+		if (
+			this.is_dragging_window &&
+			this.drag_start_position &&
+			this.drag_start_bounds
+		) {
+			// Handle window dragging
+			const local_pos = this.image_editor_context.image_container.toLocal(
+				event.global
+			);
+			const delta = new Point(
+				local_pos.x - this.drag_start_position.x,
+				local_pos.y - this.drag_start_position.y
+			);
+
+			// Update crop bounds based on drag
+			this.crop_bounds = {
+				x: this.drag_start_bounds.x + delta.x,
+				y: this.drag_start_bounds.y + delta.y,
+				width: this.drag_start_bounds.width,
+				height: this.drag_start_bounds.height
+			};
+
+			// Constrain the bounds
+			this.constrain_crop_bounds();
+
+			// Update the mask
+			this.update_crop_mask();
+
+			// Make sure to apply mask to the current background image
+			if (this.crop_mask && this.image_editor_context.background_image) {
+				this.image_editor_context.background_image.setMask(this.crop_mask);
+			}
+
+			return;
+		}
+
+		// Handle existing resize logic
+		if (
+			this.is_dragging &&
+			this.selected_handle &&
+			this.last_pointer_position
+		) {
+			// Convert from global to local, no extra divide
+			const local_pos = this.image_editor_context.image_container.toLocal(
+				event.global
+			);
+			const current_position = new Point(local_pos.x, local_pos.y);
+
+			const delta = new Point(
+				current_position.x - this.last_pointer_position.x,
+				current_position.y - this.last_pointer_position.y
+			);
+
+			this.update_crop_bounds(delta);
+			this.last_pointer_position = current_position;
+			this.update_crop_mask();
+		}
+	}
+
+	/**
+	 * handles pointer up events
+	 */
+	private handle_pointer_up(): void {
+		if (this.current_subtool !== "crop") return;
+
+		this.is_dragging = false;
+		this.is_dragging_window = false;
+		this.selected_handle = null;
+		this.last_pointer_position = null;
+		this.drag_start_position = null;
+		this.drag_start_bounds = null;
+		this.active_corner_index = -1;
+		this.active_edge_index = -1;
+
+		this.notify("change");
+	}
+
+	/**
+	 * handles the start of window dragging
+	 * @param event - the pointer event
+	 */
+	private handle_window_drag_start(event: FederatedPointerEvent): void {
+		if (this.current_subtool !== "crop") return;
+		event.stopPropagation();
+
+		this.is_dragging_window = true;
+		// Set flag indicating the crop has been manually changed
+		this.has_been_manually_changed = true;
+
+		// Store the initial position and bounds
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+		this.drag_start_position = new Point(local_pos.x, local_pos.y);
+		this.drag_start_bounds = { ...this.crop_bounds };
+	}
+
+	/**
+	 * @returns whether the crop has been manually changed by the user
+	 */
+	public get crop_manually_changed(): boolean {
+		return this.has_been_manually_changed;
+	}
+
+	on<T extends string>(event: T, callback: () => void): void {
+		this.event_callbacks.set(event, [
+			...(this.event_callbacks.get(event) || []),
+			callback
+		]);
+	}
+
+	off<T extends string>(event: T, callback: () => void): void {
+		this.event_callbacks.set(
+			event,
+			this.event_callbacks.get(event)?.filter((cb) => cb !== callback) || []
+		);
+	}
+
+	private notify<T extends string>(event: T): void {
+		for (const callback of this.event_callbacks.get(event) || []) {
+			callback();
+		}
+	}
+
+	public get_crop_bounds(): {
+		x: number;
+		y: number;
+		crop_dimensions: { width: number; height: number };
+		image_dimensions: { width: number; height: number };
+	} {
+		const { width, height } =
+			this.image_editor_context.background_image?.getLocalBounds() ?? {
+				width: 0,
+				height: 0
+			};
+		return {
+			x: this.crop_bounds.x,
+			y: this.crop_bounds.y,
+			crop_dimensions: {
+				width: this.crop_bounds.width,
+				height: this.crop_bounds.height
+			},
+			image_dimensions: {
+				width,
+				height
+			}
+		};
+	}
+
+	public get_image(): Promise<Blob | null> {
+		if (!this.image_editor_context.background_image)
+			return Promise.resolve(null);
+		const container = new Container();
+		const sprite = new Sprite(
+			this.image_editor_context.background_image.texture
+		);
+		container.addChild(sprite);
+
+		return get_canvas_blob(
+			this.image_editor_context.app.renderer,
+			container,
+			this.crop_bounds
+		);
+	}
+}

6.0.0-dev.5/imageeditor/shared/image/image.ts

@@ -0,0 +1,420 @@
+import {
+	Container,
+	Graphics,
+	Color,
+	type ColorSource,
+	RenderTexture,
+	Sprite,
+	type Renderer,
+	Texture
+} from "pixi.js";
+import { type ImageEditorContext, type Tool } from "../core/editor";
+import { type Tool as ToolbarTool, type Subtool } from "../Toolbar.svelte";
+import { type Command } from "../core/commands";
+import { make_graphics } from "../utils/pixi";
+import { get } from "svelte/store";
+
+/**
+ * Handles adding images to the editor
+ * Only a single image can be added at a time
+ * Adding an image removes the current image is one exists
+ */
+export class ImageTool implements Tool {
+	name = "image";
+	context!: ImageEditorContext;
+	current_tool!: ToolbarTool;
+	current_subtool!: Subtool;
+	async setup(
+		context: ImageEditorContext,
+		tool: ToolbarTool,
+		subtool: Subtool
+	): Promise<void> {
+		this.context = context;
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+	}
+
+	cleanup(): void {}
+
+	async add_image({
+		image,
+		fixed_canvas,
+		border_region = 0
+	}: {
+		image: Blob | File | Texture;
+		fixed_canvas: boolean;
+		border_region?: number;
+	}): Promise<void> {
+		const image_command = new AddImageCommand(
+			this.context,
+			image,
+			fixed_canvas,
+			border_region
+		);
+
+		await this.context.execute_command(image_command);
+	}
+
+	set_tool(tool: ToolbarTool, subtool: Subtool): void {
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+	}
+}
+
+interface BgImageCommand extends Command {
+	/**
+	 * Initial setup for the bg command
+	 * @returns
+	 */
+	start: () => Promise<void>;
+}
+
+export class AddImageCommand implements BgImageCommand {
+	sprite: Sprite | null = null;
+	fixed_canvas: boolean;
+	context: ImageEditorContext;
+	background: Blob | File | Texture;
+	current_canvas_size: { width: number; height: number };
+	computed_dimensions: { width: number; height: number };
+	current_scale: number;
+	current_position: { x: number; y: number };
+	border_region: number;
+
+	scaled_width!: number;
+	scaled_height!: number;
+
+	private previous_image: {
+		texture: Texture;
+		width: number;
+		height: number;
+		x: number;
+		y: number;
+		border_region: number;
+	} | null = null;
+	name: string;
+
+	constructor(
+		context: ImageEditorContext,
+		background: Blob | File | Texture,
+		fixed_canvas: boolean,
+		border_region = 0
+	) {
+		this.name = "AddImage";
+		this.context = context;
+		this.background = background;
+		this.fixed_canvas = fixed_canvas;
+		this.border_region = border_region;
+		this.current_canvas_size = get(this.context.dimensions);
+		this.current_scale = get(this.context.scale);
+		this.current_position = get(this.context.position);
+
+		this.computed_dimensions = { width: 0, height: 0 };
+
+		if (
+			this.context.background_image &&
+			this.context.background_image.texture
+		) {
+			const bg = this.context.background_image;
+			const stored_border_region = (bg as any).borderRegion || 0;
+
+			this.previous_image = {
+				texture: this.clone_texture(bg.texture),
+				width: bg.width,
+				height: bg.height,
+				x: bg.position.x,
+				y: bg.position.y,
+				border_region: stored_border_region
+			};
+		}
+	}
+
+	/**
+	 * Creates a copy of a texture to avoid reference issues
+	 */
+	private clone_texture(texture: Texture): Texture {
+		const render_texture = RenderTexture.create({
+			width: texture.width,
+			height: texture.height,
+			resolution: window.devicePixelRatio || 1
+		});
+
+		const sprite = new Sprite(texture);
+		const container = new Container();
+		container.addChild(sprite);
+
+		this.context.app.renderer.render(container, {
+			renderTexture: render_texture
+		});
+
+		container.destroy({ children: true });
+		return render_texture;
+	}
+
+	async start(): Promise<void> {
+		let image_texture: Texture;
+		if (this.background instanceof Texture) {
+			image_texture = this.background;
+		} else {
+			const img = await createImageBitmap(this.background);
+			image_texture = Texture.from(img);
+		}
+
+		this.sprite = new Sprite(image_texture);
+
+		const [width, height] = this.handle_image();
+		this.computed_dimensions = { width, height };
+	}
+
+	private handle_image(): [number, number] {
+		if (this.sprite === null) {
+			return [0, 0];
+		}
+		if (this.fixed_canvas) {
+			const effectiveCanvasWidth = Math.max(
+				this.current_canvas_size.width - this.border_region * 2,
+				10
+			);
+			const effectiveCanvasHeight = Math.max(
+				this.current_canvas_size.height - this.border_region * 2,
+				10
+			);
+
+			const { width, height, x, y } = fit_image_to_canvas(
+				this.sprite.width,
+				this.sprite.height,
+				effectiveCanvasWidth,
+				effectiveCanvasHeight
+			);
+
+			this.sprite.width = width;
+			this.sprite.height = height;
+
+			this.sprite.x = x + this.border_region;
+			this.sprite.y = y + this.border_region;
+		} else {
+			const width = this.sprite.width;
+			const height = this.sprite.height;
+
+			this.sprite.x = this.border_region;
+			this.sprite.y = this.border_region;
+
+			return [width + this.border_region * 2, height + this.border_region * 2];
+		}
+
+		return [this.current_canvas_size.width, this.current_canvas_size.height];
+	}
+
+	async execute(context?: ImageEditorContext): Promise<void> {
+		if (context) {
+			this.context = context;
+		}
+
+		await this.start();
+
+		if (this.sprite === null) {
+			return;
+		}
+
+		const { width, height } = this.computed_dimensions;
+
+		await this.context.set_image_properties({
+			scale: 1,
+			position: {
+				x: this.context.app.screen.width / 2,
+				y: this.context.app.screen.height / 2
+			},
+			width: this.fixed_canvas ? this.current_canvas_size.width : width,
+			height: this.fixed_canvas ? this.current_canvas_size.height : height
+		});
+
+		const background_layer = this.context.layer_manager.create_background_layer(
+			this.fixed_canvas ? this.current_canvas_size.width : width,
+			this.fixed_canvas ? this.current_canvas_size.height : height
+		);
+		this.sprite.zIndex = 0;
+		background_layer.addChild(this.sprite);
+
+		this.context.layer_manager.reset_layers(
+			this.fixed_canvas ? this.current_canvas_size.width : width,
+			this.fixed_canvas ? this.current_canvas_size.height : height,
+			true
+		);
+
+		if (this.border_region > 0) {
+			(this.sprite as any).borderRegion = this.border_region;
+		}
+
+		this.context.set_background_image(this.sprite);
+
+		this.context.reset();
+	}
+
+	async undo(): Promise<void> {
+		if (this.sprite) {
+			this.sprite.destroy();
+
+			if (this.previous_image) {
+				const previous_sprite = new Sprite(this.previous_image.texture);
+				previous_sprite.width = this.previous_image.width;
+				previous_sprite.height = this.previous_image.height;
+				previous_sprite.position.set(
+					this.previous_image.x,
+					this.previous_image.y
+				);
+
+				if (this.previous_image.border_region > 0) {
+					(previous_sprite as any).borderRegion =
+						this.previous_image.border_region;
+				}
+
+				await this.context.set_image_properties({
+					scale: 1,
+					position: {
+						x: this.context.app.screen.width / 2,
+						y: this.context.app.screen.height / 2
+					},
+					width: this.previous_image.width,
+					height: this.previous_image.height
+				});
+
+				const background_layer =
+					this.context.layer_manager.create_background_layer(
+						this.previous_image.width,
+						this.previous_image.height
+					);
+
+				previous_sprite.zIndex = 0;
+				background_layer.addChild(previous_sprite);
+
+				this.context.layer_manager.reset_layers(
+					this.previous_image.width,
+					this.previous_image.height,
+					true
+				);
+
+				this.context.set_background_image(previous_sprite);
+			} else {
+				await this.context.set_image_properties({
+					scale: 1,
+					position: {
+						x: this.context.app.screen.width / 2,
+						y: this.context.app.screen.height / 2
+					},
+					width: this.current_canvas_size.width,
+					height: this.current_canvas_size.height
+				});
+
+				this.context.layer_manager.create_background_layer(
+					this.current_canvas_size.width,
+					this.current_canvas_size.height
+				);
+
+				this.context.layer_manager.reset_layers(
+					this.current_canvas_size.width,
+					this.current_canvas_size.height
+				);
+			}
+
+			this.context.reset();
+		}
+	}
+}
+
+/**
+ * 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: Renderer,
+	color: ColorSource,
+	width: number,
+	height: number,
+	resize: (width: number, height: number) => void
+): BgColorCommand {
+	let sprite: Sprite;
+	return {
+		name: "AddBgColor",
+		start() {
+			container.removeChildren();
+			const graphics = make_graphics(1);
+			const texture = RenderTexture.create({
+				width,
+				height
+			});
+
+			renderer.render(graphics, { renderTexture: texture });
+			sprite = new Sprite(texture);
+			return [sprite.width, sprite.height];
+		},
+		async execute() {
+			resize(sprite.width, sprite.height);
+			sprite.zIndex = 1;
+			container.addChild(sprite);
+		},
+		undo() {
+			container.removeChildren();
+		}
+	};
+}
+
+/**
+ * Calculates new dimensions and position for an image to fit within a canvas while maintaining aspect ratio
+ * @param image_width Original width of the image
+ * @param image_height Original height of the image
+ * @param canvas_width Width of the canvas
+ * @param canvas_height Height of the canvas
+ * @returns Object containing new dimensions and position
+ */
+export function fit_image_to_canvas(
+	image_width: number,
+	image_height: number,
+	canvas_width: number,
+	canvas_height: number
+): {
+	width: number;
+	height: number;
+	x: number;
+	y: number;
+} {
+	const image_aspect_ratio = image_width / image_height;
+	const canvas_aspect_ratio = canvas_width / canvas_height;
+
+	let new_width: number;
+	let new_height: number;
+
+	if (image_aspect_ratio > canvas_aspect_ratio) {
+		new_width = canvas_width;
+		new_height = canvas_width / image_aspect_ratio;
+	} else {
+		new_height = canvas_height;
+		new_width = canvas_height * image_aspect_ratio;
+	}
+
+	const x = Math.round((canvas_width - new_width) / 2);
+	const y = Math.round((canvas_height - new_height) / 2);
+
+	return {
+		width: Math.round(new_width),
+		height: Math.round(new_height),
+		x,
+		y
+	};
+}

6.0.0-dev.5/imageeditor/shared/resize/resize.ts

@@ -0,0 +1,1759 @@
+import {
+	Container,
+	Graphics,
+	Point,
+	Rectangle,
+	FederatedPointerEvent,
+	type FederatedOptions
+} from "pixi.js";
+import { type ImageEditorContext, type Tool } from "../core/editor";
+import { type Tool as ToolbarTool, type Subtool } from "../Toolbar.svelte";
+import { type Command } from "../core/commands";
+
+/**
+ * Command that handles resizing the image and supports undo/redo
+ */
+export class ResizeCommand implements Command {
+	private original_width: number;
+	private original_height: number;
+	private original_x: number;
+	private original_y: number;
+
+	private new_width: number;
+	private new_height: number;
+	private new_x: number;
+	private new_y: number;
+	private reset_ui: () => void;
+	name: string;
+
+	constructor(
+		private context: ImageEditorContext,
+		original_state: { width: number; height: number; x: number; y: number },
+		new_state: { width: number; height: number; x: number; y: number },
+		reset_ui: () => void
+	) {
+		this.name = "Resize";
+		this.original_width = original_state.width;
+		this.original_height = original_state.height;
+		this.original_x = original_state.x;
+		this.original_y = original_state.y;
+
+		this.new_width = new_state.width;
+		this.new_height = new_state.height;
+		this.new_x = new_state.x;
+		this.new_y = new_state.y;
+		this.reset_ui = reset_ui;
+	}
+
+	async execute(context?: ImageEditorContext): Promise<void> {
+		if (context) {
+			this.context = context;
+		}
+
+		if (!this.context.background_image) return;
+
+		this.context.background_image.width = this.new_width;
+		this.context.background_image.height = this.new_height;
+		this.context.background_image.position.set(this.new_x, this.new_y);
+
+		this.reset_ui();
+	}
+
+	async undo(): Promise<void> {
+		if (!this.context.background_image) return;
+
+		this.context.background_image.width = this.original_width;
+		this.context.background_image.height = this.original_height;
+		this.context.background_image.position.set(
+			this.original_x,
+			this.original_y
+		);
+
+		this.reset_ui();
+	}
+}
+
+/**
+ * @class ResizeTool
+ * @implements {Tool}
+ * @description Implements the resize tool functionality for the image editor
+ */
+export class ResizeTool implements Tool {
+	name = "resize" as const;
+	private image_editor_context!: ImageEditorContext;
+	current_tool: ToolbarTool = "image";
+	current_subtool: Subtool = "size";
+	private current_cursor: FederatedOptions["cursor"] = "unset";
+	private readonly CORNER_SIZE = 25;
+	private readonly LINE_THICKNESS = 5;
+	private readonly HANDLE_COLOR = 0x000000;
+	private readonly HIT_AREA_SIZE = 40;
+	private borderRegion = 0;
+
+	private is_dragging = false;
+	private selected_handle: Container | null = null;
+	private active_corner_index = -1;
+	private active_edge_index = -1;
+	private last_pointer_position: Point | null = null;
+	private resize_ui_container: Container | null = null;
+	private dimensions: { width: number; height: number } = {
+		width: 0,
+		height: 0
+	};
+	private position: { x: number; y: number } = { x: 0, y: 0 };
+	private scale = 1;
+	private is_moving = false;
+	private dom_mousedown_handler: ((e: MouseEvent) => void) | null = null;
+	private dom_mousemove_handler: ((e: MouseEvent) => void) | null = null;
+	private dom_mouseup_handler: ((e: MouseEvent) => void) | null = null;
+	private event_callbacks: Map<string, (() => void)[]> = new Map();
+	private last_scale = 1;
+
+	private original_state: {
+		width: number;
+		height: number;
+		x: number;
+		y: number;
+	} | null = null;
+
+	/**
+	 * @method setup
+	 * @async
+	 * @description Sets up the resize tool with the given context and tool/subtool
+	 * @param {ImageEditorContext} context - The image editor context
+	 * @param {ToolbarTool} tool - The current tool
+	 * @param {Subtool} subtool - The current subtool
+	 * @returns {Promise<void>}
+	 */
+	async setup(
+		context: ImageEditorContext,
+		tool: ToolbarTool,
+		subtool: Subtool
+	): Promise<void> {
+		this.image_editor_context = context;
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+
+		if (context.background_image) {
+			if ((context.background_image as any).borderRegion !== undefined) {
+				this.borderRegion = (context.background_image as any).borderRegion;
+			} else {
+				const bg = context.background_image;
+				const container = context.image_container;
+
+				const isHorizontallyCentered =
+					Math.abs(bg.position.x - (container.width - bg.width) / 2) < 2;
+				const isVerticallyCentered =
+					Math.abs(bg.position.y - (container.height - bg.height) / 2) < 2;
+
+				if (!isHorizontallyCentered || !isVerticallyCentered) {
+					this.borderRegion = Math.max(bg.position.x, bg.position.y);
+
+					(context.background_image as any).borderRegion = this.borderRegion;
+				}
+			}
+		}
+
+		context.dimensions.subscribe((dimensions) => {
+			this.dimensions = dimensions;
+			if (this.resize_ui_container) {
+				this.update_resize_ui();
+			}
+		});
+
+		context.position.subscribe((position) => {
+			this.position = position;
+			if (
+				this.resize_ui_container &&
+				this.current_tool === "image" &&
+				this.current_subtool === "size"
+			) {
+				this.update_resize_ui();
+			}
+		});
+
+		context.scale.subscribe((scale) => {
+			this.scale = scale;
+			if (
+				this.resize_ui_container &&
+				this.current_tool === "image" &&
+				this.current_subtool === "size"
+			) {
+				this.update_resize_ui();
+			}
+		});
+
+		await this.init_resize_ui();
+		this.setup_event_listeners();
+
+		if (
+			this.current_subtool === "size" &&
+			this.image_editor_context.background_image
+		) {
+			const bg = this.image_editor_context.background_image;
+			const container = this.image_editor_context.image_container;
+
+			const bg_width = bg.width;
+			const bg_height = bg.height;
+			const container_bounds = container.getLocalBounds();
+			const container_width = container_bounds.width;
+			const container_height = container_bounds.height;
+
+			const min_x = -(bg_width - container_width);
+			const min_y = -(bg_height - container_height);
+			const max_x = 0;
+			const max_y = 0;
+
+			const x_out_of_bounds =
+				bg_width > container_width &&
+				(bg.position.x < min_x || bg.position.x > max_x);
+			const y_out_of_bounds =
+				bg_height > container_height &&
+				(bg.position.y < min_y || bg.position.y > max_y);
+
+			if (x_out_of_bounds || y_out_of_bounds) {
+				this.apply_boundary_constraints();
+			}
+		}
+	}
+
+	/**
+	 * @method cleanup
+	 * @description Cleans up the resize tool resources and removes event listeners
+	 * @returns {void}
+	 */
+	cleanup(): void {
+		if (this.resize_ui_container) {
+			this.image_editor_context.app.stage.removeChild(this.resize_ui_container);
+		}
+		this.cleanup_event_listeners();
+	}
+
+	/**
+	 * @method set_tool
+	 * @description Sets the current tool and subtool, updating UI visibility
+	 * @param {ToolbarTool} tool - The tool to set
+	 * @param {Subtool} subtool - The subtool to set
+	 * @returns {void}
+	 */
+	set_tool(tool: ToolbarTool, subtool: Subtool): void {
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+
+		if (tool === "image" && subtool === "size") {
+			if (this.image_editor_context.background_image) {
+				const storedBorderRegion = (
+					this.image_editor_context.background_image as any
+				).borderRegion;
+				if (typeof storedBorderRegion === "number" && storedBorderRegion > 0) {
+					this.borderRegion = storedBorderRegion;
+				}
+			}
+
+			this.show_resize_ui();
+
+			if (this.image_editor_context.background_image) {
+				const bg = this.image_editor_context.background_image;
+				const container = this.image_editor_context.image_container;
+
+				const bg_width = bg.width;
+				const bg_height = bg.height;
+				const container_bounds = container.getLocalBounds();
+				const container_width = container_bounds.width;
+				const container_height = container_bounds.height;
+
+				const effectiveWidth = container_width - this.borderRegion * 2;
+				const effectiveHeight = container_height - this.borderRegion * 2;
+
+				const min_x =
+					bg_width > effectiveWidth
+						? -(bg_width - effectiveWidth) + this.borderRegion
+						: this.borderRegion;
+				const max_x =
+					bg_width > effectiveWidth
+						? this.borderRegion
+						: container_width - bg_width - this.borderRegion;
+
+				const min_y =
+					bg_height > effectiveHeight
+						? -(bg_height - effectiveHeight) + this.borderRegion
+						: this.borderRegion;
+				const max_y =
+					bg_height > effectiveHeight
+						? this.borderRegion
+						: container_height - bg_height - this.borderRegion;
+
+				const x_out_of_bounds = bg.position.x < min_x || bg.position.x > max_x;
+				const y_out_of_bounds = bg.position.y < min_y || bg.position.y > max_y;
+
+				if (x_out_of_bounds || y_out_of_bounds) {
+					this.apply_boundary_constraints();
+				}
+			}
+		} else {
+			this.hide_resize_ui();
+		}
+	}
+
+	/**
+	 * @method init_resize_ui
+	 * @private
+	 * @async
+	 * @description Initializes the resize UI elements and sets up the update loop
+	 * @returns {Promise<void>}
+	 */
+	private async init_resize_ui(): Promise<void> {
+		this.resize_ui_container = this.make_resize_ui(
+			this.dimensions.width * this.scale,
+			this.dimensions.height * this.scale
+		);
+
+		this.resize_ui_container.position.set(this.position.x, this.position.y);
+
+		this.resize_ui_container.visible = false;
+
+		this.image_editor_context.app.stage.addChild(this.resize_ui_container);
+	}
+
+	/**
+	 * @method make_resize_ui
+	 * @private
+	 * @description Creates the resize UI with the specified dimensions
+	 * @param {number} width - Width of the resize area
+	 * @param {number} height - Height of the resize area
+	 * @returns {Container} The created resize UI container
+	 */
+	private make_resize_ui(width: number, height: number): Container {
+		const resize_container = new Container();
+		resize_container.eventMode = "static";
+		resize_container.interactiveChildren = true;
+
+		const outline = new Graphics().rect(0, 0, width, height).stroke({
+			width: 1,
+			color: 0x000000,
+			alignment: 0,
+			alpha: 0.3
+		});
+
+		const dotted_outline = new Graphics();
+
+		dotted_outline.rect(0, 0, width, height).stroke({
+			width: 1,
+			color: 0x000000,
+			alpha: 0.7,
+			pixelLine: true
+		});
+
+		const dash_length = 5;
+		const gap_length = 5;
+		const total_length = dash_length + gap_length;
+
+		for (let x = 0; x < width; x += total_length * 2) {
+			dotted_outline
+				.rect(x, 0, Math.min(dash_length, width - x), 1)
+				.fill(0x000000);
+
+			dotted_outline
+				.rect(x, height - 1, Math.min(dash_length, width - x), 1)
+				.fill(0x000000);
+		}
+
+		for (let y = 0; y < height; y += total_length * 2) {
+			dotted_outline
+				.rect(0, y, 1, Math.min(dash_length, height - y))
+				.fill(0x000000);
+
+			dotted_outline
+				.rect(width - 1, y, 1, Math.min(dash_length, height - y))
+				.fill(0x000000);
+		}
+
+		resize_container.addChild(outline);
+		resize_container.addChild(dotted_outline);
+
+		const move_area = new Graphics()
+			.rect(0, 0, width, height)
+			.fill(0xffffff, 0);
+		move_area.eventMode = "static";
+		move_area.cursor = "move";
+		resize_container.addChild(move_area);
+
+		this.create_corner_handles(resize_container, width, height);
+		this.create_edge_handles(resize_container, width, height);
+
+		return resize_container;
+	}
+
+	/**
+	 * @method create_handle
+	 * @private
+	 * @description Creates a handle for the resize UI
+	 * @param {boolean} [is_edge=false] - Whether the handle is an edge handle
+	 * @returns {Container} The created handle container
+	 */
+	private create_handle(is_edge = false): Container {
+		const handle = new Container();
+		handle.eventMode = "static";
+		handle.cursor = "pointer";
+
+		const handle_graphics = new Graphics();
+		const handle_size = is_edge ? 8 : 10;
+		handle_graphics
+			.rect(-handle_size / 2, -handle_size / 2, handle_size, handle_size)
+			.fill(0xffffff)
+			.stroke({ width: 1, color: this.HANDLE_COLOR });
+		handle.addChild(handle_graphics);
+
+		const hit_size = is_edge ? this.HIT_AREA_SIZE * 1.5 : this.HIT_AREA_SIZE;
+		handle.hitArea = new Rectangle(
+			-hit_size / 2,
+			-hit_size / 2,
+			hit_size,
+			hit_size
+		);
+
+		return handle;
+	}
+
+	/**
+	 * @method create_edge_handles
+	 * @private
+	 * @description Creates edge handles for the resize UI
+	 * @param {Container} container - The container to add handles to
+	 * @param {number} width - Width of the resize area
+	 * @param {number} height - Height of the resize area
+	 * @returns {void}
+	 */
+	private create_edge_handles(
+		container: Container,
+		width: number,
+		height: number
+	): void {
+		[-1, 1].forEach((i, index) => {
+			const handle = this.create_handle(true);
+			handle.rotation = 0;
+
+			handle.on("pointerdown", (event: FederatedPointerEvent) => {
+				this.handle_pointer_down(event, handle, -1, index);
+			});
+
+			handle.x = width / 2;
+			handle.y = i < 0 ? 0 : height;
+			handle.cursor = "ns-resize";
+
+			container.addChild(handle);
+		});
+
+		[-1, 1].forEach((i, index) => {
+			const handle = this.create_handle(true);
+			handle.rotation = 0;
+			handle.on("pointerdown", (event: FederatedPointerEvent) => {
+				this.handle_pointer_down(event, handle, -1, index + 2);
+			});
+
+			handle.x = i < 0 ? 0 : width;
+			handle.y = height / 2;
+			handle.cursor = "ew-resize";
+			container.addChild(handle);
+		});
+	}
+
+	/**
+	 * @method create_corner_handles
+	 * @private
+	 * @description Creates corner handles for the resize UI
+	 * @param {Container} container - The container to add handles to
+	 * @param {number} width - Width of the resize area
+	 * @param {number} height - Height of the resize area
+	 * @returns {void}
+	 */
+	private create_corner_handles(
+		container: Container,
+		width: number,
+		height: number
+	): void {
+		const corners = [
+			{ x: 0, y: 0, cursor: "nwse-resize" },
+			{ x: width, y: 0, cursor: "nesw-resize" },
+			{ x: 0, y: height, cursor: "nesw-resize" },
+			{ x: width, y: height, cursor: "nwse-resize" }
+		];
+
+		corners.forEach(({ x, y, cursor }, i) => {
+			const corner = this.create_handle(false);
+			corner.x = x;
+			corner.y = y;
+
+			corner.on("pointerdown", (event: FederatedPointerEvent) => {
+				this.handle_pointer_down(event, corner, i, -1);
+			});
+
+			corner.cursor = cursor;
+
+			container.addChild(corner);
+		});
+	}
+
+	/**
+	 * @method handle_pointer_down
+	 * @private
+	 * @description Handles pointer down events on handles
+	 * @param {FederatedPointerEvent} event - The pointer event
+	 * @param {Container} handle - The handle that was clicked
+	 * @param {number} corner_index - Index of the corner (-1 if not a corner)
+	 * @param {number} edge_index - Index of the edge (-1 if not an edge)
+	 * @returns {void}
+	 */
+	private handle_pointer_down(
+		event: FederatedPointerEvent,
+		handle: Container,
+		corner_index: number,
+		edge_index: number
+	): void {
+		if (this.current_subtool !== "size") return;
+
+		event.stopPropagation();
+
+		this.is_dragging = true;
+		this.selected_handle = handle;
+		this.active_corner_index = corner_index;
+		this.active_edge_index = edge_index;
+
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+		this.last_pointer_position = new Point(local_pos.x, local_pos.y);
+
+		if (this.image_editor_context.background_image) {
+			const bg = this.image_editor_context.background_image;
+			this.original_state = {
+				width: bg.width,
+				height: bg.height,
+				x: bg.position.x,
+				y: bg.position.y
+			};
+		}
+	}
+
+	/**
+	 * Maintains aspect ratio during resizing
+	 * @param new_width - The new width
+	 * @param new_height - The new height
+	 * @param original_aspect_ratio - The original aspect ratio
+	 * @param delta - The delta to apply
+	 * @returns The adjusted dimensions
+	 */
+	private maintain_aspect_ratio(
+		new_width: number,
+		new_height: number,
+		original_aspect_ratio: number,
+		delta: Point
+	): { width: number; height: number } {
+		const abs_delta_x = Math.abs(delta.x);
+		const abs_delta_y = Math.abs(delta.y);
+
+		if (abs_delta_x > abs_delta_y * 1.2) {
+			new_height = new_width / original_aspect_ratio;
+		} else if (abs_delta_y > abs_delta_x * 1.2) {
+			new_width = new_height * original_aspect_ratio;
+		} else {
+			if (new_width / original_aspect_ratio > new_height) {
+				new_height = new_width / original_aspect_ratio;
+			} else {
+				new_width = new_height * original_aspect_ratio;
+			}
+		}
+
+		return { width: new_width, height: new_height };
+	}
+
+	/**
+	 * Limits dimensions based on constraints
+	 * @param width - The width to limit
+	 * @param height - The height to limit
+	 * @param maintain_aspect_ratio - Whether to maintain aspect ratio
+	 * @returns The limited dimensions
+	 */
+	private limit_dimensions(
+		width: number,
+		height: number,
+		maintain_aspect_ratio: boolean
+	): { width: number; height: number } {
+		const max_width = this.dimensions.width;
+		const max_height = this.dimensions.height;
+
+		let new_width = width;
+		let new_height = height;
+
+		if (new_width > max_width) {
+			if (maintain_aspect_ratio && this.active_corner_index !== -1) {
+				new_height = (max_width / new_width) * new_height;
+			}
+			new_width = max_width;
+		}
+
+		if (new_height > max_height) {
+			if (maintain_aspect_ratio && this.active_corner_index !== -1) {
+				new_width = (max_height / new_height) * new_width;
+			}
+			new_height = max_height;
+		}
+
+		new_width = Math.max(20, new_width);
+		new_height = Math.max(20, new_height);
+
+		return { width: new_width, height: new_height };
+	}
+
+	/**
+	 * Calculates position deltas based on dimension changes
+	 * @param old_width - The original width
+	 * @param old_height - The original height
+	 * @param new_width - The new width
+	 * @param new_height - The new height
+	 * @returns Object containing x and y position deltas
+	 */
+	private calculate_position_deltas(
+		old_width: number,
+		old_height: number,
+		new_width: number,
+		new_height: number
+	): { x: number; y: number } {
+		let delta_x = 0;
+		let delta_y = 0;
+
+		if (this.active_corner_index === 0 || this.active_edge_index === 2) {
+			delta_x = old_width - new_width;
+		} else if (this.active_corner_index === 2) {
+			delta_x = old_width - new_width;
+			delta_y = 0;
+		}
+
+		if (
+			this.active_corner_index === 0 ||
+			this.active_corner_index === 1 ||
+			this.active_edge_index === 0
+		) {
+			delta_y = old_height - new_height;
+		}
+
+		return { x: delta_x, y: delta_y };
+	}
+
+	/**
+	 * Applies boundary constraints to keep the image within the container
+	 * @private
+	 */
+	private apply_boundary_constraints(): void {
+		if (!this.image_editor_context.background_image) return;
+
+		const bg = this.image_editor_context.background_image;
+		const image_container = this.image_editor_context.image_container;
+
+		let new_x = bg.position.x;
+		let new_y = bg.position.y;
+
+		const container_width = image_container.width;
+		const container_height = image_container.height;
+		const bg_width = bg.width;
+		const bg_height = bg.height;
+
+		const effectiveWidth = container_width - this.borderRegion * 2;
+		const effectiveHeight = container_height - this.borderRegion * 2;
+
+		if (bg_width > effectiveWidth) {
+			const min_x = -(bg_width - effectiveWidth) + this.borderRegion;
+			const max_x = this.borderRegion;
+			new_x = Math.max(min_x, Math.min(max_x, new_x));
+		} else {
+			const min_x = this.borderRegion;
+			const max_x = container_width - bg_width - this.borderRegion;
+			if (new_x < min_x || new_x > max_x) {
+				new_x = Math.max(min_x, Math.min(max_x, new_x));
+			}
+		}
+
+		if (bg_height > effectiveHeight) {
+			const min_y = -(bg_height - effectiveHeight) + this.borderRegion;
+			const max_y = this.borderRegion;
+			new_y = Math.max(min_y, Math.min(max_y, new_y));
+		} else {
+			const min_y = this.borderRegion;
+			const max_y = container_height - bg_height - this.borderRegion;
+			if (new_y < min_y || new_y > max_y) {
+				new_y = Math.max(min_y, Math.min(max_y, new_y));
+			}
+		}
+
+		bg.position.set(new_x, new_y);
+
+		if (this.resize_ui_container) {
+			const total_x = image_container.position.x + new_x * this.scale;
+			const total_y = image_container.position.y + new_y * this.scale;
+			this.resize_ui_container.position.set(total_x, total_y);
+		}
+	}
+
+	/**
+	 * Updates the resize bounds based on the delta
+	 * @param delta - The delta to apply
+	 * @param maintain_aspect_ratio - Whether to maintain the aspect ratio
+	 */
+	private update_resize_bounds(
+		delta: Point,
+		maintain_aspect_ratio = false
+	): void {
+		const background_image = this.image_editor_context.background_image;
+
+		if (!background_image) return;
+
+		const original_width = background_image.width;
+		const original_height = background_image.height;
+		const original_x = background_image.position.x;
+		const original_y = background_image.position.y;
+		const original_aspect_ratio = original_width / original_height;
+
+		let current_position: Point;
+
+		if (this.active_corner_index !== -1) {
+			switch (this.active_corner_index) {
+				case 0:
+					current_position = new Point(
+						original_x - delta.x,
+						original_y - delta.y
+					);
+					break;
+				case 1:
+					current_position = new Point(
+						original_x + original_width + delta.x,
+						original_y - delta.y
+					);
+					break;
+				case 2:
+					current_position = new Point(
+						original_x - delta.x,
+						original_y + original_height + delta.y
+					);
+					break;
+				case 3:
+					current_position = new Point(
+						original_x + original_width + delta.x,
+						original_y + original_height + delta.y
+					);
+					break;
+				default:
+					return;
+			}
+
+			const dimensions = this.handle_direct_corner_resize(
+				current_position,
+				original_width,
+				original_height,
+				original_x,
+				original_y,
+				original_aspect_ratio,
+				maintain_aspect_ratio
+			);
+
+			background_image.width = dimensions.width;
+			background_image.height = dimensions.height;
+			background_image.position.set(dimensions.x, dimensions.y);
+		} else if (this.active_edge_index !== -1) {
+			switch (this.active_edge_index) {
+				case 0:
+					current_position = new Point(
+						original_x + original_width / 2,
+						original_y - delta.y
+					);
+					break;
+				case 1:
+					current_position = new Point(
+						original_x + original_width / 2,
+						original_y + original_height + delta.y
+					);
+					break;
+				case 2:
+					current_position = new Point(
+						original_x - delta.x,
+						original_y + original_height / 2
+					);
+					break;
+				case 3:
+					current_position = new Point(
+						original_x + original_width + delta.x,
+						original_y + original_height / 2
+					);
+					break;
+				default:
+					return;
+			}
+
+			const dimensions = this.handle_direct_edge_resize(
+				current_position,
+				original_width,
+				original_height,
+				original_x,
+				original_y
+			);
+
+			background_image.width = dimensions.width;
+			background_image.height = dimensions.height;
+			background_image.position.set(dimensions.x, dimensions.y);
+		}
+
+		this.update_resize_ui();
+	}
+
+	/**
+	 * updates the resize ui position and dimensions
+	 */
+	private update_resize_ui(): void {
+		if (
+			!this.resize_ui_container ||
+			!this.image_editor_context.background_image ||
+			!this.image_editor_context.background_image.position
+		)
+			return;
+
+		const background_image = this.image_editor_context.background_image;
+		const image_container = this.image_editor_context.image_container;
+
+		const container_global_pos = image_container.getGlobalPosition();
+
+		const bg_pos_x = background_image.position.x * this.scale;
+		const bg_pos_y = background_image.position.y * this.scale;
+
+		this.resize_ui_container.position.set(
+			container_global_pos.x + bg_pos_x,
+			container_global_pos.y + bg_pos_y
+		);
+
+		const scaled_width = background_image.width * this.scale;
+		const scaled_height = background_image.height * this.scale;
+
+		const outline = this.resize_ui_container.getChildAt(0) as Graphics;
+		outline
+			.clear()
+			.rect(0, 0, scaled_width, scaled_height)
+			.stroke({ width: 1, color: 0x000000, alignment: 0, alpha: 0.3 });
+
+		const dotted_outline = this.resize_ui_container.getChildAt(1) as Graphics;
+		dotted_outline.clear();
+
+		dotted_outline.rect(0, 0, scaled_width, scaled_height).stroke({
+			width: 1,
+			color: 0x000000,
+			alpha: 0.7,
+			pixelLine: true
+		});
+
+		if (
+			!this.is_dragging &&
+			!this.is_moving &&
+			Math.abs(this.scale - this.last_scale) < 0.001
+		) {
+			const dash_length = 5;
+			const gap_length = 5;
+			const total_length = dash_length + gap_length;
+
+			for (let x = 0; x < scaled_width; x += total_length * 2) {
+				dotted_outline
+					.rect(x, 0, Math.min(dash_length, scaled_width - x), 1)
+					.fill(0x000000);
+
+				dotted_outline
+					.rect(
+						x,
+						scaled_height - 1,
+						Math.min(dash_length, scaled_width - x),
+						1
+					)
+					.fill(0x000000);
+			}
+
+			for (let y = 0; y < scaled_height; y += total_length * 2) {
+				dotted_outline
+					.rect(0, y, 1, Math.min(dash_length, scaled_height - y))
+					.fill(0x000000);
+
+				dotted_outline
+					.rect(
+						scaled_width - 1,
+						y,
+						1,
+						Math.min(dash_length, scaled_height - y)
+					)
+					.fill(0x000000);
+			}
+		}
+
+		this.last_scale = this.scale;
+
+		const move_area = this.resize_ui_container.getChildAt(2) as Graphics;
+		move_area.clear().rect(0, 0, scaled_width, scaled_height).fill(0xffffff, 0);
+
+		this.update_handle_positions(scaled_width, scaled_height);
+	}
+
+	/**
+	 * updates the positions of all handles
+	 * @param width - width of the resize area
+	 * @param height - height of the resize area
+	 */
+	private update_handle_positions(width: number, height: number): void {
+		if (!this.resize_ui_container) return;
+
+		const handles = this.resize_ui_container.children.slice(3);
+
+		const move_area = this.resize_ui_container.getChildAt(2) as Graphics;
+		move_area.clear().rect(0, 0, width, height).fill(0xffffff, 0);
+
+		const corners = handles.slice(0, 4);
+		const cornerPositions = [
+			{ x: 0, y: 0 },
+			{ x: width, y: 0 },
+			{ x: 0, y: height },
+			{ x: width, y: height }
+		];
+
+		corners.forEach((handle, i) => {
+			handle.position.set(cornerPositions[i].x, cornerPositions[i].y);
+		});
+
+		const edges = handles.slice(4);
+		edges.forEach((handle, i) => {
+			if (i < 2) {
+				handle.position.set(width / 2, i === 0 ? 0 : height);
+			} else {
+				handle.position.set(i === 2 ? 0 : width, height / 2);
+			}
+		});
+	}
+
+	/**
+	 * sets up event listeners for the resize tool
+	 */
+	private setup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+		stage.eventMode = "static";
+		stage.on("pointermove", this.handle_pointer_move.bind(this));
+		stage.on("pointerup", this.handle_pointer_up.bind(this));
+		stage.on("pointerupoutside", this.handle_pointer_up.bind(this));
+
+		this.setup_dom_event_listeners();
+	}
+
+	/**
+	 * Sets up direct DOM event listeners for dragging the background image
+	 */
+	private setup_dom_event_listeners(): void {
+		this.cleanup_dom_event_listeners();
+
+		const canvas = this.image_editor_context.app.canvas;
+
+		this.dom_mousedown_handler = (e: MouseEvent) => {
+			if (this.current_subtool !== "size") return;
+
+			if (this.is_dragging || this.selected_handle) return;
+
+			if (!this.image_editor_context.background_image) return;
+
+			const bg = this.image_editor_context.background_image;
+
+			const container = this.image_editor_context.image_container;
+			const containerBounds = container.getBounds();
+
+			const rect = canvas.getBoundingClientRect();
+			const x = e.clientX - rect.left;
+			const y = e.clientY - rect.top;
+
+			const localX = (x - containerBounds.x) / this.scale;
+			const localY = (y - containerBounds.y) / this.scale;
+
+			if (
+				localX >= bg.position.x &&
+				localX <= bg.position.x + bg.width &&
+				localY >= bg.position.y &&
+				localY <= bg.position.y + bg.height
+			) {
+				this.is_moving = true;
+
+				this.last_pointer_position = new Point(localX, localY);
+
+				this.original_state = {
+					width: bg.width,
+					height: bg.height,
+					x: bg.position.x,
+					y: bg.position.y
+				};
+
+				e.preventDefault();
+				e.stopPropagation();
+			}
+		};
+
+		this.dom_mousemove_handler = (e: MouseEvent) => {
+			if (this.current_subtool !== "size" || !this.is_moving) return;
+
+			if (
+				!this.last_pointer_position ||
+				!this.image_editor_context.background_image
+			)
+				return;
+
+			const container = this.image_editor_context.image_container;
+			const containerBounds = container.getBounds();
+
+			const rect = canvas.getBoundingClientRect();
+			const x = e.clientX - rect.left;
+			const y = e.clientY - rect.top;
+
+			const localX = (x - containerBounds.x) / this.scale;
+			const localY = (y - containerBounds.y) / this.scale;
+
+			const current_position = new Point(localX, localY);
+
+			this.handle_image_dragging(current_position);
+
+			this.last_pointer_position = current_position;
+
+			e.preventDefault();
+			e.stopPropagation();
+		};
+
+		this.dom_mouseup_handler = (e: MouseEvent) => {
+			if (this.current_subtool !== "size") return;
+
+			if (this.original_state && this.image_editor_context.background_image) {
+				const bg = this.image_editor_context.background_image;
+				const new_state = {
+					width: bg.width,
+					height: bg.height,
+					x: bg.position.x,
+					y: bg.position.y
+				};
+
+				if (
+					this.original_state.width !== new_state.width ||
+					this.original_state.height !== new_state.height ||
+					this.original_state.x !== new_state.x ||
+					this.original_state.y !== new_state.y
+				) {
+					const resize_command = new ResizeCommand(
+						this.image_editor_context,
+						this.original_state,
+						new_state,
+						this.update_resize_ui.bind(this)
+					);
+
+					this.image_editor_context.execute_command(resize_command);
+				}
+
+				this.original_state = null;
+			}
+
+			this.is_moving = false;
+			this.last_pointer_position = null;
+
+			this.update_resize_ui();
+
+			e.preventDefault();
+			e.stopPropagation();
+		};
+
+		canvas.addEventListener("mousedown", this.dom_mousedown_handler);
+		window.addEventListener("mousemove", this.dom_mousemove_handler);
+		window.addEventListener("mouseup", this.dom_mouseup_handler);
+	}
+
+	/**
+	 * Cleans up DOM event listeners
+	 */
+	private cleanup_dom_event_listeners(): void {
+		const canvas = this.image_editor_context.app.canvas;
+
+		if (this.dom_mousedown_handler) {
+			canvas.removeEventListener("mousedown", this.dom_mousedown_handler);
+			this.dom_mousedown_handler = null;
+		}
+
+		if (this.dom_mousemove_handler) {
+			window.removeEventListener("mousemove", this.dom_mousemove_handler);
+			this.dom_mousemove_handler = null;
+		}
+
+		if (this.dom_mouseup_handler) {
+			window.removeEventListener("mouseup", this.dom_mouseup_handler);
+			this.dom_mouseup_handler = null;
+		}
+	}
+
+	/**
+	 * removes event listeners for the resize tool
+	 */
+	private cleanup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+
+		stage.off("pointermove", this.handle_pointer_move.bind(this));
+		stage.off("pointerup", this.handle_pointer_up.bind(this));
+		stage.off("pointerupoutside", this.handle_pointer_up.bind(this));
+
+		this.cleanup_dom_event_listeners();
+	}
+
+	/**
+	 * Handles pointer move events
+	 */
+	private handle_pointer_move(event: FederatedPointerEvent): void {
+		if (this.current_subtool !== "size") return;
+
+		const local_pos = this.image_editor_context.image_container.toLocal(
+			event.global
+		);
+		const current_position = new Point(local_pos.x, local_pos.y);
+
+		if (this.is_moving && this.last_pointer_position) {
+			this.handle_image_dragging(current_position);
+
+			this.last_pointer_position = current_position;
+		} else if (this.is_dragging && this.selected_handle) {
+			if (!this.image_editor_context.background_image) return;
+
+			const bg = this.image_editor_context.background_image;
+			const maintain_aspect_ratio =
+				this.active_corner_index !== -1 && !event.shiftKey;
+
+			const original_width = bg.width;
+			const original_height = bg.height;
+			const original_x = bg.position.x;
+			const original_y = bg.position.y;
+			const original_aspect_ratio = original_width / original_height;
+
+			let dimensions: { width: number; height: number; x: number; y: number };
+
+			if (this.active_corner_index !== -1) {
+				dimensions = this.handle_direct_corner_resize(
+					current_position,
+					original_width,
+					original_height,
+					original_x,
+					original_y,
+					original_aspect_ratio,
+					maintain_aspect_ratio
+				);
+			} else if (this.active_edge_index !== -1) {
+				dimensions = this.handle_direct_edge_resize(
+					current_position,
+					original_width,
+					original_height,
+					original_x,
+					original_y
+				);
+			} else {
+				return;
+			}
+
+			dimensions = this.limit_dimensions_to_container(
+				dimensions,
+				original_x,
+				original_y,
+				original_width,
+				original_height,
+				maintain_aspect_ratio
+			);
+
+			bg.width = dimensions.width;
+			bg.height = dimensions.height;
+			bg.position.set(dimensions.x, dimensions.y);
+
+			this.update_resize_ui();
+
+			this.last_pointer_position = current_position;
+		}
+	}
+	/**
+	 * handles pointer up events
+	 */
+	private handle_pointer_up(): void {
+		if (this.current_subtool !== "size") return;
+
+		this.is_dragging = false;
+		this.is_moving = false;
+		this.selected_handle = null;
+		this.last_pointer_position = null;
+		this.active_corner_index = -1;
+		this.active_edge_index = -1;
+
+		this.update_resize_ui();
+		this.notify("change");
+	}
+
+	/**
+	 * Handles dragging of the background image
+	 * @param current_position - The current pointer position
+	 * @private
+	 */
+	private handle_image_dragging(current_position: Point): void {
+		if (
+			!this.last_pointer_position ||
+			!this.image_editor_context.background_image
+		) {
+			return;
+		}
+
+		const bg = this.image_editor_context.background_image;
+		const image_container =
+			this.image_editor_context.image_container.getLocalBounds();
+
+		const dx = current_position.x - this.last_pointer_position.x;
+		const dy = current_position.y - this.last_pointer_position.y;
+
+		let new_x = bg.position.x + dx;
+		let new_y = bg.position.y + dy;
+
+		const container_width = image_container.width;
+		const container_height = image_container.height;
+		const bg_width = bg.width;
+		const bg_height = bg.height;
+
+		const effectiveWidth = container_width - this.borderRegion * 2;
+		const effectiveHeight = container_height - this.borderRegion * 2;
+
+		if (bg_width > effectiveWidth) {
+			const min_x = -(bg_width - effectiveWidth) + this.borderRegion;
+			const max_x = this.borderRegion;
+			new_x = Math.max(min_x, Math.min(max_x, new_x));
+		} else {
+			const min_x = this.borderRegion;
+			const max_x = container_width - bg_width - this.borderRegion;
+			new_x = Math.max(min_x, Math.min(max_x, new_x));
+		}
+
+		if (bg_height > effectiveHeight) {
+			const min_y = -(bg_height - effectiveHeight) + this.borderRegion;
+			const max_y = this.borderRegion;
+			new_y = Math.max(min_y, Math.min(max_y, new_y));
+		} else {
+			const min_y = this.borderRegion;
+			const max_y = container_height - bg_height - this.borderRegion;
+			new_y = Math.max(min_y, Math.min(max_y, new_y));
+		}
+
+		bg.position.set(new_x, new_y);
+
+		this.update_resize_ui();
+	}
+
+	/**
+	 * Handles corner resizing
+	 * @param current_position - The current mouse position
+	 * @param original_width - The original width
+	 * @param original_height - The original height
+	 * @param original_x - The original x position
+	 * @param original_y - The original y position
+	 * @param original_aspect_ratio - The original aspect ratio
+	 * @param maintain_aspect_ratio - Whether to maintain aspect ratio
+	 * @returns The new dimensions and position
+	 * @private
+	 */
+	private handle_direct_corner_resize(
+		current_position: Point,
+		original_width: number,
+		original_height: number,
+		original_x: number,
+		original_y: number,
+		original_aspect_ratio: number,
+		maintain_aspect_ratio: boolean
+	): { width: number; height: number; x: number; y: number } {
+		let raw_width = 0;
+		let raw_height = 0;
+		let new_x = original_x;
+		let new_y = original_y;
+
+		switch (this.active_corner_index) {
+			case 0:
+				raw_width = original_x + original_width - current_position.x;
+				raw_height = original_y + original_height - current_position.y;
+				break;
+			case 1:
+				raw_width = current_position.x - original_x;
+				raw_height = original_y + original_height - current_position.y;
+				break;
+			case 2:
+				raw_width = original_x + original_width - current_position.x;
+				raw_height = current_position.y - original_y;
+				break;
+			case 3:
+				raw_width = current_position.x - original_x;
+				raw_height = current_position.y - original_y;
+				break;
+		}
+
+		raw_width = Math.max(20, raw_width);
+		raw_height = Math.max(20, raw_height);
+
+		let new_width = raw_width;
+		let new_height = raw_height;
+
+		if (maintain_aspect_ratio) {
+			const diagonal_vector = {
+				x: current_position.x - (original_x + original_width / 2),
+				y: current_position.y - (original_y + original_height / 2)
+			};
+
+			const angle = Math.abs(Math.atan2(diagonal_vector.y, diagonal_vector.x));
+
+			if (angle < Math.PI / 4 || angle > (3 * Math.PI) / 4) {
+				new_height = new_width / original_aspect_ratio;
+			} else {
+				new_width = new_height * original_aspect_ratio;
+			}
+		}
+
+		switch (this.active_corner_index) {
+			case 0:
+				new_x = original_x + original_width - new_width;
+				new_y = original_y + original_height - new_height;
+				break;
+			case 1:
+				new_y = original_y + original_height - new_height;
+				break;
+			case 2:
+				new_x = original_x + original_width - new_width;
+				break;
+			case 3:
+				break;
+		}
+
+		return { width: new_width, height: new_height, x: new_x, y: new_y };
+	}
+
+	/**
+	 * Handles edge resizing
+	 * @param current_position - The current mouse position
+	 * @param original_width - The original width
+	 * @param original_height - The original height
+	 * @param original_x - The original x position
+	 * @param original_y - The original y position
+	 * @returns The new dimensions and position
+	 * @private
+	 */
+	private handle_direct_edge_resize(
+		current_position: Point,
+		original_width: number,
+		original_height: number,
+		original_x: number,
+		original_y: number
+	): { width: number; height: number; x: number; y: number } {
+		let new_width = original_width;
+		let new_height = original_height;
+		let new_x = original_x;
+		let new_y = original_y;
+
+		switch (this.active_edge_index) {
+			case 0:
+				new_height = Math.max(
+					20,
+					original_y + original_height - current_position.y
+				);
+				new_y = current_position.y;
+				break;
+			case 1:
+				new_height = Math.max(20, current_position.y - original_y);
+				break;
+			case 2:
+				new_width = Math.max(
+					20,
+					original_x + original_width - current_position.x
+				);
+				new_x = current_position.x;
+				break;
+			case 3:
+				new_width = Math.max(20, current_position.x - original_x);
+				break;
+		}
+
+		return { width: new_width, height: new_height, x: new_x, y: new_y };
+	}
+
+	/**
+	 * Limits dimensions to container size
+	 * @param dimensions - The dimensions to limit
+	 * @param original_x - The original x position
+	 * @param original_y - The original y position
+	 * @param original_width - The original width
+	 * @param original_height - The original height
+	 * @param maintain_aspect_ratio - Whether to maintain aspect ratio
+	 * @returns The limited dimensions and position
+	 * @private
+	 */
+	private limit_dimensions_to_container(
+		dimensions: { width: number; height: number; x: number; y: number },
+		original_x: number,
+		original_y: number,
+		original_width: number,
+		original_height: number,
+		maintain_aspect_ratio: boolean
+	): { width: number; height: number; x: number; y: number } {
+		let {
+			width: new_width,
+			height: new_height,
+			x: new_x,
+			y: new_y
+		} = dimensions;
+
+		const effective_container_width =
+			this.dimensions.width - this.borderRegion * 2;
+		const effective_container_height =
+			this.dimensions.height - this.borderRegion * 2;
+
+		const pre_limit_width = new_width;
+		const pre_limit_height = new_height;
+
+		const size_limited = this.apply_size_limits(
+			new_width,
+			new_height,
+			effective_container_width,
+			effective_container_height,
+			maintain_aspect_ratio,
+			pre_limit_width / pre_limit_height
+		);
+
+		new_width = size_limited.width;
+		new_height = size_limited.height;
+
+		const position_adjusted = this.adjust_position_for_resizing(
+			new_width,
+			new_height,
+			original_x,
+			original_y,
+			original_width,
+			original_height
+		);
+
+		new_x = position_adjusted.x;
+		new_y = position_adjusted.y;
+
+		const border_constrained = this.apply_border_constraints(
+			new_width,
+			new_height,
+			new_x,
+			new_y,
+			maintain_aspect_ratio,
+			pre_limit_width / pre_limit_height
+		);
+
+		return border_constrained;
+	}
+
+	/**
+	 * Apply size limits to ensure dimensions don't exceed container
+	 * @private
+	 */
+	private apply_size_limits(
+		width: number,
+		height: number,
+		max_width: number,
+		max_height: number,
+		maintain_aspect_ratio: boolean,
+		aspect_ratio: number
+	): { width: number; height: number } {
+		let new_width = width;
+		let new_height = height;
+
+		const needs_width_limit = new_width > max_width;
+		const needs_height_limit = new_height > max_height;
+
+		if (needs_width_limit && needs_height_limit) {
+			const width_scale = max_width / new_width;
+			const height_scale = max_height / new_height;
+
+			if (width_scale < height_scale) {
+				new_width = max_width;
+				if (maintain_aspect_ratio) {
+					new_height = new_width / aspect_ratio;
+				}
+			} else {
+				new_height = max_height;
+				if (maintain_aspect_ratio) {
+					new_width = new_height * aspect_ratio;
+				}
+			}
+		} else if (needs_width_limit) {
+			new_width = max_width;
+			if (maintain_aspect_ratio) {
+				new_height = new_width / aspect_ratio;
+			}
+		} else if (needs_height_limit) {
+			new_height = max_height;
+			if (maintain_aspect_ratio) {
+				new_width = new_height * aspect_ratio;
+			}
+		}
+
+		return { width: new_width, height: new_height };
+	}
+
+	/**
+	 * Adjust position based on which handles are being dragged
+	 * @private
+	 */
+	private adjust_position_for_resizing(
+		new_width: number,
+		new_height: number,
+		original_x: number,
+		original_y: number,
+		original_width: number,
+		original_height: number
+	): { x: number; y: number } {
+		let new_x = original_x;
+		let new_y = original_y;
+
+		switch (this.active_corner_index) {
+			case 0:
+				new_x = original_x + original_width - new_width;
+				new_y = original_y + original_height - new_height;
+				break;
+			case 1:
+				new_y = original_y + original_height - new_height;
+				break;
+			case 2:
+				new_x = original_x + original_width - new_width;
+				break;
+			case 3:
+				break;
+		}
+
+		if (this.active_edge_index !== -1) {
+			switch (this.active_edge_index) {
+				case 0:
+					new_y = original_y + original_height - new_height;
+					break;
+				case 2:
+					new_x = original_x + original_width - new_width;
+					break;
+			}
+		}
+
+		return { x: new_x, y: new_y };
+	}
+
+	/**
+	 * Apply border region constraints to prevent image from intruding on border
+	 * @private
+	 */
+	private apply_border_constraints(
+		width: number,
+		height: number,
+		x: number,
+		y: number,
+		maintain_aspect_ratio: boolean,
+		aspect_ratio: number
+	): { width: number; height: number; x: number; y: number } {
+		const top_left_constrained = this.apply_top_left_constraints(
+			width,
+			height,
+			x,
+			y,
+			maintain_aspect_ratio,
+			aspect_ratio
+		);
+
+		const all_constrained = this.apply_bottom_right_constraints(
+			top_left_constrained.width,
+			top_left_constrained.height,
+			top_left_constrained.x,
+			top_left_constrained.y,
+			maintain_aspect_ratio,
+			aspect_ratio
+		);
+
+		all_constrained.width = Math.max(20, all_constrained.width);
+		all_constrained.height = Math.max(20, all_constrained.height);
+
+		return all_constrained;
+	}
+
+	/**
+	 * Apply top and left border constraints
+	 * @private
+	 */
+	private apply_top_left_constraints(
+		width: number,
+		height: number,
+		x: number,
+		y: number,
+		maintain_aspect_ratio: boolean,
+		aspect_ratio: number
+	): { width: number; height: number; x: number; y: number } {
+		let new_width = width;
+		let new_height = height;
+		let new_x = x;
+		let new_y = y;
+
+		if (new_x < this.borderRegion) {
+			if (
+				this.active_corner_index === 0 ||
+				this.active_corner_index === 2 ||
+				this.active_edge_index === 2
+			) {
+				new_width -= this.borderRegion - new_x;
+				if (maintain_aspect_ratio) {
+					new_height = new_width / aspect_ratio;
+				}
+			}
+			new_x = this.borderRegion;
+		}
+
+		if (new_y < this.borderRegion) {
+			if (
+				this.active_corner_index === 0 ||
+				this.active_corner_index === 1 ||
+				this.active_edge_index === 0
+			) {
+				new_height -= this.borderRegion - new_y;
+				if (maintain_aspect_ratio) {
+					new_width = new_height * aspect_ratio;
+				}
+			}
+			new_y = this.borderRegion;
+		}
+
+		return { width: new_width, height: new_height, x: new_x, y: new_y };
+	}
+
+	/**
+	 * Apply bottom and right border constraints
+	 * @private
+	 */
+	private apply_bottom_right_constraints(
+		width: number,
+		height: number,
+		x: number,
+		y: number,
+		maintain_aspect_ratio: boolean,
+		aspect_ratio: number
+	): { width: number; height: number; x: number; y: number } {
+		let new_width = width;
+		let new_height = height;
+		let new_x = x;
+		let new_y = y;
+
+		if (new_x + new_width > this.dimensions.width - this.borderRegion) {
+			if (
+				this.active_corner_index === 1 ||
+				this.active_corner_index === 3 ||
+				this.active_edge_index === 3
+			) {
+				new_width = this.dimensions.width - this.borderRegion - new_x;
+				if (maintain_aspect_ratio) {
+					new_height = new_width / aspect_ratio;
+				}
+			} else {
+				const right_edge = new_x + new_width;
+				const excess = right_edge - (this.dimensions.width - this.borderRegion);
+				new_x = Math.max(this.borderRegion, new_x - excess);
+			}
+		}
+
+		if (new_y + new_height > this.dimensions.height - this.borderRegion) {
+			if (
+				this.active_corner_index === 2 ||
+				this.active_corner_index === 3 ||
+				this.active_edge_index === 1
+			) {
+				new_height = this.dimensions.height - this.borderRegion - new_y;
+				if (maintain_aspect_ratio) {
+					new_width = new_height * aspect_ratio;
+				}
+			} else {
+				const bottom_edge = new_y + new_height;
+				const excess =
+					bottom_edge - (this.dimensions.height - this.borderRegion);
+				new_y = Math.max(this.borderRegion, new_y - excess);
+			}
+		}
+
+		return { width: new_width, height: new_height, x: new_x, y: new_y };
+	}
+
+	/**
+	 * Shows the resize UI
+	 * @private
+	 */
+	private show_resize_ui(): void {
+		if (this.resize_ui_container) {
+			this.resize_ui_container.visible = true;
+			this.update_resize_ui();
+		}
+
+		if (this.image_editor_context.background_image) {
+			const bg = this.image_editor_context.background_image;
+			this.current_cursor = bg.cursor;
+			bg.cursor = "move";
+		}
+
+		this.setup_dom_event_listeners();
+	}
+
+	/**
+	 * Hides the resize UI
+	 * @private
+	 */
+	private hide_resize_ui(): void {
+		if (this.resize_ui_container) {
+			this.resize_ui_container.visible = false;
+		}
+
+		if (this.image_editor_context.background_image) {
+			const bg = this.image_editor_context.background_image;
+			bg.cursor = this.current_cursor;
+		}
+
+		this.cleanup_dom_event_listeners();
+	}
+
+	on<T extends string>(event: T, callback: () => void): void {
+		this.event_callbacks.set(event, [
+			...(this.event_callbacks.get(event) || []),
+			callback
+		]);
+	}
+
+	off<T extends string>(event: T, callback: () => void): void {
+		this.event_callbacks.set(
+			event,
+			this.event_callbacks.get(event)?.filter((cb) => cb !== callback) || []
+		);
+	}
+
+	private notify<T extends string>(event: T): void {
+		for (const callback of this.event_callbacks.get(event) || []) {
+			callback();
+		}
+	}
+
+	/**
+	 * Sets the border region explicitly
+	 * @param borderRegion The border region size in pixels
+	 */
+	public set_border_region(borderRegion: number): void {
+		this.borderRegion = borderRegion;
+
+		if (this.image_editor_context?.background_image) {
+			(this.image_editor_context.background_image as any).borderRegion =
+				borderRegion;
+		}
+
+		if (this.resize_ui_container) {
+			this.update_resize_ui();
+		}
+
+		if (
+			this.current_subtool === "size" &&
+			this.image_editor_context?.background_image
+		) {
+			this.apply_boundary_constraints();
+		}
+	}
+}

6.0.0-dev.5/imageeditor/shared/types.ts

@@ -0,0 +1,29 @@
+export interface ImageBlobs {
+	background: Blob | null;
+	layers: (Blob | null)[];
+	composite: Blob | null;
+}
+
+export interface LayerOptions {
+	allow_additional_layers: boolean;
+	layers: string[];
+	disabled: boolean;
+}
+
+export type Source = "upload" | "webcam" | "clipboard";
+export type Transform = "crop" | "resize";
+
+export interface WebcamOptions {
+	mirror: boolean;
+	constraints: Record<string, any>;
+}
+
+export interface WatermarkOptions {
+	watermark: string | Blob | null;
+	position:
+		| [number, number]
+		| "top-left"
+		| "top-right"
+		| "bottom-left"
+		| "bottom-right";
+}

6.0.0-dev.5/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);
+		}
+	};
+}

6.0.0-dev.5/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];
+}

6.0.0-dev.5/imageeditor/shared/utils/pixi.ts

@@ -0,0 +1,71 @@
+import { Graphics, Rectangle, type Renderer, type Container } from "pixi.js";
+
+/**
+ * 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.s
+ * @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.
+ */
+export function get_canvas_blob(
+	renderer: Renderer,
+	obj: Container | null,
+	bounds?: { x: number; y: number; width: number; height: number }
+): Promise<Blob | null> {
+	return new Promise((resolve) => {
+		if (!obj) {
+			resolve(null);
+			return;
+		}
+
+		const image_bounds = obj.getLocalBounds();
+		const frame = bounds
+			? new Rectangle(bounds.x, bounds.y, bounds.width, bounds.height)
+			: new Rectangle(0, 0, image_bounds.width, image_bounds.height);
+
+		const src_canvas = renderer.extract.canvas({
+			target: obj,
+			resolution: 1,
+			frame
+		});
+
+		src_canvas.toBlob?.((blob) => {
+			if (!blob) {
+				resolve(null);
+			}
+			resolve(blob);
+		});
+	});
+}
+
+export interface ImageBlobs {
+	background: Blob | null;
+	layers: (Blob | null)[];
+	composite: Blob | null;
+}

6.0.0-dev.5/imageeditor/shared/zoom/zoom.ts

@@ -0,0 +1,675 @@
+import {
+	Point,
+	type FederatedWheelEvent,
+	type FederatedPointerEvent
+} from "pixi.js";
+import { type ImageEditorContext, type Tool } from "../core/editor";
+import { type Tool as ToolbarTool, type Subtool } from "../Toolbar.svelte";
+import { get, writable } from "svelte/store";
+
+/**
+ * ZoomTool class for handling zoom and pan functionality in the image editor
+ * Implements the Tool interface
+ */
+export class ZoomTool implements Tool {
+	name = "zoom";
+	min_zoom = writable(true);
+
+	private image_editor_context!: ImageEditorContext;
+
+	private readonly max_zoom = 10;
+	private readonly border_padding = 30;
+
+	private pad_bottom = 0;
+	private is_pinching = false;
+	private is_dragging = false;
+	private is_pointer_dragging = false;
+	private last_touch_position: Point | null = null;
+	private last_pinch_distance = 0;
+	private drag_start = new Point();
+	private current_tool!: ToolbarTool;
+	private current_subtool!: Subtool;
+	private local_scale = 1;
+	private local_dimensions: { width: number; height: number } = {
+		width: 0,
+		height: 0
+	};
+	private local_position: { x: number; y: number } = { x: 0, y: 0 };
+
+	/**
+	 * Prevents default behavior for events
+	 * @param {FederatedWheelEvent | FederatedPointerEvent} event - The event to prevent default behavior for
+	 */
+	prevent_default(
+		event: FederatedWheelEvent | FederatedPointerEvent | WheelEvent
+	): void {
+		event.preventDefault();
+		event.stopPropagation();
+	}
+
+	/**
+	 * Sets the current tool and subtool
+	 * @param {ToolbarTool} tool - The tool to set
+	 * @param {Subtool} subtool - The subtool to set
+	 */
+	set_tool(tool: ToolbarTool, subtool: Subtool): void {
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+	}
+
+	/**
+	 * Sets the zoom level to a specific percentage or fits the image to the screen
+	 * @param {number | 'fit'} zoom_level - The zoom level to set (0-1) or 'fit' to use min_zoom
+	 * @returns {void}
+	 */
+	set_zoom(zoom_level: number | "fit"): void {
+		const fit_zoom = this.calculate_min_zoom(
+			this.local_dimensions.width,
+			this.local_dimensions.height
+		);
+
+		let target_zoom: number;
+		const is_fit_zoom = zoom_level === "fit";
+		if (is_fit_zoom) {
+			target_zoom = fit_zoom;
+		} else {
+			target_zoom = Math.max(0, Math.min(this.max_zoom, zoom_level));
+		}
+
+		const canvas = this.image_editor_context.app.screen;
+		const canvas_width = canvas.width;
+		const canvas_height = canvas.height;
+
+		let center_point: { x: number; y: number };
+
+		center_point = {
+			x: canvas_width / 2,
+			y: canvas_height / 2
+		};
+
+		this.zoom_to_point(target_zoom, center_point, true, is_fit_zoom);
+	}
+
+	/**
+	 * Sets up the zoom tool with the given context and state
+	 * @param {ImageEditorContext} context - The image editor context
+	 * @param {ToolbarTool} tool - The current tool
+	 * @param {Subtool} subtool - The current subtool
+	 * @returns {Promise<void>}
+	 */
+	async setup(
+		context: ImageEditorContext,
+		tool: ToolbarTool,
+		subtool: Subtool
+	): Promise<void> {
+		this.image_editor_context = context;
+		this.current_tool = tool;
+		this.current_subtool = subtool;
+		this.pad_bottom = context.pad_bottom;
+		const { width, height } = await this.get_container_dimensions();
+		const fit_zoom = this.calculate_min_zoom(width, height);
+		const min_zoom = Math.min(fit_zoom, 1);
+
+		this.local_scale = min_zoom;
+
+		const canvas = this.image_editor_context.app.screen;
+
+		const center_x = canvas.width / 2;
+		const center_y = canvas.height / 2;
+
+		const scaled_width = width * min_zoom;
+		const scaled_height = height * min_zoom;
+		const initial_x = center_x - scaled_width / 2;
+		const initial_y = center_y - scaled_height / 2;
+
+		this.local_position = { x: initial_x, y: initial_y };
+
+		this.setup_event_listeners();
+
+		await this.image_editor_context.set_image_properties({
+			scale: min_zoom,
+			position: { x: initial_x, y: initial_y }
+		});
+
+		this.image_editor_context.dimensions.subscribe((dimensions) => {
+			this.local_dimensions = dimensions;
+		});
+
+		this.image_editor_context.scale.subscribe((scale) => {
+			this.local_scale = scale;
+		});
+
+		this.image_editor_context.position.subscribe((position) => {
+			this.local_position = position;
+		});
+	}
+
+	/**
+	 * Sets up event listeners for zoom and pan functionality
+	 * @private
+	 */
+	private setup_event_listeners(): void {
+		const stage = this.image_editor_context.app.stage;
+		const canvas = this.image_editor_context.app.canvas;
+
+		canvas.addEventListener("wheel", this.prevent_default, { passive: false });
+
+		stage.eventMode = "static";
+		stage.hitArea = this.image_editor_context.app.screen;
+
+		const wheel_listener = this.handle_wheel.bind(this);
+		stage.addEventListener("wheel", wheel_listener, { passive: false });
+
+		if ("ontouchstart" in window) {
+			stage.addEventListener(
+				"touchstart",
+				this.handle_touch_start.bind(this) as EventListener
+			);
+			stage.addEventListener(
+				"touchmove",
+				this.handle_touch_move.bind(this) as EventListener
+			);
+			stage.addEventListener(
+				"touchend",
+				this.handle_touch_end.bind(this) as EventListener
+			);
+		} else {
+			stage.addEventListener(
+				"pointerdown",
+				this.handle_pointer_down.bind(this)
+			);
+			stage.addEventListener(
+				"pointermove",
+				this.handle_pointer_move.bind(this)
+			);
+			stage.addEventListener("pointerup", this.handle_pointer_up.bind(this));
+			stage.addEventListener(
+				"pointerupoutside",
+				this.handle_pointer_up.bind(this)
+			);
+		}
+	}
+
+	/**
+	 * Handles wheel events for zooming
+	 * @param {FederatedWheelEvent} event - The wheel event
+	 * @private
+	 */
+	private handle_wheel(event: FederatedWheelEvent): void {
+		const is_trackpad = event.deltaMode === 0 && Math.abs(event.deltaY) < 50;
+		const scroll_speed = is_trackpad ? 30 : 10;
+
+		if (event.altKey || event.metaKey) {
+			const local_point = this.image_editor_context.app.stage.toLocal(
+				event.global
+			);
+			const zoom_delta = -event.deltaY * (is_trackpad ? 0.001 : 0.0005);
+			const new_scale = this.local_scale * (1 + zoom_delta);
+			this.zoom_to_point(new_scale, local_point, true);
+		} else {
+			const delta_x = event.deltaX;
+			const delta_y = event.deltaY;
+			const raw_position = {
+				x: this.local_position.x - (delta_x / 100) * scroll_speed,
+				y: this.local_position.y - (delta_y / 100) * scroll_speed
+			};
+
+			const canvas = this.image_editor_context.app.screen;
+			const scaled_width = this.local_dimensions.width * this.local_scale;
+			const scaled_height = this.local_dimensions.height * this.local_scale;
+			const available_width = canvas.width - this.border_padding * 2;
+			const available_height =
+				canvas.height - this.border_padding * 2 - this.pad_bottom;
+
+			let final_position = { ...raw_position };
+
+			if (scaled_width <= available_width) {
+				final_position.x = (canvas.width - scaled_width) / 2;
+			} else {
+				const max_offset = canvas.width / 2;
+				const left_bound = max_offset;
+				const right_bound = canvas.width - max_offset - scaled_width;
+				final_position.x = Math.min(
+					Math.max(raw_position.x, right_bound),
+					left_bound
+				);
+			}
+
+			if (scaled_height <= available_height) {
+				final_position.y =
+					(canvas.height - this.pad_bottom - scaled_height) / 2;
+			} else {
+				const max_offset = (canvas.height - this.pad_bottom) / 2;
+				const top_bound = max_offset;
+				const bottom_bound =
+					canvas.height - this.pad_bottom - max_offset - scaled_height;
+				final_position.y = Math.min(
+					Math.max(raw_position.y, bottom_bound),
+					top_bound
+				);
+			}
+
+			this.image_editor_context.set_image_properties({
+				scale: this.local_scale,
+				position: final_position
+			});
+		}
+	}
+
+	/**
+	 * Cleans up resources and event listeners
+	 */
+	cleanup(): void {
+		const stage = this?.image_editor_context?.app?.stage;
+		if (!stage) return;
+		stage.removeEventListener("wheel", this.handle_wheel.bind(this));
+
+		if ("ontouchstart" in window) {
+			stage.removeEventListener(
+				"touchstart",
+				this.handle_touch_start.bind(this) as EventListener
+			);
+			stage.removeEventListener(
+				"touchmove",
+				this.handle_touch_move.bind(this) as EventListener
+			);
+			stage.removeEventListener(
+				"touchend",
+				this.handle_touch_end.bind(this) as EventListener
+			);
+		} else {
+			stage.removeEventListener(
+				"pointerdown",
+				this.handle_pointer_down.bind(this)
+			);
+			stage.removeEventListener(
+				"pointermove",
+				this.handle_pointer_move.bind(this)
+			);
+			stage.removeEventListener("pointerup", this.handle_pointer_up.bind(this));
+			stage.removeEventListener(
+				"pointerupoutside",
+				this.handle_pointer_up.bind(this)
+			);
+		}
+	}
+
+	/**
+	 * Gets the dimensions of the container
+	 * @returns {Promise<{width: number, height: number}>} The container dimensions
+	 * @private
+	 */
+	private async get_container_dimensions(): Promise<{
+		width: number;
+		height: number;
+	}> {
+		const bounds = this.image_editor_context.image_container.getLocalBounds();
+		return {
+			width: bounds.width,
+			height: bounds.height
+		};
+	}
+
+	/**
+	 * Calculates the minimum zoom level to fit the image in the viewport
+	 * @param {number} container_width - The width of the container
+	 * @param {number} container_height - The height of the container
+	 * @returns {number} The minimum zoom level
+	 * @private
+	 */
+	private calculate_min_zoom(
+		container_width: number,
+		container_height: number
+	): number {
+		const canvas = this.image_editor_context.app.screen;
+		const viewport_width = canvas.width;
+		const viewport_height = canvas.height;
+
+		if (
+			!container_width ||
+			!viewport_width ||
+			!container_height ||
+			!viewport_height
+		) {
+			return 1;
+		}
+
+		const available_width = viewport_width - this.border_padding * 2;
+		const available_height =
+			viewport_height - this.border_padding * 2 - this.pad_bottom;
+
+		const width_ratio = available_width / container_width;
+		const height_ratio = available_height / container_height;
+
+		return Math.min(width_ratio, height_ratio);
+	}
+
+	/**
+	 * Handles touch start events
+	 * @param {TouchEvent} event - The touch event
+	 * @private
+	 */
+	private handle_touch_start(event: FederatedPointerEvent): void {
+		event.preventDefault();
+
+		const touchEvent = event as any;
+
+		if (touchEvent.touches && touchEvent.touches.length === 2) {
+			this.is_pinching = true;
+			this.last_pinch_distance = Math.hypot(
+				touchEvent.touches[0].pageX - touchEvent.touches[1].pageX,
+				touchEvent.touches[0].pageY - touchEvent.touches[1].pageY
+			);
+		} else if (touchEvent.touches && touchEvent.touches.length === 1) {
+			this.is_dragging = true;
+			const rect = this.image_editor_context.app.view.getBoundingClientRect();
+			this.last_touch_position = new Point(
+				touchEvent.touches[0].pageX - rect.left,
+				touchEvent.touches[0].pageY - rect.top
+			);
+		}
+	}
+
+	/**
+	 * Handles touch move events
+	 * @param {TouchEvent} event - The touch event
+	 * @private
+	 */
+	private handle_touch_move(event: FederatedPointerEvent): void {
+		event.preventDefault();
+
+		const touchEvent = event as any;
+
+		if (
+			this.is_pinching &&
+			touchEvent.touches &&
+			touchEvent.touches.length === 2
+		) {
+			const rect = this.image_editor_context.app.view.getBoundingClientRect();
+			const current_distance = Math.hypot(
+				touchEvent.touches[0].pageX - touchEvent.touches[1].pageX,
+				touchEvent.touches[0].pageY - touchEvent.touches[1].pageY
+			);
+
+			const pinch_center = {
+				x:
+					(touchEvent.touches[0].pageX + touchEvent.touches[1].pageX) / 2 -
+					rect.left,
+				y:
+					(touchEvent.touches[0].pageY + touchEvent.touches[1].pageY) / 2 -
+					rect.top
+			};
+
+			const scale_val = current_distance / this.last_pinch_distance;
+			this.last_pinch_distance = current_distance;
+
+			this.zoom_to_point(this.local_scale * scale_val, pinch_center);
+		} else if (
+			this.is_dragging &&
+			touchEvent.touches &&
+			touchEvent.touches.length === 1 &&
+			this.last_touch_position
+		) {
+			const rect = this.image_editor_context.app.view.getBoundingClientRect();
+			const current_position = new Point(
+				touchEvent.touches[0].pageX - rect.left,
+				touchEvent.touches[0].pageY - rect.top
+			);
+
+			const dx = current_position.x - this.last_touch_position.x;
+			const dy = current_position.y - this.last_touch_position.y;
+
+			this.image_editor_context.set_image_properties({
+				position: {
+					x: this.local_position.x + dx,
+					y: this.local_position.y + dy
+				}
+			});
+
+			this.last_touch_position = current_position;
+		}
+	}
+
+	/**
+	 * Handles touch end events
+	 * @param {TouchEvent} event - The touch event
+	 * @private
+	 */
+	private handle_touch_end(event: FederatedPointerEvent): void {
+		event.preventDefault();
+
+		const touchEvent = event as any;
+
+		if (touchEvent.touches && touchEvent.touches.length < 2) {
+			this.is_pinching = false;
+			if (touchEvent.touches && touchEvent.touches.length === 1) {
+				const rect = this.image_editor_context.app.view.getBoundingClientRect();
+				this.last_touch_position = new Point(
+					touchEvent.touches[0].pageX - rect.left,
+					touchEvent.touches[0].pageY - rect.top
+				);
+				this.is_dragging = true;
+			}
+		}
+		if (touchEvent.touches && touchEvent.touches.length === 0) {
+			this.is_dragging = false;
+			this.last_touch_position = null;
+			this.last_pinch_distance = 0;
+		}
+	}
+
+	/**
+	 * Gets the bounded position to keep the image within the viewport
+	 * @param {Object} position - The position to bound
+	 * @param {number} position.x - The x coordinate
+	 * @param {number} position.y - The y coordinate
+	 * @returns {Object} The bounded position
+	 * @private
+	 */
+	private get_bounded_position(position: { x: number; y: number }): {
+		x: number;
+		y: number;
+	} {
+		const canvas = this.image_editor_context.app.screen;
+		const scaled_width = this.local_dimensions.width * this.local_scale;
+		const scaled_height = this.local_dimensions.height * this.local_scale;
+
+		const center_position = {
+			x: (canvas.width - scaled_width) / 2,
+			y: (canvas.height - scaled_height - this.pad_bottom) / 2
+		};
+
+		if (scaled_width <= canvas.width && scaled_height <= canvas.height) {
+			return center_position;
+		}
+
+		let x = position.x;
+		let y = position.y;
+
+		if (scaled_width <= canvas.width) {
+			x = center_position.x;
+		} else {
+			const min_x = canvas.width - scaled_width;
+			const max_x = 0;
+			x = Math.max(min_x, Math.min(max_x, position.x));
+		}
+
+		if (scaled_height <= canvas.height - this.pad_bottom) {
+			y = center_position.y;
+		} else {
+			const min_y = canvas.height - scaled_height - this.pad_bottom;
+			const max_y = 0;
+			y = Math.max(min_y, Math.min(max_y, position.y));
+		}
+
+		return { x, y };
+	}
+
+	/**
+	 * Zooms to a specific point with a new zoom level
+	 * @param {number} new_zoom - The new zoom level
+	 * @param {Object} point - The point to zoom to
+	 * @param {number} point.x - The x coordinate of the point
+	 * @param {number} point.y - The y coordinate of the point
+	 * @param {boolean} hard - Whether to apply a hard zoom (no animation)
+	 * @param {boolean} is_fit_zoom - Whether this is a fit zoom operation
+	 * @private
+	 */
+	private zoom_to_point(
+		new_zoom: number,
+		point: { x: number; y: number },
+		hard?: boolean,
+		is_fit_zoom?: boolean
+	): void {
+		const container = this.image_editor_context.image_container;
+		const current_world_pos = container.getGlobalPosition();
+		const current_scale = container.scale.x;
+
+		const cursor_image_pixel = {
+			x: (point.x - current_world_pos.x) / current_scale,
+			y: (point.y - current_world_pos.y) / current_scale
+		};
+
+		const fit_zoom = this.calculate_min_zoom(
+			this.local_dimensions.width,
+			this.local_dimensions.height
+		);
+		const min_zoom = Math.min(fit_zoom, 1);
+		new_zoom = Math.min(Math.max(new_zoom, min_zoom), this.max_zoom);
+
+		const new_container_world_pos = {
+			x: point.x - cursor_image_pixel.x * new_zoom,
+			y: point.y - cursor_image_pixel.y * new_zoom
+		};
+
+		if (new_zoom === min_zoom || is_fit_zoom) {
+			const canvas_width = this.image_editor_context.app.screen.width;
+			const canvas_height = this.image_editor_context.app.screen.height;
+			const new_scaled_width = this.local_dimensions.width * new_zoom;
+			const new_scaled_height = this.local_dimensions.height * new_zoom;
+
+			new_container_world_pos.x = (canvas_width - new_scaled_width) / 2;
+			new_container_world_pos.y =
+				(canvas_height - this.pad_bottom - new_scaled_height) / 2;
+		}
+
+		this.image_editor_context.set_image_properties({
+			scale: new_zoom,
+			position: new_container_world_pos,
+			animate: typeof hard === "boolean" ? !hard : new_zoom === min_zoom
+		});
+		this.min_zoom.set(new_zoom === min_zoom);
+	}
+
+	/**
+	 * Handles pointer down events
+	 * @param {FederatedPointerEvent} event - The pointer event
+	 * @private
+	 */
+	private handle_pointer_down(event: FederatedPointerEvent): void {
+		if (event.button === 0 && this.current_tool === "pan") {
+			this.is_pointer_dragging = true;
+			this.drag_start.copyFrom(event.global);
+			this.drag_start.x -= this.local_position.x;
+			this.drag_start.y -= this.local_position.y;
+		}
+	}
+
+	/**
+	 * Handles pointer move events
+	 * @param {FederatedPointerEvent} event - The pointer event
+	 * @private
+	 */
+	private handle_pointer_move(event: FederatedPointerEvent): void {
+		if (this.is_pointer_dragging && this.current_tool === "pan") {
+			const raw_position = {
+				x: event.global.x - this.drag_start.x,
+				y: event.global.y - this.drag_start.y
+			};
+
+			const canvas = this.image_editor_context.app.screen;
+			const scaled_width = this.local_dimensions.width * this.local_scale;
+			const scaled_height = this.local_dimensions.height * this.local_scale;
+			const available_width = canvas.width - this.border_padding * 2;
+			const available_height =
+				canvas.height - this.border_padding * 2 - this.pad_bottom;
+
+			let final_position = { ...raw_position };
+
+			if (scaled_width <= available_width) {
+				final_position.x = (canvas.width - scaled_width) / 2;
+			} else {
+				final_position.x = raw_position.x;
+			}
+
+			if (scaled_height <= available_height) {
+				final_position.y =
+					(canvas.height - this.pad_bottom - scaled_height) / 2;
+			} else {
+				final_position.y = raw_position.y;
+			}
+
+			this.image_editor_context.set_image_properties({
+				scale: this.local_scale,
+				position: final_position
+			});
+		}
+	}
+
+	/**
+	 * Handles pointer up events
+	 * @param {FederatedPointerEvent} event - The pointer event
+	 * @private
+	 */
+	private handle_pointer_up(event: FederatedPointerEvent): void {
+		if (this.is_pointer_dragging && this.current_tool === "pan") {
+			this.is_pointer_dragging = false;
+
+			const raw_position = {
+				x: event.global.x - this.drag_start.x,
+				y: event.global.y - this.drag_start.y
+			};
+
+			const canvas = this.image_editor_context.app.screen;
+			const scaled_width = this.local_dimensions.width * this.local_scale;
+			const scaled_height = this.local_dimensions.height * this.local_scale;
+			const available_width = canvas.width - this.border_padding * 2;
+			const available_height =
+				canvas.height - this.border_padding * 2 - this.pad_bottom;
+
+			let final_position = { ...raw_position };
+
+			if (scaled_width <= available_width) {
+				final_position.x = (canvas.width - scaled_width) / 2;
+			} else {
+				const max_offset = canvas.width / 2;
+				const left_bound = max_offset;
+				const right_bound = canvas.width - max_offset - scaled_width;
+				final_position.x = Math.min(
+					Math.max(raw_position.x, right_bound),
+					left_bound
+				);
+			}
+
+			if (scaled_height <= available_height) {
+				final_position.y =
+					(canvas.height - this.pad_bottom - scaled_height) / 2;
+			} else {
+				const max_offset = (canvas.height - this.pad_bottom) / 2;
+				const top_bound = max_offset;
+				const bottom_bound =
+					canvas.height - this.pad_bottom - max_offset - scaled_height;
+				final_position.y = Math.min(
+					Math.max(raw_position.y, bottom_bound),
+					top_bound
+				);
+			}
+
+			this.image_editor_context.set_image_properties({
+				scale: this.local_scale,
+				position: final_position,
+				animate: true
+			});
+		}
+	}
+}

6.0.0-dev.5/imageeditor/types.ts

@@ -0,0 +1,74 @@
+import type { SelectData, ShareData } from "@gradio/utils";
+import type { LoadingStatus } from "@gradio/statustracker";
+import type { CommandNode } from "./shared/core/commands";
+import type {
+	LayerOptions,
+	Source,
+	Transform,
+	WebcamOptions
+} from "./shared/types";
+import type { Brush, Eraser } from "./shared/brush/types";
+import type { EditorData } from "./InteractiveImageEditor.svelte";
+import type { ImageBlobs } from "./shared/types";
+
+export interface ImageEditorEvents {
+	change: never;
+	error: string;
+	input: never;
+	edit: never;
+	drag: never;
+	apply: never;
+	upload: never;
+	clear: never;
+	select: SelectData;
+	share: ShareData;
+	clear_status: LoadingStatus;
+}
+
+export interface ImageEditorProps {
+	border_region?: number;
+	webcam_options?: WebcamOptions;
+	value?: EditorData | null;
+	buttons?: string[] | null;
+	height?: number;
+	width?: number;
+	_selectable?: boolean;
+	sources?: Source[];
+	placeholder?: string | undefined;
+	brush?: Brush;
+	eraser?: Eraser;
+	transforms?: Transform[];
+	layers?: LayerOptions;
+	server?: {
+		accept_blobs: (a: any) => void;
+	};
+	canvas_size?: [number, number];
+	fixed_canvas?: boolean;
+	full_history?: CommandNode | null;
+}
+
+// export let border_region = 0;
+// 	export let webcam_options: WebcamOptions;
+// 	export let value: EditorData | null = {
+// 		background: null,
+// 		layers: [],
+// 		composite: null,
+// 	};
+// 	export let buttons: string[] | null = null;
+// 	export let height = 350;
+// 	export let width: number | undefined;
+
+// 	export let _selectable = false;
+// 	export let sources: Source[] = [];
+// 	export let placeholder: string | undefined;
+// 	export let brush: Brush;
+// 	export let eraser: Eraser;
+// 	export let transforms: Transform[] = [];
+// 	export let layers: LayerOptions;
+// 	export let attached_events: string[] = [];
+// 	export let server: {
+// 		accept_blobs: (a: any) => void;
+// 	};
+// 	export let canvas_size: [number, number];
+// 	export let fixed_canvas = false;
+// 	export let full_history: CommandNode | null = null;