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

package/web/plugins-DS0hIs2V.js

@@ -0,0 +1,563 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.1 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T20:26:12.501Z
+*/
+const ACTIVITY_TYPES = Object.freeze({
+	START_FROM: "start-from",
+	CAMERA: "camera",
+	UPLOAD_LIST: "upload-list",
+	URL: "url",
+	CLOUD_IMG_EDIT: "cloud-image-edit",
+	EXTERNAL: "external"
+}), deserializeCsv = (p) => p ? p.split(",").map((p) => p.trim()).filter(Boolean) : [], serializeCsv = (p) => p.join(",");
+var EXCLUDE_COMPONENTS = [
+	"UploaderBlock",
+	"ActivityBlock",
+	"Block",
+	"SolutionBlock"
+];
+function defineComponents(p) {
+	for (let H in p) {
+		if (EXCLUDE_COMPONENTS.includes(H)) continue;
+		let U = [...H].reduce((p, H) => (H.toUpperCase() === H && (H = `-${H.toLowerCase()}`), p += H, p), "");
+		U.startsWith("-") && (U = U.replace("-", "")), U.startsWith("uc-") || (U = `uc-${U}`), p[H].reg && p[H].reg(U);
+	}
+}
+const 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 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();
+var loadCameraModule = async () => {
+	let { CameraSource: p } = await import("./CameraSource-DyPebtRF.js");
+	defineComponents({ CameraSource: p });
+};
+const cameraPlugin = {
+	id: "camera",
+	setup: async ({ pluginApi: U, uploaderApi: W }) => {
+		await loadCameraModule(), U.registry.registerSource({
+			id: "camera",
+			label: "src-type-camera",
+			icon: "camera",
+			expand: () => {
+				if (!browserFeatures.htmlMediaCapture) return ["camera"];
+				let p = deserializeCsv(U.config.get("cameraModes"));
+				return p.length ? p.map((p) => `mobile-${p}-camera`) : ["mobile-photo-camera"];
+			},
+			onSelect: () => {
+				W.setCurrentActivity(ACTIVITY_TYPES.CAMERA), W.setModalState(!0);
+			}
+		}), U.registry.registerSource({
+			id: "mobile-photo-camera",
+			label: "src-type-camera",
+			icon: "camera",
+			onSelect: () => {
+				W.openSystemDialog({
+					captureCamera: !0,
+					modeCamera: "photo"
+				});
+			}
+		}), U.registry.registerSource({
+			id: "mobile-video-camera",
+			label: "src-type-camera",
+			icon: "camera",
+			onSelect: () => {
+				W.openSystemDialog({
+					captureCamera: !0,
+					modeCamera: "video"
+				});
+			}
+		}), U.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, H] = await Promise.all([import("./uc-cloud-image-editor.min.js"), import("./CloudImageEditorActivity-Df1ySGq0.js")]);
+	defineComponents({
+		...p,
+		...H
+	});
+};
+const cloudImageEditorPlugin = {
+	id: CLOUD_EDITOR_PLUGIN_ID,
+	setup: async ({ pluginApi: H, uploaderApi: U }) => {
+		await loadEditorModule(), H.registry.registerIcon({
+			name: "edit-file",
+			svg: EDIT_FILE_ICON_SVG
+		}), H.registry.registerI18n(editorI18n), H.registry.registerFileAction({
+			id: "edit-file",
+			icon: "edit-file",
+			shouldRender: (p) => !!(p.isSuccess && p.isImage && p.cdnUrl),
+			onClick: (H) => {
+				U.setCurrentActivity?.(ACTIVITY_TYPES.CLOUD_IMG_EDIT, { internalId: H.internalId }), U.setModalState?.(!0);
+			}
+		}), H.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-BYSS-PPV.js");
+	defineComponents({ ExternalSource: p });
+};
+const externalSourcesPlugin = {
+	id: "external-sources",
+	setup: async ({ pluginApi: H, uploaderApi: U }) => {
+		await loadExternalSourceModule(), H.registry.registerActivity({
+			id: ACTIVITY_TYPES.EXTERNAL,
+			render: (p) => {
+				let H = document.createElement("uc-external-source");
+				return p.append(H), () => {
+					p.replaceChildren();
+				};
+			}
+		});
+		for (let W of Object.values(ExternalUploadSource)) H.registry.registerSource({
+			id: W,
+			label: `src-type-${W}`,
+			icon: W,
+			onSelect: () => {
+				U.setCurrentActivity(ACTIVITY_TYPES.EXTERNAL, { externalSourceType: W }), U.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-hWV7jtB2.js");
+	defineComponents({ UrlSource: p });
+};
+const urlSourcePlugin = {
+	id: "url-source",
+	setup: async ({ pluginApi: H, uploaderApi: U }) => {
+		await loadUrlSourceModule(), H.registry.registerActivity({
+			id: ACTIVITY_TYPES.URL,
+			render: (p) => {
+				let H = document.createElement("uc-url-source");
+				return p.append(H), () => {
+					p.replaceChildren();
+				};
+			}
+		}), H.registry.registerSource({
+			id: "url",
+			label: "src-type-from-url",
+			icon: "url",
+			onSelect: () => {
+				U.setCurrentActivity(ACTIVITY_TYPES.URL), U.setModalState(!0);
+			}
+		});
+	}
+};
+export { cloudImageEditorPlugin as a, browserInfo as c, defineComponents as d, deserializeCsv as f, externalSourcesPlugin as i, ExternalUploadSource as l, ACTIVITY_TYPES as m, instagramPlugin as n, cameraPlugin as o, serializeCsv as p, imageShrinkPlugin as r, browserFeatures as s, urlSourcePlugin as t, UploadSource as u };