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

package/web/plugins-CzNtrVQB.js

@@ -0,0 +1,562 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.1 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T20:26:09.550Z
+*/
+var EXCLUDE_COMPONENTS = [
+	"UploaderBlock",
+	"ActivityBlock",
+	"Block",
+	"SolutionBlock"
+];
+function defineComponents(H) {
+	for (let U in H) {
+		if (EXCLUDE_COMPONENTS.includes(U)) continue;
+		let W = [...U].reduce((p, H) => (H.toUpperCase() === H && (H = `-${H.toLowerCase()}`), p += H, p), "");
+		W.startsWith("-") && (W = W.replace("-", "")), W.startsWith("uc-") || (W = `uc-${W}`), H[U].reg && H[U].reg(W);
+	}
+}
+const deserializeCsv = (p) => p ? p.split(",").map((p) => p.trim()).filter(Boolean) : [], serializeCsv = (p) => p.join(","), ACTIVITY_TYPES = Object.freeze({
+	START_FROM: "start-from",
+	CAMERA: "camera",
+	UPLOAD_LIST: "upload-list",
+	URL: "url",
+	CLOUD_IMG_EDIT: "cloud-image-edit",
+	EXTERNAL: "external"
+});
+var calcIsDesktopSafari = () => {
+	let p = navigator.userAgent;
+	return /Macintosh|Windows/.test(p) && /Version\/[\d.]+.*Safari/.test(p) && !/Chrome|Chromium|Edg|OPR/.test(p);
+}, calcHtmlMediaCaptureSupport = () => "capture" in document.createElement("input");
+const calcBrowserInfo = () => ({ safariDesktop: calcIsDesktopSafari() }), calcBrowserFeatures = () => ({ htmlMediaCapture: calcHtmlMediaCaptureSupport() }), browserInfo = calcBrowserInfo(), browserFeatures = calcBrowserFeatures(), ExternalUploadSource = Object.freeze({
+	FACEBOOK: "facebook",
+	DROPBOX: "dropbox",
+	GDRIVE: "gdrive",
+	GPHOTOS: "gphotos",
+	FLICKR: "flickr",
+	VK: "vk",
+	EVERNOTE: "evernote",
+	BOX: "box",
+	ONEDRIVE: "onedrive",
+	HUDDLE: "huddle"
+}), UploadSourceMobile = Object.freeze({
+	MOBILE_VIDEO_CAMERA: "mobile-video-camera",
+	MOBILE_PHOTO_CAMERA: "mobile-photo-camera"
+}), UploadSource = Object.freeze({
+	LOCAL: "local",
+	DROP_AREA: "drop-area",
+	CAMERA: "camera",
+	EXTERNAL: "external",
+	API: "js-api",
+	URL: "url",
+	...UploadSourceMobile,
+	...ExternalUploadSource
+});
+var loadCameraModule = async () => {
+	let { CameraSource: p } = await import("./CameraSource-pj7Xo81m.js");
+	defineComponents({ CameraSource: p });
+};
+const cameraPlugin = {
+	id: "camera",
+	setup: async ({ pluginApi: p, uploaderApi: H }) => {
+		await loadCameraModule(), p.registry.registerSource({
+			id: "camera",
+			label: "src-type-camera",
+			icon: "camera",
+			expand: () => {
+				if (!browserFeatures.htmlMediaCapture) return ["camera"];
+				let H = deserializeCsv(p.config.get("cameraModes"));
+				return H.length ? H.map((p) => `mobile-${p}-camera`) : ["mobile-photo-camera"];
+			},
+			onSelect: () => {
+				H.setCurrentActivity(ACTIVITY_TYPES.CAMERA), H.setModalState(!0);
+			}
+		}), p.registry.registerSource({
+			id: "mobile-photo-camera",
+			label: "src-type-camera",
+			icon: "camera",
+			onSelect: () => {
+				H.openSystemDialog({
+					captureCamera: !0,
+					modeCamera: "photo"
+				});
+			}
+		}), p.registry.registerSource({
+			id: "mobile-video-camera",
+			label: "src-type-camera",
+			icon: "camera",
+			onSelect: () => {
+				H.openSystemDialog({
+					captureCamera: !0,
+					modeCamera: "video"
+				});
+			}
+		}), p.registry.registerActivity({
+			id: ACTIVITY_TYPES.CAMERA,
+			render: (p) => {
+				let H = document.createElement("uc-camera-source");
+				return p.append(H), () => {
+					p.replaceChildren();
+				};
+			}
+		});
+	}
+};
+var CLOUD_EDITOR_PLUGIN_ID = "cloud-image-editor", EDIT_FILE_ICON_SVG = "<svg viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'><path fill='currentColor' fill-rule='evenodd' d='M18.558 2.804a.78.78 0 0 0-.557.235l-.008.007-2.472 2.46 3.847 3.848 2.46-2.473.004-.003a.78.78 0 0 0 0-1.108l-.004-.003-2.712-2.728a.78.78 0 0 0-.558-.235Zm-.248 7.613-3.852-3.852-8.93 8.887-1.516 5.41 5.41-1.515 8.888-8.93Zm-.636-8.934a2.28 2.28 0 0 1 2.512.505l2.702 2.717.002.002a2.278 2.278 0 0 1 0 3.234l-.002.002-12.541 12.602a.75.75 0 0 1-.33.193l-6.884 1.928a.75.75 0 0 1-.925-.924l1.928-6.885a.75.75 0 0 1 .193-.33l12.603-12.54a2.28 2.28 0 0 1 .742-.504Z' clip-rule='evenodd'/></svg>", editorI18n = { en: {
+	"edit-image": "Edit image",
+	"edit-detail": "Details",
+	"file-item-edit-button": "Edit",
+	"a11y-editor-tab-filters": "Filters",
+	"a11y-editor-tab-tuning": "Tuning",
+	"a11y-editor-tab-crop": "Crop",
+	"a11y-cloud-editor-apply-filter": "Apply {{name}} filter",
+	"a11y-cloud-editor-apply-crop": "Apply {{name}} operation",
+	"a11y-cloud-editor-apply-tuning": "Apply {{name}} tuning",
+	"a11y-cloud-editor-apply-aspect-ratio": "Apply operation {{name}} {{value}}",
+	"crop-to-shape": "Crop to {{value}}",
+	custom: "Freeform",
+	"freeform-crop": "Freeform crop",
+	"cancel-edit": "Cancel edit",
+	back: "Back",
+	apply: "Apply",
+	rotate: "Rotate",
+	"flip-vertical": "Flip vertical",
+	"flip-horizontal": "Flip horizontal",
+	brightness: "Brightness",
+	contrast: "Contrast",
+	saturation: "Saturation",
+	exposure: "Exposure",
+	gamma: "Gamma",
+	vibrance: "Vibrance",
+	warmth: "Warmth",
+	enhance: "Enhance",
+	original: "Original",
+	resize: "Resize image",
+	crop: "Crop",
+	"select-color": "Select color",
+	text: "Text",
+	draw: "Draw",
+	"tab-view": "Preview",
+	"tab-details": "Details"
+} }, loadEditorModule = async () => {
+	let [p, U] = await Promise.all([import("./cloud-image-editor-DSW3oWq-.js"), import("./CloudImageEditorActivity-DinG5r0y.js")]);
+	defineComponents({
+		...p,
+		...U
+	});
+};
+const cloudImageEditorPlugin = {
+	id: CLOUD_EDITOR_PLUGIN_ID,
+	setup: async ({ pluginApi: p, uploaderApi: H }) => {
+		await loadEditorModule(), p.registry.registerIcon({
+			name: "edit-file",
+			svg: EDIT_FILE_ICON_SVG
+		}), p.registry.registerI18n(editorI18n), p.registry.registerFileAction({
+			id: "edit-file",
+			icon: "edit-file",
+			shouldRender: (p) => !!(p.isSuccess && p.isImage && p.cdnUrl),
+			onClick: (p) => {
+				H.setCurrentActivity?.(ACTIVITY_TYPES.CLOUD_IMG_EDIT, { internalId: p.internalId }), H.setModalState?.(!0);
+			}
+		}), p.registry.registerActivity({
+			id: ACTIVITY_TYPES.CLOUD_IMG_EDIT,
+			render: (p) => {
+				let H = document.createElement("uc-cloud-image-editor-activity");
+				return p.append(H), () => {
+					p.replaceChildren();
+				};
+			}
+		});
+	}
+};
+var loadExternalSourceModule = async () => {
+	let { ExternalSource: p } = await import("./ExternalSource-C57a61QN.js");
+	defineComponents({ ExternalSource: p });
+};
+const externalSourcesPlugin = {
+	id: "external-sources",
+	setup: async ({ pluginApi: p, uploaderApi: H }) => {
+		await loadExternalSourceModule(), p.registry.registerActivity({
+			id: ACTIVITY_TYPES.EXTERNAL,
+			render: (p) => {
+				let H = document.createElement("uc-external-source");
+				return p.append(H), () => {
+					p.replaceChildren();
+				};
+			}
+		});
+		for (let U of Object.values(ExternalUploadSource)) p.registry.registerSource({
+			id: U,
+			label: `src-type-${U}`,
+			icon: U,
+			onSelect: () => {
+				H.setCurrentActivity(ACTIVITY_TYPES.EXTERNAL, { externalSourceType: U }), H.setModalState(!0);
+			}
+		});
+	}
+};
+var readJpegChunks = () => {
+	let p = [];
+	return {
+		stack: p,
+		promiseReadJpegChunks: (H) => new Promise((U, W) => {
+			let G = 2, K = (p, H) => {
+				let U = new FileReader();
+				U.addEventListener("load", () => {
+					H(new DataView(U.result));
+				}), U.addEventListener("error", (p) => {
+					W(`Reader error: ${p}`);
+				}), U.readAsArrayBuffer(p);
+			}, q = () => K(H.slice(G, G + 128), (p) => {
+				let H, U, W;
+				for (H = U = 0, W = p.byteLength; W >= 0 ? U < W : U > W; H = W >= 0 ? ++U : --U) if (p.getUint8(H) === 255) {
+					G += H;
+					break;
+				}
+				J();
+			}), J = () => {
+				let J = G;
+				return K(H.slice(G, G += 4), (Y) => {
+					if (Y.byteLength !== 4 || Y.getUint8(0) !== 255) {
+						W("Corrupted");
+						return;
+					}
+					let X = Y.getUint8(1);
+					if (X === 218) {
+						U(!0);
+						return;
+					}
+					let Z = Y.getUint16(2) - 2;
+					return K(H.slice(G, G += Z), (H) => {
+						if (H.byteLength !== Z) {
+							W("Corrupted");
+							return;
+						}
+						p.push({
+							startPos: J,
+							length: Z,
+							marker: X,
+							view: H
+						}), q();
+					});
+				});
+			};
+			FileReader && DataView || W("Not Support"), K(H.slice(0, 2), (p) => {
+				p.getUint16(0) !== 65496 && W("Not jpeg"), q();
+			});
+		})
+	};
+}, getIccProfile = async (p) => {
+	let H = [], { promiseReadJpegChunks: U, stack: W } = readJpegChunks();
+	return await U(p), W.forEach(({ marker: p, view: U }) => {
+		p === 226 && U.getUint32(0) === 1229144927 && U.getUint32(4) === 1347571526 && U.getUint32(8) === 1229735168 && H.push(U);
+	}), H;
+}, replaceJpegChunk = async (p, H, U) => {
+	{
+		let W = [], G = [], { promiseReadJpegChunks: K, stack: q } = readJpegChunks();
+		await K(p), q.forEach((p) => {
+			if (p.marker === H) return W.push(p.startPos), G.push(p.length);
+		});
+		let J = [p.slice(0, 2)];
+		for (let p of U) {
+			let U = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+			U.setUint16(0, 65280 + H), U.setUint16(2, p.byteLength + 2), J.push(U.buffer), J.push(p);
+		}
+		let Y = 2;
+		for (let H = 0; H < W.length; H++) W[H] > Y && J.push(p.slice(Y, W[H])), Y = W[H] + G[H] + 4;
+		return J.push(p.slice(Y, p.size)), new Blob(J, { type: p.type });
+	}
+}, MARKER = 226, replaceIccProfile = (p, H) => replaceJpegChunk(p, MARKER, H.map((p) => p.buffer)), stripIccProfile = async (p) => {
+	try {
+		return await replaceIccProfile(p, []);
+	} catch (p) {
+		throw Error(`Failed to strip ICC profile: ${p}`);
+	}
+}, canvasToBlob = (p, H, U) => new Promise((W, G) => {
+	p.toBlob((p) => {
+		if (!p) {
+			G("Failed to convert canvas to blob");
+			return;
+		}
+		W(p);
+	}, H, U), p.width = p.height = 1;
+}), createCanvas = () => {
+	let p = document.createElement("canvas");
+	return {
+		canvas: p,
+		ctx: p.getContext("2d")
+	};
+}, hasTransparency = (p) => {
+	let { ctx: H, canvas: U } = createCanvas();
+	U.width = U.height = 50, H.drawImage(p, 0, 0, 50, 50);
+	let W = H.getImageData(0, 0, 50, 50).data;
+	U.width = U.height = 1;
+	for (let p = 3; p < W.length; p += 4) if (W[p] < 254) return !0;
+	return !1;
+}, getExif = async (p) => {
+	let H = null, { promiseReadJpegChunks: U, stack: W } = readJpegChunks();
+	return await U(p), W.forEach(({ marker: p, view: U }) => {
+		if (!H && p === 225 && U.byteLength >= 14 && U.getUint32(0) === 1165519206 && U.getUint16(4) === 0) {
+			H = U;
+			return;
+		}
+	}), H;
+}, base64ImageSrc = "data:image/jpg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/4QA6RXhpZgAATU0AKgAAAAgAAwESAAMAAAABAAYAAAEoAAMAAAABAAIAAAITAAMAAAABAAEAAAAAAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////wAALCAABAAIBASIA/8QAJgABAAAAAAAAAAAAAAAAAAAAAxABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQAAPwBH/9k=", isApplied = void 0, isBrowserApplyExifOrientation = () => new Promise((p) => {
+	if (isApplied !== void 0) p(isApplied);
+	else {
+		let H = new Image();
+		H.addEventListener("load", () => {
+			isApplied = H.naturalWidth < H.naturalHeight, H.src = "//:0", p(isApplied);
+		}), H.src = base64ImageSrc;
+	}
+}), findExifOrientation = (p, H) => {
+	let U, W, G, K;
+	if (!p || p.byteLength < 14 || p.getUint32(0) !== 1165519206 || p.getUint16(4) !== 0) return;
+	if (p.getUint16(6) === 18761) W = !0;
+	else if (p.getUint16(6) === 19789) W = !1;
+	else return;
+	if (p.getUint16(8, W) !== 42) return;
+	G = 8 + p.getUint32(10, W);
+	let q = p.getUint16(G - 2, W);
+	for (U = 0, K = q; K >= 0 ? U < K : U > K; K >= 0 ? ++U : --U) {
+		if (p.byteLength < G + 10) return;
+		p.getUint16(G, W) === 274 && H(G + 8, W), G += 12;
+	}
+}, setExifOrientation = (p, H) => {
+	findExifOrientation(p, (U, W) => p.setUint16(U, H, W));
+}, replaceExif = async (p, H, U) => (U && setExifOrientation(H, 1), replaceJpegChunk(p, 225, [H.buffer])), processImage = (p, H) => new Promise((U, W) => {
+	H && (p.src = H), p.complete ? U(p) : (p.addEventListener("load", () => {
+		U(p);
+	}), p.addEventListener("error", () => {
+		W(/* @__PURE__ */ Error("Failed to load image. Probably not an image."));
+	}));
+}), imageLoader = (p) => processImage(new Image(), p), allowLayers = [1, 3], markers = [
+	192,
+	193,
+	194,
+	195,
+	197,
+	198,
+	199,
+	201,
+	202,
+	203,
+	205,
+	206,
+	207
+], sizes = {
+	squareSide: [
+		Math.floor(Math.sqrt(5 * 1e3 * 1e3)),
+		4096,
+		8192,
+		11180,
+		10836,
+		11402,
+		14188,
+		16384
+	],
+	dimension: [
+		4096,
+		8192,
+		16384,
+		32767,
+		65535
+	]
+}, shouldSkipShrink = async (p) => {
+	let H = !1, { promiseReadJpegChunks: U, stack: W } = readJpegChunks();
+	return await U(p).then(() => (W.forEach(({ marker: p, view: U }) => {
+		if (!H && markers.indexOf(p) >= 0) {
+			let p = U.getUint8(5);
+			allowLayers.indexOf(p) < 0 && (H = !0);
+		}
+	}), H)).catch(() => H);
+}, memoize = (p, H) => {
+	let U = {};
+	return (...W) => {
+		let G = H(W, U);
+		return G in U ? U[G] : U[G] = p(...W);
+	};
+}, memoKeySerializer = (p, H) => {
+	let [U] = p, W = Object.keys(H).map((p) => parseInt(p, 10)).sort((p, H) => p - H);
+	for (let p = 0; p < W.length; p++) {
+		let G = W[p], K = !!H[G];
+		if (G > U && K || G < U && !K) return G;
+	}
+	return U;
+}, TestPixel = {
+	R: 55,
+	G: 110,
+	B: 165,
+	A: 255
+}, FILL_STYLE = `rgba(${TestPixel.R}, ${TestPixel.G}, ${TestPixel.B}, ${TestPixel.A / 255})`, canvasTest = (p, H) => {
+	try {
+		let U = [
+			p - 1,
+			H - 1,
+			1,
+			1
+		], { canvas: W, ctx: G } = createCanvas();
+		W.width = 1, W.height = 1;
+		let { canvas: K, ctx: q } = createCanvas();
+		K.width = p, K.height = H, q && (q.fillStyle = FILL_STYLE, q.fillRect(...U), G.drawImage(K, p - 1, H - 1, 1, 1, 0, 0, 1, 1));
+		let J = G && G.getImageData(0, 0, 1, 1).data, Y = !1;
+		return J && (Y = J[0] === TestPixel.R && J[1] === TestPixel.G && J[2] === TestPixel.B && J[3] === TestPixel.A), K.width = K.height = 1, Y;
+	} catch {
+		return console.error(`Failed to test for max canvas size of ${p}x${H}.`), !1;
+	}
+};
+function wrapAsync(p) {
+	return (...H) => new Promise((U) => {
+		setTimeout(() => {
+			U(p(...H));
+		}, 0);
+	});
+}
+var squareTest = wrapAsync(memoize(canvasTest, memoKeySerializer)), dimensionTest = wrapAsync(memoize(canvasTest, memoKeySerializer)), testCanvasSize = async (p, H) => {
+	let U = sizes.squareSide.find((U) => U * U >= p * H), W = sizes.dimension.find((U) => U >= p && U >= H);
+	if (!U || !W) throw Error("Not supported");
+	let [G, K] = await Promise.all([squareTest(U, U), dimensionTest(W, 1)]);
+	if (G && K) return !0;
+	throw Error("Not supported");
+}, canvasResize = async (p, H, U) => {
+	try {
+		let { ctx: W, canvas: G } = createCanvas();
+		return G.width = H, G.height = U, W.imageSmoothingQuality = "high", W.drawImage(p, 0, 0, H, U), p instanceof HTMLImageElement && (p.src = "//:0"), p instanceof HTMLCanvasElement && (p.width = p.height = 1), G;
+	} catch (p) {
+		throw Error("Canvas resize error", { cause: p });
+	}
+}, native = ({ img: p, targetW: H, targetH: U }) => canvasResize(p, H, U), calcShrinkSteps = function({ sourceW: p, targetW: H, targetH: U, step: W }) {
+	let G = [], K = H, q = U;
+	do
+		G.push([K, q]), K = Math.round(K / W), q = Math.round(q / W);
+	while (K < p * W);
+	return G.reverse();
+}, fallback = ({ img: p, sourceW: H, targetW: U, targetH: W, step: G }) => {
+	let K = calcShrinkSteps({
+		sourceW: H,
+		targetW: U,
+		targetH: W,
+		step: G
+	});
+	return K.reduce((p, [H, U], W) => p.then((p) => testCanvasSize(H, U).then(() => canvasResize(p, H, U)).catch(() => {
+		if (W === K.length - 1) throw Error("Not supported");
+		return p;
+	})), Promise.resolve(p));
+}, isIOS = () => /iPad|iPhone|iPod/.test(navigator.platform) ? !0 : navigator.maxTouchPoints && navigator.maxTouchPoints > 2 && /MacIntel/.test(navigator.platform), isIpadOS = navigator.maxTouchPoints && navigator.maxTouchPoints > 2 && /MacIntel/.test(navigator.platform), STEP = .71, shrinkImage = (p, H) => {
+	if (p.width * STEP * p.height * STEP < H.size) throw Error("Not required");
+	let U = p.width, W = U / p.height, G = Math.floor(Math.sqrt(H.size * W)), K = Math.floor(H.size / Math.sqrt(H.size * W));
+	return testCanvasSize(G, K).then(() => {
+		let { ctx: H } = createCanvas();
+		return "imageSmoothingQuality" in H && !isIOS() && !isIpadOS ? native({
+			img: p,
+			targetW: G,
+			targetH: K
+		}) : fallback({
+			img: p,
+			sourceW: U,
+			targetW: G,
+			targetH: K,
+			step: STEP
+		});
+	}).catch(() => Promise.reject("Not supported"));
+}, shrinkFile = async (p, H) => {
+	try {
+		if (await shouldSkipShrink(p)) throw Error("Should skipped");
+		let U = await Promise.allSettled([
+			getExif(p),
+			isBrowserApplyExifOrientation(),
+			getIccProfile(p)
+		]), W = !U.some((p) => p.status === "rejected"), [G, K, q] = U, J = await stripIccProfile(p).catch(() => p), Y = await imageLoader(URL.createObjectURL(J));
+		URL.revokeObjectURL(Y.src);
+		let X = await shrinkImage(Y, H), Z = "image/jpeg", Q = H?.quality || .8;
+		!W && hasTransparency(X) && (Z = "image/png", Q = void 0);
+		let $ = await canvasToBlob(X, Z, Q);
+		if (W && G.status === "fulfilled" && G.value) {
+			let p = G.value, H = K.status === "fulfilled" ? K.value : !1;
+			$ = await replaceExif($, p, H);
+		}
+		return W && q.status === "fulfilled" && q.value.length > 0 && ($ = await replaceIccProfile($, q.value)), $;
+	} catch (p) {
+		let H;
+		throw p instanceof Error && (H = p.message), typeof p == "string" && (H = p), Error(`Failed to shrink image. ${H ? `Message: "${H}".` : ""}`, { cause: p });
+	}
+}, MAX_SQUARE_SIDE = 16384, regExpShrink = /^([0-9]+)x([0-9]+)(?:\s+(\d{1,2}|100)%)?$/i;
+const parseShrink = (p) => {
+	if (typeof p != "string") return !1;
+	let H = regExpShrink.exec(p.toLocaleLowerCase()) ?? [];
+	if (H.length === 0) return !1;
+	let U = Number(H[1]) * Number(H[2]), W = MAX_SQUARE_SIDE * MAX_SQUARE_SIDE;
+	return U > W ? (console.warn(`Shrinked size can not be larger than ${Math.floor(W / 1e3 / 1e3)}MP. You have set ${H[1]}x${H[2]} (${Math.ceil(U / 1e3 / 100) / 10}MP).`), !1) : {
+		quality: H[3] ? Number(H[3]) / 100 : void 0,
+		size: U
+	};
+}, imageShrinkPlugin = {
+	id: "image-shrink",
+	setup({ pluginApi: p }) {
+		p.registry.registerFileHook({
+			type: "beforeUpload",
+			handler: async ({ file: H, mimeType: U }) => {
+				let W = p.config.get("imageShrink");
+				if (!W) return {
+					file: H,
+					mimeType: U
+				};
+				let G = parseShrink(W);
+				if (!G) return console.warn("[ImageShrinkPlugin] Image shrink settings are invalid, skipping shrinking"), {
+					file: H,
+					mimeType: U
+				};
+				try {
+					let p = await shrinkFile(H, G);
+					return {
+						file: p,
+						mimeType: p.type || U
+					};
+				} catch {
+					return {
+						file: H,
+						mimeType: U
+					};
+				}
+			}
+		});
+	}
+}, instagramPlugin = {
+	id: "instagram",
+	setup({ pluginApi: p }) {
+		p.registry.registerSource({
+			id: "instagram",
+			label: "src-type-instagram",
+			icon: "instagram",
+			expand: () => (console.error("Instagram source was removed because the Instagram Basic Display API hasn't been available since December 4, 2024. Official statement, see here: https://developers.facebook.com/blog/post/2024/09/04/update-on-instagram-basic-display-api/?locale=en_US"), []),
+			onSelect: () => {}
+		});
+	}
+};
+var loadUrlSourceModule = async () => {
+	let { UrlSource: p } = await import("./UrlSource-CqF0h6B-.js");
+	defineComponents({ UrlSource: p });
+};
+const urlSourcePlugin = {
+	id: "url-source",
+	setup: async ({ pluginApi: p, uploaderApi: H }) => {
+		await loadUrlSourceModule(), p.registry.registerActivity({
+			id: ACTIVITY_TYPES.URL,
+			render: (p) => {
+				let H = document.createElement("uc-url-source");
+				return p.append(H), () => {
+					p.replaceChildren();
+				};
+			}
+		}), p.registry.registerSource({
+			id: "url",
+			label: "src-type-from-url",
+			icon: "url",
+			onSelect: () => {
+				H.setCurrentActivity(ACTIVITY_TYPES.URL), H.setModalState(!0);
+			}
+		});
+	}
+};
+export { cloudImageEditorPlugin as a, UploadSource as c, ACTIVITY_TYPES as d, deserializeCsv as f, externalSourcesPlugin as i, browserFeatures as l, defineComponents as m, instagramPlugin as n, cameraPlugin as o, serializeCsv as p, imageShrinkPlugin as r, ExternalUploadSource as s, urlSourcePlugin as t, browserInfo as u };