upload-motion 0.0.0-stage → 0.1.0

package/dist/core-BUWs_ckM.js

@@ -0,0 +1,1256 @@
+
+//#region src/core/format.ts
+const UNITS = [
+	"B",
+	"KB",
+	"MB",
+	"GB",
+	"TB"
+];
+/**
+* `25 * 1024 * 1024` → `"25 MB"`. Uses 1024-based units so limits written the
+* usual way (`n * 1024 * 1024`) read back exactly as configured.
+*/
+function formatBytes(bytes, fractionDigits = 1) {
+	if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+	const exponent = Math.min(Math.floor(Math.log2(bytes) / 10), UNITS.length - 1);
+	const value = bytes / 1024 ** exponent;
+	const digits = exponent === 0 || value >= 100 || Number.isInteger(value) ? 0 : fractionDigits;
+	return `${value.toFixed(digits)} ${UNITS[exponent]}`;
+}
+function formatSpeed(bytesPerSecond) {
+	return `${formatBytes(bytesPerSecond)}/s`;
+}
+/** `5` → `"5 seconds"`, `90` → `"2 minutes"`, `3900` → `"1 hour"` */
+function formatDuration(seconds) {
+	if (!Number.isFinite(seconds) || seconds < 0) return "";
+	const s = Math.max(1, Math.round(seconds));
+	if (s < 60) return `${s} ${s === 1 ? "second" : "seconds"}`;
+	const m = Math.round(s / 60);
+	if (m < 60) return `${m} ${m === 1 ? "minute" : "minutes"}`;
+	const h = Math.round(m / 60);
+	return `${h} ${h === 1 ? "hour" : "hours"}`;
+}
+function formatPercent(fraction) {
+	return `${Math.round(clamp01(fraction) * 100)}%`;
+}
+function clamp01(value) {
+	return value < 0 ? 0 : value > 1 ? 1 : Number.isFinite(value) ? value : 0;
+}
+//#endregion
+//#region src/core/file-kind.ts
+const EXTENSION_KIND = {
+	jpg: "image",
+	jpeg: "image",
+	png: "image",
+	webp: "image",
+	gif: "image",
+	svg: "image",
+	avif: "image",
+	bmp: "image",
+	ico: "image",
+	heic: "image",
+	heif: "image",
+	tif: "image",
+	tiff: "image",
+	mp4: "video",
+	mov: "video",
+	webm: "video",
+	mkv: "video",
+	avi: "video",
+	m4v: "video",
+	ogv: "video",
+	mp3: "audio",
+	wav: "audio",
+	ogg: "audio",
+	oga: "audio",
+	m4a: "audio",
+	aac: "audio",
+	flac: "audio",
+	opus: "audio",
+	pdf: "pdf",
+	doc: "document",
+	docx: "document",
+	odt: "document",
+	rtf: "document",
+	pages: "document",
+	xls: "spreadsheet",
+	xlsx: "spreadsheet",
+	ods: "spreadsheet",
+	csv: "spreadsheet",
+	tsv: "spreadsheet",
+	numbers: "spreadsheet",
+	ppt: "presentation",
+	pptx: "presentation",
+	odp: "presentation",
+	key: "presentation",
+	zip: "archive",
+	rar: "archive",
+	"7z": "archive",
+	tar: "archive",
+	gz: "archive",
+	tgz: "archive",
+	bz2: "archive",
+	xz: "archive",
+	js: "code",
+	mjs: "code",
+	cjs: "code",
+	jsx: "code",
+	ts: "code",
+	tsx: "code",
+	py: "code",
+	rb: "code",
+	go: "code",
+	rs: "code",
+	java: "code",
+	kt: "code",
+	swift: "code",
+	c: "code",
+	cpp: "code",
+	h: "code",
+	cs: "code",
+	php: "code",
+	html: "code",
+	css: "code",
+	scss: "code",
+	sh: "code",
+	sql: "code",
+	vue: "code",
+	svelte: "code",
+	json: "data",
+	xml: "data",
+	yaml: "data",
+	yml: "data",
+	toml: "data",
+	ndjson: "data",
+	parquet: "data",
+	txt: "text",
+	md: "text",
+	log: "text",
+	ini: "text"
+};
+const MIME_KIND = [
+	[/^image\//, "image"],
+	[/^video\//, "video"],
+	[/^audio\//, "audio"],
+	[/^application\/pdf$/, "pdf"],
+	[/(msword|wordprocessingml|opendocument\.text|rtf)/, "document"],
+	[/(ms-excel|spreadsheetml|opendocument\.spreadsheet|text\/csv)/, "spreadsheet"],
+	[/(ms-powerpoint|presentationml|opendocument\.presentation)/, "presentation"],
+	[/(zip|x-rar|x-7z|x-tar|gzip|x-bzip)/, "archive"],
+	[/(javascript|typescript|x-python|x-sh)/, "code"],
+	[/(json|xml|yaml)/, "data"],
+	[/^text\//, "text"]
+];
+function getExtension(name) {
+	const dot = name.lastIndexOf(".");
+	if (dot <= 0 || dot === name.length - 1) return "";
+	return name.slice(dot + 1).toLowerCase();
+}
+/** Classifies a file by extension first (more specific), then MIME type. */
+function getFileKind(file) {
+	const fromExt = EXTENSION_KIND[getExtension(file.name)];
+	if (fromExt) return fromExt;
+	const type = (file.type ?? "").toLowerCase();
+	if (type) {
+		for (const [pattern, kind] of MIME_KIND) if (pattern.test(type)) return kind;
+	}
+	return "unknown";
+}
+/** Short badge label such as `PDF`, `DOCX`, `MP4`. Falls back to the kind. */
+function getFileLabel(file) {
+	const ext = getExtension(file.name);
+	if (ext && ext.length <= 5) return ext.toUpperCase();
+	const kind = getFileKind(file);
+	return kind === "unknown" ? "FILE" : kind.slice(0, 4).toUpperCase();
+}
+/** Kinds that browsers can render as an `<img>` without extra libraries. */
+function isPreviewableImage(file) {
+	const type = (file.type ?? "").toLowerCase();
+	if (type) return /^image\/(png|jpe?g|webp|gif|svg\+xml|avif|bmp|x-icon|vnd\.microsoft\.icon)$/.test(type);
+	return [
+		"png",
+		"jpg",
+		"jpeg",
+		"webp",
+		"gif",
+		"svg",
+		"avif",
+		"bmp",
+		"ico"
+	].includes(getExtension(file.name));
+}
+//#endregion
+//#region src/core/preset-catalog.ts
+const info = (entry) => entry;
+const PRESET_INFO = {
+	"card-fan": info({
+		id: "card-fan",
+		name: "Card Fan",
+		description: "Three media cards fan out as files approach the window, curved arrows draw themselves toward the zone, and the deck re-deals on drop. Manual upload button with inline progress.",
+		category: "reference",
+		bestFor: [
+			"Media libraries",
+			"CMS",
+			"Marketing tools"
+		],
+		defaults: { autoUpload: false }
+	}),
+	"wave-bar": info({
+		id: "wave-bar",
+		name: "Wave Bar",
+		description: "A compact upload pill: a soft fill sweeps behind the summary while a sine wave travels along the edge, then flattens into a line on success. Pause, cancel, expand and more actions built in.",
+		category: "reference",
+		bestFor: [
+			"Dashboards",
+			"Cloud storage",
+			"Background uploads"
+		],
+		defaults: { progressVariant: "wave" }
+	}),
+	"hoop-shot": info({
+		id: "hoop-shot",
+		name: "Hoop Shot",
+		description: "A playful, physics-driven uploader: pull a file back, watch the dotted trajectory, release to shoot it into the hoop. Real gravity, rim bounces and bank shots – plus keyboard and \"Shoot all\" for instant perfect shots.",
+		category: "reference",
+		bestFor: [
+			"Consumer apps",
+			"Onboarding",
+			"Portfolios",
+			"Delight moments"
+		],
+		defaults: { autoUpload: false }
+	}),
+	essential: info({
+		id: "essential",
+		name: "Essential",
+		description: "Restrained and professional: a quiet dashed zone, thin progress bars, gentle list transitions. Motion that informs rather than performs.",
+		category: "professional",
+		bestFor: [
+			"Admin panels",
+			"Forms",
+			"Enterprise SaaS"
+		]
+	}),
+	"segment-ring": info({
+		id: "segment-ring",
+		name: "Segment Ring",
+		description: "One dial, many files: each upload owns an arc sized by its bytes and coloured by type, filling independently. The ring morphs into a checkmark when the batch completes.",
+		category: "professional",
+		bestFor: [
+			"Batch uploads",
+			"Analytics",
+			"Cloud storage"
+		],
+		defaults: { progressVariant: "ring" }
+	}),
+	beam: info({
+		id: "beam",
+		name: "Gradient Beam",
+		description: "A light beam circles the zone’s border and speeds up when files approach. Progress bars are gradient beams with a travelling highlight. Made for dark, premium UIs.",
+		category: "expressive",
+		bestFor: [
+			"Developer tools",
+			"AI products",
+			"Dark dashboards"
+		],
+		defaults: { progressVariant: "beam" }
+	}),
+	magnetic: info({
+		id: "magnetic",
+		name: "Magnetic",
+		description: "A dot field that reacts to your cursor: the core is pulled toward the pointer, a spotlight follows it and dots swell nearby. Dropped files snap into the list with a spring.",
+		category: "expressive",
+		bestFor: [
+			"Landing pages",
+			"Creative tools",
+			"Design apps"
+		]
+	}),
+	portal: info({
+		id: "portal",
+		name: "Portal",
+		description: "Files spiral into a rotating portal from wherever you drop them. The portal’s rim fills with aggregate progress and flashes when everything lands.",
+		category: "expressive",
+		bestFor: [
+			"Consumer apps",
+			"Gaming",
+			"Creative platforms"
+		]
+	}),
+	liquid: info({
+		id: "liquid",
+		name: "Liquid Fill",
+		description: "The zone is a vessel that fills with liquid as bytes arrive – layered waves, rising bubbles, and text that inverts as the level passes it. Turns to success colour when full.",
+		category: "expressive",
+		bestFor: [
+			"Consumer apps",
+			"Single large uploads",
+			"Mobile"
+		]
+	}),
+	stack: info({
+		id: "stack",
+		name: "Dimensional Stack",
+		description: "Files form a 3D deck: the front card uploads while the rest wait in perspective. Finished cards fly to a tray; hover to fan the deck. A full list view is one click away.",
+		category: "expressive",
+		bestFor: [
+			"Document workflows",
+			"Portfolios",
+			"Review queues"
+		]
+	}),
+	orbit: info({
+		id: "orbit",
+		name: "Orbit",
+		description: "Files orbit an upload core in three lanes. Orbits tighten as bytes transfer, and each finished file falls into the core with a pulse. Failed files drift to a halt.",
+		category: "expressive",
+		bestFor: [
+			"Landing pages",
+			"Multi-file batches",
+			"Consumer apps"
+		]
+	}),
+	bloom: info({
+		id: "bloom",
+		name: "Image Bloom",
+		description: "A gallery grid where each image starts blurred and desaturated, then blooms into full colour from the centre as it uploads – finishing with a petal burst.",
+		category: "media",
+		bestFor: [
+			"Photo galleries",
+			"Social apps",
+			"E-commerce"
+		]
+	}),
+	"page-reveal": info({
+		id: "page-reveal",
+		name: "Page Reveal",
+		description: "Documents become pages: a scan line inks each line as bytes upload – showing the real first lines of text, CSV, JSON and code files – then an “Uploaded” stamp lands.",
+		category: "media",
+		bestFor: [
+			"Document management",
+			"Legal & finance",
+			"Knowledge bases"
+		]
+	}),
+	filmstrip: info({
+		id: "filmstrip",
+		name: "Filmstrip",
+		description: "Videos turn into filmstrips using frames extracted in the browser. Frames light up as the upload advances while a playhead tracks progress.",
+		category: "media",
+		bestFor: [
+			"Video platforms",
+			"Course builders",
+			"Social media tools"
+		]
+	}),
+	waveform: info({
+		id: "waveform",
+		name: "Audio Waveform",
+		description: "Audio files show their true waveform, decoded locally, filling bar by bar with an equaliser bounce at the playhead. Includes local preview playback.",
+		category: "media",
+		bestFor: [
+			"Podcasts",
+			"Music platforms",
+			"Voice notes"
+		]
+	}),
+	pixel: info({
+		id: "pixel",
+		name: "Pixel Assembly",
+		description: "Every file assembles from 64 pixels flying into place in a shuffled order driven by real progress. Images use their own pixels; other files build a tinted mosaic.",
+		category: "media",
+		bestFor: [
+			"Creative tools",
+			"Games",
+			"Retro / playful brands"
+		]
+	}),
+	adaptive: info({
+		id: "adaptive",
+		name: "Adaptive Media",
+		description: "Picks the right motion per file: images bloom, videos become filmstrips, audio draws its waveform, documents reveal their pages. Override the mapping with `fileAnimations`.",
+		category: "media",
+		bestFor: [
+			"Mixed-media inboxes",
+			"Asset managers",
+			"Chat attachments"
+		]
+	})
+};
+/** Built-in presets in gallery order. */
+const presetCatalog = [
+	PRESET_INFO["card-fan"],
+	PRESET_INFO["wave-bar"],
+	PRESET_INFO["hoop-shot"],
+	PRESET_INFO.essential,
+	PRESET_INFO["segment-ring"],
+	PRESET_INFO.beam,
+	PRESET_INFO.magnetic,
+	PRESET_INFO.portal,
+	PRESET_INFO.liquid,
+	PRESET_INFO.stack,
+	PRESET_INFO.orbit,
+	PRESET_INFO.bloom,
+	PRESET_INFO["page-reveal"],
+	PRESET_INFO.filmstrip,
+	PRESET_INFO.waveform,
+	PRESET_INFO.pixel,
+	PRESET_INFO.adaptive
+];
+//#endregion
+//#region src/core/validation.ts
+/** Normalises `accept` to lower-case tokens: `['image/*', '.pdf', 'application/json']`. */
+function parseAccept(accept) {
+	if (!accept) return [];
+	return (typeof accept === "string" ? accept.split(",") : accept.flatMap((a) => a.split(","))).map((token) => token.trim().toLowerCase()).filter(Boolean);
+}
+/** Mirrors the browser's `accept` matching rules. An empty list accepts everything. */
+function isFileAccepted(file, accept) {
+	if (accept.length === 0) return true;
+	const type = (file.type ?? "").toLowerCase();
+	const ext = getExtension(file.name);
+	return accept.some((token) => {
+		if (token.startsWith(".")) return ext !== "" && token.slice(1) === ext;
+		if (token.endsWith("/*")) return type.startsWith(token.slice(0, -1));
+		return type === token;
+	});
+}
+const MIME_NAMES = {
+	"application/pdf": "PDF",
+	"application/json": "JSON",
+	"application/zip": "ZIP",
+	"text/csv": "CSV",
+	"text/plain": "TXT",
+	"application/msword": "DOC",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document": "DOCX",
+	"application/vnd.ms-excel": "XLS",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "XLSX",
+	"application/vnd.ms-powerpoint": "PPT",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation": "PPTX"
+};
+/** Human description of an accept list: `"Images, PDF"`. */
+function describeAccept(accept) {
+	const words = accept.map((token) => {
+		if (token === "image/*") return "Images";
+		if (token === "video/*") return "Videos";
+		if (token === "audio/*") return "Audio";
+		if (token === "text/*") return "Text files";
+		if (token.startsWith(".")) return token.slice(1).toUpperCase();
+		if (MIME_NAMES[token]) return MIME_NAMES[token];
+		return (token.split("/")[1] ?? token).replace(/^(x-|vnd\.)/, "").split(/[.+-]/)[0].toUpperCase();
+	});
+	return Array.from(new Set(words)).join(", ");
+}
+function validateFile(file, rules, items) {
+	const errors = [];
+	if (!isFileAccepted(file, rules.accept)) errors.push({
+		code: "file-invalid-type",
+		message: `${file.name} isn't an accepted file type (${describeAccept(rules.accept)}).`
+	});
+	if (rules.maxSize !== void 0 && file.size > rules.maxSize) errors.push({
+		code: "file-too-large",
+		message: `${file.name} is ${formatBytes(file.size)}; the limit is ${formatBytes(rules.maxSize)}.`
+	});
+	if (rules.minSize !== void 0 && file.size < rules.minSize) errors.push({
+		code: "file-too-small",
+		message: `${file.name} is smaller than the ${formatBytes(rules.minSize)} minimum.`
+	});
+	if (rules.validate) {
+		const custom = rules.validate(file, { items });
+		if (custom) errors.push({
+			code: "custom",
+			message: custom
+		});
+	}
+	return errors;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/core/errors.ts
+const BRAND = Symbol.for("upload-motion.UploadError");
+/** Error type produced by built-in transports and by the store when wrapping handler failures. */
+var UploadError = class extends Error {
+	constructor(code, message, init = {}) {
+		super(message, init.cause === void 0 ? void 0 : { cause: init.cause });
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "status", void 0);
+		_defineProperty(this, "retryable", void 0);
+		_defineProperty(this, "response", void 0);
+		_defineProperty(this, BRAND, true);
+		this.name = "UploadError";
+		this.code = code;
+		this.status = init.status;
+		this.response = init.response;
+		this.retryable = init.retryable ?? defaultRetryable(code, init.status);
+	}
+};
+function defaultRetryable(code, status) {
+	if (code === "network" || code === "timeout") return true;
+	if (code === "http" && status !== void 0) return status >= 500 || status === 408 || status === 429;
+	return code === "handler";
+}
+/** Works across bundle copies (no `instanceof` pitfalls). */
+function isUploadError(value) {
+	return typeof value === "object" && value !== null && value[BRAND] === true;
+}
+function httpErrorMessage(status) {
+	if (status === 401 || status === 403) return `Not allowed to upload (HTTP ${status})`;
+	if (status === 404) return "Upload endpoint not found (HTTP 404)";
+	if (status === 408) return "The server timed out (HTTP 408)";
+	if (status === 413) return "File is too large for the server (HTTP 413)";
+	if (status === 415) return "The server rejected this file type (HTTP 415)";
+	if (status === 429) return "Too many uploads – try again shortly (HTTP 429)";
+	if (status >= 500) return `Server error (HTTP ${status})`;
+	return `Upload failed (HTTP ${status})`;
+}
+function toUploadError(error) {
+	if (isUploadError(error)) return error;
+	if (error instanceof DOMException && error.name === "AbortError") return new UploadError("aborted", "Upload aborted", {
+		cause: error,
+		retryable: false
+	});
+	return new UploadError("handler", error instanceof Error && error.message ? error.message : "Upload failed", { cause: error });
+}
+//#endregion
+//#region src/core/store.ts
+let idCounter = 0;
+function createId(prefix) {
+	idCounter += 1;
+	return `${prefix}_${idCounter.toString(36)}${Math.random().toString(36).slice(2, 7)}`;
+}
+const now = () => Date.now();
+const scheduleFrame = typeof requestAnimationFrame === "function" ? (cb) => {
+	const handle = requestAnimationFrame(cb);
+	return () => cancelAnimationFrame(handle);
+} : (cb) => {
+	const handle = setTimeout(cb, 16);
+	return () => clearTimeout(handle);
+};
+const IN_FLIGHT = /* @__PURE__ */ new Set([
+	"queued",
+	"uploading",
+	"paused",
+	"success"
+]);
+function computeTotals(items) {
+	const totals = {
+		count: items.length,
+		progress: 0,
+		loaded: 0,
+		size: 0,
+		speed: 0,
+		eta: null,
+		pending: 0,
+		queued: 0,
+		uploading: 0,
+		paused: 0,
+		success: 0,
+		error: 0,
+		canceled: 0,
+		active: 0,
+		isUploading: false,
+		isComplete: false
+	};
+	let weighted = 0;
+	let weightedLoaded = 0;
+	for (const item of items) {
+		totals[item.status] += 1;
+		if (!IN_FLIGHT.has(item.status)) continue;
+		const weight = Math.max(item.size, 1);
+		weighted += weight;
+		weightedLoaded += item.status === "success" ? weight : item.progress * weight;
+		totals.size += item.size;
+		totals.loaded += item.status === "success" ? item.size : item.loaded;
+		if (item.status === "uploading") totals.speed += item.speed;
+	}
+	totals.progress = weighted > 0 ? clamp01(weightedLoaded / weighted) : 0;
+	totals.active = totals.queued + totals.uploading;
+	totals.isUploading = totals.uploading > 0;
+	totals.eta = totals.speed > 0 ? Math.max(0, (totals.size - totals.loaded) / totals.speed) : null;
+	totals.isComplete = totals.success > 0 && totals.pending + totals.queued + totals.uploading + totals.paused === 0;
+	return totals;
+}
+function normalizeIds(ids, all) {
+	if (ids === void 0) return [...all];
+	return typeof ids === "string" ? [ids] : [...ids];
+}
+function createUploadStore(initialOptions = {}) {
+	let options = initialOptions;
+	const items = /* @__PURE__ */ new Map();
+	let order = [];
+	const runtimes = /* @__PURE__ */ new Map();
+	let rejections = [];
+	let snapshot = null;
+	const listeners = /* @__PURE__ */ new Set();
+	const eventHandlers = /* @__PURE__ */ new Map();
+	let cancelScheduled = null;
+	let completeArmed = false;
+	function notify() {
+		if (cancelScheduled) {
+			cancelScheduled();
+			cancelScheduled = null;
+		}
+		for (const listener of [...listeners]) listener();
+	}
+	/** `sync` for state transitions, batched for progress ticks. */
+	function commit(sync) {
+		snapshot = null;
+		if (sync) notify();
+		else if (!cancelScheduled) cancelScheduled = scheduleFrame(() => {
+			cancelScheduled = null;
+			notify();
+		});
+		if (options.onChange) options.onChange(order.map((id) => items.get(id)));
+	}
+	function emit(event, payload) {
+		const handlers = eventHandlers.get(event);
+		if (handlers) for (const handler of [...handlers]) handler(payload);
+	}
+	function patch(id, changes) {
+		const current = items.get(id);
+		if (!current) return void 0;
+		const next = {
+			...current,
+			...changes
+		};
+		items.set(id, next);
+		return next;
+	}
+	function runtime(id) {
+		let rt = runtimes.get(id);
+		if (!rt) {
+			rt = {
+				controller: null,
+				reason: null,
+				lastTime: 0,
+				lastLoaded: 0,
+				autoRetries: 0,
+				retryTimer: null
+			};
+			runtimes.set(id, rt);
+		}
+		return rt;
+	}
+	function clearRetryTimer(id) {
+		const rt = runtimes.get(id);
+		if (rt?.retryTimer) {
+			clearTimeout(rt.retryTimer);
+			rt.retryTimer = null;
+		}
+	}
+	function retryConfig() {
+		const retry = options.retry;
+		if (typeof retry === "number") return {
+			attempts: retry,
+			delay: 800
+		};
+		return {
+			attempts: retry?.attempts ?? 0,
+			delay: retry?.delay ?? 800
+		};
+	}
+	function pump() {
+		if (!options.upload) return;
+		const limit = Math.max(1, Math.floor(options.concurrency ?? 3));
+		let active = 0;
+		for (const id of order) if (items.get(id)?.status === "uploading") active += 1;
+		const t = now();
+		for (const id of order) {
+			if (active >= limit) break;
+			const item = items.get(id);
+			if (item?.status === "queued" && (item.retryAt === null || item.retryAt <= t)) {
+				run(id);
+				active += 1;
+			}
+		}
+	}
+	function checkComplete() {
+		if (!completeArmed) return;
+		const list = order.map((id) => items.get(id));
+		if (list.some((item) => item.status === "queued" || item.status === "uploading")) return;
+		completeArmed = false;
+		const settled = list.filter((item) => item.startedAt !== null);
+		emit("complete", settled);
+		options.onQueueComplete?.(settled);
+	}
+	function run(id) {
+		const handler = options.upload;
+		const initial = items.get(id);
+		if (!handler || !initial) return;
+		completeArmed = true;
+		const rt = runtime(id);
+		const controller = new AbortController();
+		rt.controller = controller;
+		rt.reason = null;
+		rt.lastTime = now();
+		rt.lastLoaded = 0;
+		const started = patch(id, {
+			status: "uploading",
+			progress: 0,
+			loaded: 0,
+			speed: 0,
+			eta: null,
+			attempts: initial.attempts + 1,
+			error: null,
+			startedAt: now(),
+			completedAt: null,
+			retryAt: null
+		});
+		commit(true);
+		emit("start", started);
+		options.onUploadStart?.(started);
+		let settled = false;
+		const onProgress = (loaded, total) => {
+			if (settled || controller.signal.aborted) return;
+			const current = items.get(id);
+			if (!current || current.status !== "uploading") return;
+			const denominator = total && total > 0 ? total : Math.max(current.size, 1);
+			const fraction = Math.max(current.progress, clamp01(loaded / denominator));
+			const fileLoaded = Math.round(fraction * current.size);
+			const t = now();
+			let speed = current.speed;
+			const dt = t - rt.lastTime;
+			if (dt >= 250) {
+				const instant = (fileLoaded - rt.lastLoaded) / dt * 1e3;
+				speed = speed > 0 ? speed * .6 + instant * .4 : instant;
+				rt.lastTime = t;
+				rt.lastLoaded = fileLoaded;
+			}
+			const eta = speed > 0 ? Math.max(0, (current.size - fileLoaded) / speed) : null;
+			const next = patch(id, {
+				progress: fraction,
+				loaded: fileLoaded,
+				speed,
+				eta
+			});
+			commit(false);
+			options.onUploadProgress?.(next);
+		};
+		const finish = (outcome) => {
+			if (settled) return;
+			settled = true;
+			rt.controller = null;
+			const reason = rt.reason;
+			rt.reason = null;
+			const current = items.get(id);
+			if (!current) {
+				pump();
+				checkComplete();
+				return;
+			}
+			if (reason === "pause") patch(id, {
+				status: "paused",
+				speed: 0,
+				eta: null
+			});
+			else if (reason === "cancel" || reason === "dispose") {
+				const canceled = patch(id, {
+					status: "canceled",
+					speed: 0,
+					eta: null
+				});
+				emit("cancel", canceled);
+				options.onUploadCancel?.(canceled);
+			} else if (outcome.ok) {
+				const done = patch(id, {
+					status: "success",
+					progress: 1,
+					loaded: current.size,
+					speed: 0,
+					eta: 0,
+					response: outcome.response,
+					completedAt: now()
+				});
+				rt.autoRetries = 0;
+				emit("success", done);
+				options.onUploadSuccess?.(done, outcome.response);
+			} else {
+				const error = toUploadError(outcome.error);
+				const retry = retryConfig();
+				if (error.code === "aborted") {
+					const canceled = patch(id, {
+						status: "canceled",
+						speed: 0,
+						eta: null,
+						error: null
+					});
+					emit("cancel", canceled);
+					options.onUploadCancel?.(canceled);
+				} else if (error.retryable && rt.autoRetries < retry.attempts) {
+					rt.autoRetries += 1;
+					const delay = retry.delay * 2 ** (rt.autoRetries - 1);
+					patch(id, {
+						status: "queued",
+						error,
+						speed: 0,
+						eta: null,
+						retryAt: now() + delay
+					});
+					rt.retryTimer = setTimeout(() => {
+						rt.retryTimer = null;
+						if (items.get(id)?.status === "queued") {
+							patch(id, { retryAt: null });
+							pump();
+							commit(true);
+						}
+					}, delay);
+				} else {
+					const failed = patch(id, {
+						status: "error",
+						error,
+						speed: 0,
+						eta: null
+					});
+					emit("error", failed);
+					options.onUploadError?.(failed, error);
+				}
+			}
+			commit(true);
+			pump();
+			checkComplete();
+		};
+		const context = {
+			file: started.file,
+			item: started,
+			signal: controller.signal,
+			attempt: started.attempts,
+			onProgress
+		};
+		Promise.resolve().then(() => handler(context)).then((response) => finish({
+			ok: true,
+			response
+		}), (error) => finish({
+			ok: false,
+			error
+		}));
+	}
+	function abortItem(id, reason) {
+		const rt = runtimes.get(id);
+		if (rt?.controller) {
+			rt.reason = reason;
+			rt.controller.abort(reason);
+			return true;
+		}
+		return false;
+	}
+	const store = {
+		getSnapshot() {
+			if (!snapshot) {
+				const list = order.map((id) => items.get(id));
+				const handler = options.upload;
+				snapshot = {
+					items: list,
+					rejections,
+					totals: computeTotals(list),
+					transport: handler ? handler.simulated ? "simulated" : "network" : "none"
+				};
+			}
+			return snapshot;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		on(event, handler) {
+			let set = eventHandlers.get(event);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				eventHandlers.set(event, set);
+			}
+			set.add(handler);
+			return () => set.delete(handler);
+		},
+		setOptions(next) {
+			const transportChanged = Boolean(next.upload) !== Boolean(options.upload) || next.upload?.simulated !== options.upload?.simulated;
+			options = next;
+			if (transportChanged) commit(true);
+			pump();
+		},
+		getOptions() {
+			return options;
+		},
+		getInitialOptions() {
+			return initialOptions;
+		},
+		addFiles(input) {
+			const files = Array.from(input);
+			const accept = parseAccept(options.accept);
+			const single = options.multiple === false;
+			const maxFiles = single ? 1 : options.maxFiles ?? Infinity;
+			const currentList = order.map((id) => items.get(id));
+			let slots = single ? 1 : maxFiles - currentList.length;
+			const acceptedFiles = [];
+			const rejected = [];
+			files.forEach((file, index) => {
+				const errors = validateFile(file, {
+					accept,
+					maxSize: options.maxSize,
+					minSize: options.minSize,
+					validate: options.validate
+				}, currentList);
+				if (errors.length === 0 && (slots <= 0 || single && index > 0)) errors.push({
+					code: "too-many-files",
+					message: single ? `Only one file can be uploaded – ${file.name} was skipped.` : `You can add up to ${maxFiles} ${maxFiles === 1 ? "file" : "files"} – ${file.name} was skipped.`
+				});
+				if (errors.length > 0) rejected.push({
+					id: createId("rej"),
+					file,
+					errors,
+					at: now()
+				});
+				else {
+					acceptedFiles.push(file);
+					slots -= 1;
+				}
+			});
+			if (single && acceptedFiles.length > 0 && order.length > 0) store.remove([...order]);
+			const autoStart = Boolean(options.upload) && options.autoUpload !== false;
+			const accepted = acceptedFiles.map((file) => {
+				const item = {
+					id: createId("file"),
+					file,
+					name: file.name,
+					size: file.size,
+					type: file.type,
+					extension: getExtension(file.name),
+					kind: getFileKind(file),
+					status: autoStart ? "queued" : "pending",
+					progress: 0,
+					loaded: 0,
+					speed: 0,
+					eta: null,
+					attempts: 0,
+					error: null,
+					response: void 0,
+					addedAt: now(),
+					startedAt: null,
+					completedAt: null,
+					retryAt: null
+				};
+				items.set(item.id, item);
+				order.push(item.id);
+				return item;
+			});
+			if (rejected.length > 0) rejections = [...rejections, ...rejected].slice(-20);
+			if (accepted.length > 0 || rejected.length > 0) commit(true);
+			if (accepted.length > 0) {
+				emit("added", accepted);
+				options.onFilesAdded?.(accepted);
+			}
+			if (rejected.length > 0) {
+				emit("rejected", rejected);
+				options.onFilesRejected?.(rejected);
+			}
+			pump();
+			return {
+				accepted,
+				rejected
+			};
+		},
+		start(ids) {
+			let changed = false;
+			for (const id of normalizeIds(ids, order)) if (items.get(id)?.status === "pending" && options.upload) {
+				patch(id, { status: "queued" });
+				changed = true;
+			}
+			if (changed) commit(true);
+			pump();
+		},
+		cancel(ids) {
+			let changed = false;
+			for (const id of normalizeIds(ids, order)) {
+				const item = items.get(id);
+				if (!item) continue;
+				clearRetryTimer(id);
+				if (item.status === "uploading") abortItem(id, "cancel");
+				else if (item.status === "queued" || item.status === "paused" || item.status === "pending") {
+					const canceled = patch(id, {
+						status: "canceled",
+						speed: 0,
+						eta: null,
+						retryAt: null
+					});
+					emit("cancel", canceled);
+					options.onUploadCancel?.(canceled);
+					changed = true;
+				}
+			}
+			if (changed) {
+				commit(true);
+				checkComplete();
+			}
+		},
+		retry(ids) {
+			let changed = false;
+			for (const id of normalizeIds(ids, order)) {
+				const item = items.get(id);
+				if (!item || item.status !== "error" && item.status !== "canceled") continue;
+				clearRetryTimer(id);
+				runtime(id).autoRetries = 0;
+				patch(id, {
+					status: options.upload ? "queued" : "pending",
+					error: null,
+					progress: 0,
+					loaded: 0,
+					speed: 0,
+					eta: null,
+					retryAt: null
+				});
+				changed = true;
+			}
+			if (changed) commit(true);
+			pump();
+		},
+		pause(ids) {
+			let changed = false;
+			for (const id of normalizeIds(ids, order)) {
+				const item = items.get(id);
+				if (!item) continue;
+				if (item.status === "uploading") abortItem(id, "pause");
+				else if (item.status === "queued") {
+					clearRetryTimer(id);
+					patch(id, {
+						status: "paused",
+						retryAt: null
+					});
+					changed = true;
+				}
+			}
+			if (changed) commit(true);
+		},
+		resume(ids) {
+			let changed = false;
+			for (const id of normalizeIds(ids, order)) if (items.get(id)?.status === "paused") {
+				patch(id, { status: options.upload ? "queued" : "pending" });
+				changed = true;
+			}
+			if (changed) commit(true);
+			pump();
+		},
+		remove(ids) {
+			const list = typeof ids === "string" ? [ids] : ids;
+			const removed = [];
+			for (const id of list) {
+				const item = items.get(id);
+				if (!item) continue;
+				clearRetryTimer(id);
+				abortItem(id, "remove");
+				items.delete(id);
+				runtimes.delete(id);
+				removed.push(item);
+			}
+			if (removed.length === 0) return;
+			const removedIds = new Set(removed.map((item) => item.id));
+			order = order.filter((id) => !removedIds.has(id));
+			commit(true);
+			for (const item of removed) {
+				emit("removed", item);
+				options.onFileRemoved?.(item);
+			}
+			pump();
+			checkComplete();
+		},
+		clear(filter = "all") {
+			const match = {
+				all: () => true,
+				completed: (item) => item.status === "success",
+				failed: (item) => item.status === "error",
+				canceled: (item) => item.status === "canceled"
+			};
+			const ids = order.filter((id) => match[filter](items.get(id)));
+			if (filter === "all") rejections = [];
+			if (ids.length > 0) store.remove(ids);
+			else if (filter === "all") commit(true);
+		},
+		dismissRejection(id) {
+			const next = id === void 0 ? [] : rejections.filter((rejection) => rejection.id !== id);
+			if (next.length !== rejections.length) {
+				rejections = next;
+				commit(true);
+			}
+		},
+		getItem(id) {
+			return items.get(id);
+		},
+		dispose() {
+			for (const id of order) {
+				clearRetryTimer(id);
+				abortItem(id, "dispose");
+			}
+			if (cancelScheduled) {
+				cancelScheduled();
+				cancelScheduled = null;
+			}
+		}
+	};
+	return store;
+}
+//#endregion
+//#region src/core/transports.ts
+function resolve(value, item) {
+	return typeof value === "function" ? value(item) : value;
+}
+function defaultParse(xhr) {
+	const text = xhr.responseText;
+	if ((xhr.getResponseHeader("content-type") ?? "").includes("json") || /^\s*[[{]/.test(text)) try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+	return text;
+}
+/**
+* Real network transport built on `XMLHttpRequest`, the only browser API that
+* reports upload progress for request bodies on HTTP/1.1.
+*/
+function createXhrUploader(options) {
+	const { method = "POST", body = "form-data", fieldName = "file", withCredentials = false, timeout = 0, parseResponse = defaultParse, isSuccess = (status) => status >= 200 && status < 300 } = options;
+	return async function xhrUpload({ file, item, signal, onProgress }) {
+		const [url, headers, fields] = await Promise.all([
+			resolve(options.url, item),
+			options.headers ? resolve(options.headers, item) : void 0,
+			options.formData ? resolve(options.formData, item) : void 0
+		]);
+		if (signal.aborted) throw new UploadError("aborted", "Upload aborted", { retryable: false });
+		return new Promise((resolvePromise, reject) => {
+			const xhr = new XMLHttpRequest();
+			xhr.open(method, url, true);
+			xhr.withCredentials = withCredentials;
+			xhr.timeout = timeout;
+			for (const [key, value] of Object.entries(headers ?? {})) xhr.setRequestHeader(key, value);
+			const onAbort = () => xhr.abort();
+			signal.addEventListener("abort", onAbort, { once: true });
+			const cleanup = () => signal.removeEventListener("abort", onAbort);
+			xhr.upload.onprogress = (event) => {
+				if (event.lengthComputable) onProgress(event.loaded, event.total);
+			};
+			xhr.onload = () => {
+				cleanup();
+				if (isSuccess(xhr.status)) {
+					try {
+						resolvePromise(parseResponse(xhr));
+					} catch (error) {
+						reject(new UploadError("invalid-response", "Could not read the server response", {
+							cause: error,
+							retryable: false
+						}));
+					}
+					return;
+				}
+				let response;
+				try {
+					response = defaultParse(xhr);
+				} catch {
+					response = void 0;
+				}
+				reject(new UploadError("http", (typeof response === "object" && response !== null && typeof response.error === "string" ? response.error : void 0) ?? httpErrorMessage(xhr.status), {
+					status: xhr.status,
+					response
+				}));
+			};
+			xhr.onerror = () => {
+				cleanup();
+				reject(new UploadError("network", "Network error – check your connection and try again"));
+			};
+			xhr.ontimeout = () => {
+				cleanup();
+				reject(new UploadError("timeout", "The upload timed out"));
+			};
+			xhr.onabort = () => {
+				cleanup();
+				reject(new UploadError("aborted", "Upload aborted", { retryable: false }));
+			};
+			if (body === "raw") xhr.send(file);
+			else {
+				const form = new FormData();
+				for (const [key, value] of Object.entries(fields ?? {})) form.append(key, value);
+				form.append(fieldName, file, file.name);
+				xhr.send(form);
+			}
+		});
+	};
+}
+/**
+* Demo transport: no bytes leave the browser. The returned handler is flagged
+* `simulated: true` so built-in components display a "Simulated" badge.
+*/
+function createSimulatedUploader(options = {}) {
+	const { speed = [15e5, 6e6], minDuration = 1400, failureRate = 0, latency = 250 } = options;
+	const handler = ({ file, signal, onProgress }) => new Promise((resolvePromise, reject) => {
+		const bytesPerSecond = Array.isArray(speed) ? speed[0] + Math.random() * (speed[1] - speed[0]) : speed;
+		const total = Math.max(file.size, 1);
+		const duration = Math.max(minDuration, total / bytesPerSecond * 1e3);
+		const failAt = Math.random() < failureRate ? .25 + Math.random() * .5 : Infinity;
+		let elapsed = 0;
+		let timer;
+		const tickMs = 80;
+		const abort = () => {
+			if (timer !== void 0) clearTimeout(timer);
+			reject(new UploadError("aborted", "Upload aborted", { retryable: false }));
+		};
+		if (signal.aborted) return abort();
+		signal.addEventListener("abort", abort, { once: true });
+		const tick = () => {
+			elapsed += tickMs * (.55 + Math.random() * .9);
+			const fraction = Math.min(elapsed / duration, 1);
+			if (fraction >= failAt) {
+				signal.removeEventListener("abort", abort);
+				reject(new UploadError("network", "Simulated network failure"));
+				return;
+			}
+			onProgress(Math.round(fraction * total), total);
+			if (fraction >= 1) {
+				signal.removeEventListener("abort", abort);
+				resolvePromise({
+					simulated: true,
+					name: file.name,
+					size: file.size
+				});
+				return;
+			}
+			timer = setTimeout(tick, tickMs);
+		};
+		timer = setTimeout(tick, latency);
+	});
+	return Object.assign(handler, { simulated: true });
+}
+//#endregion
+export { formatSpeed as C, formatPercent as S, getFileLabel as _, UploadError as a, formatBytes as b, toUploadError as c, parseAccept as d, validateFile as f, getFileKind as g, getExtension as h, createUploadStore as i, describeAccept as l, presetCatalog as m, createXhrUploader as n, httpErrorMessage as o, PRESET_INFO as p, computeTotals as r, isUploadError as s, createSimulatedUploader as t, isFileAccepted as u, isPreviewableImage as v, formatDuration as x, clamp01 as y };