pic-compressor 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present, chandq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,90 @@
+# pic-compressor
+
+[![CI](https://github.com/chandq/pic-compressor/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/chandq/pic-compressor/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/pic-compressor?logo=npm)](https://www.npmjs.com/package/pic-compressor)
+[![Coverage](https://img.shields.io/badge/coverage-lines%2090.84%25-brightgreen?logo=vitest)](vitest.config.ts)
+[![License](https://img.shields.io/npm/l/pic-compressor)](LICENSE)
+[![Node.js](https://img.shields.io/node/v/pic-compressor)](package.json)
+
+独立的浏览器图片压缩工具，基于 Canvas，零运行时依赖，支持普通图片、长截图、全景图、Blob、FileList、目标体积迭代和取消操作。
+
+## 安装
+
+```bash
+npm install pic-compressor
+```
+
+## 使用
+
+```ts
+import { compressImage } from 'pic-compressor';
+
+const result = await compressImage(file, {
+  preset: 'balanced',
+  outputMode: 'compact'
+});
+
+console.log(result.file, result.width, result.height, result.afterKB);
+```
+
+预设包括 `balanced`、`social`、`high-quality`、`thumbnail` 和 `long-image`。显式参数优先于预设。默认 `balanced` 目标为最大 1920px、约 500KB，长图会保留合理长边并受像素和 Canvas 上限约束。
+
+指定目标体积时，压缩器会先搜索最高可接受质量，必要时再按比例缩小尺寸：
+
+```ts
+const result = await compressImage(file, {
+  mime: 'image/webp',
+  targetFileSizeKB: 300,
+  outputMode: 'compact',
+  onProgress: (progress) => console.log(`${progress}%`)
+});
+```
+
+输入可以是 `File`、`Blob` 或 `FileList`。Blob 可通过 `fileName` 指定输出文件名。默认保留旧版 Data URL 和二进制字段；在生产环境推荐 `outputMode: 'compact'` 降低内存峰值。
+
+格式转换允许体积变大，例如 JPEG 转 PNG。对于同格式输出，`keepOriginalIfLarger` 默认为 `true`；若业务需要保留更大的重编码结果，可设置为 `false`。
+
+## 浏览器 CDN
+
+```html
+<script src="https://unpkg.com/pic-compressor/dist/index.umd.js"></script>
+<script>
+  const result = await PicCompressor.compressImage(file, { outputMode: 'compact' });
+</script>
+```
+
+## 开发
+
+```bash
+npm install
+npm run verify
+npm run build
+```
+
+构建输出：
+
+- `dist/index.mjs`：ESM
+- `dist/index.cjs`：CommonJS
+- `dist/index.d.mts` / `dist/index.d.cts`：TypeScript 声明
+- `dist/index.umd.js`：压缩后的 UMD 浏览器包及 Source Map
+
+ESM、CommonJS、UMD 和类型声明均由 tsdown 生成，Lint 和格式化由 Oxc 的 `oxlint`/`oxfmt` 完成。
+
+## API
+
+完整参数和返回值见 [docs/api.md](docs/api.md)。
+
+## 社区与贡献
+
+- 参与开发请阅读 [CONTRIBUTING.md](CONTRIBUTING.md)
+- 社区行为规范见 [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)
+- 安全问题请按照 [SECURITY.md](SECURITY.md) 私下报告，不要提交公开 Issue
+- 仓库开发约定及自动化工具指南见 [AGENTS.md](AGENTS.md)
+
+## 兼容性
+
+目标环境需要 `File`、`Blob`、`FileReader`、`Canvas 2D` 和图片解码 API。原生 iOS、Android、React Native 文件 URI 需要先转换为 Web `File`，或使用原生图片 API。
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,543 @@
+/*! pic-compressor v0.1.0 | MIT License | https://github.com/chandq/pic-compressor */
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region src/index.ts
+/**
+* Browser image compression utilities.
+* @packageDocumentation
+*/
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+const IMAGE_TYPES = [
+	"image/jpeg",
+	"image/png",
+	"image/webp",
+	"image/avif"
+];
+const DEFAULT_MAX_EDGE = 2560;
+const DEFAULT_MAX_PIXELS = 8388608;
+const LONG_IMAGE_RATIO = 3;
+const DEFAULT_MAX_CANVAS_DIMENSION = 8192;
+const DEFAULT_MAX_ITERATIONS = 8;
+/** Detect whether the current runtime can create a usable Canvas 2D context. */
+function supportCanvas() {
+	if (typeof document === "undefined" || typeof document.createElement !== "function") return false;
+	try {
+		const canvas = document.createElement("canvas");
+		return typeof canvas.getContext === "function" && canvas.getContext("2d") !== null;
+	} catch {
+		return false;
+	}
+}
+const IMAGE_COMPRESSION_PRESETS = {
+	balanced: {
+		quality: .82,
+		minQuality: .6,
+		maxWidth: 1920,
+		maxHeight: 1920,
+		maxPixels: 6291456,
+		targetFileSizeKB: 500,
+		preserveLongImage: true
+	},
+	social: {
+		quality: .82,
+		minQuality: .62,
+		maxWidth: 1280,
+		maxHeight: 1280,
+		maxPixels: 4194304,
+		targetFileSizeKB: 300,
+		preserveLongImage: true
+	},
+	"high-quality": {
+		quality: .88,
+		minQuality: .72,
+		maxWidth: 2560,
+		maxHeight: 2560,
+		maxPixels: DEFAULT_MAX_PIXELS,
+		targetFileSizeKB: 1024,
+		preserveLongImage: true
+	},
+	thumbnail: {
+		quality: .78,
+		minQuality: .58,
+		maxWidth: 400,
+		maxHeight: 400,
+		maxPixels: 16e4,
+		targetFileSizeKB: 30
+	},
+	"long-image": {
+		quality: .82,
+		minQuality: .65,
+		maxWidth: 1080,
+		maxHeight: DEFAULT_MAX_CANVAS_DIMENSION,
+		maxPixels: 12582912,
+		preserveLongImage: true
+	}
+};
+function isFile(value) {
+	return typeof File !== "undefined" && value instanceof File || Object.prototype.toString.call(value) === "[object File]";
+}
+function isFileList(value) {
+	return typeof FileList !== "undefined" && value instanceof FileList || Object.prototype.toString.call(value) === "[object FileList]";
+}
+function isBlob(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob || Object.prototype.toString.call(value) === "[object Blob]";
+}
+function createAbortError() {
+	if (typeof DOMException !== "undefined") return new DOMException("Image compression aborted", "AbortError");
+	const error = /* @__PURE__ */ new Error("Image compression aborted");
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw createAbortError();
+}
+function assertFiniteNumber(value, name, min, max = Infinity) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) throw new RangeError(`${name} must be a finite number between ${min} and ${max}`);
+}
+function normalizeOptions(options) {
+	const { preset = "balanced", quality: configuredQuality, mime = "image/jpeg", maxWidth, maxHeight, maxSize, minFileSizeKB = 50, maxPixels: configuredMaxPixels, maxCanvasDimension = DEFAULT_MAX_CANVAS_DIMENSION, preserveLongImage: configuredPreserveLongImage, targetFileSizeKB: configuredTargetFileSizeKB, minQuality: configuredMinQuality, maxIterations = DEFAULT_MAX_ITERATIONS, concurrency = 2, outputMode = "legacy", keepOriginalIfLarger = true, backgroundColor = "#fff", strictMime = false, onProgress, signal, fileName = "image" } = isObject(options) ? options : {};
+	const presetOptions = IMAGE_COMPRESSION_PRESETS[preset];
+	if (!presetOptions) throw new TypeError(`Unsupported image compression preset: ${String(preset)}`);
+	const quality = configuredQuality ?? presetOptions.quality;
+	const minQuality = configuredMinQuality ?? Math.min(presetOptions.minQuality, quality);
+	const maxPixels = configuredMaxPixels ?? presetOptions.maxPixels;
+	const targetFileSizeKB = configuredTargetFileSizeKB === null ? void 0 : configuredTargetFileSizeKB ?? presetOptions.targetFileSizeKB;
+	const hasExplicitDimensions = maxWidth !== void 0 || maxHeight !== void 0 || maxSize !== void 0;
+	const resolvedMaxWidth = hasExplicitDimensions ? maxWidth ?? maxSize : presetOptions.maxWidth;
+	const resolvedMaxHeight = hasExplicitDimensions ? maxHeight ?? maxSize : presetOptions.maxHeight;
+	const preserveLongImage = configuredPreserveLongImage ?? (!hasExplicitDimensions && !!presetOptions.preserveLongImage);
+	assertFiniteNumber(quality, "quality", 0, 1);
+	assertFiniteNumber(minQuality, "minQuality", 0, 1);
+	if (minQuality > quality) throw new RangeError("minQuality must not be greater than quality");
+	if (!IMAGE_TYPES.includes(mime)) throw new TypeError(`Unsupported image mime type: ${String(mime)}`);
+	if (resolvedMaxWidth !== void 0) assertFiniteNumber(resolvedMaxWidth, "maxWidth", 1);
+	if (resolvedMaxHeight !== void 0) assertFiniteNumber(resolvedMaxHeight, "maxHeight", 1);
+	if (maxSize !== void 0) assertFiniteNumber(maxSize, "maxSize", 1);
+	assertFiniteNumber(minFileSizeKB, "minFileSizeKB", 0);
+	assertFiniteNumber(maxPixels, "maxPixels", 1);
+	assertFiniteNumber(maxCanvasDimension, "maxCanvasDimension", 1);
+	if (targetFileSizeKB !== void 0) assertFiniteNumber(targetFileSizeKB, "targetFileSizeKB", 1);
+	assertFiniteNumber(maxIterations, "maxIterations", 1);
+	assertFiniteNumber(concurrency, "concurrency", 1);
+	if (typeof keepOriginalIfLarger !== "boolean") throw new TypeError("keepOriginalIfLarger must be a boolean");
+	if (typeof backgroundColor !== "string") throw new TypeError("backgroundColor must be a string");
+	if (typeof strictMime !== "boolean") throw new TypeError("strictMime must be a boolean");
+	if (typeof preserveLongImage !== "boolean") throw new TypeError("preserveLongImage must be a boolean");
+	if (onProgress !== void 0 && typeof onProgress !== "function") throw new TypeError("onProgress must be a function");
+	if (typeof fileName !== "string" || fileName.length === 0) throw new TypeError("fileName must be a non-empty string");
+	if (outputMode !== "legacy" && outputMode !== "compact") throw new TypeError(`outputMode must be "legacy" or "compact"`);
+	return {
+		preset,
+		quality,
+		mime,
+		maxWidth: resolvedMaxWidth === void 0 ? void 0 : Math.floor(resolvedMaxWidth),
+		maxHeight: resolvedMaxHeight === void 0 ? void 0 : Math.floor(resolvedMaxHeight),
+		minFileSizeKB,
+		maxPixels: Math.floor(maxPixels),
+		maxCanvasDimension: Math.floor(maxCanvasDimension),
+		preserveLongImage,
+		targetFileSizeKB,
+		minQuality,
+		maxIterations: Math.max(1, Math.floor(maxIterations)),
+		concurrency: Math.max(1, Math.floor(concurrency)),
+		outputMode,
+		keepOriginalIfLarger,
+		backgroundColor,
+		strictMime,
+		onProgress,
+		signal,
+		fileName
+	};
+}
+function blobToFile(blob, fileName) {
+	return new File([blob], fileName, {
+		type: blob.type,
+		lastModified: Date.now()
+	});
+}
+function calculateTargetSize(maxWidth, maxHeight, maxPixels, maxCanvasDimension, preserveLongImage, originWidth, originHeight) {
+	let targetMaxWidth = maxWidth;
+	let targetMaxHeight = maxHeight;
+	if (targetMaxWidth === void 0 && targetMaxHeight === void 0) {
+		targetMaxWidth = DEFAULT_MAX_EDGE;
+		targetMaxHeight = DEFAULT_MAX_EDGE;
+	}
+	const aspectRatio = Math.max(originWidth / originHeight, originHeight / originWidth);
+	if (preserveLongImage && aspectRatio >= LONG_IMAGE_RATIO) {
+		if (originWidth >= originHeight) targetMaxWidth = maxCanvasDimension;
+		else targetMaxHeight = maxCanvasDimension;
+	}
+	targetMaxWidth = Math.min(targetMaxWidth ?? maxCanvasDimension, maxCanvasDimension);
+	targetMaxHeight = Math.min(targetMaxHeight ?? maxCanvasDimension, maxCanvasDimension);
+	const dimensionScale = Math.min(1, targetMaxWidth / originWidth, targetMaxHeight / originHeight);
+	const pixelScale = Math.min(1, Math.sqrt(maxPixels / (originWidth * originHeight)));
+	const scale = Math.min(dimensionScale, pixelScale);
+	return {
+		width: Math.max(1, Math.floor(originWidth * scale)),
+		height: Math.max(1, Math.floor(originHeight * scale))
+	};
+}
+function readBlob(blob, mode, signal) {
+	return new Promise((resolve, reject) => {
+		throwIfAborted(signal);
+		const reader = new FileReader();
+		let settled = false;
+		const cleanup = () => {
+			reader.onerror = null;
+			reader.onabort = null;
+			reader.onload = null;
+			signal?.removeEventListener("abort", abort);
+		};
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const abort = () => {
+			try {
+				reader.abort();
+			} finally {
+				fail(createAbortError());
+			}
+		};
+		reader.onerror = () => fail(reader.error ?? /* @__PURE__ */ new Error("Failed to read image data"));
+		reader.onabort = () => fail(createAbortError());
+		reader.onload = () => {
+			if (settled) return;
+			const result = reader.result;
+			if (mode === "dataURL" && typeof result === "string") {
+				settled = true;
+				cleanup();
+				resolve(result);
+			} else if (mode === "arrayBuffer" && result instanceof ArrayBuffer) {
+				settled = true;
+				cleanup();
+				resolve(result);
+			} else fail(/* @__PURE__ */ new Error(`Unexpected FileReader result for ${mode}`));
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		if (mode === "dataURL") reader.readAsDataURL(blob);
+		else reader.readAsArrayBuffer(blob);
+	});
+}
+async function decodeImage(file, signal) {
+	throwIfAborted(signal);
+	if (typeof createImageBitmap === "function") try {
+		const bitmap = await createImageBitmap(file);
+		try {
+			throwIfAborted(signal);
+			if (!bitmap.width || !bitmap.height) throw new Error("Decoded image has invalid dimensions");
+		} catch (error) {
+			bitmap.close();
+			throw error;
+		}
+		return {
+			source: bitmap,
+			width: bitmap.width,
+			height: bitmap.height,
+			release: () => bitmap.close()
+		};
+	} catch (error) {
+		if (error.name === "AbortError") throw error;
+	}
+	return new Promise((resolve, reject) => {
+		const image = new Image();
+		let objectURL;
+		let settled = false;
+		const cleanup = () => {
+			image.onload = null;
+			image.onerror = null;
+			signal?.removeEventListener("abort", abort);
+			if (objectURL && typeof URL.revokeObjectURL === "function") URL.revokeObjectURL(objectURL);
+		};
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const abort = () => fail(createAbortError());
+		image.onload = () => {
+			if (settled) return;
+			settled = true;
+			const width = image.naturalWidth || image.width;
+			const height = image.naturalHeight || image.height;
+			cleanup();
+			if (!width || !height) reject(/* @__PURE__ */ new Error("Decoded image has invalid dimensions"));
+			else resolve({
+				source: image,
+				width,
+				height,
+				release: () => void 0
+			});
+		};
+		image.onerror = () => fail(/* @__PURE__ */ new Error(`Failed to decode image: ${file.name}`));
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			if (typeof URL !== "undefined" && typeof URL.createObjectURL === "function") {
+				objectURL = URL.createObjectURL(file);
+				image.src = objectURL;
+			} else readBlob(file, "dataURL", signal).then((src) => image.src = src, fail);
+		} catch (error) {
+			fail(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+}
+function canvasToBlob(canvas, mime, quality) {
+	if (typeof canvas.toBlob === "function") return new Promise((resolve, reject) => {
+		canvas.toBlob((blob) => blob ? resolve(blob) : reject(/* @__PURE__ */ new Error("Canvas image encoding failed")), mime, quality);
+	});
+	try {
+		const [header, encoded = ""] = canvas.toDataURL(mime, quality).split(",");
+		const actualMime = /^data:([^;]+)/.exec(header ?? "")?.[1] || mime;
+		const binary = atob(encoded);
+		const bytes = new Uint8Array(binary.length);
+		for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+		return Promise.resolve(new Blob([bytes], { type: actualMime }));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function normalizeMime(mime) {
+	if (mime === "image/jpg") return "image/jpeg";
+	return IMAGE_TYPES.includes(mime) ? mime : void 0;
+}
+function replaceFileExtension(name, mime) {
+	const extension = {
+		"image/jpeg": "jpg",
+		"image/png": "png",
+		"image/webp": "webp",
+		"image/avif": "avif"
+	};
+	const dotIndex = name.lastIndexOf(".");
+	return `${dotIndex > 0 ? name.slice(0, dotIndex) : name || "image"}.${extension[mime]}`;
+}
+function reportProgress(options, progress) {
+	if (!options.onProgress) return;
+	try {
+		options.onProgress(Math.max(0, Math.min(100, Math.round(progress))));
+	} catch {}
+}
+function requiresCompression(file, options) {
+	const sizeKB = file.size / 1024;
+	return sizeKB >= options.minFileSizeKB || options.targetFileSizeKB !== void 0 && sizeKB > options.targetFileSizeKB;
+}
+function supportsLossyQuality(mime) {
+	return mime === "image/jpeg" || mime === "image/webp" || mime === "image/avif";
+}
+function getEncodedMime(blob, requestedMime, strictMime) {
+	const actualMime = normalizeMime(blob.type);
+	if (!actualMime) throw new Error(`Canvas returned unsupported image mime type: ${blob.type || "unknown"}`);
+	if (strictMime && actualMime !== requestedMime) throw new Error(`Current runtime does not support encoding ${requestedMime}; received ${actualMime} instead`);
+	return actualMime;
+}
+async function encodeCanvas(canvas, options, targetBytes, remainingIterations, completedIterations) {
+	let iterations = 0;
+	const encode = async (quality) => {
+		throwIfAborted(options.signal);
+		const blob = await canvasToBlob(canvas, options.mime, quality);
+		iterations++;
+		reportProgress(options, 10 + (completedIterations + iterations) / options.maxIterations * 80);
+		return {
+			blob,
+			mime: getEncodedMime(blob, options.mime, options.strictMime),
+			quality
+		};
+	};
+	const result = await encode(options.quality);
+	if (targetBytes === void 0 || result.blob.size <= targetBytes || !supportsLossyQuality(result.mime) || remainingIterations <= 1 || options.quality <= options.minQuality) return {
+		...result,
+		iterations
+	};
+	const minimumQualityResult = await encode(options.minQuality);
+	if (minimumQualityResult.blob.size > targetBytes) return {
+		...minimumQualityResult,
+		iterations
+	};
+	let bestResult = minimumQualityResult;
+	let lowerQuality = options.minQuality;
+	let upperQuality = options.quality;
+	const searchIterations = remainingIterations - iterations;
+	for (let index = 0; index < searchIterations && upperQuality - lowerQuality > .01; index++) {
+		const nextQuality = (lowerQuality + upperQuality) / 2;
+		const nextResult = await encode(nextQuality);
+		if (nextResult.blob.size <= targetBytes) {
+			bestResult = nextResult;
+			lowerQuality = nextQuality;
+		} else upperQuality = nextQuality;
+	}
+	return {
+		...bestResult,
+		iterations
+	};
+}
+async function encodeImage(decoded, initialWidth, initialHeight, options, targetBytes) {
+	let width = initialWidth;
+	let height = initialHeight;
+	let totalIterations = 0;
+	let lastResult;
+	while (totalIterations < options.maxIterations) {
+		const canvas = document.createElement("canvas");
+		canvas.width = width;
+		canvas.height = height;
+		const context = canvas.getContext("2d");
+		if (!context) throw new Error("Failed to create Canvas 2D context");
+		context.imageSmoothingEnabled = true;
+		context.imageSmoothingQuality = "high";
+		if (options.mime === "image/jpeg") {
+			context.fillStyle = options.backgroundColor;
+			context.fillRect(0, 0, width, height);
+		}
+		context.drawImage(decoded.source, 0, 0, width, height);
+		throwIfAborted(options.signal);
+		try {
+			lastResult = await encodeCanvas(canvas, options, targetBytes, options.maxIterations - totalIterations, totalIterations);
+			totalIterations += lastResult.iterations;
+		} finally {
+			canvas.width = 1;
+			canvas.height = 1;
+		}
+		if (targetBytes === void 0 || lastResult.blob.size <= targetBytes || totalIterations >= options.maxIterations) return {
+			...lastResult,
+			width,
+			height,
+			iterations: totalIterations
+		};
+		const targetScale = Math.min(.9, Math.sqrt(targetBytes / lastResult.blob.size) * .95);
+		const nextWidth = Math.max(1, Math.floor(width * targetScale));
+		const nextHeight = Math.max(1, Math.floor(height * targetScale));
+		if (nextWidth === width && nextHeight === height || width === 1 && height === 1) return {
+			...lastResult,
+			width,
+			height,
+			iterations: totalIterations
+		};
+		width = nextWidth;
+		height = nextHeight;
+	}
+	if (!lastResult) throw new Error("Image encoding did not produce a result");
+	return {
+		...lastResult,
+		width,
+		height,
+		iterations: totalIterations
+	};
+}
+async function compressOne(file, options, canvasSupported) {
+	reportProgress(options, 0);
+	throwIfAborted(options.signal);
+	if (file.type && !file.type.startsWith("image/")) throw new TypeError(`${file.name} is not an image file`);
+	const beforeKB = file.size / 1024;
+	if (!requiresCompression(file, options)) {
+		reportProgress(options, 100);
+		return { file };
+	}
+	if (!canvasSupported) throw new Error("Current runtime environment not support Canvas");
+	const decoded = await decodeImage(file, options.signal);
+	try {
+		reportProgress(options, 8);
+		throwIfAborted(options.signal);
+		const targetSize = calculateTargetSize(options.maxWidth, options.maxHeight, options.maxPixels, options.maxCanvasDimension, options.preserveLongImage, decoded.width, decoded.height);
+		const configuredTargetBytes = options.targetFileSizeKB === void 0 ? void 0 : options.targetFileSizeKB * 1024;
+		const sourceMime = normalizeMime(file.type);
+		const dimensionsInitiallyUnchanged = targetSize.width === decoded.width && targetSize.height === decoded.height;
+		const originalSizeTargetBytes = options.keepOriginalIfLarger && dimensionsInitiallyUnchanged && sourceMime === options.mime ? Math.max(0, file.size - 1) : void 0;
+		const encodingTargetBytes = configuredTargetBytes === void 0 ? originalSizeTargetBytes : originalSizeTargetBytes === void 0 ? configuredTargetBytes : Math.min(configuredTargetBytes, originalSizeTargetBytes);
+		const encoded = await encodeImage(decoded, targetSize.width, targetSize.height, options, encodingTargetBytes);
+		throwIfAborted(options.signal);
+		const { blob, mime: actualMime, width, height, quality, iterations } = encoded;
+		if (options.keepOriginalIfLarger && dimensionsInitiallyUnchanged && sourceMime === actualMime && blob.size >= file.size) {
+			reportProgress(options, 100);
+			return { file };
+		}
+		const outputFile = new File([blob], replaceFileExtension(file.name, actualMime), {
+			type: actualMime,
+			lastModified: file.lastModified
+		});
+		const result = {
+			file: outputFile,
+			beforeKB: Number(beforeKB.toFixed(2)),
+			afterKB: Number((outputFile.size / 1024).toFixed(2)),
+			width,
+			height,
+			mime: actualMime,
+			compressed: true,
+			quality,
+			iterations,
+			...options.targetFileSizeKB === void 0 ? {} : { targetAchieved: blob.size <= options.targetFileSizeKB * 1024 }
+		};
+		if (options.outputMode === "legacy") {
+			const [beforeSrc, afterSrc, arrayBuffer] = await Promise.all([
+				readBlob(file, "dataURL", options.signal),
+				readBlob(blob, "dataURL", options.signal),
+				readBlob(blob, "arrayBuffer", options.signal)
+			]);
+			throwIfAborted(options.signal);
+			result.origin = file;
+			result.beforeSrc = beforeSrc;
+			result.afterSrc = afterSrc;
+			result.bufferArray = new Uint8Array(arrayBuffer);
+		}
+		reportProgress(options, 100);
+		return result;
+	} finally {
+		decoded.release();
+	}
+}
+async function mapWithConcurrency(items, concurrency, worker) {
+	const results = [];
+	let cursor = 0;
+	let failed = false;
+	const execute = async () => {
+		while (!failed && cursor < items.length) {
+			const index = cursor++;
+			try {
+				results[index] = await worker(items[index], index);
+			} catch (error) {
+				failed = true;
+				throw error;
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, execute));
+	return results;
+}
+function compressImage(file, options = {}) {
+	const singleFile = isFile(file);
+	const singleBlob = !singleFile && isBlob(file);
+	const multipleFiles = isFileList(file);
+	if (!singleFile && !singleBlob && !multipleFiles) throw new TypeError(`${String(file)} require be File or FileList`);
+	const normalizedOptions = normalizeOptions(options);
+	throwIfAborted(normalizedOptions.signal);
+	if (singleFile || singleBlob) {
+		const normalizedFile = singleFile ? file : blobToFile(file, normalizedOptions.fileName);
+		return compressOne(normalizedFile, normalizedOptions, !requiresCompression(normalizedFile, normalizedOptions) || supportCanvas());
+	}
+	const files = Array.from(file);
+	const canvasSupported = !files.some((item) => requiresCompression(item, normalizedOptions)) || supportCanvas();
+	const progresses = Array.from({ length: files.length }, () => 0);
+	return mapWithConcurrency(files, normalizedOptions.concurrency, (item, index) => {
+		return compressOne(item, normalizedOptions.onProgress ? {
+			...normalizedOptions,
+			onProgress: (progress) => {
+				progresses[index] = progress;
+				reportProgress(normalizedOptions, progresses.reduce((sum, current) => sum + current, 0) / files.length);
+			}
+		} : normalizedOptions, canvasSupported);
+	});
+}
+var src_default = {
+	IMAGE_COMPRESSION_PRESETS,
+	supportCanvas,
+	compressImage
+};
+//#endregion
+exports.IMAGE_COMPRESSION_PRESETS = IMAGE_COMPRESSION_PRESETS;
+exports.compressImage = compressImage;
+exports.default = src_default;
+exports.supportCanvas = supportCanvas;