@uploadcare/file-uploader 1.27.0 → 1.28.0-alpha.0

package/dist/LitUploaderBlock-BA34rzeU.js

@@ -0,0 +1,998 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.0 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T14:46:15.080Z
+*/
+import { $ as createCdnUrl, A as CameraSourceTypes, B as SharedInstance, I as activityBlockCtx, M as createL10n, N as getPluralForm, O as warnOnce, P as EventType, Q as stringToArray, R as uploaderBlockCtx, V as DEFAULT_CDN_CNAME, et as createCdnUrlModifiers, i as calculateMaxCenteredCropFrame, it as sharedConfigKey, j as LitBlock, lt as debounce, ot as UID, pt as PubSub, r as parseCropPreset } from "./Icon-CqTVC82Q.js";
+import { c as UploadSource, d as ACTIVITY_TYPES, f as deserializeCsv, l as browserFeatures, p as serializeCsv, s as ExternalUploadSource, u as browserInfo } from "./plugins-DxjsQUa8.js";
+import { n as PACKAGE_VERSION, t as PACKAGE_NAME } from "./env-B1nfXy9i.js";
+import { NetworkError, Queue, UploadError, getUserAgent, uploadFileGroup } from "@uploadcare/upload-client";
+var msToUnixTimestamp = (p) => typeof p == "number" ? Math.floor(p / 1e3) : 0;
+const isSecureTokenExpired = (p, { threshold: H }) => {
+	let { secureExpire: U } = p, W = msToUnixTimestamp(Date.now()), G = Number(U);
+	return W + msToUnixTimestamp(H) >= G;
+};
+var SecureUploadsManager = class extends SharedInstance {
+	constructor(...p) {
+		super(...p), this._secureToken = null;
+	}
+	async getSecureToken() {
+		let { secureSignature: p, secureExpire: H, secureUploadsSignatureResolver: U, secureUploadsExpireThreshold: W } = this._cfg;
+		if ((p || H) && U && console.warn("Both secureSignature/secureExpire and secureUploadsSignatureResolver are set. secureUploadsSignatureResolver will be used."), U) {
+			if (!this._secureToken || isSecureTokenExpired(this._secureToken, { threshold: W })) {
+				this._secureToken ? this._debugPrint("Secure signature is expired. Resolving a new one...") : this._debugPrint("Secure signature is not set yet.");
+				try {
+					let p = await U();
+					p ? !p.secureSignature || !p.secureExpire ? console.error("Secure signature resolver returned an invalid result:", p) : (this._debugPrint("Secure signature resolved:", p), this._debugPrint("Secure signature will expire in", (/* @__PURE__ */ new Date(Number(p.secureExpire) * 1e3)).toISOString()), this._secureToken = p) : (this._debugPrint("Secure signature resolver returned nothing."), this._secureToken = null);
+				} catch (p) {
+					console.error("Secure signature resolving failed. Falling back to the previous one.", p), this._sharedInstancesBag.telemetryManager.sendEventError(p, "secureUploadsSignatureResolver. Secure signature resolving failed. Falling back to the previous one.");
+				}
+			}
+			return this._secureToken;
+		}
+		return p && H ? (this._debugPrint("Secure signature and expire are set. Using them...", {
+			secureSignature: p,
+			secureExpire: H
+		}), {
+			secureSignature: p,
+			secureExpire: H
+		}) : null;
+	}
+	destroy() {
+		super.destroy(), this._secureToken = null;
+	}
+};
+const validateCollectionUploadError = (p, H) => {
+	if (p.failedCount > 0) return {
+		type: "SOME_FILES_HAS_ERRORS",
+		message: H.l10n("some-files-were-not-uploaded")
+	};
+}, validateMultiple = (p, H) => {
+	let U = p.totalCount, W = H.cfg.multiple ? H.cfg.multipleMin : 0, G = H.cfg.multiple ? H.cfg.multipleMax : 1;
+	if (W && U < W) return {
+		type: "TOO_FEW_FILES",
+		message: H.l10n("files-count-limit-error-too-few", {
+			min: W,
+			max: G,
+			total: U
+		}),
+		payload: {
+			total: U,
+			min: W,
+			max: G
+		}
+	};
+	if (G && U > G) return {
+		type: "TOO_MANY_FILES",
+		message: H.l10n("files-count-limit-error-too-many", {
+			min: W,
+			max: G,
+			total: U
+		}),
+		payload: {
+			total: U,
+			min: W,
+			max: G
+		}
+	};
+}, BASIC_IMAGE_WILDCARD = "image/*", HEIC_IMAGE_MIME_LIST = [
+	"image/heif",
+	"image/heif-sequence",
+	"image/heic",
+	"image/heic-sequence",
+	"image/avif",
+	"image/avif-sequence",
+	".heif",
+	".heifs",
+	".heic",
+	".heics",
+	".avif",
+	".avifs"
+], IMAGE_ACCEPT_LIST = (() => browserInfo.safariDesktop ? [BASIC_IMAGE_WILDCARD] : [BASIC_IMAGE_WILDCARD, ...HEIC_IMAGE_MIME_LIST])(), mergeFileTypes = (p) => p ? p.filter((p) => typeof p == "string").flatMap((p) => stringToArray(p)) : [], matchMimeType = (p, H) => H.some((H) => {
+	if (H.endsWith("*")) {
+		let U = H.replace("*", "");
+		return p.startsWith(U);
+	}
+	return p === H;
+}), matchExtension = (p, H) => H.some((H) => H.startsWith(".") ? p.toLowerCase().endsWith(H.toLowerCase()) : !1), fileIsImage = (p) => {
+	let H = p?.type;
+	return H ? matchMimeType(H, IMAGE_ACCEPT_LIST) : !1;
+}, validateFileType = (p, H) => {
+	let U = H.cfg.imgOnly, W = H.cfg.accept, G = mergeFileTypes([...U ? IMAGE_ACCEPT_LIST : [], W]);
+	if (!G.length) return;
+	let K = p.mimeType, q = p.name;
+	if (!K || !q) return;
+	let J = matchMimeType(K, G), Y = matchExtension(q, G);
+	if (!J && !Y) return {
+		type: "FORBIDDEN_FILE_TYPE",
+		message: H.l10n("file-type-not-allowed"),
+		payload: { entry: p }
+	};
+}, validateIsImage = (p, H) => {
+	let U = H.cfg.imgOnly, W = p.isImage;
+	if (!(!U || W) && !(!p.fileInfo && p.externalUrl) && !(!p.fileInfo && !p.mimeType)) return {
+		type: "NOT_AN_IMAGE",
+		message: H.l10n("images-only-accepted"),
+		payload: { entry: p }
+	};
+};
+var BASE = 1e3;
+const ByteUnitEnum = Object.freeze({
+	AUTO: "auto",
+	BYTE: "byte",
+	KB: "kb",
+	MB: "mb",
+	GB: "gb",
+	TB: "tb",
+	PB: "pb"
+});
+var round = (p) => Math.ceil(p * 100) / 100;
+const prettyBytes = (p, H = ByteUnitEnum.AUTO) => {
+	let U = H === ByteUnitEnum.AUTO;
+	return H === ByteUnitEnum.BYTE || U && p < BASE ** 1 ? `${p} ${getPluralForm("en-US", p) === "one" ? "byte" : "bytes"}` : H === ByteUnitEnum.KB || U && p < BASE ** 2 ? `${round(p / BASE ** 1)} KB` : H === ByteUnitEnum.MB || U && p < BASE ** 3 ? `${round(p / BASE ** 2)} MB` : H === ByteUnitEnum.GB || U && p < BASE ** 4 ? `${round(p / BASE ** 3)} GB` : H === ByteUnitEnum.TB || U && p < BASE ** 5 ? `${round(p / BASE ** 4)} TB` : `${round(p / BASE ** 5)} PB`;
+}, validateMaxSizeLimit = (p, H) => {
+	let U = H.cfg.maxLocalFileSizeBytes, W = p.size;
+	if (U && W && W > U) return {
+		type: "FILE_SIZE_EXCEEDED",
+		message: H.l10n("files-max-size-limit-error", { maxFileSize: prettyBytes(U) }),
+		payload: { entry: p }
+	};
+}, validateUploadError = (p, H) => {
+	let { internalId: U } = p;
+	if (!H._uploadCollection.hasItem(U)) return;
+	let W = H._uploadCollection.read(U)?.getValue("uploadError");
+	if (!W) return;
+	if (W instanceof UploadError) return {
+		type: "UPLOAD_ERROR",
+		message: W.message,
+		payload: {
+			entry: p,
+			error: W
+		}
+	};
+	if (W instanceof NetworkError) return {
+		type: "NETWORK_ERROR",
+		message: W.message,
+		payload: {
+			entry: p,
+			error: W
+		}
+	};
+	let G = W instanceof Error ? W : Error("Unknown error", { cause: W });
+	return {
+		type: "UNKNOWN_ERROR",
+		message: G.message,
+		payload: {
+			entry: p,
+			error: G
+		}
+	};
+};
+var LOG_TEXT = {
+	FILE_VALIDATION_FAILED: "File validator execution has failed",
+	FILE_VALIDATION_TIMEOUT: "File validator execution has timed out",
+	COLLECTION_VALIDATION_FAILED: "Collection validator execution has failed",
+	MISSING_ERROR_MESSAGE: "Missing message. We recommend adding message: value."
+}, getValidatorDescriptor = (p) => typeof p == "function" ? {
+	runOn: "change",
+	validator: p
+} : p, ValidationManager = class extends SharedInstance {
+	get _uploadCollection() {
+		return this._sharedInstancesBag.uploadCollection;
+	}
+	constructor(p) {
+		super(p), this._commonFileValidators = [
+			validateIsImage,
+			validateFileType,
+			validateMaxSizeLimit,
+			validateUploadError
+		], this._commonCollectionValidators = [validateMultiple, validateCollectionUploadError], this._queue = new Queue(20), this._runQueueDebounced = debounce(() => {
+			this._queue.run();
+		}, 500), this._isDestroyed = !1, this._entryValidationState = /* @__PURE__ */ new Map();
+		let H = debounce(() => {
+			this.runFileValidators("change"), this.runCollectionValidators();
+		}, 0);
+		this.addSub(this._ctx.sub(sharedConfigKey("maxLocalFileSizeBytes"), H)), this.addSub(this._ctx.sub(sharedConfigKey("multipleMin"), H)), this.addSub(this._ctx.sub(sharedConfigKey("multipleMax"), H)), this.addSub(this._ctx.sub(sharedConfigKey("multiple"), H)), this.addSub(this._ctx.sub(sharedConfigKey("imgOnly"), H)), this.addSub(this._ctx.sub(sharedConfigKey("accept"), H)), this.addSub(this._ctx.sub(sharedConfigKey("validationConcurrency"), (p) => {
+			this._queue.concurrency = p;
+		}));
+	}
+	runFileValidators(p, H) {
+		if (this._isDestroyed) return;
+		let U = H ?? this._uploadCollection.items();
+		for (let H of U) {
+			let U = this._uploadCollection.read(H);
+			U && this._runFileValidatorsForEntry(U, p);
+		}
+	}
+	runCollectionValidators() {
+		if (this._isDestroyed) return;
+		let p = this._sharedInstancesBag.api, H = p.getOutputCollectionState(), U = [], W = this._cfg.collectionValidators;
+		for (let G of [...this._commonCollectionValidators, ...W]) try {
+			let W = G(H, p);
+			if (!W) continue;
+			W && (U.push(this._addCustomTypeToValidationError(W)), W.message || console.warn(LOG_TEXT.MISSING_ERROR_MESSAGE));
+		} catch (p) {
+			console.warn(LOG_TEXT.COLLECTION_VALIDATION_FAILED, p);
+		}
+		this._ctx.pub("*collectionErrors", U), U.length > 0 && this._sharedInstancesBag.eventEmitter.emit(EventType.COMMON_UPLOAD_FAILED, () => p.getOutputCollectionState(), { debounce: !0 });
+	}
+	cleanupValidationForEntry(p) {
+		let H = this._entryValidationState.get(p.uid);
+		H && (H.abortController?.abort(), this._entryValidationState.delete(p.uid));
+	}
+	async _runFileValidatorsForEntry(p, H) {
+		if (this._isDestroyed) return;
+		let U = this._sharedInstancesBag.api, W = this._getEntryValidationState(p), G = W.promise ?? Promise.resolve(), K = (async () => {
+			if (this._isDestroyed || (await G, this._isDestroyed)) return;
+			let K = this._getValidatorDescriptorsForEntry(p, H);
+			if (K.length === 0 || !this._uploadCollection.hasItem(p.uid)) return;
+			p.setMultipleValues({
+				isQueuedForValidation: !0,
+				isValidationPending: !0
+			});
+			let q = U.getOutputItem(p.uid), J = new AbortController();
+			W.abortController = J;
+			let Y = this._cfg.validationTimeout, X = this._getValidatorDescriptors(), Z = new Set(K.map((p) => p.validator)), Q = [];
+			for (let p of X) if (!Z.has(p.validator)) {
+				let H = W.lastErrorThrownByValidator.get(p.validator);
+				H && Q.push(H);
+			}
+			let $ = K.map((p) => async () => {
+				if (this._isDestroyed) return;
+				let H = setTimeout(() => {
+					W.skippedValidators.add(p.validator), J.abort(), console.warn(LOG_TEXT.FILE_VALIDATION_TIMEOUT);
+				}, Y);
+				try {
+					let H = await p.validator(q, U, { signal: J.signal });
+					if (!H || J.signal.aborted) {
+						W.lastErrorThrownByValidator.set(p.validator, void 0);
+						return;
+					}
+					let G = this._addCustomTypeToValidationError(H);
+					W.lastErrorThrownByValidator.set(p.validator, G), Q.push(G), H.message || console.warn(LOG_TEXT.MISSING_ERROR_MESSAGE);
+				} catch (H) {
+					J.signal.aborted || (W.skippedValidators.add(p.validator), console.warn(LOG_TEXT.FILE_VALIDATION_FAILED, H), this._sharedInstancesBag.telemetryManager.sendEventError(H, `file validator. ${LOG_TEXT.FILE_VALIDATION_FAILED}`));
+				} finally {
+					clearTimeout(H), p.runOn !== "change" && W.skippedValidators.add(p.validator);
+				}
+			});
+			if (this._runQueueDebounced(), await this._queue.add(async () => {
+				this._isDestroyed || (p.setValue("isQueuedForValidation", !1), await Promise.all($.map((p) => p())).catch(() => {}));
+			}, { autoRun: !1 }), J.signal.aborted) {
+				p.setMultipleValues({
+					isQueuedForValidation: !1,
+					isValidationPending: !1
+				});
+				return;
+			}
+			p.setMultipleValues({
+				isValidationPending: !1,
+				isQueuedForValidation: !1,
+				errors: Q
+			});
+		})();
+		W.promise = K;
+		try {
+			await K;
+		} finally {
+			W.promise === K && (W.promise = void 0);
+		}
+	}
+	_addCustomTypeToValidationError(p) {
+		return {
+			...p,
+			type: p.type ?? "CUSTOM_ERROR"
+		};
+	}
+	_getEntryValidationState(p) {
+		let H = this._entryValidationState.get(p.uid);
+		if (H) return H;
+		let U = {
+			abortController: void 0,
+			skippedValidators: /* @__PURE__ */ new WeakSet(),
+			promise: void 0,
+			lastErrorThrownByValidator: /* @__PURE__ */ new WeakMap()
+		};
+		return this._entryValidationState.set(p.uid, U), U;
+	}
+	_getValidatorDescriptors() {
+		let p = this._cfg.fileValidators;
+		return [...this._commonFileValidators, ...p].map(getValidatorDescriptor);
+	}
+	_getValidatorDescriptorsForEntry(p, H) {
+		let U = this._getEntryValidationState(p);
+		return this._getValidatorDescriptors().filter((p) => !U.skippedValidators.has(p.validator)).filter((p) => p.runOn === H);
+	}
+	destroy() {
+		this._isDestroyed = !0, this._runQueueDebounced.cancel();
+		for (let p of this._entryValidationState.values()) p.abortController?.abort(), p.promise = void 0;
+		this._entryValidationState.clear();
+	}
+}, MSG_NAME = "[Typed State] Wrong property name: ", TypedData = class {
+	constructor(p) {
+		this._ctxId = UID.generateFastUid(), this._data = PubSub.registerCtx(p, this._ctxId);
+	}
+	get uid() {
+		return this._ctxId;
+	}
+	setValue(p, H) {
+		if (!this._data.has(p)) {
+			console.warn(`${MSG_NAME}${String(p)}`);
+			return;
+		}
+		this._data.read(p) !== H && this._data.pub(p, H);
+	}
+	setMultipleValues(p) {
+		for (let [H, U] of Object.entries(p)) this.setValue(H, U);
+	}
+	getValue(p) {
+		return this._data.has(p) || console.warn(`${MSG_NAME}${String(p)}`), this._data.read(p);
+	}
+	subscribe(p, H) {
+		return this._data.sub(p, H);
+	}
+	destroy() {
+		PubSub.deleteCtx(this._ctxId);
+	}
+}, TypedCollection = class p {
+	static {
+		this._destroyDelayMs = 1e4;
+	}
+	constructor(p) {
+		this._subsMap = Object.create(null), this._propertyObservers = /* @__PURE__ */ new Set(), this._collectionObservers = /* @__PURE__ */ new Set(), this._items = /* @__PURE__ */ new Set(), this._removed = /* @__PURE__ */ new Set(), this._added = /* @__PURE__ */ new Set(), this._markedToDestroy = /* @__PURE__ */ new Set(), this._initialValue = p.initialValue, this._ctxId = UID.generateFastUid(), this._data = PubSub.registerCtx({}, this._ctxId), this._watchList = p.watchList || [];
+		let H = Object.create(null);
+		this._notifyObservers = (p, U) => {
+			this._observeTimeout && window.clearTimeout(this._observeTimeout), H[p] || (H[p] = /* @__PURE__ */ new Set()), H[p].add(U), this._observeTimeout = window.setTimeout(() => {
+				Object.keys(H).length !== 0 && (this._propertyObservers.forEach((p) => {
+					p({ ...H });
+				}), H = Object.create(null));
+			}), this._scheduleDestroyMarkedItems();
+		}, p.handler && this.observeCollection(p.handler);
+	}
+	_notify() {
+		this._notifyTimeout && window.clearTimeout(this._notifyTimeout), this._notifyTimeout = window.setTimeout(() => {
+			let p = new Set(this._added), H = new Set(this._removed);
+			this._added.clear(), this._removed.clear();
+			for (let U of this._collectionObservers) U?.([...this._items], p, H);
+			this._scheduleDestroyMarkedItems();
+		});
+	}
+	_scheduleDestroyMarkedItems() {
+		this._markedToDestroy.size !== 0 && (this._destroyTimeout && window.clearTimeout(this._destroyTimeout), this._destroyTimeout = window.setTimeout(() => {
+			let p = [...this._markedToDestroy];
+			this._markedToDestroy.clear();
+			for (let H of p) H.destroy();
+		}, p._destroyDelayMs));
+	}
+	observeCollection(p) {
+		return this._collectionObservers.add(p), this._items.size > 0 && this._notify(), () => {
+			this.unobserveCollection(p);
+		};
+	}
+	unobserveCollection(p) {
+		this._collectionObservers.delete(p);
+	}
+	add(p) {
+		let H = new TypedData(this._initialValue);
+		for (let [U, W] of Object.entries(p)) H.setValue(U, W);
+		return this._items.add(H.uid), this._notify(), this._data.add(H.uid, H), this._added.add(H), this._watchList.forEach((p) => {
+			this._subsMap[H.uid] || (this._subsMap[H.uid] = []), this._subsMap[H.uid]?.push(H.subscribe(p, () => {
+				this._notifyObservers(p, H.uid);
+			}));
+		}), H.uid;
+	}
+	hasItem(p) {
+		return this._items.has(p);
+	}
+	read(p) {
+		return this._data.read(p) ?? null;
+	}
+	readProp(p, H) {
+		let U = this.read(p);
+		if (!U) throw Error(`TypedCollection#readProp: Item with id ${p} not found`);
+		return U.getValue(H);
+	}
+	publishProp(p, H, U) {
+		let W = this.read(p);
+		if (!W) throw Error(`TypedCollection#publishProp: Item with id ${p} not found`);
+		W.setValue(H, U);
+	}
+	remove(p) {
+		let H = this.read(p);
+		H && (this._removed.add(H), this._markedToDestroy.add(H)), this._items.delete(p), this._notify(), this._data.pub(p, void 0), this._subsMap[p]?.forEach((p) => {
+			p();
+		}), delete this._subsMap[p];
+	}
+	clearAll() {
+		this._items.forEach((p) => {
+			this.remove(p);
+		});
+	}
+	observeProperties(p) {
+		return this._propertyObservers.add(p), () => {
+			this.unobserveProperties(p);
+		};
+	}
+	unobserveProperties(p) {
+		this._propertyObservers.delete(p);
+	}
+	findItems(p) {
+		let H = [];
+		return this._items.forEach((U) => {
+			let W = this.read(U);
+			W && p(W) && H.push(U);
+		}), H;
+	}
+	items() {
+		return [...this._items];
+	}
+	get size() {
+		return this._items.size;
+	}
+	destroy() {
+		this._observeTimeout && window.clearTimeout(this._observeTimeout), this._notifyTimeout && window.clearTimeout(this._notifyTimeout), this._destroyTimeout && window.clearTimeout(this._destroyTimeout);
+		for (let p of this._markedToDestroy) p.destroy();
+		this._markedToDestroy.clear(), PubSub.deleteCtx(this._ctxId), this._propertyObservers = /* @__PURE__ */ new Set(), this._collectionObservers = /* @__PURE__ */ new Set();
+		for (let p of Object.keys(this._subsMap)) this._subsMap[p]?.forEach((p) => {
+			p();
+		}), delete this._subsMap[p];
+	}
+};
+const calcCameraModes = (p) => ({
+	isVideoRecordingEnabled: deserializeCsv(p.cameraModes).includes(CameraSourceTypes.VIDEO),
+	isPhotoEnabled: deserializeCsv(p.cameraModes).includes(CameraSourceTypes.PHOTO)
+}), findBlockInCtx = (p, H) => {
+	for (let U of p) if (H(U)) return U;
+}, hasBlockInCtx = (p, H) => {
+	for (let U of p) if (H(U)) return !0;
+	return !1;
+};
+function applyStyles(p, H) {
+	for (let U in H) U.includes("-") ? p.style.setProperty(U, String(H[U])) : p.style[U] = String(H[U]);
+}
+var cdnUrlRegex = RegExp("^/?([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})(?:/(-/(?:[^/]+/)+)?([^/]*))?$", "i");
+const parseCdnUrl = ({ url: p, cdnBase: H }) => {
+	let U = new URL(H), W = new URL(DEFAULT_CDN_CNAME), G = new URL(p);
+	if (U.host !== G.host && W.host !== G.host) return null;
+	let K = cdnUrlRegex.exec(G.pathname);
+	if (!K) return null;
+	let [, q, J, Y] = K;
+	return q ? {
+		uuid: q,
+		cdnUrlModifiers: J || "",
+		filename: Y || null
+	} : null;
+}, getOutputData = (p) => p.uploadCollection.items().map((H) => p.api.getOutputItem(H));
+function memoize(p) {
+	let H = /* @__PURE__ */ new Map();
+	return (...U) => {
+		let W = JSON.stringify(U);
+		if (H.has(W)) return H.get(W);
+		let G = p(...U);
+		return H.set(W, G), G;
+	};
+}
+function createAsyncAssertWrapper(p) {
+	let H = !1;
+	return setTimeout(() => {
+		H = !0;
+	}, 0), (U) => ((...W) => (H && warnOnce(p), U(...W)));
+}
+function buildOutputCollectionState(p) {
+	let H = {}, U = p.ctx, W = {
+		progress: () => U.read("*commonProgress"),
+		errors: () => U.read("*collectionErrors"),
+		group: () => U.read("*groupInfo"),
+		totalCount: () => p.uploadCollection.size,
+		failedCount: () => H.failedEntries.length,
+		successCount: () => H.successEntries.length,
+		uploadingCount: () => H.uploadingEntries.length,
+		status: () => H.isFailed ? "failed" : H.isUploading ? "uploading" : H.isSuccess ? "success" : "idle",
+		isSuccess: () => H.allEntries.length > 0 && H.errors.length === 0 && H.successEntries.length === H.allEntries.length,
+		isUploading: () => H.allEntries.some((p) => p.status === "uploading"),
+		isFailed: () => H.errors.length > 0 || H.failedEntries.length > 0,
+		allEntries: () => getOutputData(p),
+		successEntries: () => H.allEntries.filter((p) => p.status === "success"),
+		failedEntries: () => H.allEntries.filter((p) => p.status === "failed"),
+		uploadingEntries: () => H.allEntries.filter((p) => p.status === "uploading"),
+		idleEntries: () => H.allEntries.filter((p) => p.status === "idle")
+	}, G = createAsyncAssertWrapper("You're trying to access the OutputCollectionState asynchronously. In this case, the data you retrieve will be newer than it was when the OutputCollectionState was created or when the event was dispatched. If you want to retain the state at a specific moment in time, you should use the spread operator like this: `{...outputCollectionState}` or `{...e.detail}`");
+	for (let [p, U] of Object.entries(W)) {
+		let W = p, K = memoize(G(U));
+		Object.defineProperty(H, W, {
+			get: K,
+			enumerable: !0
+		});
+	}
+	return H;
+}
+var UploaderPublicApi = class extends SharedInstance {
+	constructor(...p) {
+		super(...p), this._l10n = createL10n(() => this._ctx), this.addFileFromUrl = (p, { silent: H, fileName: U, source: W } = {}) => {
+			let G = this._uploadCollection.add({
+				externalUrl: p,
+				fileName: U ?? null,
+				silent: H ?? !1,
+				source: W ?? UploadSource.API
+			});
+			return this.getOutputItem(G);
+		}, this.addFileFromUuid = (p, { silent: H, fileName: U, source: W } = {}) => {
+			let G = this._uploadCollection.add({
+				uuid: p,
+				fileName: U ?? null,
+				silent: H ?? !1,
+				source: W ?? UploadSource.API
+			});
+			return this.getOutputItem(G);
+		}, this.addFileFromCdnUrl = (p, { silent: H, fileName: U, source: W } = {}) => {
+			let G = parseCdnUrl({
+				url: p,
+				cdnBase: this.cfg.cdnCname
+			});
+			if (!G) throw Error("Invalid CDN URL");
+			let K = this._uploadCollection.add({
+				uuid: G.uuid,
+				cdnUrl: p,
+				cdnUrlModifiers: G.cdnUrlModifiers,
+				fileName: U ?? G.filename ?? null,
+				silent: H ?? !1,
+				source: W ?? UploadSource.API
+			});
+			return this.getOutputItem(K);
+		}, this.addFileFromObject = (p, { silent: H, fileName: U, source: W, fullPath: G } = {}) => {
+			let K = this._uploadCollection.add({
+				file: p,
+				isImage: fileIsImage(p),
+				mimeType: p.type,
+				fileName: U ?? p.name,
+				fileSize: p.size,
+				silent: H ?? !1,
+				source: W ?? UploadSource.API,
+				fullPath: G ?? null
+			});
+			return this.getOutputItem(K);
+		}, this.removeFileByInternalId = (p) => {
+			if (!this._uploadCollection.read(p)) throw Error(`File with internalId ${p} not found`);
+			this._uploadCollection.remove(p);
+		}, this.uploadAll = () => {
+			let p = this._uploadCollection.items().filter((p) => {
+				let H = this._uploadCollection.read(p);
+				return H ? !H.getValue("isRemoved") && !H.getValue("isUploading") && !H.getValue("fileInfo") && H.getValue("errors").length === 0 && !H.getValue("isValidationPending") && !H.getValue("isQueuedForValidation") : !1;
+			});
+			p.length !== 0 && (this._ctx.pub("*uploadTrigger", new Set(p)), this._sharedInstancesBag.eventEmitter.emit(EventType.COMMON_UPLOAD_START, this.getOutputCollectionState()));
+		}, this.openSystemDialog = (p = {}) => {
+			let U = serializeCsv(mergeFileTypes([this.cfg.accept ?? "", ...this.cfg.imgOnly ? IMAGE_ACCEPT_LIST : []])), W = "uploadcare-file-input", G = document.createElement("input");
+			if (G.setAttribute(W, ""), applyStyles(G, {
+				opacity: 0,
+				height: 0,
+				width: 0,
+				visibility: "hidden",
+				position: "absolute",
+				top: 0,
+				left: 0
+			}), G.type = "file", G.multiple = this.cfg.multiple, p.captureCamera) {
+				G.capture = this.cfg.cameraCapture;
+				let { isPhotoEnabled: U, isVideoRecordingEnabled: W } = calcCameraModes(this.cfg);
+				p.modeCamera === CameraSourceTypes.PHOTO && U ? G.accept = BASIC_IMAGE_WILDCARD : p.modeCamera === CameraSourceTypes.VIDEO && W ? G.accept = "video/*" : G.accept = [BASIC_IMAGE_WILDCARD, W && "video/*"].filter(Boolean).join(",");
+			} else G.accept = U;
+			G.addEventListener("change", () => {
+				G.files && ([...G.files].forEach((H) => {
+					this.addFileFromObject(H, { source: p.captureCamera ? UploadSource.CAMERA : UploadSource.LOCAL });
+				}), this._ctx.pub("*currentActivity", ACTIVITY_TYPES.UPLOAD_LIST), this._sharedInstancesBag.modalManager?.open(ACTIVITY_TYPES.UPLOAD_LIST), G.remove());
+			}, { once: !0 }), document.querySelectorAll(`[${W}]`).forEach((p) => {
+				p.remove();
+			}), document.body.appendChild(G), G.dispatchEvent(new MouseEvent("click"));
+		}, this.initFlow = (p = !1) => {
+			if (this._uploadCollection.size > 0 && !p) this._ctx.pub("*currentActivity", ACTIVITY_TYPES.UPLOAD_LIST), this._sharedInstancesBag.modalManager?.open(ACTIVITY_TYPES.UPLOAD_LIST);
+			else if (this._sourceList?.length === 1) {
+				let p = this._sourceList[0];
+				if (p === "local") {
+					this._ctx.pub("*currentActivity", ACTIVITY_TYPES.UPLOAD_LIST), this.openSystemDialog();
+					return;
+				}
+				if (p === "camera" && browserFeatures.htmlMediaCapture) {
+					let { isPhotoEnabled: p, isVideoRecordingEnabled: U } = calcCameraModes(this.cfg);
+					if (p && U) {
+						this._ctx.pub("*currentActivity", ACTIVITY_TYPES.START_FROM);
+						return;
+					} else if (p || U) {
+						this.openSystemDialog({
+							captureCamera: !0,
+							modeCamera: p ? CameraSourceTypes.PHOTO : CameraSourceTypes.VIDEO
+						});
+						return;
+					} else this.openSystemDialog({
+						captureCamera: !0,
+						modeCamera: CameraSourceTypes.PHOTO
+					});
+				}
+				setTimeout(() => {
+					if (p !== this._sourceList[0]) return;
+					let H = this._sharedInstancesBag.blocksRegistry;
+					findBlockInCtx(H, (H) => "type" in H && H.type === p)?.activate();
+				}, 0), this._ctx.read("*currentActivity") && this._sharedInstancesBag.modalManager?.open(this._ctx.read("*currentActivity"));
+			} else this._ctx.pub("*currentActivity", ACTIVITY_TYPES.START_FROM), this._sharedInstancesBag.modalManager?.open(ACTIVITY_TYPES.START_FROM);
+		}, this.doneFlow = () => {
+			let p = findBlockInCtx(this._sharedInstancesBag.blocksRegistry, (p) => "doneActivity" in p);
+			p && (this._ctx.pub("*currentActivity", p.doneActivity), this._ctx.pub("*history", p.doneActivity ? [p.doneActivity] : []), this._ctx.read("*currentActivity") || this._sharedInstancesBag.modalManager?.closeAll());
+		}, this.setCurrentActivity = (p, ...H) => {
+			setTimeout(() => {
+				if (hasBlockInCtx(this._sharedInstancesBag.blocksRegistry, (H) => H.activityType === p)) {
+					this._ctx.pub("*currentActivityParams", H[0] ?? {}), this._ctx.pub("*currentActivity", p);
+					return;
+				}
+				console.warn(`Activity type "${p}" not found in the context`);
+			});
+		}, this.getCurrentActivity = () => this._ctx.read("*currentActivity"), this.setModalState = (p) => {
+			setTimeout(() => {
+				if (p && !this._ctx.read("*currentActivity")) {
+					console.warn("Can't open modal without current activity. Please use \"setCurrentActivity\" method first.");
+					return;
+				}
+				p ? this._sharedInstancesBag.modalManager?.open(this._ctx.read("*currentActivity")) : (this._sharedInstancesBag.modalManager?.close(this._ctx.read("*currentActivity")), this._ctx.pub("*currentActivity", null));
+			});
+		};
+	}
+	get _uploadCollection() {
+		return this._sharedInstancesBag.uploadCollection;
+	}
+	get cfg() {
+		return this._cfg;
+	}
+	get l10n() {
+		return this._l10n;
+	}
+	removeAllFiles() {
+		this._uploadCollection.clearAll();
+	}
+	getOutputItem(p) {
+		let H = PubSub.getCtx(p);
+		if (!H) throw Error(`UploaderPublicApi#getOutputItem: Entry with ID "${p}" not found in the upload collection`);
+		let U = H.store, W = U.fileInfo, G = U.isRemoved ? "removed" : U.errors.length > 0 ? "failed" : U.fileInfo ? "success" : U.isUploading ? "uploading" : "idle";
+		return {
+			uuid: W?.uuid ?? U.uuid ?? null,
+			internalId: p,
+			name: W?.originalFilename ?? U.fileName,
+			size: W?.size ?? U.fileSize,
+			isImage: W?.isImage ?? U.isImage,
+			mimeType: W?.mimeType ?? U.mimeType,
+			file: U.file,
+			externalUrl: U.externalUrl,
+			cdnUrlModifiers: U.cdnUrlModifiers,
+			cdnUrl: U.cdnUrl ?? W?.cdnUrl ?? null,
+			fullPath: U.fullPath,
+			uploadProgress: U.uploadProgress,
+			fileInfo: W ?? null,
+			metadata: U.metadata ?? W?.metadata ?? null,
+			isSuccess: G === "success",
+			isUploading: G === "uploading",
+			isFailed: G === "failed",
+			isRemoved: G === "removed",
+			isValidationPending: U.isValidationPending,
+			errors: U.errors,
+			status: G,
+			source: U?.source
+		};
+	}
+	getOutputCollectionState() {
+		return buildOutputCollectionState(this._sharedInstancesBag);
+	}
+	get _sourceList() {
+		let p = [];
+		return this.cfg.sourceList && (p = stringToArray(this.cfg.sourceList)), p;
+	}
+};
+const initialUploadEntryData = {
+	file: null,
+	externalUrl: null,
+	fileName: null,
+	fileSize: null,
+	lastModified: Date.now(),
+	uploadProgress: 0,
+	uuid: null,
+	isImage: !1,
+	mimeType: null,
+	ctxName: null,
+	cdnUrl: null,
+	cdnUrlModifiers: null,
+	fileInfo: null,
+	isUploading: !1,
+	abortController: null,
+	thumbUrl: null,
+	silent: !1,
+	source: null,
+	fullPath: null,
+	metadata: null,
+	errors: [],
+	uploadError: null,
+	isRemoved: !1,
+	isQueuedForUploading: !1,
+	isValidationPending: !1,
+	isQueuedForValidation: !1
+};
+function customUserAgent(p) {
+	return getUserAgent({
+		...p,
+		libraryName: PACKAGE_NAME,
+		libraryVersion: PACKAGE_VERSION
+	});
+}
+var ACTIVE_ATTR = "active", ACTIVE_PROP = "___ACTIVITY_IS_ACTIVE___", LitActivityBlock = class p extends LitBlock {
+	constructor(...p) {
+		super(...p), this.historyTracked = !1, this.init$ = activityBlockCtx(this), this._debouncedHistoryFlush = debounce(this._historyFlush.bind(this), 10);
+	}
+	_deactivate() {
+		let H = p._activityCallbacks.get(this);
+		this[ACTIVE_PROP] = !1, this.removeAttribute(ACTIVE_ATTR), H?.deactivateCallback?.();
+	}
+	_activate() {
+		let H = p._activityCallbacks.get(this);
+		this.$["*historyBack"] = this.historyBack.bind(this), this[ACTIVE_PROP] = !0, this.setAttribute(ACTIVE_ATTR, ""), H?.activateCallback?.(), this._debouncedHistoryFlush(), this.emit(EventType.ACTIVITY_CHANGE, { activity: this.activityType });
+	}
+	initCallback() {
+		super.initCallback(), this.activityType && (this.hasAttribute("activity") || this.setAttribute("activity", this.activityType), this.sub("*currentActivity", (p) => {
+			try {
+				this.activityType !== p && this[ACTIVE_PROP] ? this._deactivate() : this.activityType === p && !this[ACTIVE_PROP] && this._activate();
+			} catch (p) {
+				this.telemetryManager.sendEventError(p, `activity "${this.activityType}"`), console.error(`Error in activity "${this.activityType}". `, p);
+				let H = this.$["*history"][this.$["*history"].length - 1];
+				this.$["*currentActivity"] = H ?? null;
+			}
+			p || (this.$["*history"] = []);
+		}));
+	}
+	_historyFlush() {
+		let p = this.$["*history"];
+		p && (p.length > 10 && (p = p.slice(p.length - 11, p.length - 1)), this.historyTracked && p[p.length - 1] !== this.activityType && p.push(this.activityType), this.$["*history"] = p);
+	}
+	_isActivityRegistered() {
+		return !!this.activityType && p._activityCallbacks.has(this);
+	}
+	static {
+		this._activityCallbacks = /* @__PURE__ */ new Map();
+	}
+	get isActivityActive() {
+		return !!this[ACTIVE_PROP];
+	}
+	get couldOpenActivity() {
+		return !0;
+	}
+	registerActivity(H, U = {}) {
+		let { onActivate: W, onDeactivate: G } = U;
+		p._activityCallbacks.set(this, {
+			activateCallback: W,
+			deactivateCallback: G
+		});
+	}
+	_unregisterActivity() {
+		this.isActivityActive && this._deactivate(), p._activityCallbacks.delete(this);
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback(), this._isActivityRegistered() && this._unregisterActivity();
+		let H = this.$["*currentActivity"];
+		this.blocksRegistry && ([...this.blocksRegistry].find((U) => U instanceof p && U.activityType === H) || (this.$["*currentActivity"] = null, this.modalManager?.closeAll()));
+	}
+	get activityParams() {
+		return this.$["*currentActivityParams"];
+	}
+	get initActivity() {
+		return this.getCssData("--cfg-init-activity") ?? null;
+	}
+	get doneActivity() {
+		return this.getCssData("--cfg-done-activity") ?? null;
+	}
+	historyBack() {
+		let p = this.$["*history"];
+		if (p) {
+			let H = p.pop();
+			for (; H === this.activityType;) H = p.pop();
+			let U = !!H;
+			H && (U = [...this.blocksRegistry].find((p) => p.activityType === H)?.couldOpenActivity ?? !1), H = U ? H : null, this.$["*currentActivity"] = H ?? null, H && this.modalManager?.open(H), this.$["*history"] = p, H || this.modalManager?.closeAll();
+		}
+	}
+};
+LitActivityBlock.activities = ACTIVITY_TYPES;
+var LitUploaderBlock = class H extends LitActivityBlock {
+	constructor(...p) {
+		super(...p), this.couldBeCtxOwner = !1, this._isCtxOwner = !1, this.init$ = uploaderBlockCtx(this), this._flushOutputItems = debounce(async () => {
+			if (this.getOutputData().length !== this.uploadCollection.size) return;
+			let p = this.api.getOutputCollectionState();
+			this.$["*collectionState"] = p, this.emit(EventType.CHANGE, () => this.api.getOutputCollectionState(), { debounce: !0 }), this.cfg.groupOutput && p.totalCount > 0 && p.status === "success" && this._createGroup(p);
+		}, 300), this._handleCollectionUpdate = (p, H, U) => {
+			if (this.isConnected) {
+				(H.size || U.size) && (this.$["*groupInfo"] = null), this.validationManager.runFileValidators("add", [...H].map((p) => p.uid));
+				for (let p of H) p.getValue("silent") || this.emit(EventType.FILE_ADDED, this.api.getOutputItem(p.uid));
+				this.validationManager.runCollectionValidators();
+				for (let p of U) {
+					this.$["*uploadTrigger"].delete(p.uid), this.validationManager.cleanupValidationForEntry(p), p.getValue("abortController")?.abort(), p.setMultipleValues({
+						isRemoved: !0,
+						abortController: null,
+						isUploading: !1,
+						uploadProgress: 0
+					});
+					let H = p?.getValue("thumbUrl");
+					H && URL.revokeObjectURL(H), this.emit(EventType.FILE_REMOVED, this.api.getOutputItem(p.uid));
+				}
+				this.$["*uploadList"] = p.map((p) => ({ uid: p })), this._flushCommonUploadProgress(), this._flushOutputItems();
+			}
+		}, this._handleCollectionPropertiesUpdate = (p) => {
+			if (!this.isConnected) return;
+			this._flushOutputItems();
+			let H = this.uploadCollection, U = [...new Set(Object.entries(p).filter(([p]) => [
+				"uploadError",
+				"fileInfo",
+				"cdnUrl",
+				"cdnUrlModifiers"
+			].includes(p)).flatMap(([, p]) => [...p]))];
+			if (U.length > 0 && setTimeout(() => {
+				if (!this.isConnected) return;
+				let H = U.filter((H) => p.fileInfo?.has(H) && !!PubSub.getCtx(H)?.store.fileInfo);
+				H.length > 0 && this.validationManager.runFileValidators("upload", H), this.validationManager.runFileValidators("change", U);
+			}), p.uploadProgress) {
+				for (let H of p.uploadProgress) {
+					let p = PubSub.getCtx(H);
+					if (!p) continue;
+					let { isUploading: U, silent: W } = p.store;
+					U && !W && this.emit(EventType.FILE_UPLOAD_PROGRESS, this.api.getOutputItem(H));
+				}
+				this._flushCommonUploadProgress();
+			}
+			if (p.isUploading) for (let H of p.isUploading) {
+				let p = PubSub.getCtx(H);
+				if (!p) continue;
+				let { isUploading: U, silent: W } = p.store;
+				U && !W && this.emit(EventType.FILE_UPLOAD_START, this.api.getOutputItem(H));
+			}
+			if (p.fileInfo) {
+				for (let H of p.fileInfo) {
+					let p = PubSub.getCtx(H);
+					if (!p) continue;
+					let { fileInfo: U, silent: W } = p.store;
+					U && !W && this.emit(EventType.FILE_UPLOAD_SUCCESS, this.api.getOutputItem(H));
+				}
+				this.cfg.cropPreset && this._setInitialCrop(), this.cfg.cloudImageEditorAutoOpen && this._openCloudImageEditor();
+			}
+			if (p.errors) {
+				this.validationManager.runCollectionValidators();
+				for (let H of p.errors) {
+					let p = PubSub.getCtx(H);
+					if (!p) continue;
+					let { errors: U } = p.store;
+					U.length > 0 && (this.emit(EventType.FILE_UPLOAD_FAILED, this.api.getOutputItem(H)), this.emit(EventType.COMMON_UPLOAD_FAILED, () => this.api.getOutputCollectionState(), { debounce: !0 }));
+				}
+				let U = H.findItems((p) => !!p.getValue("fileInfo")), W = H.findItems((p) => p.getValue("errors").length > 0);
+				H.size > 0 && W.length === 0 && H.size === U.length && this.$["*collectionErrors"].length === 0 && this.emit(EventType.COMMON_UPLOAD_SUCCESS, this.api.getOutputCollectionState());
+			}
+			p.cdnUrl && ([...p.cdnUrl].filter((p) => !!this.uploadCollection.read(p)?.getValue("cdnUrl")).forEach((p) => {
+				this.emit(EventType.FILE_URL_CHANGED, this.api.getOutputItem(p));
+			}), this.$["*groupInfo"] = null);
+		}, this._flushCommonUploadProgress = () => {
+			let p = 0, H = [...this.$["*uploadTrigger"]].filter((p) => !!this.uploadCollection.read(p));
+			H.forEach((H) => {
+				let U = this.uploadCollection.readProp(H, "uploadProgress");
+				typeof U == "number" && (p += U);
+			});
+			let U = H.length ? Math.round(p / H.length) : 0;
+			this.$["*commonProgress"] !== U && (this.$["*commonProgress"] = U, this.emit(EventType.COMMON_UPLOAD_PROGRESS, this.api.getOutputCollectionState()));
+		};
+	}
+	get _hasCtxOwner() {
+		return this.hasBlockInCtx((p) => p instanceof H ? p._isCtxOwner && p.isConnected && p !== this : !1);
+	}
+	initCallback() {
+		super.initCallback(), this._addSharedContextInstance("*uploadCollection", () => new TypedCollection({
+			initialValue: initialUploadEntryData,
+			watchList: [
+				"uploadProgress",
+				"uploadError",
+				"fileInfo",
+				"errors",
+				"cdnUrl",
+				"isUploading",
+				"isValidationPending"
+			]
+		})), this._addSharedContextInstance("*secureUploadsManager", (p) => new SecureUploadsManager(p)), this._addSharedContextInstance("*validationManager", (p) => new ValidationManager(p)), this._addSharedContextInstance("*publicApi", (p) => new UploaderPublicApi(p)), !this._hasCtxOwner && this.couldBeCtxOwner && this._initCtxOwner();
+	}
+	getAPI() {
+		return this.api;
+	}
+	get validationManager() {
+		return this._getSharedContextInstance("*validationManager");
+	}
+	get api() {
+		return this._getSharedContextInstance("*publicApi");
+	}
+	get uploadCollection() {
+		return this._getSharedContextInstance("*uploadCollection");
+	}
+	get secureUploadsManager() {
+		return this._getSharedContextInstance("*secureUploadsManager");
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback(), this._isCtxOwner && this._unobserveUploadCollection(), this._flushOutputItems.cancel();
+	}
+	connectedCallback() {
+		super.connectedCallback(), this._isCtxOwner && this._observeUploadCollection();
+	}
+	_initCtxOwner() {
+		this._isCtxOwner = !0, this._observeUploadCollection(), this.subConfigValue("maxConcurrentRequests", (p) => {
+			this.$["*uploadQueue"].concurrency = Number(p) || 1;
+		});
+	}
+	_observeUploadCollection() {
+		this._unobserveUploadCollection(), this._unobserveCollection = this.uploadCollection.observeCollection(this._handleCollectionUpdate), this._unobserveCollectionProperties = this.uploadCollection.observeProperties(this._handleCollectionPropertiesUpdate);
+	}
+	_unobserveUploadCollection() {
+		this._unobserveCollectionProperties?.(), this._unobserveCollection?.(), this._unobserveCollectionProperties = void 0, this._unobserveCollection = void 0;
+	}
+	async _createGroup(p) {
+		let H = await this.getUploadClientOptions(), U = p.allEntries.map((p) => p.uuid + (p.cdnUrlModifiers ? `/${p.cdnUrlModifiers}` : "")), W = new AbortController(), G = await uploadFileGroup(U, {
+			...H,
+			signal: W.signal
+		});
+		if (this.$["*collectionState"] !== p) {
+			W.abort();
+			return;
+		}
+		this.$["*groupInfo"] = G;
+		let K = this.api.getOutputCollectionState();
+		this.emit(EventType.GROUP_CREATED, K), this.emit(EventType.CHANGE, () => this.api.getOutputCollectionState(), { debounce: !0 }), this.$["*collectionState"] = K;
+	}
+	_openCloudImageEditor() {
+		let [p] = this.uploadCollection.findItems((p) => !!p.getValue("fileInfo") && p.getValue("isImage")).map((p) => this.uploadCollection.read(p));
+		p && this.uploadCollection.size === 1 && this.cfg.useCloudImageEditor && this.hasBlockInCtx((p) => p.activityType === LitActivityBlock.activities.CLOUD_IMG_EDIT) && (this.$["*currentActivityParams"] = { internalId: p.uid }, this.$["*currentActivity"] = LitActivityBlock.activities.CLOUD_IMG_EDIT, this.modalManager?.open(LitActivityBlock.activities.CLOUD_IMG_EDIT));
+	}
+	_setInitialCrop() {
+		let H = parseCropPreset(this.cfg.cropPreset);
+		if (H) {
+			let [U] = H, W = this.uploadCollection.findItems((p) => !!p.getValue("fileInfo") && p.getValue("isImage") && !p.getValue("cdnUrlModifiers")?.includes("/crop/")).map((p) => this.uploadCollection.read(p)).filter(Boolean);
+			for (let H of W) {
+				let W = H.getValue("fileInfo");
+				if (!W || !W.imageInfo) {
+					console.warn("Failed to get image info for entry", H.uid);
+					continue;
+				}
+				let { width: G, height: K } = W.imageInfo, q = calculateMaxCenteredCropFrame(G, K, typeof U?.width == "number" && typeof U?.height == "number" && U.width > 0 && U.height > 0 ? U.width / U.height : 1), J = createCdnUrlModifiers(`crop/${q.width}x${q.height}/${q.x},${q.y}`, "preview"), Y = H.getValue("cdnUrl");
+				if (!Y) {
+					console.warn("Failed to get cdnUrl for entry", H.uid);
+					continue;
+				}
+				H.setMultipleValues({
+					cdnUrlModifiers: J,
+					cdnUrl: createCdnUrl(Y, J)
+				}), this.uploadCollection.size === 1 && this.cfg.useCloudImageEditor && this.hasBlockInCtx((p) => p.activityType === LitActivityBlock.activities.CLOUD_IMG_EDIT) && (this.$["*currentActivityParams"] = { internalId: H.uid }, this.$["*currentActivity"] = LitActivityBlock.activities.CLOUD_IMG_EDIT, this.modalManager?.open(LitActivityBlock.activities.CLOUD_IMG_EDIT));
+			}
+		}
+	}
+	async getMetadataFor(p) {
+		let H = this.cfg.metadata || void 0;
+		return typeof H == "function" ? await H(this.api.getOutputItem(p)) : H;
+	}
+	async getUploadClientOptions() {
+		let p = await this.secureUploadsManager.getSecureToken().catch(() => null);
+		return {
+			store: this.cfg.store,
+			publicKey: this.cfg.pubkey,
+			baseCDN: this.cfg.cdnCname,
+			baseURL: this.cfg.baseUrl,
+			userAgent: customUserAgent,
+			integration: this.cfg.userAgentIntegration,
+			secureSignature: p?.secureSignature,
+			secureExpire: p?.secureExpire,
+			retryThrottledRequestMaxTimes: this.cfg.retryThrottledRequestMaxTimes,
+			retryNetworkErrorMaxTimes: this.cfg.retryNetworkErrorMaxTimes,
+			multipartMinFileSize: this.cfg.multipartMinFileSize,
+			multipartChunkSize: this.cfg.multipartChunkSize,
+			maxConcurrentRequests: this.cfg.multipartMaxConcurrentRequests,
+			multipartMaxAttempts: this.cfg.multipartMaxAttempts,
+			checkForUrlDuplicates: !!this.cfg.checkForUrlDuplicates,
+			saveUrlForRecurrentUploads: !!this.cfg.saveUrlForRecurrentUploads
+		};
+	}
+	getOutputData() {
+		return getOutputData(this._sharedInstancesBag);
+	}
+};
+LitUploaderBlock.extSrcList = Object.freeze({ ...ExternalUploadSource }), LitUploaderBlock.sourceTypes = Object.freeze({ ...UploadSource });
+export { LitActivityBlock as n, LitUploaderBlock as t };