@takazudo/zudo-image-tweaker 0.1.0

package/dist/exif/index.js

@@ -0,0 +1,100 @@
+import x from "sharp";
+const y = /(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})/, N = 306, p = 34665, D = 36867, F = 36868, h = 2, U = 12, B = 64, M = 64;
+function C(n) {
+  const r = n.match(y);
+  if (!r) return null;
+  const [, t, d, s, c, T, E] = r, o = /* @__PURE__ */ new Date(`${t}-${d}-${s}T${c}:${T}:${E}Z`);
+  return Number.isNaN(o.getTime()) ? null : o.getUTCFullYear() === Number(t) && o.getUTCMonth() === Number(d) - 1 && o.getUTCDate() === Number(s) && o.getUTCHours() === Number(c) && o.getUTCMinutes() === Number(T) && o.getUTCSeconds() === Number(E) ? o : null;
+}
+function R(n) {
+  const r = Math.min(n.length - 8, B);
+  for (let t = 0; t <= r; t++) {
+    if (n[t] === 73 && n[t + 1] === 73 && n[t + 2] === 42 && n[t + 3] === 0)
+      return { base: t, littleEndian: !0 };
+    if (n[t] === 77 && n[t + 1] === 77 && n[t + 2] === 0 && n[t + 3] === 42)
+      return { base: t, littleEndian: !1 };
+  }
+  return null;
+}
+function S(n) {
+  const r = R(n);
+  if (!r) return null;
+  const { base: t, littleEndian: d } = r, s = (e) => e >= 0 && e + 2 <= n.length ? d ? n.readUInt16LE(e) : n.readUInt16BE(e) : null, c = (e) => e >= 0 && e + 4 <= n.length ? d ? n.readUInt32LE(e) : n.readUInt32BE(e) : null, T = (e, u) => {
+    const i = s(e);
+    if (i === null || e + 2 + i * U > n.length) return null;
+    const l = /* @__PURE__ */ new Map();
+    for (let a = 0; a < i; a++) {
+      const A = e + 2 + a * U, m = s(A);
+      m !== null && u.includes(m) && l.set(m, A);
+    }
+    return l;
+  }, E = (e) => {
+    const u = s(e + 2), i = c(e + 4);
+    if (u !== h || i === null || i < 1 || i > M)
+      return null;
+    let l;
+    if (i <= 4)
+      l = e + 8;
+    else {
+      const a = c(e + 8);
+      if (a === null) return null;
+      l = t + a;
+    }
+    return l + i > n.length ? null : n.toString("latin1", l, l + i);
+  }, o = c(t + 4);
+  if (o === null) return null;
+  const f = T(t + o, [N, p]);
+  if (f === null) return null;
+  const I = [], g = f.get(p);
+  if (g !== void 0) {
+    const e = c(g + 8);
+    if (e !== null) {
+      const u = T(t + e, [D, F]);
+      if (u !== null)
+        for (const i of [D, F]) {
+          const l = u.get(i);
+          l !== void 0 && I.push(l);
+        }
+    }
+  }
+  const _ = f.get(N);
+  _ !== void 0 && I.push(_);
+  for (const e of I) {
+    const u = E(e);
+    if (u === null) continue;
+    const i = C(u);
+    if (i) return i;
+  }
+  return null;
+}
+function v(n) {
+  if (!n || n.length === 0) return null;
+  const r = Buffer.isBuffer(n) ? n : Buffer.from(n);
+  try {
+    const t = S(r);
+    if (t) return t;
+  } catch {
+  }
+  return C(r.toString("latin1"));
+}
+async function G(n) {
+  return x(n).rotate().keepIccProfile().toBuffer();
+}
+async function P(n) {
+  return x(n).toBuffer();
+}
+function H(n, r) {
+  if (!Number.isFinite(n) || !Number.isFinite(r) || n <= 0 || r <= 0)
+    throw new Error(`deriveOrientation: invalid dimensions width=${n} height=${r}`);
+  return n > r ? "landscape" : n < r ? "portrait" : "square";
+}
+function O(n, r) {
+  return !Number.isFinite(n) || n <= 0 ? [] : r.filter((t) => t <= n);
+}
+export {
+  G as bakeOrientation,
+  H as deriveOrientation,
+  v as parseExifDate,
+  O as pickVariantWidths,
+  P as stripExif
+};

package/dist/heif/index.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Node-native HEIC/HEIF -> JPEG conversion, with a dependency-free ISOBMFF
+ * ICC-profile extractor.
+ *
+ * TRUSTED-INPUT ONLY: the Node/WASM fallback decoder (`heic-decode` ->
+ * bundled `libheif-js` 1.19.8) predates the libheif 1.22.0 fixes for
+ * CVE-2026-32740 (heap overflow) and CVE-2026-32739 (infinite-loop DoS).
+ * Only decode HEIC/HEIF files from sources you trust. The decoder runs
+ * inside a WASM sandbox and `maxInputBytes` rejects oversized inputs
+ * before they reach it, but both are defense-in-depth, not a substitute
+ * for trusting the source. Bump `heic-decode` once its bundled
+ * `libheif-js` reaches >= 1.22.0.
+ *
+ * Why the box parser: `libheif-js` 1.19.8's high-level ICC API
+ * (`heif_image_handle_get_color_profile_type` et al.) is broken and
+ * reports "not present" even when a profile exists, so the ICC profile is
+ * pulled directly out of the container's meta/iprp/ipco/ipma boxes
+ * instead. It is then spliced into the output JPEG as a raw APP2 marker
+ * (see `embedIccProfileInJpeg`) rather than handed to sharp's
+ * `withIccProfile()`, which performs a colour-managed transform from the
+ * (assumed sRGB) input to the target profile -- since the decoded pixels
+ * are already in the space the extracted profile describes, that would
+ * alter already-correct sample values instead of just tagging them.
+ *
+ * Why the sips/Node split exists at all: system libheif (what macOS
+ * `sips` and sharp's bundled libvips use) can predate 1.18.0 and
+ * hardcodes a strict security limit on auxiliary-image references, which
+ * rejects the HDR "gain map" (`tmap` compatible-brand) HEIC files emitted
+ * by recent iPhone/Android cameras ("Too many auxiliary image
+ * references"). `sips` is tried first on macOS for speed with no extra
+ * deps; the Node fallback's bundled WASM `libheif-js` doesn't carry that
+ * limit, so it also serves as the fallback whenever `sips` is unavailable
+ * OR fails on a given input (including that documented limitation).
+ * `ConvertHeifResult.converter` reports which path produced the output.
+ *
+ * Residual Node-fallback divergence from `sips`: files whose wide-gamut
+ * colour is described only by an `nclx` colr box (no embedded ICC
+ * profile) lose that colour description on the Node path — the output
+ * JPEG carries no ICC profile and decodes as sRGB. `sips` converts such
+ * files through the system colour engine and tags the output itself.
+ * Source EXIF, previously also lost on this path, is now copied into the
+ * output (see `extractExifFromHeif`), with the EXIF Orientation tag
+ * neutralised to 1 because the WASM decoder already applies the
+ * container's irot/imir transforms to the pixels.
+ */
+export interface ConvertHeifToJpegOptions {
+    /** JPEG encode quality, 1-100. @default 90 */
+    quality?: number;
+    /** Reject inputs larger than this many bytes before decoding. @default 268435456 (256 MiB) */
+    maxInputBytes?: number;
+    /**
+     * Node path only: reject inputs whose container declares more pixels
+     * than this before the WASM decode. @default 268402689 (sharp's default
+     * limitInputPixels, 0x3FFF x 0x3FFF)
+     */
+    maxDecodePixels?: number;
+    /**
+     * `sips` path only: kill the `sips` subprocess if it hasn't exited after
+     * this many ms, falling back to the Node/WASM path. @default 60000
+     */
+    sipsTimeoutMs?: number;
+}
+export interface ConvertHeifResult {
+    buffer: Buffer;
+    width: number;
+    height: number;
+    iccApplied: boolean;
+    /**
+     * Which conversion path produced the output: macOS `sips`, or the
+     * Node/WASM fallback. The fallback diverges from `sips` for nclx-only
+     * wide-gamut files (see the module doc comment), so callers that care
+     * can detect it here.
+     */
+    converter: 'sips' | 'node';
+}
+/**
+ * Convert a HEIF/HEIC source to JPEG.
+ *
+ * Primary path: macOS `sips`, tried only when `input` is a file path —
+ * feature-detected via `execFile`'s ENOENT (never a shell string, so
+ * paths containing spaces or shell metacharacters pass through
+ * unmangled). Fallback (non-macOS, `sips` missing, `sips` fails for any
+ * reason -- including the documented auxiliary-image-reference limit on
+ * HDR gain-map files -- or `input` is a Buffer): {@link
+ * convertHeifToJpegNode}. If both paths fail, the thrown error includes
+ * both underlying failures.
+ */
+export declare function convertHeifToJpeg(input: string | Buffer, opts?: ConvertHeifToJpegOptions): Promise<ConvertHeifResult>;
+/**
+ * Node-native HEIF/HEIC -> JPEG conversion: decode via `heic-decode`
+ * (`libheif-js` WASM), extract the source ICC profile via
+ * {@link extractIccFromHeif}, and encode via sharp.
+ *
+ * `heic-decode` is imported lazily so its WASM decoder only loads on this
+ * fallback path, not on every `sips`-capable macOS call.
+ *
+ * Known limitation: `heic-decode`'s default export decodes the first
+ * top-level image in the container, not necessarily the item marked
+ * primary in the `pitm` box (which is what {@link extractIccFromHeif}
+ * targets). This is a non-issue for single-image consumer photos,
+ * including HDR gain-map ("tmap") files, whose gain map is an auxiliary
+ * image reference on the same item rather than a separate top-level
+ * image — but a multi-image container whose primary item isn't first
+ * would decode the wrong image while attaching the correct image's ICC
+ * profile to it.
+ */
+export declare function convertHeifToJpegNode(input: string | Buffer, opts?: ConvertHeifToJpegOptions): Promise<ConvertHeifResult>;
+/**
+ * Extract the EXIF metadata of a HEIF file as a TIFF-format block (the
+ * payload of a JPEG APP1 `Exif\0\0` segment), by finding the `Exif` item
+ * in meta/iinf and resolving its bytes through meta/iloc.
+ *
+ * The EXIF Orientation tag (IFD0 0x0112) in the returned block is
+ * neutralised to 1: the WASM decoder already applies the container's
+ * irot/imir transforms to the pixels, so carrying the source orientation
+ * forward would double-rotate in EXIF-aware viewers.
+ *
+ * Returns null when the file has no EXIF item or on any
+ * malformed/truncated box layout — same degrade-gracefully contract as
+ * {@link extractIccFromHeif}.
+ */
+export declare function extractExifFromHeif(b: Buffer): Buffer | null;
+/**
+ * Extract the ICC profile associated with a HEIF file's primary item, by
+ * walking meta/pitm (primary item id) and meta/iprp/{ipco,ipma} (item
+ * properties + their associations) to find the primary item's `colr` box.
+ *
+ * Returns the ICC profile bytes when the primary item has a `colr` box of
+ * type `prof`/`rICC`, or null when it doesn't (e.g. nclx-only files, or
+ * any structurally unexpected/malformed box layout). Never throws: any
+ * out-of-bounds read on a malformed/truncated box layout is caught and
+ * surfaces as "no ICC available" instead of an uncaught RangeError.
+ *
+ * Known limitation: only the first `ipma` box under `iprp` is consulted
+ * (ISOBMFF technically permits more than one). Every real-world file this
+ * was validated against — including camera-generated HDR gain-map files
+ * — carries a single ipma box, so this hasn't been a problem in practice.
+ */
+export declare function extractIccFromHeif(b: Buffer): Buffer | null;

package/dist/heif/index.js

@@ -0,0 +1,275 @@
+import { randomUUID as O } from "node:crypto";
+import S from "node:fs/promises";
+import k from "node:os";
+import v from "node:path";
+import P from "sharp";
+import { r as $, a as z, i as H } from "../run-BIjGA2Fu.js";
+const T = 90, D = 256 * 1024 * 1024, N = 6e4, F = 16383 * 16383;
+async function J(t) {
+  return typeof t == "string" ? (await S.stat(t)).size : t.length;
+}
+async function L(t, r) {
+  const a = await J(t);
+  if (a > r)
+    throw new Error(`HEIF input of ${a} bytes exceeds maxInputBytes (${r})`);
+}
+async function at(t, r = {}) {
+  const a = r.quality ?? T, n = r.maxInputBytes ?? D, o = r.maxDecodePixels ?? F, s = r.sipsTimeoutMs ?? N;
+  await L(t, n);
+  let e = null;
+  if (typeof t == "string") {
+    const i = await R(t, a, s);
+    if (i.result) return i.result;
+    e = i.error;
+  }
+  try {
+    return await X(t, { quality: a, maxInputBytes: n, maxDecodePixels: o });
+  } catch (i) {
+    const d = [typeof t == "string" ? e ? `'sips' failed (${e.message})` : "'sips' is unavailable (non-macOS)" : null, `the Node fallback also failed: ${i.message}`].filter(Boolean).join(" and ");
+    throw new Error(`HEIF conversion failed: ${d}.`);
+  }
+}
+async function R(t, r, a) {
+  const n = v.join(k.tmpdir(), `heif-sips-${process.pid}-${O()}.jpg`);
+  try {
+    await $(
+      "sips",
+      [
+        "-s",
+        "format",
+        "jpeg",
+        "-s",
+        "formatOptions",
+        String(r),
+        z(t),
+        "--out",
+        n
+      ],
+      { timeoutMs: a }
+    );
+  } catch (o) {
+    return await S.rm(n, { force: !0 }), H(o) ? { result: null, error: null } : { result: null, error: o };
+  }
+  try {
+    const o = await S.readFile(n), s = await P(o).metadata();
+    return {
+      result: {
+        buffer: o,
+        width: s.width ?? 0,
+        height: s.height ?? 0,
+        iccApplied: !!s.icc,
+        converter: "sips"
+      },
+      error: null
+    };
+  } finally {
+    await S.rm(n, { force: !0 });
+  }
+}
+async function X(t, r = {}) {
+  const a = r.quality ?? T, n = r.maxInputBytes ?? D, o = r.maxDecodePixels ?? F;
+  await L(t, n);
+  const s = typeof t == "string" ? await S.readFile(t) : t;
+  V(s, o);
+  const { default: e } = await import("heic-decode"), { width: i, height: l, data: d } = await e({ buffer: s }), y = Z(s), h = y !== null && y.length <= q ? y : null, c = G(s);
+  let f = await P(Buffer.from(d.buffer, d.byteOffset, d.byteLength), {
+    raw: { width: i, height: l, channels: 4 }
+  }).removeAlpha().jpeg({ quality: a }).toBuffer();
+  return h && (f = Y(f, h)), c && (f = W(f, c)), {
+    buffer: f,
+    width: i,
+    height: l,
+    iccApplied: h !== null,
+    converter: "node"
+  };
+}
+function V(t, r) {
+  let a = null;
+  try {
+    const n = E(t, 0, t.length, "meta");
+    if (!n) return;
+    const o = E(t, n.bodyStart + 4, n.bodyEnd, "iprp");
+    if (!o) return;
+    const s = E(t, o.bodyStart, o.bodyEnd, "ipco");
+    if (!s) return;
+    for (const e of b(t, s.bodyStart, s.bodyEnd)) {
+      if (e.type !== "ispe" || e.bodyEnd - e.bodyStart < 12) continue;
+      const i = t.readUInt32BE(e.bodyStart + 4), l = t.readUInt32BE(e.bodyStart + 8);
+      if (i * l > r) {
+        a = { width: i, height: l };
+        break;
+      }
+    }
+  } catch {
+    return;
+  }
+  if (a)
+    throw new Error(
+      `HEIF declares an image of ${a.width}x${a.height} pixels, exceeding the ${r}-pixel decode limit (maxDecodePixels)`
+    );
+}
+const U = Buffer.from("ICC_PROFILE\0", "latin1"), x = 65533 - U.length - 1 - 1, q = 255 * x;
+function Y(t, r) {
+  if (t.length < 2 || t[0] !== 255 || t[1] !== 216)
+    throw new Error("Expected a JPEG buffer starting with the SOI marker");
+  const a = Math.max(1, Math.ceil(r.length / x)), n = [];
+  for (let o = 0; o < a; o++) {
+    const s = r.subarray(o * x, (o + 1) * x), e = 2 + U.length + 1 + 1 + s.length, i = Buffer.alloc(4 + U.length + 2);
+    i.writeUInt8(255, 0), i.writeUInt8(226, 1), i.writeUInt16BE(e, 2), U.copy(i, 4), i.writeUInt8(o + 1, 4 + U.length), i.writeUInt8(a, 4 + U.length + 1), n.push(i, s);
+  }
+  return Buffer.concat([t.subarray(0, 2), ...n, t.subarray(2)]);
+}
+const C = Buffer.from("Exif\0\0", "latin1");
+function W(t, r) {
+  if (t.length < 2 || t[0] !== 255 || t[1] !== 216)
+    throw new Error("Expected a JPEG buffer starting with the SOI marker");
+  const a = 2 + C.length + r.length;
+  if (a > 65535) return t;
+  const n = Buffer.alloc(4 + C.length);
+  return n.writeUInt8(255, 0), n.writeUInt8(225, 1), n.writeUInt16BE(a, 2), C.copy(n, 4), Buffer.concat([t.subarray(0, 2), n, r, t.subarray(2)]);
+}
+function G(t) {
+  try {
+    const r = E(t, 0, t.length, "meta");
+    if (!r) return null;
+    const a = r.bodyStart + 4, n = K(t, a, r.bodyEnd);
+    if (n === null) return null;
+    const o = Q(t, a, r.bodyEnd, n);
+    if (!o || o.length < 12 || o.offset + o.length > t.length) return null;
+    const s = t.subarray(o.offset, o.offset + o.length), e = 4 + s.readUInt32BE(0);
+    if (e >= s.length - 8) return null;
+    const i = s.toString("latin1", e, e + 2);
+    return i !== "II" && i !== "MM" ? null : j(s.subarray(e));
+  } catch {
+    return null;
+  }
+}
+function K(t, r, a) {
+  const n = E(t, r, a, "iinf");
+  if (!n) return null;
+  const o = t.readUInt8(n.bodyStart), s = n.bodyStart + 4 + (o === 0 ? 2 : 4);
+  for (const e of b(t, s, n.bodyEnd)) {
+    if (e.type !== "infe") continue;
+    const i = t.readUInt8(e.bodyStart);
+    if (i < 2) continue;
+    const l = i === 2 ? 2 : 4, d = i === 2 ? t.readUInt16BE(e.bodyStart + 4) : t.readUInt32BE(e.bodyStart + 4), y = e.bodyStart + 4 + l + 2;
+    if (t.toString("latin1", y, y + 4) === "Exif") return d;
+  }
+  return null;
+}
+function Q(t, r, a, n) {
+  const o = E(t, r, a, "iloc");
+  if (!o) return null;
+  const s = t.readUInt8(o.bodyStart);
+  let e = o.bodyStart + 4;
+  const i = t.readUInt16BE(e);
+  e += 2;
+  const l = i >> 12 & 15, d = i >> 8 & 15, y = i >> 4 & 15, h = s >= 1 ? i & 15 : 0, c = (f) => {
+    let u;
+    return f === 0 ? u = 0 : f === 8 ? u = Number(t.readBigUInt64BE(e)) : u = t.readUIntBE(e, f), e += f, u;
+  };
+  let m;
+  s < 2 ? (m = t.readUInt16BE(e), e += 2) : (m = t.readUInt32BE(e), e += 4);
+  for (let f = 0; f < m; f++) {
+    let u;
+    s < 2 ? (u = t.readUInt16BE(e), e += 2) : (u = t.readUInt32BE(e), e += 4);
+    let I = 0;
+    s >= 1 && (I = t.readUInt16BE(e) & 15, e += 2);
+    const p = t.readUInt16BE(e);
+    e += 2;
+    const w = c(y), g = t.readUInt16BE(e);
+    e += 2;
+    let B = null;
+    for (let _ = 0; _ < g; _++) {
+      h > 0 && c(h);
+      const A = c(l), M = c(d);
+      _ === 0 && (B = { offset: w + A, length: M });
+    }
+    if (u === n)
+      return I !== 0 || p !== 0 || g !== 1 ? null : B;
+  }
+  return null;
+}
+function j(t) {
+  const r = Buffer.from(t);
+  try {
+    const a = r.toString("latin1", 0, 2) === "II", n = (i) => a ? r.readUInt16LE(i) : r.readUInt16BE(i), s = ((i) => a ? r.readUInt32LE(i) : r.readUInt32BE(i))(4), e = n(s);
+    for (let i = 0; i < e; i++) {
+      const l = s + 2 + i * 12;
+      if (n(l) === 274) {
+        a ? r.writeUInt16LE(1, l + 8) : r.writeUInt16BE(1, l + 8);
+        break;
+      }
+    }
+  } catch {
+  }
+  return r;
+}
+function* b(t, r, a) {
+  let n = r;
+  for (; n + 8 <= a; ) {
+    let o = t.readUInt32BE(n);
+    const s = t.toString("latin1", n + 4, n + 8);
+    let e = 8;
+    if (o === 1) {
+      if (n + 16 > a) break;
+      o = Number(t.readBigUInt64BE(n + 8)), e = 16;
+    } else o === 0 && (o = a - n);
+    if (o < e || n + o > a) break;
+    yield { type: s, start: n, header: e, size: o, bodyStart: n + e, bodyEnd: n + o }, n += o;
+  }
+}
+function E(t, r, a, n) {
+  for (const o of b(t, r, a))
+    if (o.type === n) return o;
+  return null;
+}
+function Z(t) {
+  try {
+    const r = E(t, 0, t.length, "meta");
+    if (!r) return null;
+    const a = r.bodyStart + 4, n = E(t, a, r.bodyEnd, "pitm");
+    if (!n) return null;
+    const s = t.readUInt8(n.bodyStart) === 0 ? t.readUInt16BE(n.bodyStart + 4) : t.readUInt32BE(n.bodyStart + 4), e = E(t, a, r.bodyEnd, "iprp");
+    if (!e) return null;
+    const i = E(t, e.bodyStart, e.bodyEnd, "ipco");
+    if (!i) return null;
+    const l = [...b(t, i.bodyStart, i.bodyEnd)], d = E(t, e.bodyStart, e.bodyEnd, "ipma");
+    if (!d) return null;
+    const y = t.readUInt8(d.bodyStart), h = t.readUIntBE(d.bodyStart + 1, 3);
+    let c = d.bodyStart + 4;
+    const m = t.readUInt32BE(c);
+    c += 4;
+    let f = null;
+    for (let u = 0; u < m; u++) {
+      const I = y < 1 ? t.readUInt16BE(c) : t.readUInt32BE(c);
+      c += y < 1 ? 2 : 4;
+      const p = t.readUInt8(c);
+      c += 1;
+      const w = [];
+      for (let g = 0; g < p; g++) {
+        let B;
+        h & 1 ? (B = t.readUInt16BE(c) & 32767, c += 2) : (B = t.readUInt8(c) & 127, c += 1), w.push(B);
+      }
+      I === s && (f = w);
+    }
+    if (!f) return null;
+    for (const u of f) {
+      const I = l[u - 1];
+      if (I && I.type === "colr") {
+        const p = t.toString("latin1", I.bodyStart, I.bodyStart + 4);
+        if (p === "prof" || p === "rICC")
+          return t.subarray(I.bodyStart + 4, I.bodyEnd);
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+export {
+  at as convertHeifToJpeg,
+  X as convertHeifToJpegNode,
+  G as extractExifFromHeif,
+  Z as extractIccFromHeif
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './variants/index.js';
+export * from './heif/index.js';
+export * from './ogp/index.js';
+export * from './budget/index.js';
+export * from './square/index.js';
+export * from './product-photo/index.js';
+export * from './calibrate/index.js';
+export * from './composite/index.js';
+export * from './blurhash/index.js';
+export * from './exif/index.js';
+export * from './browser/index.js';
+export type { ImageInput } from './composite/index.js';
+export type { Orientation } from './exif/index.js';
+export { deriveOrientation } from './exif/index.js';

package/dist/index.js

@@ -0,0 +1,68 @@
+import { D as a, a as o, b as t, c as s, d as E, e as p, I as i, P as n, S as A, V as m, f as T, n as S, p as I, g as _, h as c, s as d } from "./presets-PTxNoMdy.js";
+import { convertHeifToJpeg as f, convertHeifToJpegNode as O, extractExifFromHeif as F, extractIccFromHeif as D } from "./heif/index.js";
+import { generateOgpFromLandscape as N, generateOgpImage as h, generateSmartOgp as u } from "./ogp/index.js";
+import { encodeUnderByteBudget as L } from "./budget/index.js";
+import { cropToSquare as P, insetOnSquare as C, padToSquare as M, padToSquareCentered as G, trimPadSquare as R } from "./square/index.js";
+import { alphaTrim as H, composeProductPhoto as V, generateShadowLayers as k, removeBackground as v } from "./product-photo/index.js";
+import { calibrateTargetFromSamples as b, normalizeBackgroundColor as q, sampleBackgroundColor as y } from "./calibrate/index.js";
+import { compositeBatch as Y, compositeOverlay as J } from "./composite/index.js";
+import { batchBlurhashToDataUri as z, blurhashToDataUri as K, encodeImageToBlurhash as Q } from "./blurhash/index.js";
+import { bakeOrientation as Z, deriveOrientation as $, parseExifDate as ee, pickVariantWidths as re, stripExif as ae } from "./exif/index.js";
+import { DEFAULT_MAX_CANVAS_AREA as te, HEIC_DECODE_FAILED_MESSAGE as se, MISSING_EXIFR_MESSAGE as Ee, MISSING_HEIC2ANY_MESSAGE as pe, ORIENTATION_BAKE_FAILED_MESSAGE_PREFIX as ie, deriveGeometry as ne, needsOrientationBake as Ae, prepareImageForUpload as me, roundAspectRatio as Te } from "./browser/index.js";
+export {
+  a as DEFAULT_CACHE_FILENAME,
+  o as DEFAULT_CONCURRENCY,
+  t as DEFAULT_FORMATS,
+  te as DEFAULT_MAX_CANVAS_AREA,
+  s as DEFAULT_OGP_FILENAME,
+  E as DEFAULT_QUALITY,
+  p as DEFAULT_WIDTHS,
+  se as HEIC_DECODE_FAILED_MESSAGE,
+  i as IMAGE_EXTENSION_REGEX,
+  Ee as MISSING_EXIFR_MESSAGE,
+  pe as MISSING_HEIC2ANY_MESSAGE,
+  ie as ORIENTATION_BAKE_FAILED_MESSAGE_PREFIX,
+  n as PHOTO_VARIANT_WIDTHS,
+  A as SUPPORTED_IMAGE_EXTENSIONS,
+  m as VariantProcessingError,
+  H as alphaTrim,
+  Z as bakeOrientation,
+  z as batchBlurhashToDataUri,
+  K as blurhashToDataUri,
+  b as calibrateTargetFromSamples,
+  V as composeProductPhoto,
+  Y as compositeBatch,
+  J as compositeOverlay,
+  f as convertHeifToJpeg,
+  O as convertHeifToJpegNode,
+  P as cropToSquare,
+  T as defaultTagParser,
+  ne as deriveGeometry,
+  $ as deriveOrientation,
+  Q as encodeImageToBlurhash,
+  L as encodeUnderByteBudget,
+  F as extractExifFromHeif,
+  D as extractIccFromHeif,
+  N as generateOgpFromLandscape,
+  h as generateOgpImage,
+  k as generateShadowLayers,
+  u as generateSmartOgp,
+  C as insetOnSquare,
+  Ae as needsOrientationBake,
+  S as noTagParser,
+  q as normalizeBackgroundColor,
+  M as padToSquare,
+  G as padToSquareCentered,
+  ee as parseExifDate,
+  I as photoVariantsPreset,
+  re as pickVariantWidths,
+  me as prepareImageForUpload,
+  _ as processImages,
+  c as processOne,
+  v as removeBackground,
+  Te as roundAspectRatio,
+  y as sampleBackgroundColor,
+  d as selectVariantWidths,
+  ae as stripExif,
+  R as trimPadSquare
+};

package/dist/ogp/index.d.ts

@@ -0,0 +1,72 @@
+/** File path or in-memory buffer accepted as the compositor's source image. */
+export type OgpInput = string | Buffer;
+export interface OgpBaseOptions {
+    /** Output canvas width. Default 1200. */
+    width?: number;
+    /** Output canvas height. Default 630. */
+    height?: number;
+    /** JPEG quality (1-100). Default 85. */
+    quality?: number;
+    /** Progressive JPEG encoding. Default true. */
+    progressive?: boolean;
+    /** When set, also writes the result to this path; the result then carries `path`. */
+    outPath?: string;
+}
+export interface OgpImageOptions extends OgpBaseOptions {
+    /** Size of the centered square card. Default 600. */
+    foregroundSize?: number;
+    /** Corner radius applied to the card via an SVG mask. 0 (default) skips masking. */
+    cornerRadius?: number;
+    /** Gaussian blur sigma for the background. Default 45. */
+    blurSigma?: number;
+    /** Background desaturation, 0-1. Default 0.1. */
+    desaturate?: number;
+    /** Top gradient darkness, 0-1. Default 0.3. */
+    topGradientOpacity?: number;
+    /** Bottom gradient darkness, 0-1. Default 0.2. */
+    bottomGradientOpacity?: number;
+    /** Fraction of canvas height covered by the top gradient. Default 0.25. */
+    gradientTopHeight?: number;
+    /** Fraction of canvas height covered by the bottom gradient. Default 0.25. */
+    gradientBottomHeight?: number;
+    /** Drop shadow opacity, 0-1. Default 0.25. */
+    shadowOpacity?: number;
+    /** Drop shadow blur radius. Default 24. */
+    shadowBlur?: number;
+    /** Vertical drop shadow offset. Default 8. */
+    shadowOffsetY?: number;
+}
+export type OgpFromLandscapeOptions = OgpBaseOptions;
+export interface SmartOgpOptions extends OgpImageOptions {
+    /** Aspect ratio (width / height) at or above which the landscape branch is used. Default 1.5. */
+    landscapeThreshold?: number;
+}
+export interface OgpResult {
+    buffer: Buffer;
+    width: number;
+    height: number;
+    format: 'jpeg';
+    /** Present only when `outPath` was passed. */
+    path?: string;
+}
+export interface SmartOgpResult extends OgpResult {
+    /** Which dispatch branch produced this result. */
+    method: 'landscape' | 'composite';
+}
+/**
+ * Composite a blurred, desaturated cover-crop background with gradient
+ * overlays, a drop shadow, and a centered square card (optionally
+ * rounded-corner masked). Best suited to square/portrait sources.
+ */
+export declare function generateOgpImage(input: OgpInput, opts?: OgpImageOptions): Promise<OgpResult>;
+/**
+ * Simple cover-crop to the target canvas, no compositing. Best suited to
+ * already-landscape sources where a blurred-background card would waste
+ * detail.
+ */
+export declare function generateOgpFromLandscape(input: OgpInput, opts?: OgpFromLandscapeOptions): Promise<OgpResult>;
+/**
+ * Dispatches to {@link generateOgpFromLandscape} or {@link generateOgpImage}
+ * based on the source's aspect ratio.
+ */
+export declare function generateSmartOgp(input: OgpInput, opts?: SmartOgpOptions): Promise<SmartOgpResult>;