img-subir 0.0.1

package/dist/chunk-CWZBNFPK.js

@@ -0,0 +1,1004 @@
+// src/errors.ts
+var UsageError = class extends Error {
+  name = "UsageError";
+};
+
+// src/presets.ts
+var stdFloor = { ui: 0.985, photo: 0.96, graphic: 0.985 };
+var stdQuality = {
+  ui: { webp: 82, avif: 60, jpeg: 85, png: 95 },
+  photo: { webp: 80, avif: 55, jpeg: 78, png: 90 },
+  graphic: { webp: 90, avif: 65, jpeg: 88, png: 100 }
+};
+var base = {
+  floor: stdFloor,
+  quality: stdQuality,
+  avifMinGain: 0.15,
+  avifMaxPixels: 4e6,
+  losslessWebp: false,
+  lossless: false,
+  minGainPercent: 5
+};
+var presets = {
+  web: {
+    ...base,
+    name: "web",
+    maxWidth: 1920,
+    candidates: ["webp", "avif", "png", "jpeg"],
+    note: "Website assets, Subir pages, docs. AVIF kept only when \u226515% smaller than WebP."
+  },
+  github: {
+    ...base,
+    name: "github",
+    maxWidth: 1600,
+    candidates: ["webp", "png", "jpeg"],
+    note: "README / PR screenshots. Never emits AVIF."
+  },
+  screenshot: {
+    ...base,
+    name: "screenshot",
+    maxWidth: 1600,
+    candidates: ["webp", "png"],
+    floor: { ui: 0.99, photo: 0.99, graphic: 0.99 },
+    losslessWebp: true,
+    forceKind: "ui",
+    note: "Crisp UI captures. Forces kind=ui and also tries lossless WebP."
+  },
+  og: {
+    ...base,
+    name: "og",
+    maxWidth: 1200,
+    maxHeight: 630,
+    candidates: ["jpeg", "png"],
+    floor: { ui: 0.97, photo: 0.95, graphic: 0.97 },
+    note: "Open Graph / social cards. JPEG/PNG only; many crawlers dislike WebP."
+  },
+  thumb: {
+    ...base,
+    name: "thumb",
+    maxWidth: 480,
+    candidates: ["webp", "avif"],
+    floor: { ui: 0.95, photo: 0.93, graphic: 0.95 },
+    quality: {
+      ui: { webp: 75, avif: 50, jpeg: 75, png: 85 },
+      photo: { webp: 70, avif: 45, jpeg: 70, png: 80 },
+      graphic: { webp: 80, avif: 55, jpeg: 80, png: 90 }
+    },
+    note: "Thumbnails, avatars, cards. Aggressive; pair with --target-kb."
+  },
+  lossless: {
+    ...base,
+    name: "lossless",
+    candidates: ["png", "webp"],
+    floor: { ui: 1, photo: 1, graphic: 1 },
+    losslessWebp: true,
+    lossless: true,
+    minGainPercent: 1,
+    note: "Pixel-exact. No resize, no lossy encoders."
+  }
+};
+var presetNames = Object.keys(presets);
+function getPreset(name) {
+  const n = name ?? "web";
+  const p = presets[n];
+  if (!p) {
+    throw new UsageError(`Unknown preset "${name}". Valid presets: ${presetNames.join(", ")}`);
+  }
+  return p;
+}
+
+// src/core/classify.ts
+import path from "path";
+import sharp from "sharp";
+var UI_NAME_HINTS = /screen ?shot|cleanshot|@[23]x|capture|screencap|frame|mockup|ui-|-ui\b/i;
+var PHOTO_NAME_HINTS = /\b(img|dsc|pxl|imag|photo|pic)[_-]?\d{3,}/i;
+var DEVICE_SIZES = /* @__PURE__ */ new Set([
+  "2880x1800",
+  "3024x1964",
+  "3456x2234",
+  "2560x1600",
+  "2560x1664",
+  "3072x1920",
+  "5120x2880",
+  "3840x2160",
+  "1170x2532",
+  "1179x2556",
+  "1290x2796",
+  "1284x2778",
+  "1125x2436",
+  "1080x2340",
+  "1440x3120",
+  "2048x2732"
+]);
+async function classify(info, input = info.path) {
+  const { data, info: raw } = await sharp(input, { pages: 1 }).rotate().resize({ width: 256, height: 256, fit: "inside", withoutEnlargement: true, kernel: "nearest" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { width, height, channels } = raw;
+  const colors = /* @__PURE__ */ new Set();
+  let flat = 0;
+  let total = 0;
+  let transparent = 0;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = (y * width + x) * channels;
+      const c = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
+      if (colors.size < 2e5) colors.add(c);
+      if (data[i + 3] < 255) transparent++;
+      if (x > 0) {
+        const j = i - channels;
+        total++;
+        if (data[j] === data[i] && data[j + 1] === data[i + 1] && data[j + 2] === data[i + 2]) flat++;
+      }
+    }
+  }
+  const flatShare = total ? flat / total : 0;
+  const distinctColors = colors.size;
+  const transparentShare = width * height ? transparent / (width * height) : 0;
+  const hasTransparency = transparentShare > 1e-3;
+  let score = 0;
+  if (flatShare > 0.45) score += 2;
+  else if (flatShare > 0.25) score += 1;
+  else if (flatShare < 0.08) score -= 2;
+  else if (flatShare < 0.15) score -= 1;
+  if (distinctColors < 2e3) score += 1;
+  else if (distinctColors > 2e4) score -= 1;
+  const name = path.basename(info.path);
+  if (UI_NAME_HINTS.test(name)) score += 1;
+  if (PHOTO_NAME_HINTS.test(name)) score -= 1;
+  if (DEVICE_SIZES.has(`${info.width}x${info.height}`)) score += 1;
+  let kind;
+  if (hasTransparency && distinctColors < 4e3 && flatShare > 0.3) kind = "graphic";
+  else if (score >= 1) kind = "ui";
+  else if (score <= -1) kind = "photo";
+  else kind = flatShare > 0.2 ? "ui" : "photo";
+  return { kind, stats: { distinctColors, flatShare: Number(flatShare.toFixed(3)), transparentShare: Number(transparentShare.toFixed(4)), score } };
+}
+
+// src/core/discover.ts
+import fg from "fast-glob";
+import { stat } from "fs/promises";
+import path2 from "path";
+var BACKUP_DIR = ".img-subir-originals";
+var IMAGE_EXTS = ["png", "jpg", "jpeg", "webp", "avif", "gif", "svg"];
+var IGNORE = ["**/node_modules/**", "**/.git/**", `**/${BACKUP_DIR}/**`];
+function extPattern() {
+  const all = IMAGE_EXTS.flatMap((e) => [e, e.toUpperCase()]);
+  return `**/*.{${all.join(",")}}`;
+}
+async function discover(inputs, cwd, excludeDirs = []) {
+  const files = /* @__PURE__ */ new Set();
+  const roots = /* @__PURE__ */ new Set();
+  const ignore = IGNORE;
+  const excluded = (f) => excludeDirs.some((d) => f === d || f.startsWith(d + path2.sep));
+  for (const input of inputs) {
+    const abs = path2.resolve(cwd, input);
+    let s = null;
+    try {
+      s = await stat(abs);
+    } catch {
+      s = null;
+    }
+    if (s?.isDirectory()) {
+      roots.add(abs);
+      const found = await fg(extPattern(), { cwd: abs, absolute: true, ignore, onlyFiles: true, dot: false });
+      for (const f of found) files.add(path2.normalize(f));
+    } else if (s?.isFile()) {
+      files.add(abs);
+      roots.add(path2.dirname(abs));
+    } else {
+      const found = await fg(input, { cwd, absolute: true, ignore, onlyFiles: true, dot: false });
+      if (found.length === 0) {
+        throw new UsageError(`No such file, directory or glob match: ${input}`);
+      }
+      for (const f of found) files.add(path2.normalize(f));
+      roots.add(cwd);
+    }
+  }
+  return { files: [...files].filter((f) => !excluded(f)).sort(), roots: [...roots] };
+}
+
+// src/core/probe.ts
+import { stat as stat2 } from "fs/promises";
+import path3 from "path";
+import sharp2 from "sharp";
+function normalizeFormat(f, filePath) {
+  switch (f) {
+    case "jpeg":
+    case "jpg":
+      return "jpeg";
+    case "png":
+    case "webp":
+    case "gif":
+    case "svg":
+      return f;
+    case "heif":
+      return "avif";
+    default: {
+      const ext = path3.extname(filePath).slice(1).toLowerCase();
+      if (ext === "jpg") return "jpeg";
+      if (ext === "avif") return "avif";
+      return ext || "png";
+    }
+  }
+}
+async function probe(filePath) {
+  const s = await stat2(filePath);
+  const ext = path3.extname(filePath).toLowerCase();
+  if (ext === ".svg") {
+    let width2 = 0;
+    let height2 = 0;
+    try {
+      const m2 = await sharp2(filePath).metadata();
+      width2 = m2.width ?? 0;
+      height2 = m2.height ?? 0;
+    } catch {
+    }
+    return { path: filePath, format: "svg", width: width2, height: height2, bytes: s.size, hasAlpha: true, animated: false };
+  }
+  const m = await sharp2(filePath, { animated: true }).metadata();
+  const pages = m.pages ?? 1;
+  const width = m.width ?? 0;
+  const height = pages > 1 ? m.pageHeight ?? Math.round((m.height ?? 0) / pages) : m.height ?? 0;
+  const swap = m.orientation !== void 0 && m.orientation >= 5;
+  return {
+    path: filePath,
+    format: normalizeFormat(m.format, filePath),
+    width: swap ? height : width,
+    height: swap ? width : height,
+    bytes: s.size,
+    hasAlpha: Boolean(m.hasAlpha),
+    animated: pages > 1
+  };
+}
+
+// src/core/rewrite-refs.ts
+import fg2 from "fast-glob";
+import { readFile, writeFile } from "fs/promises";
+import path4 from "path";
+var DEFAULT_REF_GLOBS = ["**/*.{html,htm,md,mdx,tsx,jsx,ts,js,mjs,css,scss,vue,svelte,astro,json,yml,yaml}"];
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toPosix(p) {
+  return p.split(path4.sep).join("/");
+}
+function spellings(textFile, target, roots) {
+  const out = /* @__PURE__ */ new Set();
+  const rel = toPosix(path4.relative(path4.dirname(textFile), target));
+  if (rel && !rel.startsWith("/")) {
+    out.add(rel);
+    if (!rel.startsWith(".")) out.add(`./${rel}`);
+  }
+  for (const root of roots) {
+    const fromRoot = toPosix(path4.relative(root, target));
+    if (fromRoot && !fromRoot.startsWith("..") && !path4.isAbsolute(fromRoot)) out.add(`/${fromRoot}`);
+  }
+  for (const s of [...out]) {
+    const enc = encodeURI(s);
+    if (enc !== s) out.add(enc);
+  }
+  return [...out];
+}
+var LEAD = String.raw`(^|[\s"'\`(<=,])`;
+var TRAIL = String.raw`(?=$|[\s"'\`)>?#,;])`;
+async function rewriteRefs(renamed, roots, globs = DEFAULT_REF_GLOBS, dryRun = false) {
+  if (renamed.length === 0) return [];
+  const results = [];
+  const renamedSet = new Set(renamed.map((r) => path4.normalize(r.to)));
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const files = (await fg2(globs, {
+      cwd: root,
+      absolute: true,
+      onlyFiles: true,
+      ignore: ["**/node_modules/**", "**/.git/**", `**/${BACKUP_DIR}/**`, "**/dist/**", "**/build/**"]
+    })).map((f) => path4.normalize(f));
+    for (const file of files) {
+      if (seen.has(file) || renamedSet.has(file)) continue;
+      seen.add(file);
+      let text;
+      try {
+        text = await readFile(file, "utf8");
+      } catch {
+        continue;
+      }
+      if (text.includes("\0")) continue;
+      let changed = false;
+      for (const r of renamed) {
+        const fromSpellings = spellings(file, r.from, roots);
+        const toSpellings = spellings(file, r.to, roots);
+        let count = 0;
+        for (let i = 0; i < fromSpellings.length; i++) {
+          const from = fromSpellings[i];
+          const to = toSpellings[i] ?? toSpellings[0];
+          const re = new RegExp(`${LEAD}${escapeRe(from)}${TRAIL}`, "g");
+          text = text.replace(re, (_m, pre) => {
+            count++;
+            return `${pre}${to}`;
+          });
+        }
+        if (count > 0) {
+          changed = true;
+          results.push({ file, from: r.from, to: r.to, count });
+        }
+      }
+      if (changed && !dryRun) await writeFile(file, text);
+    }
+  }
+  return results;
+}
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var VERSION = require2("../package.json").version;
+
+// src/core/optimize.ts
+import { access as access2, copyFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import os from "os";
+import path6 from "path";
+import sharp4 from "sharp";
+
+// src/core/quality.ts
+import sharp3 from "sharp";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+var ssimLib = require3("ssim.js");
+var ssim = ssimLib.default ?? ssimLib;
+var SSIM_MAX_WIDTH = 512;
+var FLATTEN_BG = { r: 128, g: 128, b: 128 };
+function asImage(data, width, height) {
+  return { data: new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength), width, height };
+}
+async function toComparable(input, width, hasAlpha, height) {
+  const target = Math.min(SSIM_MAX_WIDTH, width);
+  const resize = height ? { width: target, height, fit: "fill" } : { width: target, withoutEnlargement: true, kernel: "lanczos3" };
+  const base2 = input.clone().resize(resize).ensureAlpha();
+  const { data: rgba, info } = await base2.clone().raw().toBuffer({ resolveWithObject: true });
+  const flat = await sharp3(rgba, { raw: { width: info.width, height: info.height, channels: 4 } }).flatten({ background: FLATTEN_BG }).ensureAlpha().raw().toBuffer();
+  const out = { color: asImage(flat, info.width, info.height), width: info.width, height: info.height };
+  if (hasAlpha) {
+    const a = Buffer.alloc(info.width * info.height * 4);
+    for (let i = 0, j = 0; i < rgba.length; i += 4, j += 4) {
+      const v = rgba[i + 3];
+      a[j] = v;
+      a[j + 1] = v;
+      a[j + 2] = v;
+      a[j + 3] = 255;
+    }
+    out.alpha = asImage(a, info.width, info.height);
+  }
+  return out;
+}
+function fromRaw(raw) {
+  return sharp3(raw.data, { raw: { width: raw.width, height: raw.height, channels: raw.channels } });
+}
+async function compareSsim(reference, encoded) {
+  const hasAlpha = Boolean(reference.alpha);
+  let cand = await toComparable(sharp3(encoded, { pages: 1 }), reference.width, hasAlpha);
+  if (cand.width !== reference.width || cand.height !== reference.height) {
+    cand = await toComparable(sharp3(encoded, { pages: 1 }), reference.width, hasAlpha, reference.height);
+  }
+  let score = ssim(reference.color, cand.color, { ssim: "fast" }).mssim;
+  if (reference.alpha && cand.alpha) score = Math.min(score, ssim(reference.alpha, cand.alpha, { ssim: "fast" }).mssim);
+  return score;
+}
+function alphaIsOpaque(raw) {
+  if (raw.channels !== 4) return true;
+  const d = raw.data;
+  for (let i = 3; i < d.length; i += 4) if (d[i] !== 255) return false;
+  return true;
+}
+function stripAlpha(raw) {
+  if (raw.channels !== 4) return raw;
+  const px = raw.width * raw.height;
+  const out = Buffer.alloc(px * 3);
+  const d = raw.data;
+  for (let i = 0, j = 0; i < px; i++, j += 3) {
+    const k = i * 4;
+    out[j] = d[k];
+    out[j + 1] = d[k + 1];
+    out[j + 2] = d[k + 2];
+  }
+  return { data: out, width: raw.width, height: raw.height, channels: 3 };
+}
+
+// src/core/encode.ts
+function encode(raw, spec) {
+  const img = fromRaw(raw);
+  return applyEncoder(img, spec).toBuffer();
+}
+function applyEncoder(img, spec) {
+  const q = spec.quality ?? 80;
+  switch (spec.format) {
+    case "webp":
+      return spec.lossless ? img.webp({ lossless: true, effort: 6 }) : img.webp({ quality: q, effort: 4, alphaQuality: 90, smartSubsample: true });
+    case "avif":
+      return img.avif({ quality: q, effort: 4, chromaSubsampling: "4:2:0" });
+    case "jpeg":
+      return img.jpeg({ quality: q, mozjpeg: true, progressive: true });
+    case "png":
+      return spec.lossless ? img.png({ compressionLevel: 9, adaptiveFiltering: true, palette: false, effort: 10 }) : img.png({ compressionLevel: 9, palette: true, quality: q, effort: 8, dither: 0.6 });
+    case "gif":
+      return img.gif({ effort: 8 });
+  }
+}
+function extFor(format) {
+  return format === "jpeg" ? ".jpg" : `.${format}`;
+}
+
+// src/core/svg.ts
+import { optimize as svgoOptimize } from "svgo";
+function optimizeSvg(source) {
+  const r = svgoOptimize(source, {
+    multipass: true,
+    plugins: [
+      {
+        name: "preset-default",
+        params: {
+          overrides: {
+            cleanupIds: false
+          }
+        }
+      }
+    ]
+  });
+  return r.data;
+}
+
+// src/core/write.ts
+import { access, mkdir, rename, rm, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+import { randomBytes } from "crypto";
+async function writeOutput(data, plan) {
+  const outDir = path5.dirname(plan.outputPath);
+  await mkdir(outDir, { recursive: true });
+  const tmp = path5.join(outDir, `.${path5.basename(plan.outputPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  await writeFile2(tmp, data, { flag: "wx" });
+  const res = {};
+  const samePath = path5.resolve(plan.inputPath) === path5.resolve(plan.outputPath);
+  try {
+    if (plan.separateOut && !samePath) {
+      await rename(tmp, plan.outputPath);
+      return res;
+    }
+    if (samePath) {
+      let backupPath;
+      if (plan.backup) {
+        backupPath = await moveToBackup(plan.inputPath);
+        res.backupPath = backupPath;
+      }
+      try {
+        await rename(tmp, plan.outputPath);
+      } catch (e) {
+        if (backupPath) await rename(backupPath, plan.inputPath).catch(() => void 0);
+        throw e;
+      }
+      return res;
+    }
+    await rename(tmp, plan.outputPath);
+    if (plan.backup) res.backupPath = await moveToBackup(plan.inputPath);
+    else await rm(plan.inputPath, { force: true });
+    return res;
+  } finally {
+    await rm(tmp, { force: true }).catch(() => void 0);
+  }
+}
+async function moveToBackup(inputPath) {
+  const backupDir = path5.join(path5.dirname(inputPath), BACKUP_DIR);
+  await mkdir(backupDir, { recursive: true });
+  const backupPath = await uniquePath(path5.join(backupDir, path5.basename(inputPath)));
+  await rename(inputPath, backupPath);
+  return backupPath;
+}
+async function uniquePath(p) {
+  let candidate = p;
+  let i = 1;
+  for (; ; ) {
+    try {
+      await access(candidate);
+    } catch {
+      return candidate;
+    }
+    const ext = path5.extname(p);
+    candidate = path5.join(path5.dirname(p), `${path5.basename(p, ext)}.${i++}${ext}`);
+  }
+}
+
+// src/core/optimize.ts
+var LOSSY_INPUTS = /* @__PURE__ */ new Set(["webp", "jpeg", "avif"]);
+function resolveOptions(opts) {
+  return {
+    ...opts,
+    cwd: opts.cwd ?? process.cwd(),
+    backup: opts.backup ?? true,
+    rename: opts.rename ?? true,
+    dryRun: opts.dryRun ?? false,
+    fast: opts.fast ?? false,
+    format: opts.format ?? "auto",
+    kind: opts.kind ?? "auto"
+  };
+}
+async function optimize(options) {
+  const started = Date.now();
+  const opts = resolveOptions(options);
+  const preset = getPreset(opts.preset);
+  const outAbs = opts.out ? path6.resolve(opts.cwd, opts.out) : void 0;
+  const { files, roots } = await discover(opts.paths, opts.cwd, outAbs ? [outAbs] : []);
+  if (outAbs && roots.some((r) => path6.resolve(r) === outAbs)) {
+    throw new UsageError(`--out must differ from the input directory (${path6.relative(opts.cwd, outAbs) || "."}); drop --out to optimize in place`);
+  }
+  const ctx = { opts, preset, roots };
+  const concurrency = Math.max(1, opts.concurrency ?? Math.max(1, os.cpus().length - 1));
+  const results = new Array(files.length);
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, files.length) }, async () => {
+      while (next < files.length) {
+        const i = next++;
+        const r = await optimizeFile(files[i], ctx);
+        results[i] = r;
+        opts.onFile?.(r);
+      }
+    })
+  );
+  const renamed = results.filter((r) => r.output && r.status !== "failed" && r.status !== "kept" && path6.basename(r.output.path) !== path6.basename(r.input.path)).map((r) => ({ from: r.input.path, to: r.output.path }));
+  let rewrittenRefs = [];
+  if (opts.rewriteRefs && !outAbs) {
+    const globs = Array.isArray(opts.rewriteRefs) ? opts.rewriteRefs : DEFAULT_REF_GLOBS;
+    rewrittenRefs = await rewriteRefs(renamed, roots, globs, opts.dryRun);
+  }
+  const backupDirs = [...new Set(results.filter((r) => r.backupPath).map((r) => path6.dirname(r.backupPath)))];
+  return {
+    schemaVersion: 1,
+    version: VERSION,
+    preset: preset.name,
+    dryRun: opts.dryRun,
+    files: results,
+    totals: totals(results, Date.now() - started),
+    renamed,
+    rewrittenRefs,
+    backupDirs
+  };
+}
+function totals(results, durationMs) {
+  const t = {
+    files: results.length,
+    inputBytes: 0,
+    outputBytes: 0,
+    savedBytes: 0,
+    savedPercent: 0,
+    optimized: 0,
+    kept: 0,
+    failed: 0,
+    budgetMissed: 0,
+    durationMs
+  };
+  for (const r of results) {
+    t.inputBytes += r.input.bytes;
+    t.outputBytes += r.output && r.status !== "kept" && r.status !== "failed" ? r.output.bytes : r.input.bytes;
+    if (r.status === "optimized") t.optimized++;
+    else if (r.status === "kept") t.kept++;
+    else if (r.status === "failed") t.failed++;
+    else if (r.status === "budget-missed") t.budgetMissed++;
+  }
+  t.savedBytes = t.inputBytes - t.outputBytes;
+  t.savedPercent = t.inputBytes ? round1(t.savedBytes / t.inputBytes * 100) : 0;
+  return t;
+}
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+function isInside(file, dir) {
+  const rel = path6.relative(dir, file);
+  return rel !== "" && !rel.startsWith("..") && !path6.isAbsolute(rel);
+}
+function rootFor(file, roots) {
+  let best = "";
+  for (const r of roots) if (isInside(file, r) && r.length > best.length) best = r;
+  return best || path6.dirname(file);
+}
+function mirrorPath(input, ctx) {
+  const root = rootFor(input, ctx.roots);
+  return path6.join(path6.resolve(ctx.opts.cwd, ctx.opts.out), path6.relative(root, input));
+}
+function outputPathFor(input, format, ctx) {
+  const { opts } = ctx;
+  const parsed = path6.parse(input);
+  const ext = opts.rename ? extFor(format) : parsed.ext;
+  const name = `${parsed.name}${opts.suffix ?? ""}${ext}`;
+  if (opts.out) {
+    const root = rootFor(input, ctx.roots);
+    return path6.join(path6.resolve(opts.cwd, opts.out), path6.relative(root, parsed.dir), name);
+  }
+  return path6.join(parsed.dir, name);
+}
+function targetSize(info, ctx) {
+  const maxW = ctx.opts.maxWidth ?? (ctx.preset.lossless ? void 0 : ctx.preset.maxWidth);
+  const maxH = ctx.opts.maxHeight ?? (ctx.preset.lossless ? void 0 : ctx.preset.maxHeight);
+  let { width, height } = info;
+  if (!width || !height) return { width, height, resized: false };
+  let scale = 1;
+  if (maxW && width > maxW) scale = Math.min(scale, maxW / width);
+  if (maxH && height > maxH) scale = Math.min(scale, maxH / height);
+  if (scale < 1) {
+    width = Math.max(1, Math.round(width * scale));
+    height = Math.max(1, Math.round(height * scale));
+    return { width, height, resized: true };
+  }
+  return { width, height, resized: false };
+}
+function allowedFormats(info, ctx) {
+  const f = ctx.opts.format ?? "auto";
+  if (f === "keep") return info.format === "svg" ? [] : [info.format === "gif" ? "webp" : info.format];
+  if (f !== "auto") return [f];
+  return ctx.preset.candidates;
+}
+function buildSpecs(info, kind, pixels, ctx) {
+  const { preset, opts } = ctx;
+  const formats = allowedFormats(info, ctx);
+  const explicit = opts.format && opts.format !== "auto" && opts.format !== "keep";
+  const q = preset.quality[kind];
+  const specs = [];
+  for (const f of formats) {
+    switch (f) {
+      case "webp":
+        if (!preset.lossless) specs.push({ format: "webp", quality: opts.quality ?? q.webp });
+        if (preset.lossless || preset.losslessWebp && kind !== "photo") specs.push({ format: "webp", lossless: true });
+        break;
+      case "avif":
+        if (explicit || pixels <= preset.avifMaxPixels) specs.push({ format: "avif", quality: opts.quality ?? q.avif });
+        break;
+      case "jpeg":
+        if (!info.hasAlpha && !preset.lossless) specs.push({ format: "jpeg", quality: opts.quality ?? q.jpeg });
+        break;
+      case "png":
+        if (preset.lossless || kind === "graphic") specs.push({ format: "png", lossless: true });
+        if (!preset.lossless) specs.push({ format: "png", quality: opts.quality ?? q.png });
+        break;
+      case "gif":
+        break;
+    }
+  }
+  return specs;
+}
+async function optimizeFile(file, ctx) {
+  const started = Date.now();
+  let info;
+  try {
+    info = await probe(file);
+  } catch (e) {
+    return failed({ path: file, format: "png", width: 0, height: 0, bytes: 0, hasAlpha: false, animated: false }, e, started);
+  }
+  let result;
+  try {
+    if (info.format === "svg") result = await handleSvg(info, ctx, started);
+    else if (info.animated) result = await handleAnimated(info, ctx, started);
+    else result = await handleRaster(info, ctx, started);
+  } catch (e) {
+    return failed(info, e, started);
+  }
+  if (result.status === "kept" && ctx.opts.out) {
+    const dest = mirrorPath(info.path, ctx);
+    if (!ctx.opts.dryRun) {
+      try {
+        await mkdir2(path6.dirname(dest), { recursive: true });
+        await copyFile(info.path, dest);
+      } catch (e) {
+        return failed(info, e, started);
+      }
+    }
+    result.copiedTo = dest;
+  }
+  if (ctx.opts.targetKb && result.status !== "failed") {
+    const finalBytes = result.output && result.status !== "kept" ? result.output.bytes : result.input.bytes;
+    if (finalBytes > ctx.opts.targetKb * 1024) result.status = "budget-missed";
+  }
+  return result;
+}
+function failed(info, e, started) {
+  return {
+    input: info,
+    output: null,
+    kind: "photo",
+    status: "failed",
+    savedBytes: 0,
+    savedPercent: 0,
+    actions: [],
+    candidates: [],
+    error: e instanceof Error ? e.message : String(e),
+    durationMs: Date.now() - started
+  };
+}
+function kept(info, kind, reason, candidates, actions, started) {
+  return { input: info, output: null, kind, status: "kept", savedBytes: 0, savedPercent: 0, actions, candidates, reason, durationMs: Date.now() - started };
+}
+async function exists(p) {
+  try {
+    await access2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function finish(info, kind, data, out, candidates, actions, ctx, started, status = "optimized") {
+  const separateOut = Boolean(ctx.opts.out) && path6.resolve(out.path) !== path6.resolve(info.path);
+  if (out.path !== info.path && !separateOut && await exists(out.path)) {
+    return kept(info, kind, `output path already exists: ${path6.basename(out.path)} (remove it or use --suffix/--out)`, candidates, actions, started);
+  }
+  let backupPath;
+  if (!ctx.opts.dryRun) {
+    const w = await writeOutput(data, { inputPath: info.path, outputPath: out.path, backup: ctx.opts.backup, separateOut });
+    backupPath = w.backupPath;
+  }
+  const savedBytes = info.bytes - out.bytes;
+  return {
+    input: info,
+    output: out,
+    kind,
+    status,
+    savedBytes,
+    savedPercent: round1(savedBytes / info.bytes * 100),
+    actions,
+    candidates,
+    backupPath,
+    durationMs: Date.now() - started
+  };
+}
+function belowMinGain(info, bytes, ctx, sameLossyFormat) {
+  const gain = (info.bytes - bytes) / info.bytes * 100;
+  const min = sameLossyFormat ? Math.max(ctx.preset.minGainPercent, 10) : ctx.preset.minGainPercent;
+  if (bytes >= info.bytes) return `no candidate smaller than original (best: ${fmtBytes(bytes)})`;
+  if (gain < min) return `gain ${round1(gain)}% is below the ${min}% threshold${sameLossyFormat ? " for re-encoding an already lossy file" : ""}`;
+  return null;
+}
+async function handleSvg(info, ctx, started) {
+  const src = await readFile2(info.path, "utf8");
+  const outData = optimizeSvg(src);
+  const bytes = Buffer.byteLength(outData);
+  const candidates = [{ format: "svg", bytes, lossless: true, passed: true }];
+  const why = belowMinGain(info, bytes, ctx, false);
+  if (why) return kept(info, "svg", why, candidates, [], started);
+  const outPath = outputPathFor(info.path, "svg", ctx);
+  return finish(info, "svg", outData, { path: outPath, format: "svg", width: info.width, height: info.height, bytes, lossless: true }, candidates, ["svgo"], ctx, started);
+}
+async function handleAnimated(info, ctx, started) {
+  const formats = allowedFormats(info, ctx);
+  if (!formats.includes("webp")) {
+    return kept(info, "animated", `animated input; preset "${ctx.preset.name}" does not allow WebP so it was left as-is`, [], [], started);
+  }
+  const size = targetSize(info, ctx);
+  const actions = [];
+  const q = ctx.opts.quality ?? ctx.preset.quality.ui.webp;
+  let img = sharp4(info.path, { animated: true });
+  if (size.resized) {
+    img = img.resize({ width: size.width, height: size.height, fit: "inside", withoutEnlargement: true, kernel: "lanczos3" });
+    actions.push(`resize:${size.width}x${size.height}`);
+  }
+  actions.push("strip-metadata");
+  const lossless = ctx.preset.lossless;
+  const buf = await (lossless ? img.webp({ lossless: true, effort: 6 }) : img.webp({ quality: q, effort: 4 })).toBuffer();
+  const candidates = [{ format: "webp", bytes: buf.length, quality: lossless ? void 0 : q, lossless, passed: true }];
+  const why = belowMinGain(info, buf.length, ctx, info.format === "webp" && !lossless);
+  if (why) return kept(info, "animated", why, candidates, actions, started);
+  actions.push(lossless ? "encode:webp-animated-lossless" : `encode:webp-animated@${q}`);
+  const outPath = outputPathFor(info.path, "webp", ctx);
+  return finish(
+    info,
+    "animated",
+    buf,
+    { path: outPath, format: "webp", width: size.width, height: size.height, bytes: buf.length, quality: lossless ? void 0 : q, lossless },
+    candidates,
+    actions,
+    ctx,
+    started
+  );
+}
+async function handleRaster(input, ctx, started) {
+  let info = input;
+  const { preset, opts } = ctx;
+  const actions = [];
+  const explicitKind = preset.forceKind ?? (opts.kind && opts.kind !== "auto" ? opts.kind : void 0);
+  const kind = explicitKind ?? (await classify(info)).kind;
+  const size = targetSize(info, ctx);
+  let pipeline = sharp4(info.path, { pages: 1 }).rotate();
+  if (size.resized) {
+    pipeline = pipeline.resize({ width: size.width, height: size.height, fit: "inside", withoutEnlargement: true, kernel: "lanczos3" });
+    actions.push(`resize:${size.width}x${size.height}`);
+  }
+  pipeline = pipeline.toColourspace("srgb");
+  pipeline = info.hasAlpha ? pipeline.ensureAlpha() : pipeline.removeAlpha();
+  const { data, info: rawInfo } = await pipeline.raw().toBuffer({ resolveWithObject: true });
+  let raw = { data, width: rawInfo.width, height: rawInfo.height, channels: rawInfo.channels };
+  if (info.hasAlpha && alphaIsOpaque(raw)) {
+    raw = stripAlpha(raw);
+    info = { ...info, hasAlpha: false };
+    actions.push("drop-unused-alpha");
+  }
+  actions.push("strip-metadata");
+  const specs = buildSpecs(info, kind, raw.width * raw.height, ctx);
+  if (specs.length === 0) return kept(info, kind, "no encoder allowed for this input under the current preset/format", [], actions, started);
+  const floor = preset.floor[kind];
+  const reference = opts.fast ? null : await toComparable(fromRaw(raw), raw.width, info.hasAlpha);
+  const targetBytes = opts.targetKb ? opts.targetKb * 1024 : void 0;
+  const encoded = await Promise.all(
+    specs.map(async (spec) => {
+      if (spec.lossless) {
+        const buf = await encode(raw, spec);
+        return { spec, buf, cand: { format: spec.format, bytes: buf.length, lossless: true, ssim: 1, passed: true } };
+      }
+      return searchQuality(raw, spec, reference, floor, targetBytes);
+    })
+  );
+  const candidates = encoded.map((e) => e.cand);
+  const passed = encoded.filter((e) => e.cand.passed);
+  if (passed.length === 0) {
+    return kept(info, kind, `no candidate met the SSIM floor of ${floor} (try --fast, a lower --preset floor, or --kind photo)`, candidates, actions, started);
+  }
+  passed.sort((a, b) => a.cand.bytes - b.cand.bytes);
+  let best = passed[0];
+  if (best.spec.format === "avif") {
+    const bestOther = passed.find((e) => e.spec.format !== "avif");
+    if (bestOther && best.cand.bytes > bestOther.cand.bytes * (1 - preset.avifMinGain)) best = bestOther;
+  }
+  const sameLossy = best.spec.format === info.format && !best.cand.lossless && (LOSSY_INPUTS.has(info.format) || info.format === "png") && !size.resized;
+  const why = belowMinGain(info, best.cand.bytes, ctx, sameLossy);
+  if (why) return kept(info, kind, why, candidates, actions, started);
+  actions.push(`encode:${best.spec.format}${best.cand.lossless ? "-lossless" : `@${best.cand.quality}`}`);
+  const outPath = outputPathFor(info.path, best.spec.format, ctx);
+  if (!opts.rename && extFor(best.spec.format) !== path6.extname(info.path).toLowerCase().replace(".jpeg", ".jpg")) {
+    actions.push(`warn:extension-mismatch(${path6.extname(info.path)} contains ${best.spec.format})`);
+  }
+  const status = targetBytes && best.cand.bytes > targetBytes ? "budget-missed" : "optimized";
+  return finish(
+    info,
+    kind,
+    best.buf,
+    { path: outPath, format: best.spec.format, width: raw.width, height: raw.height, bytes: best.cand.bytes, quality: best.cand.quality, lossless: best.cand.lossless },
+    candidates,
+    actions,
+    ctx,
+    started,
+    status
+  );
+}
+var MAX_Q = 100;
+var MIN_Q = 1;
+var STEP = 6;
+var RETRIES = 3;
+async function searchQuality(raw, spec, reference, floor, targetBytes) {
+  const cache = /* @__PURE__ */ new Map();
+  const enc = async (q) => {
+    let b = cache.get(q);
+    if (!b) {
+      b = await encode(raw, { ...spec, quality: q });
+      cache.set(q, b);
+    }
+    return b;
+  };
+  const measure = async (q) => {
+    const buf = await enc(q);
+    const ssim2 = reference ? await compareSsim(reference, buf) : void 0;
+    const passed = ssim2 === void 0 ? true : ssim2 >= floor;
+    return { spec: { ...spec, quality: q }, buf, cand: { format: spec.format, bytes: buf.length, quality: q, ssim: ssim2 === void 0 ? void 0 : Number(ssim2.toFixed(4)), passed } };
+  };
+  const startQ = Math.min(MAX_Q, Math.max(MIN_Q, spec.quality ?? 80));
+  const floorSearch = async (from) => {
+    let q = from;
+    let r = await measure(q);
+    for (let i = 0; i < RETRIES && !r.cand.passed && q < MAX_Q; i++) {
+      q = Math.min(MAX_Q, q + STEP);
+      r = await measure(q);
+    }
+    return r;
+  };
+  if (!targetBytes) return floorSearch(startQ);
+  let lo = MIN_Q;
+  let hi = Math.min(MAX_Q, startQ + 10);
+  let fit = null;
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    const b = await enc(mid);
+    if (b.length <= targetBytes) {
+      fit = mid;
+      lo = mid + 1;
+    } else hi = mid - 1;
+  }
+  const budgeted = await floorSearch(fit ?? MIN_Q);
+  if (budgeted.cand.passed) return budgeted;
+  const fallback = await floorSearch(startQ);
+  return fallback.cand.passed ? fallback : budgeted;
+}
+async function inspect(paths, options = {}) {
+  const opts = resolveOptions({ ...options, paths });
+  const preset = getPreset(opts.preset);
+  const { files, roots } = await discover(paths, opts.cwd);
+  const ctx = { opts, preset, roots };
+  const out = [];
+  for (const f of files) {
+    let info = await probe(f);
+    let kind;
+    let floor = null;
+    let candidates = [];
+    if (info.format === "svg") {
+      kind = "svg";
+      candidates = ["svgo"];
+    } else if (info.animated) {
+      kind = "animated";
+      candidates = allowedFormats(info, ctx).includes("webp") ? ["webp-animated"] : [];
+    } else {
+      const cls = await classify(info);
+      if (info.hasAlpha && cls.stats.transparentShare === 0) info = { ...info, hasAlpha: false };
+      kind = preset.forceKind ?? (opts.kind && opts.kind !== "auto" ? opts.kind : cls.kind);
+      floor = preset.floor[kind];
+      const size2 = targetSize(info, ctx);
+      candidates = buildSpecs(info, kind, size2.width * size2.height, ctx).map((s) => `${s.format}${s.lossless ? "-lossless" : `@${s.quality}`}`);
+    }
+    const size = targetSize(info, ctx);
+    out.push({ input: info, kind, plan: { targetWidth: size.width, targetHeight: size.height, candidates, floor } });
+  }
+  return out;
+}
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(n < 10 * 1024 ? 1 : 0)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+// src/config.ts
+import { readFile as readFile3 } from "fs/promises";
+import path7 from "path";
+var CANDIDATES = ["img-subir.config.json", ".img-subirrc.json", ".img-subirrc"];
+async function readIfExists(file) {
+  try {
+    return await readFile3(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") return null;
+    throw new UsageError(`Cannot read config ${file}: ${e.message}`);
+  }
+}
+function parse(file, text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new UsageError(`Invalid JSON in ${file}: ${e.message}`);
+  }
+}
+async function loadConfig(cwd) {
+  let dir = path7.resolve(cwd);
+  for (let depth = 0; depth < 8; depth++) {
+    for (const name of CANDIDATES) {
+      const file = path7.join(dir, name);
+      const text = await readIfExists(file);
+      if (text !== null) return { config: parse(file, text), source: file };
+    }
+    const pkgFile = path7.join(dir, "package.json");
+    const pkgText = await readIfExists(pkgFile);
+    if (pkgText !== null) {
+      const pkg = parse(pkgFile, pkgText);
+      if (pkg["img-subir"]) return { config: pkg["img-subir"], source: pkgFile };
+    }
+    const parent = path7.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { config: {} };
+}
+
+export {
+  UsageError,
+  presets,
+  presetNames,
+  getPreset,
+  classify,
+  BACKUP_DIR,
+  discover,
+  probe,
+  DEFAULT_REF_GLOBS,
+  rewriteRefs,
+  VERSION,
+  optimize,
+  inspect,
+  fmtBytes,
+  loadConfig
+};
+//# sourceMappingURL=chunk-CWZBNFPK.js.map