@pz4l/tinyimg-core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,851 @@
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
+import path, { join } from "node:path";
+import { createHash } from "node:crypto";
+import os, { homedir } from "node:os";
+import { Buffer } from "node:buffer";
+import tinify from "tinify";
+import https from "node:https";
+import FormData from "form-data";
+import pLimit from "p-limit";
+import process from "node:process";
+import fs from "node:fs";
+//#region src/utils/logger.ts
+function logWarning(message) {
+	console.warn(`⚠ ${message}`);
+}
+function logInfo(message) {
+	console.log(`ℹ ${message}`);
+}
+//#endregion
+//#region src/cache/buffer-storage.ts
+/**
+* Cache storage for reading and writing compressed image data by hash.
+*
+* Uses atomic writes (temp file + rename) for concurrent safety.
+* Handles corruption gracefully by returning null on read failures.
+*/
+var BufferCacheStorage = class {
+	constructor(cacheDir) {
+		this.cacheDir = cacheDir;
+	}
+	/**
+	* Ensure cache directory exists.
+	*/
+	async ensureDir() {
+		await mkdir(this.cacheDir, {
+			recursive: true,
+			mode: 493
+		});
+	}
+	/**
+	* Get the cache file path for an image hash.
+	*
+	* @param hash - MD5 hash of the image buffer
+	* @returns Path to cache file (MD5 hash as filename, no extension)
+	*/
+	getCachePath(hash) {
+		return join(this.cacheDir, hash);
+	}
+	/**
+	* Read cached compressed image data by hash.
+	*
+	* @param hash - MD5 hash of the image buffer
+	* @returns Cached Buffer or null if not found/corrupted
+	*/
+	async read(hash) {
+		try {
+			return await readFile(this.getCachePath(hash));
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Write compressed image data to cache by hash.
+	*
+	* Uses atomic write pattern: temp file + rename.
+	*
+	* @param hash - MD5 hash of the image buffer
+	* @param data - Compressed image data to cache
+	*/
+	async write(hash, data) {
+		await this.ensureDir();
+		const cachePath = this.getCachePath(hash);
+		const tmpPath = `${cachePath}.tmp`;
+		await writeFile(tmpPath, data);
+		await rename(tmpPath, cachePath);
+	}
+};
+/**
+* Read cached image data from multiple cache directories in priority order.
+*
+* @param hash - MD5 hash of the image buffer
+* @param cacheDirs - Array of cache directories (priority order)
+* @returns First successful Buffer read or null if all miss
+*/
+async function readCacheByHash(hash, cacheDirs) {
+	for (const cacheDir of cacheDirs) {
+		const data = await new BufferCacheStorage(cacheDir).read(hash);
+		if (data !== null) {
+			logInfo(`ℹ Cache hit: ${hash.substring(0, 8)}`);
+			return data;
+		}
+	}
+	return null;
+}
+/**
+* Write compressed image data to cache by hash.
+*
+* @param hash - MD5 hash of the image buffer
+* @param data - Compressed image data to cache
+* @param cacheDir - Cache directory to write to
+*/
+async function writeCacheByHash(hash, data, cacheDir) {
+	await new BufferCacheStorage(cacheDir).write(hash, data);
+	logInfo(`ℹ Cached: ${hash.substring(0, 8)}`);
+}
+//#endregion
+//#region src/cache/hash.ts
+/**
+* Calculate MD5 hash of a file's content.
+*
+* @param filePath - Absolute path to the file
+* @returns MD5 hash as a 32-character hexadecimal string
+*
+* @example
+* ```ts
+* const hash = await calculateMD5('/path/to/image.png')
+* console.log(hash) // 'a1b2c3d4e5f6...'
+* ```
+*/
+async function calculateMD5(filePath) {
+	const content = await readFile(filePath);
+	const hash = createHash("md5");
+	hash.update(content);
+	return hash.digest("hex");
+}
+/**
+* Calculate MD5 hash of a buffer's content.
+*
+* @param buffer - Buffer to hash
+* @returns MD5 hash as a 32-character hexadecimal string
+*
+* @example
+* ```ts
+* const hash = await calculateMD5FromBuffer(buffer)
+* console.log(hash) // 'a1b2c3d4e5f6...'
+* ```
+*/
+async function calculateMD5FromBuffer(buffer) {
+	const hash = createHash("md5");
+	hash.update(buffer);
+	return hash.digest("hex");
+}
+//#endregion
+//#region src/cache/paths.ts
+/**
+* Get the project-level cache directory path.
+*
+* @param projectRoot - Absolute path to the project root directory
+* @returns Path to project cache directory: `node_modules/.tinyimg_cache/`
+*
+* @example
+* ```ts
+* const cachePath = getProjectCachePath('/Users/test/project')
+* // Returns: '/Users/test/project/node_modules/.tinyimg_cache'
+* ```
+*/
+function getProjectCachePath(projectRoot) {
+	return join(projectRoot, "node_modules", ".tinyimg_cache");
+}
+/**
+* Get the global cache directory path.
+*
+* @returns Path to global cache directory: `~/.tinyimg/cache/`
+*
+* @example
+* ```ts
+* const cachePath = getGlobalCachePath()
+* // Returns: '/Users/username/.tinyimg/cache'
+* ```
+*/
+function getGlobalCachePath() {
+	return join(homedir(), ".tinyimg", "cache");
+}
+//#endregion
+//#region src/cache/stats.ts
+/**
+* Format bytes to human-readable format.
+*
+* @param bytes - Number of bytes
+* @returns Formatted string (e.g., "1.23 MB", "456 KB")
+*
+* @example
+* ```ts
+* formatBytes(0) // "0 B"
+* formatBytes(512) // "512 B"
+* formatBytes(1024) // "1.00 KB"
+* formatBytes(1024 * 1024) // "1.00 MB"
+* formatBytes(1024 * 1024 * 1024) // "1.00 GB"
+* ```
+*/
+function formatBytes(bytes) {
+	if (bytes === 0) return "0 B";
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+/**
+* Get cache statistics for a directory.
+*
+* @param cacheDir - Cache directory path
+* @returns Cache statistics (count and size)
+*
+* @example
+* ```ts
+* const stats = await getCacheStats('/path/to/cache')
+* console.log(`Files: ${stats.count}, Size: ${formatBytes(stats.size)}`)
+* ```
+*/
+async function getCacheStats(cacheDir) {
+	try {
+		const files = await readdir(cacheDir);
+		let count = 0;
+		let size = 0;
+		for (const file of files) {
+			const stats = await stat(`${cacheDir}/${file}`);
+			if (stats.isFile()) {
+				count++;
+				size += stats.size;
+			}
+		}
+		return {
+			count,
+			size
+		};
+	} catch {
+		return {
+			count: 0,
+			size: 0
+		};
+	}
+}
+/**
+* Get cache statistics for both project and global cache.
+*
+* @param projectRoot - Optional project root directory
+* @returns Object with project and global cache statistics
+*
+* @example
+* ```ts
+* // Get both project and global stats
+* const stats = await getAllCacheStats('/project/path')
+* console.log(`Project: ${stats.project?.count}, Global: ${stats.global.count}`)
+*
+* // Get only global stats
+* const globalOnly = await getAllCacheStats()
+* console.log(`Global: ${globalOnly.global.count}`)
+* ```
+*/
+async function getAllCacheStats(projectRoot) {
+	const global = await getCacheStats(getGlobalCachePath());
+	let project = null;
+	if (projectRoot) project = await getCacheStats(getProjectCachePath(projectRoot));
+	return {
+		project,
+		global
+	};
+}
+//#endregion
+//#region src/cache/storage.ts
+/**
+* Cache storage for reading and writing compressed image data.
+*
+* Uses atomic writes (temp file + rename) for concurrent safety.
+* Handles corruption gracefully by returning null on read failures.
+*/
+var CacheStorage = class {
+	constructor(cacheDir) {
+		this.cacheDir = cacheDir;
+	}
+	/**
+	* Ensure cache directory exists.
+	*/
+	async ensureDir() {
+		await mkdir(this.cacheDir, {
+			recursive: true,
+			mode: 493
+		});
+	}
+	/**
+	* Get the cache file path for an image.
+	*
+	* @param imagePath - Absolute path to the source image
+	* @returns Path to cache file (MD5 hash as filename, no extension)
+	*/
+	async getCachePath(imagePath) {
+		const md5Hash = await calculateMD5(imagePath);
+		return join(this.cacheDir, md5Hash);
+	}
+	/**
+	* Read cached compressed image data.
+	*
+	* @param imagePath - Absolute path to the source image
+	* @returns Cached Buffer or null if not found/corrupted
+	*/
+	async read(imagePath) {
+		try {
+			return await readFile(await this.getCachePath(imagePath));
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Write compressed image data to cache.
+	*
+	* Uses atomic write pattern: temp file + rename.
+	*
+	* @param imagePath - Absolute path to the source image
+	* @param data - Compressed image data to cache
+	*/
+	async write(imagePath, data) {
+		await this.ensureDir();
+		const cachePath = await this.getCachePath(imagePath);
+		const tmpPath = `${cachePath}.tmp`;
+		await writeFile(tmpPath, data);
+		await rename(tmpPath, cachePath);
+	}
+};
+/**
+* Read cached image data from multiple cache directories in priority order.
+*
+* @param imagePath - Absolute path to the source image
+* @param cacheDirs - Array of cache directories (priority order)
+* @returns First successful Buffer read or null if all miss
+*/
+async function readCache(imagePath, cacheDirs) {
+	for (const cacheDir of cacheDirs) {
+		const data = await new CacheStorage(cacheDir).read(imagePath);
+		if (data !== null) {
+			logInfo(`ℹ️ cache hit: ${(await calculateMD5(imagePath)).substring(0, 8)}`);
+			return data;
+		}
+	}
+	return null;
+}
+/**
+* Write compressed image data to cache.
+*
+* @param imagePath - Absolute path to the source image
+* @param data - Compressed image data to cache
+* @param cacheDir - Cache directory to write to
+*/
+async function writeCache(imagePath, data, cacheDir) {
+	await new CacheStorage(cacheDir).write(imagePath, data);
+	logInfo(`ℹ️ cache miss: ${(await calculateMD5(imagePath)).substring(0, 8)}, compressed`);
+}
+//#endregion
+//#region src/compress/retry.ts
+var RetryManager = class {
+	failureCount = 0;
+	constructor(maxRetries = 8, baseDelay = 1e3) {
+		this.maxRetries = maxRetries;
+		this.baseDelay = baseDelay;
+	}
+	async execute(operation) {
+		for (let attempt = 0; attempt <= this.maxRetries; attempt++) try {
+			const result = await operation();
+			this.failureCount = 0;
+			return result;
+		} catch (error) {
+			this.failureCount++;
+			if (attempt === this.maxRetries || !this.shouldRetry(error)) throw error;
+			const delay = this.baseDelay * 2 ** attempt;
+			logWarning(`Retry ${attempt + 1}/${this.maxRetries} after ${delay}ms`);
+			await this.sleep(delay);
+		}
+		throw new Error("Max retries exceeded");
+	}
+	shouldRetry(error) {
+		if (error.code && [
+			"ECONNRESET",
+			"ETIMEDOUT",
+			"ENOTFOUND"
+		].includes(error.code)) return true;
+		if (error.statusCode && error.statusCode >= 500 && error.statusCode < 600) return true;
+		return false;
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	getFailureCount() {
+		return this.failureCount;
+	}
+	reset() {
+		this.failureCount = 0;
+	}
+};
+//#endregion
+//#region src/compress/web-compressor.ts
+const TINYPNG_WEB_URL = "https://tinypng.com/backend/opt/shrink";
+var TinyPngWebCompressor = class {
+	retryManager;
+	constructor(maxRetries = 8) {
+		this.retryManager = new RetryManager(maxRetries);
+	}
+	async compress(buffer) {
+		return this.retryManager.execute(async () => {
+			const uploadUrl = await this.uploadToTinyPngWeb(buffer);
+			const compressedBuffer = await this.downloadCompressedImage(uploadUrl);
+			const originalSize = buffer.byteLength;
+			const compressedSize = compressedBuffer.byteLength;
+			logInfo(`Compressed with [TinyPngWebCompressor]: ${originalSize} → ${compressedSize} (saved ${((1 - compressedSize / originalSize) * 100).toFixed(1)}%)`);
+			return compressedBuffer;
+		});
+	}
+	async uploadToTinyPngWeb(buffer) {
+		return new Promise((resolve, reject) => {
+			const form = new FormData();
+			form.append("file", buffer, { filename: "image.png" });
+			const req = https.request(TINYPNG_WEB_URL, {
+				method: "POST",
+				headers: form.getHeaders()
+			}, (res) => {
+				let data = "";
+				res.on("data", (chunk) => {
+					data += chunk;
+				});
+				res.on("end", () => {
+					if (res.statusCode !== 200) {
+						const error = /* @__PURE__ */ new Error(`HTTP ${res.statusCode}: ${data}`);
+						error.statusCode = res.statusCode;
+						return reject(error);
+					}
+					try {
+						const response = JSON.parse(data);
+						if (!response.output?.url) return reject(/* @__PURE__ */ new Error("No output URL in response"));
+						resolve(response.output.url);
+					} catch (error) {
+						reject(/* @__PURE__ */ new Error(`Failed to parse response: ${error.message}`));
+					}
+				});
+			});
+			req.on("error", (error) => {
+				reject(error);
+			});
+			form.pipe(req);
+		});
+	}
+	async downloadCompressedImage(url) {
+		return new Promise((resolve, reject) => {
+			https.get(url, (res) => {
+				if (res.statusCode !== 200) {
+					const error = /* @__PURE__ */ new Error(`HTTP ${res.statusCode} downloading compressed image`);
+					error.statusCode = res.statusCode;
+					return reject(error);
+				}
+				const chunks = [];
+				res.on("data", (chunk) => chunks.push(chunk));
+				res.on("end", () => resolve(Buffer.concat(chunks)));
+				res.on("error", reject);
+			}).on("error", reject);
+		});
+	}
+	getFailureCount() {
+		return this.retryManager.getFailureCount();
+	}
+};
+//#endregion
+//#region src/compress/api-compressor.ts
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+var TinyPngApiCompressor = class {
+	retryManager;
+	currentKey = null;
+	constructor(keyPool, maxRetries = 8) {
+		this.keyPool = keyPool;
+		this.retryManager = new RetryManager(maxRetries);
+	}
+	async compress(buffer) {
+		if (buffer.byteLength > MAX_FILE_SIZE) {
+			logWarning(`File exceeds 5MB limit for API compressor (${(buffer.byteLength / 1024 / 1024).toFixed(2)}MB)`);
+			throw new Error("File size exceeds 5MB limit");
+		}
+		return this.retryManager.execute(async () => {
+			const key = await this.keyPool.selectKey();
+			if (this.currentKey !== key) try {
+				tinify.key = key;
+				this.currentKey = key;
+			} catch {}
+			const originalSize = buffer.byteLength;
+			const result = await tinify.fromBuffer(buffer).toBuffer();
+			const compressedSize = result.byteLength;
+			const saved = ((1 - compressedSize / originalSize) * 100).toFixed(1);
+			this.keyPool.decrementQuota();
+			logInfo(`Compressed with [TinyPngApiCompressor]: ${originalSize} → ${compressedSize} (saved ${saved}%)`);
+			return Buffer.from(result);
+		});
+	}
+	getFailureCount() {
+		return this.retryManager.getFailureCount();
+	}
+};
+//#endregion
+//#region src/errors/types.ts
+var AllKeysExhaustedError = class extends Error {
+	constructor(message = "All API keys have exhausted quota") {
+		super(message);
+		this.name = "AllKeysExhaustedError";
+	}
+};
+var NoValidKeysError = class extends Error {
+	constructor(message = "No valid API keys available") {
+		super(message);
+		this.name = "NoValidKeysError";
+	}
+};
+var AllCompressionFailedError = class extends Error {
+	constructor(message = "All compression methods failed") {
+		super(message);
+		this.name = "AllCompressionFailedError";
+	}
+};
+//#endregion
+//#region src/compress/compose.ts
+/**
+* Compress buffer with automatic fallback through multiple compressors
+*
+* @param buffer - Original image data
+* @param options - Compression options (mode, compressors, maxRetries)
+* @returns Compressed image data
+* @throws AllCompressionFailedError when all compressors fail
+*
+* @example
+* ```ts
+* try {
+*   const compressed = await compressWithFallback(buffer, { mode: 'auto' })
+* } catch (error) {
+*   if (error instanceof AllCompressionFailedError) {
+*     // All compression methods failed
+*   }
+* }
+* ```
+*/
+async function compressWithFallback(buffer, options = {}) {
+	const compressors = options.compressors ?? [];
+	for (const compressor of compressors) try {
+		logInfo(`Attempting compression with [${compressor.constructor.name}]`);
+		return await compressor.compress(buffer);
+	} catch (error) {
+		logWarning(`[${compressor.constructor.name}] failed: ${error.message}`);
+		if (error.name === "AllCompressionFailedError") throw error;
+		continue;
+	}
+	throw new AllCompressionFailedError("All compression methods failed");
+}
+/**
+* Get default compressor types for a given mode
+* This is a helper - actual compressor instances created in service layer
+*
+* @param mode - Compression mode
+* @returns Compressor type names (not instances)
+*
+* @example
+* ```ts
+* const types = getCompressorTypesForMode('auto')
+* // Returns: ['TinyPngApiCompressor', 'TinyPngWebCompressor']
+* ```
+*/
+function getCompressorTypesForMode(mode = "auto") {
+	switch (mode) {
+		case "api": return ["TinyPngApiCompressor"];
+		case "web": return ["TinyPngWebCompressor"];
+		default: return ["TinyPngApiCompressor", "TinyPngWebCompressor"];
+	}
+}
+//#endregion
+//#region src/compress/concurrency.ts
+/**
+* Create a concurrency limiter for async operations
+*
+* @param concurrency - Max concurrent operations (default: 8)
+* @returns Limit function that wraps async operations
+*
+* @example
+* ```ts
+* const limit = createConcurrencyLimiter(2)
+* const task1 = limit(() => asyncOperation1())
+* const task2 = limit(() => asyncOperation2())
+* await Promise.all([task1, task2])
+* ```
+*/
+function createConcurrencyLimiter(concurrency = 8) {
+	return pLimit(concurrency);
+}
+/**
+* Execute tasks with concurrency control
+*
+* @param tasks - Array of async functions to execute
+* @param concurrency - Max concurrent tasks (default: 8)
+* @returns Promise resolving to array of results
+*
+* @example
+* ```ts
+* const tasks = [
+*   () => compressImage(buffer1),
+*   () => compressImage(buffer2),
+*   () => compressImage(buffer3)
+* ]
+* const results = await executeWithConcurrency(tasks, 2)
+* // Only 2 compressions run at a time
+* ```
+*/
+async function executeWithConcurrency(tasks, concurrency = 8) {
+	const limit = createConcurrencyLimiter(concurrency);
+	const limitedTasks = tasks.map((task) => limit(task));
+	return Promise.all(limitedTasks);
+}
+//#endregion
+//#region src/config/storage.ts
+const CONFIG_DIR = ".tinyimg";
+const CONFIG_FILE = "keys.json";
+function getConfigPath() {
+	const homeDir = os.homedir();
+	return path.join(homeDir, CONFIG_DIR, CONFIG_FILE);
+}
+function ensureConfigFile() {
+	const configPath = getConfigPath();
+	const configDir = path.dirname(configPath);
+	if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, {
+		recursive: true,
+		mode: 448
+	});
+	if (!fs.existsSync(configPath)) fs.writeFileSync(configPath, JSON.stringify({ keys: [] }, null, 2), { mode: 384 });
+}
+function readConfig() {
+	ensureConfigFile();
+	const configPath = getConfigPath();
+	const content = fs.readFileSync(configPath, "utf-8");
+	return JSON.parse(content);
+}
+function writeConfig(config) {
+	ensureConfigFile();
+	const configPath = getConfigPath();
+	fs.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+}
+//#endregion
+//#region src/config/loader.ts
+function loadKeys() {
+	const envKeys = process.env.TINYPNG_KEYS;
+	if (envKeys && envKeys.trim()) return envKeys.split(",").map((k) => k.trim()).filter((k) => k.length > 0).map((key) => ({ key }));
+	try {
+		return readConfig().keys.map((metadata) => ({
+			key: metadata.key,
+			valid: metadata.valid,
+			lastCheck: metadata.lastCheck
+		}));
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/keys/masker.ts
+function maskKey(key) {
+	if (key.length < 8) return "****";
+	return `${key.substring(0, 4)}****${key.substring(key.length - 4)}`;
+}
+//#endregion
+//#region src/keys/quota.ts
+const MONTHLY_LIMIT = 500;
+async function queryQuota(key) {
+	try {
+		tinify.key = key;
+		await tinify.validate();
+		const usedThisMonth = tinify.compressionCount ?? 0;
+		return Math.max(0, MONTHLY_LIMIT - usedThisMonth);
+	} catch (error) {
+		if (error?.message?.includes("credentials") || error?.message?.includes("Unauthorized") || error?.constructor?.name === "AccountError") return 0;
+		throw error;
+	}
+}
+function createQuotaTracker(key, remaining) {
+	return {
+		key,
+		remaining,
+		localCounter: remaining,
+		decrement() {
+			if (this.localCounter > 0) {
+				this.localCounter--;
+				if (this.localCounter === 0) console.warn(`⚠ Key ${maskKey(this.key)} quota exhausted, switching to next key`);
+			}
+		},
+		isZero() {
+			return this.localCounter === 0;
+		}
+	};
+}
+//#endregion
+//#region src/keys/validator.ts
+async function validateKey(key) {
+	try {
+		tinify.key = key;
+		await tinify.validate();
+		console.log(`✓ API key ${maskKey(key)} validated successfully`);
+		return true;
+	} catch (error) {
+		if (error?.message?.includes("credentials") || error?.message?.includes("Unauthorized") || error?.constructor?.name === "AccountError") {
+			console.warn(`⚠ Invalid API key ${maskKey(key)} marked and skipped`);
+			return false;
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/keys/selector.ts
+var RandomSelector = class {
+	async select(keys) {
+		const available = await this.getAvailableKeys(keys);
+		if (available.length === 0) return null;
+		return available[Math.floor(Math.random() * available.length)];
+	}
+	async getAvailableKeys(keys) {
+		const available = [];
+		for (const key of keys) {
+			if (!await validateKey(key)) continue;
+			const remaining = await queryQuota(key);
+			if (remaining === 0) {
+				logWarning(`Key ${maskKey(key)} has no quota remaining`);
+				continue;
+			}
+			available.push({
+				key,
+				tracker: createQuotaTracker(key, remaining)
+			});
+		}
+		return available;
+	}
+};
+var RoundRobinSelector = class extends RandomSelector {
+	currentIndex = 0;
+	async select(keys) {
+		const available = await this.getAvailableKeys(keys);
+		if (available.length === 0) return null;
+		const selected = available[this.currentIndex % available.length];
+		this.currentIndex++;
+		return selected;
+	}
+	reset() {
+		this.currentIndex = 0;
+	}
+};
+var PrioritySelector = class extends RandomSelector {
+	async select(keys) {
+		const available = await this.getAvailableKeys(keys);
+		if (available.length === 0) return null;
+		return available[0];
+	}
+};
+//#endregion
+//#region src/keys/pool.ts
+var KeyPool = class {
+	keys;
+	selector;
+	currentSelection = null;
+	constructor(strategy = "random") {
+		this.keys = loadKeys().map((k) => k.key);
+		if (this.keys.length === 0) throw new NoValidKeysError("No API keys configured");
+		this.selector = this.createSelector(strategy);
+	}
+	createSelector(strategy) {
+		switch (strategy) {
+			case "random": return new RandomSelector();
+			case "round-robin": return new RoundRobinSelector();
+			case "priority": return new PrioritySelector();
+			default: return new RandomSelector();
+		}
+	}
+	async selectKey() {
+		if (this.currentSelection && !this.currentSelection.tracker.isZero()) return this.currentSelection.key;
+		const selection = await this.selector.select(this.keys);
+		if (!selection) throw new AllKeysExhaustedError();
+		this.currentSelection = selection;
+		return selection.key;
+	}
+	decrementQuota() {
+		if (this.currentSelection) this.currentSelection.tracker.decrement();
+	}
+	getCurrentKey() {
+		return this.currentSelection?.key ?? null;
+	}
+};
+//#endregion
+//#region src/compress/service.ts
+/**
+* Compress a single image with cache integration and fallback
+*
+* @param buffer - Original image data
+* @param options - Compression options
+* @returns Compressed image data
+*/
+async function compressImage(buffer, options = {}) {
+	const { cache = true, projectCacheOnly = false, mode = "auto", maxRetries = 8 } = options;
+	const hash = await calculateMD5FromBuffer(buffer);
+	const hashPrefix = hash.substring(0, 8);
+	if (cache) try {
+		const cached = await readCacheByHash(hash, [getProjectCachePath(process.cwd())]);
+		if (cached) {
+			logInfo(`ℹ Cache hit: ${hashPrefix}`);
+			return cached;
+		}
+		if (!projectCacheOnly) {
+			const globalCached = await readCacheByHash(hash, [getGlobalCachePath()]);
+			if (globalCached) {
+				logInfo(`ℹ Cache hit (global): ${hashPrefix}`);
+				return globalCached;
+			}
+		}
+	} catch (error) {
+		logWarning(`Cache read failed: ${error.message}`);
+	}
+	logInfo(`ℹ Cache miss: ${hashPrefix}, compressing...`);
+	const compressed = await compressWithFallback(buffer, {
+		mode,
+		maxRetries,
+		compressors: createCompressors(options)
+	});
+	if (cache) try {
+		await writeCacheByHash(hash, compressed, getProjectCachePath(process.cwd()));
+		logInfo(`ℹ Cached: ${hashPrefix}`);
+	} catch (error) {
+		logWarning(`Cache write failed: ${error.message}`);
+	}
+	return compressed;
+}
+/**
+* Compress multiple images with concurrency control
+*
+* @param buffers - Array of image buffers
+* @param options - Compression options
+* @returns Array of compressed buffers
+*/
+async function compressImages(buffers, options = {}) {
+	const { concurrency = 8 } = options;
+	const limit = createConcurrencyLimiter(concurrency);
+	const tasks = buffers.map((buffer) => limit(() => compressImage(buffer, options)));
+	return Promise.all(tasks);
+}
+/**
+* Create compressor instances based on options
+* Factory function to inject KeyPool for API compressor
+*/
+function createCompressors(options) {
+	const { mode = "auto", maxRetries = 8, keyPool } = options;
+	const compressors = [];
+	const pool = keyPool || new KeyPool("random");
+	if (mode === "auto" || mode === "api") compressors.push(new TinyPngApiCompressor(pool, maxRetries));
+	if (mode === "auto" || mode === "web") compressors.push(new TinyPngWebCompressor(maxRetries));
+	return compressors;
+}
+//#endregion
+export { AllCompressionFailedError, AllKeysExhaustedError, BufferCacheStorage, CacheStorage, KeyPool, NoValidKeysError, PrioritySelector, RandomSelector, RetryManager, RoundRobinSelector, TinyPngApiCompressor, TinyPngWebCompressor, calculateMD5, calculateMD5FromBuffer, compressImage, compressImages, compressWithFallback, createConcurrencyLimiter, createQuotaTracker, ensureConfigFile, executeWithConcurrency, formatBytes, getAllCacheStats, getCacheStats, getCompressorTypesForMode, getGlobalCachePath, getProjectCachePath, loadKeys, logInfo, logWarning, maskKey, queryQuota, readCache, readCacheByHash, readConfig, validateKey, writeCache, writeCacheByHash, writeConfig };
+
+//# sourceMappingURL=index.mjs.map