pic-compressor 0.1.0

package/dist/index.mjs

@@ -0,0 +1,536 @@
+/*! pic-compressor v0.1.0 | MIT License | https://github.com/chandq/pic-compressor */
+//#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
+export { IMAGE_COMPRESSION_PRESETS, compressImage, src_default as default, supportCanvas };

package/dist/index.umd.js

@@ -0,0 +1,2 @@
+/*! pic-compressor v0.1.0 | MIT License | https://github.com/chandq/pic-compressor */
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports):typeof define==`function`&&define.amd?define([`exports`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e.PicCompressor={}))})(this,function(e){Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});function t(e){return typeof e==`object`&&!!e}let n=[`image/jpeg`,`image/png`,`image/webp`,`image/avif`],r=2560,i=8192;function a(){if(typeof document>`u`||typeof document.createElement!=`function`)return!1;try{let e=document.createElement(`canvas`);return typeof e.getContext==`function`&&e.getContext(`2d`)!==null}catch{return!1}}let o={balanced:{quality:.82,minQuality:.6,maxWidth:1920,maxHeight:1920,maxPixels:6291456,targetFileSizeKB:500,preserveLongImage:!0},social:{quality:.82,minQuality:.62,maxWidth:1280,maxHeight:1280,maxPixels:4194304,targetFileSizeKB:300,preserveLongImage:!0},"high-quality":{quality:.88,minQuality:.72,maxWidth:2560,maxHeight:2560,maxPixels:8388608,targetFileSizeKB:1024,preserveLongImage:!0},thumbnail:{quality:.78,minQuality:.58,maxWidth:400,maxHeight:400,maxPixels:16e4,targetFileSizeKB:30},"long-image":{quality:.82,minQuality:.65,maxWidth:1080,maxHeight:i,maxPixels:12582912,preserveLongImage:!0}};function s(e){return typeof File<`u`&&e instanceof File||Object.prototype.toString.call(e)===`[object File]`}function c(e){return typeof FileList<`u`&&e instanceof FileList||Object.prototype.toString.call(e)===`[object FileList]`}function l(e){return typeof Blob<`u`&&e instanceof Blob||Object.prototype.toString.call(e)===`[object Blob]`}function u(){if(typeof DOMException<`u`)return new DOMException(`Image compression aborted`,`AbortError`);let e=/* @__PURE__ */ Error(`Image compression aborted`);return e.name=`AbortError`,e}function d(e){if(e?.aborted)throw u()}function f(e,t,n,r=1/0){if(typeof e!=`number`||!Number.isFinite(e)||e<n||e>r)throw RangeError(`${t} must be a finite number between ${n} and ${r}`)}function p(e){let{preset:r=`balanced`,quality:a,mime:s=`image/jpeg`,maxWidth:c,maxHeight:l,maxSize:u,minFileSizeKB:d=50,maxPixels:p,maxCanvasDimension:m=i,preserveLongImage:h,targetFileSizeKB:g,minQuality:_,maxIterations:v=8,concurrency:y=2,outputMode:b=`legacy`,keepOriginalIfLarger:x=!0,backgroundColor:S=`#fff`,strictMime:C=!1,onProgress:w,signal:T,fileName:E=`image`}=t(e)?e:{},D=o[r];if(!D)throw TypeError(`Unsupported image compression preset: ${String(r)}`);let O=a??D.quality,k=_??Math.min(D.minQuality,O),A=p??D.maxPixels,j=g===null?void 0:g??D.targetFileSizeKB,M=c!==void 0||l!==void 0||u!==void 0,N=M?c??u:D.maxWidth,P=M?l??u:D.maxHeight,F=h??(!M&&!!D.preserveLongImage);if(f(O,`quality`,0,1),f(k,`minQuality`,0,1),k>O)throw RangeError(`minQuality must not be greater than quality`);if(!n.includes(s))throw TypeError(`Unsupported image mime type: ${String(s)}`);if(N!==void 0&&f(N,`maxWidth`,1),P!==void 0&&f(P,`maxHeight`,1),u!==void 0&&f(u,`maxSize`,1),f(d,`minFileSizeKB`,0),f(A,`maxPixels`,1),f(m,`maxCanvasDimension`,1),j!==void 0&&f(j,`targetFileSizeKB`,1),f(v,`maxIterations`,1),f(y,`concurrency`,1),typeof x!=`boolean`)throw TypeError(`keepOriginalIfLarger must be a boolean`);if(typeof S!=`string`)throw TypeError(`backgroundColor must be a string`);if(typeof C!=`boolean`)throw TypeError(`strictMime must be a boolean`);if(typeof F!=`boolean`)throw TypeError(`preserveLongImage must be a boolean`);if(w!==void 0&&typeof w!=`function`)throw TypeError(`onProgress must be a function`);if(typeof E!=`string`||E.length===0)throw TypeError(`fileName must be a non-empty string`);if(b!==`legacy`&&b!==`compact`)throw TypeError(`outputMode must be "legacy" or "compact"`);return{preset:r,quality:O,mime:s,maxWidth:N===void 0?void 0:Math.floor(N),maxHeight:P===void 0?void 0:Math.floor(P),minFileSizeKB:d,maxPixels:Math.floor(A),maxCanvasDimension:Math.floor(m),preserveLongImage:F,targetFileSizeKB:j,minQuality:k,maxIterations:Math.max(1,Math.floor(v)),concurrency:Math.max(1,Math.floor(y)),outputMode:b,keepOriginalIfLarger:x,backgroundColor:S,strictMime:C,onProgress:w,signal:T,fileName:E}}function m(e,t){return new File([e],t,{type:e.type,lastModified:Date.now()})}function h(e,t,n,i,a,o,s){let c=e,l=t;c===void 0&&l===void 0&&(c=r,l=r);let u=Math.max(o/s,s/o);a&&u>=3&&(o>=s?c=i:l=i),c=Math.min(c??i,i),l=Math.min(l??i,i);let d=Math.min(1,c/o,l/s),f=Math.min(1,Math.sqrt(n/(o*s))),p=Math.min(d,f);return{width:Math.max(1,Math.floor(o*p)),height:Math.max(1,Math.floor(s*p))}}function g(e,t,n){return new Promise((r,i)=>{d(n);let a=new FileReader,o=!1,s=()=>{a.onerror=null,a.onabort=null,a.onload=null,n?.removeEventListener(`abort`,l)},c=e=>{o||(o=!0,s(),i(e))},l=()=>{try{a.abort()}finally{c(u())}};a.onerror=()=>c(a.error??/* @__PURE__ */ Error(`Failed to read image data`)),a.onabort=()=>c(u()),a.onload=()=>{if(o)return;let e=a.result;t===`dataURL`&&typeof e==`string`||t===`arrayBuffer`&&e instanceof ArrayBuffer?(o=!0,s(),r(e)):c(/* @__PURE__ */ Error(`Unexpected FileReader result for ${t}`))},n?.addEventListener(`abort`,l,{once:!0}),t===`dataURL`?a.readAsDataURL(e):a.readAsArrayBuffer(e)})}async function _(e,t){if(d(t),typeof createImageBitmap==`function`)try{let n=await createImageBitmap(e);try{if(d(t),!n.width||!n.height)throw Error(`Decoded image has invalid dimensions`)}catch(e){throw n.close(),e}return{source:n,width:n.width,height:n.height,release:()=>n.close()}}catch(e){if(e.name===`AbortError`)throw e}return new Promise((n,r)=>{let i=new Image,a,o=!1,s=()=>{i.onload=null,i.onerror=null,t?.removeEventListener(`abort`,l),a&&typeof URL.revokeObjectURL==`function`&&URL.revokeObjectURL(a)},c=e=>{o||(o=!0,s(),r(e))},l=()=>c(u());i.onload=()=>{if(o)return;o=!0;let e=i.naturalWidth||i.width,t=i.naturalHeight||i.height;s(),!e||!t?r(/* @__PURE__ */ Error(`Decoded image has invalid dimensions`)):n({source:i,width:e,height:t,release:()=>void 0})},i.onerror=()=>c(/* @__PURE__ */ Error(`Failed to decode image: ${e.name}`)),t?.addEventListener(`abort`,l,{once:!0});try{typeof URL<`u`&&typeof URL.createObjectURL==`function`?(a=URL.createObjectURL(e),i.src=a):g(e,`dataURL`,t).then(e=>i.src=e,c)}catch(e){c(e instanceof Error?e:Error(String(e)))}})}function v(e,t,n){if(typeof e.toBlob==`function`)return new Promise((r,i)=>{e.toBlob(e=>e?r(e):i(/* @__PURE__ */ Error(`Canvas image encoding failed`)),t,n)});try{let[r,i=``]=e.toDataURL(t,n).split(`,`),a=/^data:([^;]+)/.exec(r??``)?.[1]||t,o=atob(i),s=new Uint8Array(o.length);for(let e=0;e<o.length;e++)s[e]=o.charCodeAt(e);return Promise.resolve(new Blob([s],{type:a}))}catch(e){return Promise.reject(e)}}function y(e){return e===`image/jpg`?`image/jpeg`:n.includes(e)?e:void 0}function b(e,t){let n={"image/jpeg":`jpg`,"image/png":`png`,"image/webp":`webp`,"image/avif":`avif`},r=e.lastIndexOf(`.`);return`${r>0?e.slice(0,r):e||`image`}.${n[t]}`}function x(e,t){if(e.onProgress)try{e.onProgress(Math.max(0,Math.min(100,Math.round(t))))}catch{}}function S(e,t){let n=e.size/1024;return n>=t.minFileSizeKB||t.targetFileSizeKB!==void 0&&n>t.targetFileSizeKB}function C(e){return e===`image/jpeg`||e===`image/webp`||e===`image/avif`}function w(e,t,n){let r=y(e.type);if(!r)throw Error(`Canvas returned unsupported image mime type: ${e.type||`unknown`}`);if(n&&r!==t)throw Error(`Current runtime does not support encoding ${t}; received ${r} instead`);return r}async function T(e,t,n,r,i){let a=0,o=async n=>{d(t.signal);let r=await v(e,t.mime,n);return a++,x(t,10+(i+a)/t.maxIterations*80),{blob:r,mime:w(r,t.mime,t.strictMime),quality:n}},s=await o(t.quality);if(n===void 0||s.blob.size<=n||!C(s.mime)||r<=1||t.quality<=t.minQuality)return{...s,iterations:a};let c=await o(t.minQuality);if(c.blob.size>n)return{...c,iterations:a};let l=c,u=t.minQuality,f=t.quality,p=r-a;for(let e=0;e<p&&f-u>.01;e++){let e=(u+f)/2,t=await o(e);t.blob.size<=n?(l=t,u=e):f=e}return{...l,iterations:a}}async function E(e,t,n,r,i){let a=t,o=n,s=0,c;for(;s<r.maxIterations;){let t=document.createElement(`canvas`);t.width=a,t.height=o;let n=t.getContext(`2d`);if(!n)throw Error(`Failed to create Canvas 2D context`);n.imageSmoothingEnabled=!0,n.imageSmoothingQuality=`high`,r.mime===`image/jpeg`&&(n.fillStyle=r.backgroundColor,n.fillRect(0,0,a,o)),n.drawImage(e.source,0,0,a,o),d(r.signal);try{c=await T(t,r,i,r.maxIterations-s,s),s+=c.iterations}finally{t.width=1,t.height=1}if(i===void 0||c.blob.size<=i||s>=r.maxIterations)return{...c,width:a,height:o,iterations:s};let l=Math.min(.9,Math.sqrt(i/c.blob.size)*.95),u=Math.max(1,Math.floor(a*l)),f=Math.max(1,Math.floor(o*l));if(u===a&&f===o||a===1&&o===1)return{...c,width:a,height:o,iterations:s};a=u,o=f}if(!c)throw Error(`Image encoding did not produce a result`);return{...c,width:a,height:o,iterations:s}}async function D(e,t,n){if(x(t,0),d(t.signal),e.type&&!e.type.startsWith(`image/`))throw TypeError(`${e.name} is not an image file`);let r=e.size/1024;if(!S(e,t))return x(t,100),{file:e};if(!n)throw Error(`Current runtime environment not support Canvas`);let i=await _(e,t.signal);try{x(t,8),d(t.signal);let n=h(t.maxWidth,t.maxHeight,t.maxPixels,t.maxCanvasDimension,t.preserveLongImage,i.width,i.height),a=t.targetFileSizeKB===void 0?void 0:t.targetFileSizeKB*1024,o=y(e.type),s=n.width===i.width&&n.height===i.height,c=t.keepOriginalIfLarger&&s&&o===t.mime?Math.max(0,e.size-1):void 0,l=a===void 0?c:c===void 0?a:Math.min(a,c),u=await E(i,n.width,n.height,t,l);d(t.signal);let{blob:f,mime:p,width:m,height:_,quality:v,iterations:S}=u;if(t.keepOriginalIfLarger&&s&&o===p&&f.size>=e.size)return x(t,100),{file:e};let C=new File([f],b(e.name,p),{type:p,lastModified:e.lastModified}),w={file:C,beforeKB:Number(r.toFixed(2)),afterKB:Number((C.size/1024).toFixed(2)),width:m,height:_,mime:p,compressed:!0,quality:v,iterations:S,...t.targetFileSizeKB===void 0?{}:{targetAchieved:f.size<=t.targetFileSizeKB*1024}};if(t.outputMode===`legacy`){let[n,r,i]=await Promise.all([g(e,`dataURL`,t.signal),g(f,`dataURL`,t.signal),g(f,`arrayBuffer`,t.signal)]);d(t.signal),w.origin=e,w.beforeSrc=n,w.afterSrc=r,w.bufferArray=new Uint8Array(i)}return x(t,100),w}finally{i.release()}}async function O(e,t,n){let r=[],i=0,a=!1;return await Promise.all(Array.from({length:Math.min(t,e.length)},async()=>{for(;!a&&i<e.length;){let t=i++;try{r[t]=await n(e[t],t)}catch(e){throw a=!0,e}}})),r}function k(e,t={}){let n=s(e),r=!n&&l(e),i=c(e);if(!n&&!r&&!i)throw TypeError(`${String(e)} require be File or FileList`);let o=p(t);if(d(o.signal),n||r){let t=n?e:m(e,o.fileName);return D(t,o,!S(t,o)||a())}let u=Array.from(e),f=!u.some(e=>S(e,o))||a(),h=Array.from({length:u.length},()=>0);return O(u,o.concurrency,(e,t)=>D(e,o.onProgress?{...o,onProgress:e=>{h[t]=e,x(o,h.reduce((e,t)=>e+t,0)/u.length)}}:o,f))}var A={IMAGE_COMPRESSION_PRESETS:o,supportCanvas:a,compressImage:k};e.IMAGE_COMPRESSION_PRESETS=o,e.compressImage=k,e.default=A,e.supportCanvas=a});

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "pic-compressor",
+  "version": "0.1.0",
+  "description": "Zero-dependency browser image compressor with presets, target-size iteration, long-image support, and batch processing.",
+  "keywords": [
+    "avif",
+    "compress",
+    "compressImage",
+    "compressImg",
+    "compressor",
+    "image",
+    "jpeg",
+    "pic-compressor",
+    "png",
+    "webp"
+  ],
+  "homepage": "https://github.com/chandq/pic-compressor#readme",
+  "bugs": {
+    "url": "https://github.com/chandq/pic-compressor/issues"
+  },
+  "license": "MIT",
+  "author": "chandq",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chandq/pic-compressor.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/index.umd.js",
+  "types": "./dist/index.d.mts",
+  "unpkg": "./dist/index.umd.js",
+  "jsdelivr": "./dist/index.umd.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": "./dist/index.mjs"
+    },
+    "./umd": "./dist/index.umd.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint .",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "verify": "npm run lint && npm run format:check && npm run typecheck && npm run test && npm run build && npm run publint",
+    "publint": "publint --pack npm",
+    "prepublishOnly": "npm run verify"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "@vitest/coverage-v8": "^5.0.1",
+    "jsdom": "^30.1.0",
+    "oxfmt": "^0.68.0",
+    "oxlint": "^1.83.0",
+    "publint": "^0.3.15",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}