gotodev-image-optimizer 0.1.1 → 0.1.2

package/dist/chunk-JJABKWGE.js

@@ -0,0 +1,705 @@
+// src/vite-plugin.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { basename, extname, resolve } from "path";
+
+// src/core/encoder.ts
+import { readFileSync } from "fs";
+import sharp4 from "sharp";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function contentHash(buffer) {
+  return createHash("sha384").update(buffer).digest("base64url").slice(0, 16);
+}
+function sriHash(buffer) {
+  const hash = createHash("sha384").update(buffer).digest("base64");
+  return `sha384-${hash}`;
+}
+
+// src/core/analyzer.ts
+import sharp from "sharp";
+
+// src/utils/entropy.ts
+function computeEntropy(pixels) {
+  const histogram = new Float64Array(256);
+  const len = pixels.length;
+  for (let i = 0; i < len; i++) {
+    const val = pixels[i];
+    if (val !== void 0) {
+      histogram[val] = (histogram[val] ?? 0) + 1;
+    }
+  }
+  let entropy = 0;
+  const lenF = len;
+  for (let i = 0; i < 256; i++) {
+    const count = histogram[i];
+    if (count && count > 0) {
+      const p = count / lenF;
+      entropy -= p * Math.log2(p);
+    }
+  }
+  return entropy;
+}
+function computeEdgeDensity(pixels, width, height) {
+  let edges = 0;
+  let total = 0;
+  for (let y = 1; y < height - 1; y++) {
+    for (let x = 1; x < width - 1; x++) {
+      const idx = y * width + x;
+      const center = pixels[idx] ?? 0;
+      const right = pixels[idx + 1] ?? 0;
+      const down = pixels[idx + width] ?? 0;
+      const dx = Math.abs(center - right);
+      const dy = Math.abs(center - down);
+      if (dx > 20 || dy > 20) {
+        edges++;
+      }
+      total++;
+    }
+  }
+  return total > 0 ? edges / total : 0;
+}
+function computeCenterWeight(tileX, tileY, tilesX, tilesY) {
+  const cx = (tileX + 0.5) / tilesX - 0.5;
+  const cy = (tileY + 0.5) / tilesY - 0.5;
+  const dist = Math.sqrt(cx * cx + cy * cy);
+  const normalizedDist = Math.min(1, dist / Math.SQRT1_2);
+  return 1 - normalizedDist * 0.4;
+}
+
+// src/core/analyzer.ts
+function computeSkinRatio(pixels, width, height) {
+  let skin = 0;
+  const total = width * height;
+  for (let i = 0; i < total; i++) {
+    const r = pixels[i * 3] ?? 0;
+    const g = pixels[i * 3 + 1] ?? 0;
+    const b = pixels[i * 3 + 2] ?? 0;
+    const cr = (r - 128) * 0.713 + (g - 128) * -0.287 + (b - 128) * -0.426 + 128;
+    const cb = (r - 128) * -0.169 + (g - 128) * -0.331 + (b - 128) * 0.5 + 128;
+    if (cr >= 133 && cr <= 173 && cb >= 77 && cb <= 127) {
+      skin++;
+    }
+  }
+  return total > 0 ? skin / total : 0;
+}
+async function analyzeImage(imagePath, tileSize = 64, detectFaces = false) {
+  const metadata = await sharp(imagePath).metadata();
+  const width = metadata.width ?? 0;
+  const height = metadata.height ?? 0;
+  if (width === 0 || height === 0) {
+    throw new Error("Could not read image dimensions");
+  }
+  const tilesX = Math.ceil(width / tileSize);
+  const tilesY = Math.ceil(height / tileSize);
+  const tiles = [];
+  let totalImportance = 0;
+  for (let ty = 0; ty < tilesY; ty++) {
+    for (let tx = 0; tx < tilesX; tx++) {
+      const left = tx * tileSize;
+      const top = ty * tileSize;
+      const tileW = Math.min(tileSize, width - left);
+      const tileH = Math.min(tileSize, height - top);
+      const buffer = await sharp(imagePath).extract({ left, top, width: tileW, height: tileH }).raw().toBuffer();
+      const raw = new Uint8Array(buffer);
+      const pixelCount = tileW * tileH;
+      const gray = new Uint8Array(pixelCount);
+      for (let i = 0; i < pixelCount; i++) {
+        const r = raw[i * 3] ?? 0;
+        const g = raw[i * 3 + 1] ?? 0;
+        const b = raw[i * 3 + 2] ?? 0;
+        gray[i] = Math.round(r * 0.299 + g * 0.587 + b * 0.114);
+      }
+      const entropy = computeEntropy(gray);
+      const edgeDensity = computeEdgeDensity(gray, tileW, tileH);
+      const centerWeight = computeCenterWeight(tx, ty, tilesX, tilesY);
+      const normalizedEntropy = entropy / 8;
+      let importance = Math.min(1, normalizedEntropy * 0.4 + edgeDensity * 0.6);
+      if (detectFaces && importance < 0.9) {
+        const skinRatio = computeSkinRatio(raw, tileW, tileH);
+        if (skinRatio > 0.05) {
+          importance = Math.min(1, importance + 0.3);
+        }
+      }
+      tiles.push({
+        x: tx,
+        y: ty,
+        entropy,
+        edgeDensity,
+        importance,
+        centerWeight
+      });
+      totalImportance += importance;
+    }
+  }
+  const tileQualities = computeTileQualities(tiles);
+  return {
+    tiles,
+    tileQualities,
+    overallImportance: tiles.length > 0 ? totalImportance / tiles.length : 0,
+    tileSize,
+    width,
+    height
+  };
+}
+function computeTileQualities(tiles) {
+  const tileQualities = [];
+  for (const tile of tiles) {
+    let importance = tile.importance;
+    if (tile.edgeDensity > 0.3) {
+      const bonus = Math.min(0.2, (tile.edgeDensity - 0.3) * 0.5);
+      importance = Math.min(1, importance + bonus);
+    }
+    if (tile.centerWeight > 0.7) {
+      importance = Math.min(1, importance + (tile.centerWeight - 0.7) * 0.3);
+    }
+    tileQualities.push({
+      x: tile.x,
+      y: tile.y,
+      saliency: importance,
+      quality: 0,
+      weight: importance ** 2 + 0.1
+    });
+  }
+  return tileQualities;
+}
+function computeTargetQuality(analysis, baseQuality = 80, options) {
+  if (analysis.tiles.length === 0) return baseQuality;
+  const minQuality = options?.minQuality ?? Math.max(20, baseQuality - 30);
+  const maxQuality = options?.maxQuality ?? Math.min(95, baseQuality + 10);
+  const tileQualities = analysis.tileQualities;
+  const weighted = tileQualities.map((tq) => ({
+    quality: minQuality + tq.saliency * (maxQuality - minQuality),
+    weight: tq.weight
+  }));
+  weighted.sort((a, b) => b.quality - a.quality);
+  const splitIndex = Math.max(1, Math.ceil(weighted.length * 0.3));
+  const highPriority = weighted.slice(0, splitIndex);
+  const lowPriority = weighted.slice(splitIndex);
+  const highW = highPriority.reduce((s, t) => s + t.weight, 0);
+  const lowW = lowPriority.reduce((s, t) => s + t.weight, 0);
+  const highAvg = highPriority.reduce((s, t) => s + t.quality * t.weight, 0) / (highW || 1);
+  const lowAvg = lowPriority.reduce((s, t) => s + t.quality * t.weight, 0) / (lowW || 1);
+  const weightedQuality = highAvg * 0.7 + lowAvg * 0.3;
+  const qualities = weighted.map((t) => t.quality);
+  const mean = qualities.reduce((s, q) => s + q, 0) / qualities.length;
+  const variance = qualities.reduce((s, q) => s + (q - mean) ** 2, 0) / qualities.length;
+  const stdDev = Math.sqrt(variance);
+  const varianceBoost = stdDev > 12 ? Math.min(5, stdDev * 0.12) : 0;
+  return Math.round(Math.min(maxQuality, Math.max(minQuality, weightedQuality + varianceBoost)));
+}
+
+// src/core/formats.ts
+var MAGIC_BYTES = {
+  jpeg: new Uint8Array([255, 216, 255]),
+  png: new Uint8Array([137, 80, 78, 71]),
+  webp: new Uint8Array([82, 73, 70, 70]),
+  gif: new Uint8Array([71, 73, 70, 56]),
+  bmp: new Uint8Array([66, 77]),
+  tiff: new Uint8Array([73, 73, 42, 0]),
+  ico: new Uint8Array([0, 0, 1, 0]),
+  svg: new Uint8Array([60])
+  // '<'
+};
+var EXTENSION_MAP = {
+  jpg: "jpeg",
+  jpeg: "jpeg",
+  png: "png",
+  webp: "webp",
+  avif: "avif",
+  gif: "gif",
+  svg: "svg",
+  bmp: "bmp",
+  tiff: "tiff",
+  tif: "tiff",
+  ico: "ico"
+};
+function detectFormat(buffer, extension) {
+  const extFormat = EXTENSION_MAP[extension.toLowerCase()];
+  if (extFormat === "svg") return "svg";
+  for (const [format, magic] of Object.entries(MAGIC_BYTES)) {
+    if (buffer.length >= magic.length) {
+      let match = true;
+      for (let i = 0; i < magic.length; i++) {
+        if (buffer[i] !== magic[i]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        if (format === "webp") {
+          const riffType = new TextDecoder().decode(buffer.slice(8, 12));
+          if (riffType === "WEBP") return "webp";
+          continue;
+        }
+        return format;
+      }
+    }
+  }
+  return extFormat ?? "jpeg";
+}
+function isAnimatedFormat(format) {
+  return format === "gif";
+}
+
+// src/core/preprocessor.ts
+import sharp2 from "sharp";
+var OVERLAP_PX = 8;
+async function preprocessImage(imagePath, analysis) {
+  const { width, height, tileSize, tiles } = analysis;
+  const sorted = [...tiles].sort((a, b) => b.importance - a.importance);
+  const topCount = Math.max(1, Math.ceil(sorted.length * 0.2));
+  const importantTiles = sorted.slice(0, topCount);
+  const composites = [];
+  for (const tile of importantTiles) {
+    const tileLeft = tile.x * tileSize;
+    const tileTop = tile.y * tileSize;
+    const tileW = Math.min(tileSize, width - tileLeft);
+    const tileH = Math.min(tileSize, height - tileTop);
+    const padL = tileLeft > 0 ? OVERLAP_PX : 0;
+    const padT = tileTop > 0 ? OVERLAP_PX : 0;
+    const padR = tileLeft + tileW < width ? OVERLAP_PX : 0;
+    const padB = tileTop + tileH < height ? OVERLAP_PX : 0;
+    const extLeft = tileLeft - padL;
+    const extTop = tileTop - padT;
+    const extWidth = tileW + padL + padR;
+    const extHeight = tileH + padT + padB;
+    const sigma = 1 + tile.importance * 1.2;
+    const sharpened = await sharp2(imagePath).extract({ left: extLeft, top: extTop, width: extWidth, height: extHeight }).sharpen(sigma).png().toBuffer();
+    const trimmed = await sharp2(sharpened).extract({ left: padL, top: padT, width: tileW, height: tileH }).png().toBuffer();
+    composites.push({ input: trimmed, top: tileTop, left: tileLeft });
+  }
+  if (composites.length === 0) {
+    return sharp2(imagePath).png().toBuffer();
+  }
+  return sharp2(imagePath).composite(composites.map((c) => ({ input: c.input, top: c.top, left: c.left }))).png().toBuffer();
+}
+
+// src/core/sanitizer.ts
+function sanitizeSvg(input) {
+  let sanitized = input;
+  sanitized = sanitized.replace(/<script[\s\S]*?<\/script>/gi, "");
+  sanitized = sanitized.replace(/<\s*script[^>]*\/?>/gi, "");
+  sanitized = sanitized.replace(/\s+on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+  sanitized = sanitized.replace(/javascript\s*:/gi, "");
+  sanitized = sanitized.replace(/data\s*:\s*text\s*\/\s*html/gi, "");
+  sanitized = sanitized.replace(/document\./gi, "");
+  sanitized = sanitized.replace(/window\./gi, "");
+  sanitized = sanitized.replace(/eval\s*\(/gi, "");
+  sanitized = sanitized.replace(/new\s+Function\s*\(/gi, "");
+  sanitized = sanitized.replace(/setTimeout\s*\(/gi, "");
+  sanitized = sanitized.replace(/setInterval\s*\(/gi, "");
+  return sanitized;
+}
+
+// src/core/tuner.ts
+import sharp3 from "sharp";
+
+// src/utils/ssim.ts
+function computeSSIM(original, compressed, width, height) {
+  const K1 = 0.01;
+  const K2 = 0.03;
+  const L = 255;
+  const C1 = (K1 * L) ** 2;
+  const C2 = (K2 * L) ** 2;
+  const windowSize = 8;
+  const step = 4;
+  let totalSSIM = 0;
+  let windows = 0;
+  for (let y = 0; y <= height - windowSize; y += step) {
+    for (let x = 0; x <= width - windowSize; x += step) {
+      let sumX = 0;
+      let sumY = 0;
+      let sumX2 = 0;
+      let sumY2 = 0;
+      let sumXY = 0;
+      let count = 0;
+      for (let wy = 0; wy < windowSize; wy++) {
+        for (let wx = 0; wx < windowSize; wx++) {
+          const idx = (y + wy) * width + (x + wx);
+          const ox = original[idx] ?? 0;
+          const cy = compressed[idx] ?? 0;
+          sumX += ox;
+          sumY += cy;
+          sumX2 += ox * ox;
+          sumY2 += cy * cy;
+          sumXY += ox * cy;
+          count++;
+        }
+      }
+      const muX = sumX / count;
+      const muY = sumY / count;
+      const sigmaX2 = sumX2 / count - muX * muX;
+      const sigmaY2 = sumY2 / count - muY * muY;
+      const sigmaXY = sumXY / count - muX * muY;
+      const numerator = (2 * muX * muY + C1) * (2 * sigmaXY + C2);
+      const denominator = (muX * muX + muY * muY + C1) * (sigmaX2 + sigmaY2 + C2);
+      totalSSIM += denominator > 0 ? numerator / denominator : 1;
+      windows++;
+    }
+  }
+  return windows > 0 ? totalSSIM / windows : 1;
+}
+
+// src/core/tuner.ts
+var SSIM_THRESHOLD = 0.97;
+var QUALITY_RANGE = [70, 75, 80, 85, 90, 95];
+async function autoTuneQuality(source, format, options) {
+  const threshold = options?.threshold ?? SSIM_THRESHOLD;
+  const minQ = options?.minQuality ?? 70;
+  const maxQ = options?.maxQuality ?? 95;
+  const candidateQualities = QUALITY_RANGE.filter((q) => q >= minQ && q <= maxQ);
+  const original = await sharp3(source).resize(256, 256, { fit: "inside" }).grayscale().raw().toBuffer();
+  const originalMeta = await sharp3(source).metadata();
+  const resizeW = Math.min(256, originalMeta.width ?? 256);
+  const resizeH = Math.min(256, originalMeta.height ?? 256);
+  let best = { quality: minQ, ssim: 1, size: Number.POSITIVE_INFINITY };
+  for (const quality of candidateQualities) {
+    const { data, info } = await sharp3(source).resize(resizeW, resizeH, { fit: "inside" })[format]({ quality }).grayscale().raw().toBuffer({ resolveWithObject: true });
+    const ssim = computeSSIM(
+      new Uint8Array(original),
+      new Uint8Array(data),
+      info.width,
+      info.height
+    );
+    const size = Buffer.byteLength(data);
+    if (ssim >= threshold && size < best.size) {
+      best = { quality, ssim, size };
+    }
+    if (ssim >= threshold && quality === minQ) {
+      return best;
+    }
+  }
+  if (best.ssim >= threshold) return best;
+  return { quality: maxQ, ssim: best.ssim, size: best.size };
+}
+
+// src/core/validator.ts
+var ValidationError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ValidationError";
+  }
+  code;
+};
+var MAX_FILE_SIZE = 50 * 1024 * 1024;
+function validatePath(filePath) {
+  if (filePath.includes("..")) {
+    throw new ValidationError("Path traversal detected", "PATH_TRAVERSAL");
+  }
+  if (filePath.includes("\0")) {
+    throw new ValidationError("Null byte in path", "NULL_BYTE");
+  }
+}
+function validateFileSize(size, maxSize = MAX_FILE_SIZE) {
+  if (size > maxSize) {
+    throw new ValidationError(`File size ${size} exceeds maximum ${maxSize}`, "FILE_TOO_LARGE");
+  }
+}
+function validateImageContent(buffer, extension) {
+  const detectedFormat = detectFormat(buffer, extension);
+  if (!detectedFormat) {
+    throw new ValidationError(`Cannot detect image format for .${extension}`, "INVALID_FORMAT");
+  }
+  return detectedFormat;
+}
+function validateOutputFormat(format) {
+  const allowed = ["avif", "webp", "jpeg", "png"];
+  if (!allowed.includes(format)) {
+    throw new ValidationError(`Unsupported output format: ${format}`, "UNSUPPORTED_OUTPUT_FORMAT");
+  }
+}
+
+// src/core/encoder.ts
+function readFileSafe(filePath) {
+  validatePath(filePath);
+  const buffer = readFileSync(filePath);
+  validateFileSize(buffer.length);
+  return buffer;
+}
+async function encodeVariant(source, width, format, quality, outDir) {
+  try {
+    validateOutputFormat(format);
+    const img = typeof source === "string" ? sharp4(source) : sharp4(source);
+    const metadata = await img.metadata();
+    if ((metadata.width ?? 0) <= width) {
+      const buffer = await img[format]({ quality }).toBuffer();
+      const hash2 = contentHash(buffer);
+      const ext2 = format === "jpeg" ? "jpg" : format;
+      const filename2 = `${hash2}-${width}.${ext2}`;
+      const outPath2 = `${outDir}/${filename2}`;
+      await sharp4(buffer).toFile(outPath2);
+      return {
+        src: filename2,
+        width,
+        format,
+        size: buffer.length,
+        integrity: sriHash(buffer)
+      };
+    }
+    const resized = typeof source === "string" ? await sharp4(source).resize(width).toBuffer() : await sharp4(source).resize(width).toBuffer();
+    const encoded = await sharp4(resized)[format]({ quality }).toBuffer();
+    const hash = contentHash(encoded);
+    const ext = format === "jpeg" ? "jpg" : format;
+    const filename = `${hash}-${width}.${ext}`;
+    const outPath = `${outDir}/${filename}`;
+    await sharp4(encoded).toFile(outPath);
+    return {
+      src: filename,
+      width,
+      format,
+      size: encoded.length,
+      integrity: sriHash(encoded)
+    };
+  } catch {
+    return null;
+  }
+}
+async function encodeImage(imagePath, options) {
+  const buffer = readFileSafe(imagePath);
+  const ext = imagePath.split(".").pop() ?? "jpg";
+  const format = validateImageContent(buffer, ext);
+  if (format === "svg") {
+    const content = buffer.toString("utf-8");
+    const sanitized = sanitizeSvg(content);
+    const hash = contentHash(Buffer.from(sanitized));
+    const filename = `${hash}.svg`;
+    const svgBuffer = Buffer.from(sanitized);
+    return {
+      src: filename,
+      width: 0,
+      height: 0,
+      format: "svg",
+      placeholder: "",
+      tiers: {},
+      variants: [
+        {
+          src: filename,
+          width: 0,
+          format: "webp",
+          size: svgBuffer.length,
+          integrity: sriHash(svgBuffer)
+        }
+      ]
+    };
+  }
+  if (isAnimatedFormat(format)) {
+    const img = sharp4(buffer, { animated: true });
+    const metadata2 = await img.metadata();
+    const width = metadata2.width ?? 0;
+    const height = metadata2.height ?? 0;
+    const webpBuffer = await img.webp({ quality: 75 }).toBuffer();
+    const hash = contentHash(webpBuffer);
+    const filename = `${hash}.webp`;
+    return {
+      src: filename,
+      width,
+      height,
+      format: "gif",
+      placeholder: "",
+      tiers: {},
+      variants: [
+        {
+          src: filename,
+          width,
+          format: "webp",
+          size: webpBuffer.length,
+          integrity: sriHash(webpBuffer)
+        }
+      ]
+    };
+  }
+  const metadata = await sharp4(buffer).metadata();
+  const originalWidth = metadata.width ?? 0;
+  const originalHeight = metadata.height ?? 0;
+  let placeholder = "";
+  if (originalWidth > 0 && originalHeight > 0) {
+    const placeholderBuffer = await sharp4(buffer).resize(32, 32, { fit: "inside" }).webp({ quality: 20 }).toBuffer();
+    placeholder = `data:image/webp;base64,${placeholderBuffer.toString("base64")}`;
+  }
+  const tiers = {};
+  const variants = [];
+  let analysis = null;
+  let preprocessedSource = null;
+  if (options.adaptive || options.preprocess) {
+    try {
+      analysis = await analyzeImage(imagePath, 64, options.faceDetection);
+    } catch {
+    }
+  }
+  if (options.preprocess && analysis) {
+    try {
+      preprocessedSource = await preprocessImage(imagePath, analysis);
+    } catch {
+    }
+  }
+  const source = preprocessedSource ?? imagePath;
+  for (const [tierKey, tierConfig] of Object.entries(options.tiers)) {
+    const tier = tierKey;
+    let quality = tierConfig.quality;
+    if (options.adaptive && analysis) {
+      try {
+        quality = computeTargetQuality(analysis, quality, {
+          minQuality: Math.max(20, quality - 30),
+          maxQuality: Math.min(95, quality + 10)
+        });
+      } catch {
+      }
+    }
+    if (options.autoTune) {
+      try {
+        const tuned = await autoTuneQuality(source, "webp", {
+          threshold: 0.97,
+          minQuality: Math.max(40, quality - 10),
+          maxQuality: Math.min(95, quality + 5)
+        });
+        quality = tuned.quality;
+      } catch {
+      }
+    }
+    const widths = tierConfig.widths.filter((w) => w <= originalWidth);
+    if (widths.length === 0) {
+      widths.push(originalWidth);
+    }
+    for (const w of widths) {
+      for (const fmt of options.formats) {
+        const variant = await encodeVariant(source, w, fmt, quality, options.outDir);
+        if (variant) {
+          variants.push(variant);
+        }
+      }
+    }
+    const bestVariant = variants.find((v) => v.format === "webp");
+    if (bestVariant) {
+      tiers[tier] = bestVariant.src;
+    }
+  }
+  return {
+    src: imagePath.split("/").pop() ?? "image",
+    width: originalWidth,
+    height: originalHeight,
+    format,
+    placeholder,
+    tiers,
+    variants
+  };
+}
+
+// src/core/manifest.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname } from "path";
+var MANIFEST_VERSION = "1.0.0";
+function createManifest() {
+  return {
+    version: MANIFEST_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: {}
+  };
+}
+function addToManifest(manifest, key, entry) {
+  manifest.entries[key] = entry;
+}
+function writeManifest(manifest, outPath) {
+  const dir = dirname(outPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(outPath, JSON.stringify(manifest, null, 2));
+}
+
+// src/vite-plugin.ts
+var IMAGE_EXTENSIONS = /\.(jpe?g|png|webp|avif|gif|svg|bmp|tiff?|ico)$/i;
+var DEFAULT_TIERS = {
+  ultra: { quality: 90, widths: [480, 768, 1024, 1920] },
+  high: { quality: 80, widths: [480, 768, 1024] },
+  medium: { quality: 60, widths: [480, 768] },
+  low: { quality: 40, widths: [480] }
+};
+function gotodevImageOptimizer(userOptions = {}) {
+  let config;
+  let manifest = createManifest();
+  const options = {
+    tiers: { ...DEFAULT_TIERS, ...userOptions.tiers },
+    adaptive: userOptions.adaptive ?? true,
+    autoTune: userOptions.autoTune ?? true,
+    preprocess: userOptions.preprocess ?? true,
+    faceDetection: userOptions.faceDetection ?? true,
+    formats: userOptions.formats ?? ["avif", "webp", "jpeg"],
+    maxFileSize: userOptions.maxFileSize ?? 50 * 1024 * 1024,
+    verbose: userOptions.verbose ?? false
+  };
+  return {
+    name: "gotodev-image-optimizer",
+    enforce: "post",
+    configResolved(resolved) {
+      config = resolved;
+    },
+    async buildStart() {
+      manifest = createManifest();
+    },
+    async transform(_code, id) {
+      if (!IMAGE_EXTENSIONS.test(id)) return;
+      if (id.includes("node_modules")) return;
+      const outDir = resolve(config.root, config.build.outDir ?? "dist", "assets");
+      if (!existsSync2(outDir)) {
+        mkdirSync2(outDir, { recursive: true });
+      }
+      const tiers = options.tiers;
+      const formats = options.formats ?? ["avif", "webp", "jpeg"];
+      try {
+        const entry = await encodeImage(id, {
+          widths: tiers.high.widths,
+          formats: [...formats],
+          tiers,
+          autoTune: options.autoTune ?? true,
+          adaptive: options.adaptive ?? true,
+          preprocess: options.preprocess ?? true,
+          faceDetection: options.faceDetection ?? true,
+          outDir
+        });
+        const key = basename(id);
+        addToManifest(manifest, key, entry);
+        if (options.verbose) {
+          console.log(`[gotodev-image-optimizer] Optimized: ${key}`);
+        }
+        const manifestData = JSON.stringify(entry);
+        const manifestPath = resolve(outDir, "gimage-manifest.json");
+        writeManifest(manifest, manifestPath);
+        return {
+          code: `export default ${manifestData};`,
+          map: null
+        };
+      } catch (error) {
+        if (options.verbose) {
+          console.error(`[gotodev-image-optimizer] Failed to optimize ${id}:`, error);
+        }
+        return {
+          code: `export default ${JSON.stringify({
+            src: basename(id),
+            width: 0,
+            height: 0,
+            format: extname(id).slice(1),
+            placeholder: "",
+            variants: [],
+            tiers: {}
+          })};`,
+          map: null
+        };
+      }
+    },
+    closeBundle() {
+      const outDir = resolve(config.root, config.build.outDir ?? "dist", "assets");
+      if (!existsSync2(outDir)) {
+        mkdirSync2(outDir, { recursive: true });
+      }
+      const manifestPath = resolve(outDir, "gimage-manifest.json");
+      writeManifest(manifest, manifestPath);
+    }
+  };
+}
+
+export {
+  isAnimatedFormat,
+  gotodevImageOptimizer
+};