@happyvertical/images 0.74.8

package/dist/index.js

@@ -0,0 +1,1302 @@
+import { createHmac } from "node:crypto";
+class ImageError extends Error {
+  constructor(message, code, adapter) {
+    super(message);
+    this.code = code;
+    this.adapter = adapter;
+    this.name = "ImageError";
+  }
+}
+class ImageNotFoundError extends ImageError {
+  constructor(path, adapter) {
+    super(`Image not found: ${path}`, "IMAGE_NOT_FOUND", adapter);
+    this.name = "ImageNotFoundError";
+  }
+}
+class UnsupportedFormatError extends ImageError {
+  constructor(format, adapter) {
+    super(`Unsupported image format: ${format}`, "UNSUPPORTED_FORMAT", adapter);
+    this.name = "UnsupportedFormatError";
+  }
+}
+class OperationNotSupportedError extends ImageError {
+  constructor(operation, adapter) {
+    super(
+      `Operation not supported: ${operation}`,
+      "OPERATION_NOT_SUPPORTED",
+      adapter
+    );
+    this.name = "OperationNotSupportedError";
+  }
+}
+class ProcessingError extends ImageError {
+  constructor(message, adapter, cause) {
+    super(message, "PROCESSING_ERROR", adapter);
+    this.cause = cause;
+    this.name = "ProcessingError";
+  }
+}
+class InvalidAdapterError extends ImageError {
+  constructor(type) {
+    super(`Invalid adapter type: ${type}`, "INVALID_ADAPTER");
+    this.name = "InvalidAdapterError";
+  }
+}
+class RemoteServiceError extends ImageError {
+  constructor(message, adapter, statusCode) {
+    super(message, "REMOTE_SERVICE_ERROR", adapter);
+    this.statusCode = statusCode;
+    this.name = "RemoteServiceError";
+  }
+}
+function signImgproxyUrl(source, config, options = {}) {
+  const adapter = new ImgproxyAdapter({
+    type: "imgproxy",
+    baseUrl: config.baseUrl,
+    key: config.key,
+    salt: config.salt
+  });
+  return adapter.getSignedUrl(source, options);
+}
+class ImgproxyAdapter {
+  baseUrl;
+  key;
+  salt;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    if (options.key && options.salt) {
+      this.key = Buffer.from(options.key, "hex");
+      this.salt = Buffer.from(options.salt, "hex");
+    }
+  }
+  /**
+   * Generate a signed imgproxy URL without fetching the image
+   *
+   * This is useful for:
+   * - Client-side usage where you want to display images directly
+   * - Debugging URL signing issues
+   * - Pre-generating URLs for batch processing
+   *
+   * @param source - Source image URL (must be http/https)
+   * @param options - Processing options
+   * @returns Signed imgproxy URL
+   *
+   * @example
+   * ```typescript
+   * const adapter = new ImgproxyAdapter({
+   *   type: 'imgproxy',
+   *   baseUrl: 'https://imgproxy.example.com',
+   *   key: 'hex-key',
+   *   salt: 'hex-salt'
+   * });
+   *
+   * // Generate thumbnail URL
+   * const url = adapter.getSignedUrl('https://example.com/image.jpg', {
+   *   width: 300,
+   *   height: 200,
+   *   fit: 'cover',
+   *   format: 'webp'
+   * });
+   * // Returns: https://imgproxy.example.com/SIGNATURE/rs:fill:300:200/aHR0cHM6Ly9.../image.webp
+   * ```
+   */
+  getSignedUrl(source, options = {}) {
+    if (!source.startsWith("http://") && !source.startsWith("https://")) {
+      throw new ProcessingError(
+        `imgproxy requires HTTP/HTTPS URLs as source. Got: ${source.substring(0, 50)}...`,
+        "imgproxy"
+      );
+    }
+    const resizeType = this.mapFitToResizeType(options.fit || "cover");
+    const processing = this.buildProcessingString({
+      resize: resizeType,
+      width: options.width || 0,
+      height: options.height || 0,
+      quality: options.quality,
+      format: options.format
+    });
+    return this.buildUrl(source, processing, options.format);
+  }
+  /**
+   * Sign a path using HMAC-SHA256
+   */
+  sign(path) {
+    if (!this.key || !this.salt) {
+      return "unsafe";
+    }
+    const hmac = createHmac("sha256", this.key);
+    hmac.update(this.salt);
+    hmac.update(path);
+    return hmac.digest("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "").substring(0, 32);
+  }
+  /**
+   * Encode source URL for imgproxy
+   */
+  encodeSource(source) {
+    return Buffer.from(source).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  }
+  /**
+   * Build imgproxy URL
+   */
+  buildUrl(source, processing, extension) {
+    const encodedSource = this.encodeSource(source);
+    const ext = extension ? `.${extension}` : "";
+    const path = `/${processing}/${encodedSource}${ext}`;
+    const signature = this.sign(path);
+    return `${this.baseUrl}/${signature}${path}`;
+  }
+  /**
+   * Convert ImageInput to URL string
+   */
+  toUrl(input) {
+    if (Buffer.isBuffer(input)) {
+      throw new ProcessingError(
+        "imgproxy adapter requires URL input, not Buffer. Upload the buffer to a storage service first.",
+        "imgproxy"
+      );
+    }
+    if (!input.startsWith("http://") && !input.startsWith("https://")) {
+      throw new ProcessingError(
+        `imgproxy adapter requires HTTP/HTTPS URLs as input. Got: ${input.substring(0, 50)}...`,
+        "imgproxy"
+      );
+    }
+    return input;
+  }
+  async getDimensions(input) {
+    const url = this.toUrl(input);
+    try {
+      const infoUrl = this.buildUrl(url, "info:1");
+      const response = await fetch(infoUrl);
+      if (!response.ok) {
+        throw new RemoteServiceError(
+          `imgproxy info request failed: ${response.statusText}`,
+          "imgproxy",
+          response.status
+        );
+      }
+      const info = await response.json();
+      return {
+        width: info.width,
+        height: info.height
+      };
+    } catch (error) {
+      if (error instanceof ProcessingError || error instanceof RemoteServiceError) {
+        throw error;
+      }
+      throw new ProcessingError(
+        `Failed to get dimensions: ${error instanceof Error ? error.message : String(error)}`,
+        "imgproxy",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async thumbnail(input, output, options = {}) {
+    const url = this.toUrl(input);
+    try {
+      const processing = this.buildProcessingString({
+        resize: "fit",
+        width: options.maxWidth || 0,
+        height: options.maxHeight || 0,
+        quality: options.quality,
+        format: options.format
+      });
+      const ext = options.format || this.inferFormat(output);
+      const imgUrl = this.buildUrl(url, processing, ext);
+      await this.fetchAndSave(imgUrl, output);
+    } catch (error) {
+      if (error instanceof ProcessingError || error instanceof RemoteServiceError) {
+        throw error;
+      }
+      throw new ProcessingError(
+        `Thumbnail generation failed: ${error instanceof Error ? error.message : String(error)}`,
+        "imgproxy",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async convert(input, output, options = {}) {
+    const url = this.toUrl(input);
+    try {
+      const format = options.format || this.inferFormat(output);
+      const processing = this.buildProcessingString({
+        quality: options.quality,
+        format
+      });
+      const imgUrl = this.buildUrl(url, processing, format);
+      await this.fetchAndSave(imgUrl, output);
+    } catch (error) {
+      if (error instanceof ProcessingError || error instanceof RemoteServiceError) {
+        throw error;
+      }
+      throw new ProcessingError(
+        `Format conversion failed: ${error instanceof Error ? error.message : String(error)}`,
+        "imgproxy",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async getMetadata(input) {
+    const url = this.toUrl(input);
+    try {
+      const infoUrl = this.buildUrl(url, "info:1");
+      const response = await fetch(infoUrl);
+      if (!response.ok) {
+        throw new RemoteServiceError(
+          `imgproxy info request failed: ${response.statusText}`,
+          "imgproxy",
+          response.status
+        );
+      }
+      const info = await response.json();
+      return {
+        width: info.width,
+        height: info.height,
+        format: info.type || "unknown"
+        // imgproxy returns limited metadata
+        // Additional EXIF/IPTC/XMP not typically available
+      };
+    } catch (error) {
+      if (error instanceof ProcessingError || error instanceof RemoteServiceError) {
+        throw error;
+      }
+      throw new ProcessingError(
+        `Failed to get metadata: ${error instanceof Error ? error.message : String(error)}`,
+        "imgproxy",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async hash(_input, _algorithm = "perceptual") {
+    throw new OperationNotSupportedError(
+      "hash (imgproxy does not support direct hashing - fetch image first)",
+      "imgproxy"
+    );
+  }
+  async resize(input, output, options) {
+    const url = this.toUrl(input);
+    try {
+      const resizeType = this.mapFitToResizeType(options.fit || "cover");
+      const processing = this.buildProcessingString({
+        resize: resizeType,
+        width: options.width || 0,
+        height: options.height || 0,
+        quality: options.quality,
+        format: options.format
+      });
+      const ext = options.format || this.inferFormat(output);
+      const imgUrl = this.buildUrl(url, processing, ext);
+      await this.fetchAndSave(imgUrl, output);
+    } catch (error) {
+      if (error instanceof ProcessingError || error instanceof RemoteServiceError) {
+        throw error;
+      }
+      throw new ProcessingError(
+        `Resize failed: ${error instanceof Error ? error.message : String(error)}`,
+        "imgproxy",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Build imgproxy processing string
+   */
+  buildProcessingString(opts) {
+    const parts = [];
+    if (opts.resize) {
+      const w = opts.width || 0;
+      const h = opts.height || 0;
+      parts.push(`rs:${opts.resize}:${w}:${h}`);
+    }
+    if (opts.quality) {
+      parts.push(`q:${opts.quality}`);
+    }
+    return parts.length > 0 ? parts.join("/") : "raw:1";
+  }
+  /**
+   * Map fit mode to imgproxy resize type
+   */
+  mapFitToResizeType(fit) {
+    const map = {
+      cover: "fill",
+      // Fill and crop
+      contain: "fit",
+      // Fit within
+      fill: "force",
+      // Force exact size
+      inside: "fit",
+      // Same as contain
+      outside: "fill"
+      // Same as cover
+    };
+    return map[fit] || "fit";
+  }
+  /**
+   * Fetch image from imgproxy and save to file
+   */
+  async fetchAndSave(url, output) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new RemoteServiceError(
+        `imgproxy request failed: ${response.statusText}`,
+        "imgproxy",
+        response.status
+      );
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const { writeFile } = await import("node:fs/promises");
+    await writeFile(output, buffer);
+  }
+  /**
+   * Infer image format from file extension
+   */
+  inferFormat(path) {
+    const ext = path.split(".").pop()?.toLowerCase();
+    const map = {
+      jpg: "jpeg",
+      jpeg: "jpeg",
+      png: "png",
+      webp: "webp",
+      avif: "avif",
+      gif: "gif",
+      tiff: "tiff",
+      tif: "tiff"
+    };
+    return map[ext || ""] || "jpeg";
+  }
+}
+const imgproxy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ImgproxyAdapter,
+  signImgproxyUrl
+}, Symbol.toStringTag, { value: "Module" }));
+class JimpAdapter {
+  jimpStatic = null;
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Stored for API compatibility and future extensibility
+  options;
+  /**
+   * Create a new Jimp adapter
+   * @param options - Jimp adapter options
+   */
+  constructor(options = { type: "jimp" }) {
+    this.options = options;
+  }
+  /**
+   * Lazily load Jimp module
+   */
+  async getJimp() {
+    if (!this.jimpStatic) {
+      try {
+        const jimpModule = await import("jimp");
+        this.jimpStatic = jimpModule.Jimp;
+      } catch (error) {
+        throw new ProcessingError(
+          "Jimp library is not installed. Install it with: npm install jimp",
+          "jimp",
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+    return this.jimpStatic;
+  }
+  async getDimensions(input) {
+    const Jimp = await this.getJimp();
+    try {
+      const image = await Jimp.read(input);
+      return { width: image.width, height: image.height };
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async thumbnail(input, output, options = {}) {
+    const Jimp = await this.getJimp();
+    try {
+      const image = await Jimp.read(input);
+      if (options.maxWidth && options.maxHeight) {
+        image.scaleToFit({ w: options.maxWidth, h: options.maxHeight });
+      } else if (options.maxWidth) {
+        const scale = options.maxWidth / image.width;
+        if (scale < 1) {
+          image.scale(scale);
+        }
+      } else if (options.maxHeight) {
+        const scale = options.maxHeight / image.height;
+        if (scale < 1) {
+          image.scale(scale);
+        }
+      }
+      await this.writeWithOptions(image, output, options.quality);
+    } catch (error) {
+      if (error instanceof ProcessingError || error instanceof ImageNotFoundError) {
+        throw error;
+      }
+      throw this.mapError(error, input);
+    }
+  }
+  async convert(input, output, options = {}) {
+    const Jimp = await this.getJimp();
+    try {
+      const image = await Jimp.read(input);
+      await this.writeWithOptions(image, output, options.quality);
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async getMetadata(input) {
+    const Jimp = await this.getJimp();
+    try {
+      const image = await Jimp.read(input);
+      const mime = this.getMimeFromInput(input);
+      const format = this.formatFromMime(mime);
+      return {
+        width: image.width,
+        height: image.height,
+        format,
+        channels: 4,
+        // Jimp uses RGBA internally
+        hasAlpha: true
+        // Jimp always works with alpha channel
+        // Jimp has limited metadata extraction
+        // EXIF/IPTC/XMP not directly supported
+      };
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async hash(input, algorithm = "perceptual") {
+    const Jimp = await this.getJimp();
+    try {
+      if (algorithm === "md5" || algorithm === "sha256") {
+        const { createHash } = await import("node:crypto");
+        const image2 = await Jimp.read(input);
+        const buffer = await image2.getBuffer("image/png");
+        return createHash(algorithm).update(buffer).digest("hex");
+      }
+      const image = await Jimp.read(input);
+      const resized = image.clone().resize({ w: 8, h: 8 }).greyscale();
+      const data = resized.bitmap.data;
+      let sum = 0;
+      const pixels = [];
+      for (let i = 0; i < data.length; i += 4) {
+        const gray = data[i];
+        pixels.push(gray);
+        sum += gray;
+      }
+      const avg = sum / pixels.length;
+      let hash = "";
+      for (const val of pixels) {
+        hash += val >= avg ? "1" : "0";
+      }
+      return BigInt(`0b${hash}`).toString(16).padStart(16, "0");
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async resize(input, output, options) {
+    const Jimp = await this.getJimp();
+    try {
+      const image = await Jimp.read(input);
+      const fit = options.fit || "cover";
+      if (options.width && options.height) {
+        if (fit === "cover") {
+          image.cover({ w: options.width, h: options.height });
+        } else if (fit === "contain" || fit === "inside") {
+          image.contain({ w: options.width, h: options.height });
+        } else {
+          image.resize({ w: options.width, h: options.height });
+        }
+      } else if (options.width) {
+        const scale = options.width / image.width;
+        image.scale(scale);
+      } else if (options.height) {
+        const scale = options.height / image.height;
+        image.scale(scale);
+      }
+      await this.writeWithOptions(image, output, options.quality);
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  /**
+   * Write image with quality settings based on output format
+   */
+  async writeWithOptions(image, output, quality) {
+    const format = this.inferFormat(output);
+    const mime = this.mimeFromFormat(format);
+    if (format === "avif") {
+      throw new UnsupportedFormatError("avif", "jimp");
+    }
+    const buffer = await image.getBuffer(mime, {
+      quality: quality ?? 80
+    });
+    const { writeFile } = await import("node:fs/promises");
+    await writeFile(output, buffer);
+  }
+  /**
+   * Infer image format from file extension
+   */
+  inferFormat(path) {
+    const ext = path.split(".").pop()?.toLowerCase();
+    const map = {
+      jpg: "jpeg",
+      jpeg: "jpeg",
+      png: "png",
+      webp: "webp",
+      avif: "avif",
+      gif: "gif",
+      tiff: "tiff",
+      tif: "tiff",
+      bmp: "png"
+      // Convert BMP to PNG
+    };
+    return map[ext || ""] || "jpeg";
+  }
+  /**
+   * Get MIME type from format
+   */
+  mimeFromFormat(format) {
+    const map = {
+      jpeg: "image/jpeg",
+      png: "image/png",
+      webp: "image/webp",
+      avif: "image/avif",
+      gif: "image/gif",
+      tiff: "image/tiff"
+    };
+    return map[format] || "image/jpeg";
+  }
+  /**
+   * Get format from MIME type
+   */
+  formatFromMime(mime) {
+    const map = {
+      "image/jpeg": "jpeg",
+      "image/png": "png",
+      "image/webp": "webp",
+      "image/gif": "gif",
+      "image/tiff": "tiff",
+      "image/bmp": "bmp"
+    };
+    return map[mime] || "unknown";
+  }
+  /**
+   * Try to determine MIME type from input
+   */
+  getMimeFromInput(input) {
+    if (typeof input === "string") {
+      const format = this.inferFormat(input);
+      return this.mimeFromFormat(format);
+    }
+    return "image/png";
+  }
+  /**
+   * Map Jimp errors to our error types
+   */
+  mapError(error, input) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("no such file") || message.includes("ENOENT") || message.includes("Could not find")) {
+      const path = typeof input === "string" ? input : "<buffer>";
+      throw new ImageNotFoundError(path, "jimp");
+    }
+    if (message.includes("not supported") || message.includes("Could not find MIME")) {
+      throw new UnsupportedFormatError("unknown", "jimp");
+    }
+    return new ProcessingError(
+      `Image processing failed: ${message}`,
+      "jimp",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+const jimp = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  JimpAdapter
+}, Symbol.toStringTag, { value: "Module" }));
+class SharpAdapter {
+  sharp = null;
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Stored for API compatibility and future extensibility
+  options;
+  /**
+   * Create a new Sharp adapter
+   * @param options - Sharp adapter options
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Lazily load sharp module
+   */
+  async getSharp() {
+    if (!this.sharp) {
+      try {
+        this.sharp = (await import("sharp")).default;
+      } catch (error) {
+        throw new ProcessingError(
+          "Sharp library is not installed. Install it with: npm install sharp",
+          "sharp",
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+    return this.sharp;
+  }
+  async getDimensions(input) {
+    const sharp2 = await this.getSharp();
+    try {
+      const metadata = await sharp2(input).metadata();
+      if (!metadata.width || !metadata.height) {
+        throw new ProcessingError(
+          "Could not determine image dimensions",
+          "sharp"
+        );
+      }
+      return { width: metadata.width, height: metadata.height };
+    } catch (error) {
+      if (error instanceof ProcessingError) throw error;
+      throw this.mapError(error, input);
+    }
+  }
+  async thumbnail(input, output, options = {}) {
+    const sharp2 = await this.getSharp();
+    try {
+      let pipeline = sharp2(input).resize({
+        width: options.maxWidth,
+        height: options.maxHeight,
+        fit: options.fit || "inside",
+        withoutEnlargement: true
+      });
+      if (options.format) {
+        pipeline = pipeline.toFormat(options.format, {
+          quality: options.quality
+        });
+      } else if (options.quality) {
+        const format = this.inferFormat(output);
+        pipeline = pipeline.toFormat(format, { quality: options.quality });
+      }
+      await pipeline.toFile(output);
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async convert(input, output, options = {}) {
+    const sharp2 = await this.getSharp();
+    try {
+      const format = options.format || this.inferFormat(output);
+      await sharp2(input).toFormat(format, { quality: options.quality }).toFile(output);
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async getMetadata(input) {
+    const sharp2 = await this.getSharp();
+    try {
+      const meta = await sharp2(input).metadata();
+      if (!meta.width || !meta.height || !meta.format) {
+        throw new ProcessingError("Could not extract image metadata", "sharp");
+      }
+      return {
+        width: meta.width,
+        height: meta.height,
+        format: meta.format,
+        space: meta.space,
+        channels: meta.channels,
+        depth: meta.depth,
+        density: meta.density,
+        hasAlpha: meta.hasAlpha,
+        orientation: meta.orientation,
+        exif: meta.exif ? this.parseExifBuffer(meta.exif) : void 0,
+        iptc: meta.iptc ? this.parseIptcBuffer(meta.iptc) : void 0,
+        xmp: meta.xmp ? this.parseXmpBuffer(meta.xmp) : void 0
+      };
+    } catch (error) {
+      if (error instanceof ProcessingError) throw error;
+      throw this.mapError(error, input);
+    }
+  }
+  async hash(input, algorithm = "perceptual") {
+    const sharp2 = await this.getSharp();
+    try {
+      if (algorithm === "md5" || algorithm === "sha256") {
+        const { createHash } = await import("node:crypto");
+        const buffer = await sharp2(input).toBuffer();
+        return createHash(algorithm).update(buffer).digest("hex");
+      }
+      const { data } = await sharp2(input).resize(8, 8, { fit: "fill" }).grayscale().raw().toBuffer({ resolveWithObject: true });
+      const avg = data.reduce((sum, val) => sum + val, 0) / data.length;
+      let hash = "";
+      for (const val of data) {
+        hash += val >= avg ? "1" : "0";
+      }
+      return BigInt(`0b${hash}`).toString(16).padStart(16, "0");
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  async resize(input, output, options) {
+    const sharp2 = await this.getSharp();
+    try {
+      let pipeline = sharp2(input).resize({
+        width: options.width,
+        height: options.height,
+        fit: options.fit || "cover"
+      });
+      if (options.format) {
+        pipeline = pipeline.toFormat(options.format, {
+          quality: options.quality
+        });
+      } else if (options.quality) {
+        const format = this.inferFormat(output);
+        pipeline = pipeline.toFormat(format, { quality: options.quality });
+      }
+      await pipeline.toFile(output);
+    } catch (error) {
+      throw this.mapError(error, input);
+    }
+  }
+  /**
+   * Infer image format from file extension
+   */
+  inferFormat(path) {
+    const ext = path.split(".").pop()?.toLowerCase();
+    const map = {
+      jpg: "jpeg",
+      jpeg: "jpeg",
+      png: "png",
+      webp: "webp",
+      avif: "avif",
+      gif: "gif",
+      tiff: "tiff",
+      tif: "tiff"
+    };
+    return map[ext || ""] || "jpeg";
+  }
+  /**
+   * Parse EXIF buffer to object (basic parsing)
+   */
+  parseExifBuffer(buffer) {
+    return { raw: `${buffer.toString("base64").slice(0, 100)}...` };
+  }
+  /**
+   * Parse IPTC buffer to object (basic parsing)
+   */
+  parseIptcBuffer(buffer) {
+    return { raw: `${buffer.toString("base64").slice(0, 100)}...` };
+  }
+  /**
+   * Parse XMP buffer to object (basic parsing)
+   */
+  parseXmpBuffer(buffer) {
+    try {
+      const xmpString = buffer.toString("utf8");
+      return { raw: `${xmpString.slice(0, 500)}...` };
+    } catch {
+      return { raw: `${buffer.toString("base64").slice(0, 100)}...` };
+    }
+  }
+  /**
+   * Map sharp errors to our error types
+   */
+  mapError(error, input) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("Input file is missing")) {
+      const path = typeof input === "string" ? input : "<buffer>";
+      throw new ImageNotFoundError(path, "sharp");
+    }
+    if (message.includes("Input buffer contains unsupported image format")) {
+      throw new ProcessingError("Unsupported image format", "sharp");
+    }
+    return new ProcessingError(
+      `Image processing failed: ${message}`,
+      "sharp",
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+const sharp = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SharpAdapter
+}, Symbol.toStringTag, { value: "Module" }));
+let cachedFontData = null;
+let cachedFontName = null;
+async function loadGoogleFont(fontName) {
+  if (cachedFontData && cachedFontName === fontName) {
+    return cachedFontData;
+  }
+  const fontUrl = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(fontName)}:wght@400;600;700&display=swap`;
+  const cssResponse = await fetch(fontUrl, {
+    headers: {
+      // Use an old user agent to get WOFF format (Satori doesn't support woff2)
+      "User-Agent": "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)"
+    }
+  });
+  if (!cssResponse.ok) {
+    throw new Error(`Failed to fetch font CSS: ${cssResponse.statusText}`);
+  }
+  const css = await cssResponse.text();
+  let urlMatch = css.match(
+    /src:\s*url\(([^)]+)\)\s*format\(['"]truetype['"]\)/
+  );
+  if (!urlMatch) {
+    urlMatch = css.match(/src:\s*url\(([^)]+)\)\s*format\(['"]woff['"]\)/);
+  }
+  if (!urlMatch) {
+    urlMatch = css.match(/src:\s*url\(([^)]+)\)(?!\s*format\(['"]woff2['"]\))/);
+  }
+  if (!urlMatch) {
+    throw new Error(
+      `Could not find compatible font URL in CSS for ${fontName}. CSS: ${css.slice(0, 300)}...`
+    );
+  }
+  const fontFileUrl = urlMatch[1];
+  const fontResponse = await fetch(fontFileUrl);
+  if (!fontResponse.ok) {
+    throw new Error(`Failed to fetch font file: ${fontResponse.statusText}`);
+  }
+  cachedFontData = await fontResponse.arrayBuffer();
+  cachedFontName = fontName;
+  return cachedFontData;
+}
+function renderDefaultTemplate({
+  title,
+  options
+}) {
+  const {
+    width,
+    brandColor,
+    backgroundColor,
+    subtitle,
+    fontFamily
+  } = options;
+  return {
+    type: "div",
+    props: {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        width: "100%",
+        height: "100%",
+        backgroundColor,
+        padding: "60px",
+        fontFamily
+      },
+      children: [
+        // Top accent bar
+        {
+          type: "div",
+          props: {
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              right: 0,
+              height: "8px",
+              backgroundColor: brandColor
+            }
+          }
+        },
+        // Subtitle
+        subtitle ? {
+          type: "div",
+          props: {
+            style: {
+              fontSize: "24px",
+              fontWeight: 600,
+              color: brandColor,
+              marginBottom: "20px",
+              textTransform: "uppercase",
+              letterSpacing: "2px"
+            },
+            children: subtitle
+          }
+        } : null,
+        // Title
+        {
+          type: "div",
+          props: {
+            style: {
+              fontSize: Math.min(72, Math.floor(width / (title.length * 0.6))),
+              fontWeight: 700,
+              color: "#1e293b",
+              lineHeight: 1.2,
+              maxWidth: "90%"
+            },
+            children: title
+          }
+        },
+        // Bottom accent
+        {
+          type: "div",
+          props: {
+            style: {
+              position: "absolute",
+              bottom: "60px",
+              left: "60px",
+              width: "80px",
+              height: "4px",
+              backgroundColor: brandColor
+            }
+          }
+        }
+      ].filter(Boolean)
+    }
+  };
+}
+function renderNewsTemplate({ title, options }) {
+  const {
+    width,
+    brandColor,
+    backgroundColor,
+    subtitle,
+    fontFamily
+  } = options;
+  return {
+    type: "div",
+    props: {
+      style: {
+        display: "flex",
+        flexDirection: "row",
+        width: "100%",
+        height: "100%",
+        backgroundColor,
+        fontFamily
+      },
+      children: [
+        // Left accent bar
+        {
+          type: "div",
+          props: {
+            style: {
+              width: "16px",
+              height: "100%",
+              backgroundColor: brandColor
+            }
+          }
+        },
+        // Content area
+        {
+          type: "div",
+          props: {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              justifyContent: "center",
+              flex: 1,
+              padding: "60px"
+            },
+            children: [
+              // Category badge (using flex with alignSelf since Satori doesn't support inline-flex)
+              subtitle ? {
+                type: "div",
+                props: {
+                  style: {
+                    display: "flex",
+                    alignSelf: "flex-start",
+                    backgroundColor: brandColor,
+                    color: "#ffffff",
+                    fontSize: "18px",
+                    fontWeight: 600,
+                    padding: "8px 16px",
+                    borderRadius: "4px",
+                    marginBottom: "24px",
+                    textTransform: "uppercase",
+                    letterSpacing: "1px"
+                  },
+                  children: subtitle
+                }
+              } : null,
+              // Title
+              {
+                type: "div",
+                props: {
+                  style: {
+                    fontSize: Math.min(
+                      64,
+                      Math.floor((width - 100) / (title.length * 0.5))
+                    ),
+                    fontWeight: 700,
+                    color: "#0f172a",
+                    lineHeight: 1.15
+                  },
+                  children: title
+                }
+              }
+            ].filter(Boolean)
+          }
+        }
+      ]
+    }
+  };
+}
+function renderMinimalTemplate({
+  title,
+  options
+}) {
+  const { width, brandColor, backgroundColor, fontFamily } = options;
+  return {
+    type: "div",
+    props: {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        width: "100%",
+        height: "100%",
+        backgroundColor,
+        padding: "80px",
+        fontFamily
+      },
+      children: [
+        // Decorative line
+        {
+          type: "div",
+          props: {
+            style: {
+              width: "60px",
+              height: "3px",
+              backgroundColor: brandColor,
+              marginBottom: "40px"
+            }
+          }
+        },
+        // Title
+        {
+          type: "div",
+          props: {
+            style: {
+              fontSize: Math.min(56, Math.floor(width / (title.length * 0.55))),
+              fontWeight: 600,
+              color: "#334155",
+              lineHeight: 1.3,
+              textAlign: "center",
+              maxWidth: "85%"
+            },
+            children: title
+          }
+        },
+        // Decorative line
+        {
+          type: "div",
+          props: {
+            style: {
+              width: "60px",
+              height: "3px",
+              backgroundColor: brandColor,
+              marginTop: "40px"
+            }
+          }
+        }
+      ]
+    }
+  };
+}
+async function generateHeadlineCard(title, options = {}) {
+  const width = options.width ?? 1200;
+  const height = options.height ?? 630;
+  const brandColor = options.brandColor ?? "#3b82f6";
+  const backgroundColor = options.backgroundColor ?? "#ffffff";
+  options.textColor ?? "#64748b";
+  const template = options.template ?? "default";
+  const fontFamily = options.fontFamily ?? "Inter";
+  const resolvedOptions = {
+    ...options,
+    width,
+    brandColor,
+    backgroundColor,
+    fontFamily
+  };
+  const [{ default: satori }, { Resvg }] = await Promise.all([
+    import("satori"),
+    import("@resvg/resvg-js")
+  ]);
+  const fontData = options.fontData ?? await loadGoogleFont(fontFamily);
+  let content;
+  switch (template) {
+    case "news":
+      content = renderNewsTemplate({ title, options: resolvedOptions });
+      break;
+    case "minimal":
+      content = renderMinimalTemplate({ title, options: resolvedOptions });
+      break;
+    default:
+      content = renderDefaultTemplate({ title, options: resolvedOptions });
+  }
+  const svg = await satori(content, {
+    width,
+    height,
+    fonts: [
+      {
+        name: fontFamily,
+        data: fontData,
+        weight: 400,
+        style: "normal"
+      },
+      {
+        name: fontFamily,
+        data: fontData,
+        weight: 600,
+        style: "normal"
+      },
+      {
+        name: fontFamily,
+        data: fontData,
+        weight: 700,
+        style: "normal"
+      }
+    ]
+  });
+  const resvg = new Resvg(svg, {
+    fitTo: {
+      mode: "width",
+      value: width
+    }
+  });
+  const pngData = resvg.render();
+  const buffer = Buffer.from(pngData.asPng());
+  return {
+    buffer,
+    width,
+    height,
+    mimeType: "image/png"
+  };
+}
+function resetFontCache() {
+  cachedFontData = null;
+  cachedFontName = null;
+}
+function isSharpOptions(options) {
+  return !options.type || options.type === "sharp";
+}
+function isJimpOptions(options) {
+  return options.type === "jimp";
+}
+function isImgproxyOptions(options) {
+  return options.type === "imgproxy";
+}
+function loadEnvConfig(options) {
+  if (typeof process === "undefined" || !process.env) {
+    return options;
+  }
+  const env = process.env;
+  const envDefaults = {};
+  const typeEnv = env.HAVE_IMAGES_TYPE || env.HAVE_IMAGES_ADAPTER;
+  if (typeEnv && !options.type) {
+    envDefaults.type = typeEnv;
+  }
+  if (env.HAVE_IMAGES_BASE_URL) {
+    envDefaults.baseUrl = env.HAVE_IMAGES_BASE_URL;
+  }
+  if (env.HAVE_IMAGES_KEY) {
+    envDefaults.key = env.HAVE_IMAGES_KEY;
+  }
+  if (env.HAVE_IMAGES_SALT) {
+    envDefaults.salt = env.HAVE_IMAGES_SALT;
+  }
+  return { ...envDefaults, ...options };
+}
+async function getImageProcessor(options = {}) {
+  options = loadEnvConfig(options);
+  if (isSharpOptions(options)) {
+    const { SharpAdapter: SharpAdapter2 } = await Promise.resolve().then(() => sharp);
+    return new SharpAdapter2(options);
+  }
+  if (isJimpOptions(options)) {
+    const { JimpAdapter: JimpAdapter2 } = await Promise.resolve().then(() => jimp);
+    return new JimpAdapter2(options);
+  }
+  if (isImgproxyOptions(options)) {
+    const { ImgproxyAdapter: ImgproxyAdapter2 } = await Promise.resolve().then(() => imgproxy);
+    return new ImgproxyAdapter2(options);
+  }
+  throw new InvalidAdapterError(
+    options.type || "unknown"
+  );
+}
+function getAvailableAdapters() {
+  return ["sharp", "jimp", "imgproxy"];
+}
+const factory = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getAvailableAdapters,
+  getImageProcessor
+}, Symbol.toStringTag, { value: "Module" }));
+let cachedProcessor = null;
+let detectionAttempted = false;
+async function getDefaultProcessor(adapterOptions) {
+  if (adapterOptions?.type) {
+    const { getImageProcessor: getImageProcessor2 } = await Promise.resolve().then(() => factory);
+    return getImageProcessor2(adapterOptions);
+  }
+  if (cachedProcessor && !adapterOptions) {
+    return cachedProcessor;
+  }
+  if (!detectionAttempted) {
+    detectionAttempted = true;
+    try {
+      await import("sharp");
+      const { SharpAdapter: SharpAdapter2 } = await Promise.resolve().then(() => sharp);
+      cachedProcessor = new SharpAdapter2({});
+    } catch {
+      const { JimpAdapter: JimpAdapter2 } = await Promise.resolve().then(() => jimp);
+      cachedProcessor = new JimpAdapter2({ type: "jimp" });
+    }
+  }
+  if (!cachedProcessor) {
+    throw new Error("No image processor available. Install sharp or jimp.");
+  }
+  return cachedProcessor;
+}
+function resetProcessor() {
+  cachedProcessor = null;
+  detectionAttempted = false;
+}
+async function getDimensions(input, adapterOptions) {
+  const processor = await getDefaultProcessor(adapterOptions);
+  return processor.getDimensions(input);
+}
+async function generateThumbnail(input, output, options, adapterOptions) {
+  const processor = await getDefaultProcessor(adapterOptions);
+  return processor.thumbnail(input, output, options);
+}
+async function convertFormat(input, output, options, adapterOptions) {
+  const processor = await getDefaultProcessor(adapterOptions);
+  return processor.convert(input, output, options);
+}
+async function getImageMetadata(input, adapterOptions) {
+  const processor = await getDefaultProcessor(adapterOptions);
+  return processor.getMetadata(input);
+}
+async function getImageHash(input, algorithm = "perceptual", adapterOptions) {
+  const processor = await getDefaultProcessor(adapterOptions);
+  return processor.hash(input, algorithm);
+}
+async function resizeImage(input, output, options, adapterOptions) {
+  const processor = await getDefaultProcessor(adapterOptions);
+  return processor.resize(input, output, options);
+}
+export {
+  ImageError,
+  ImageNotFoundError,
+  ImgproxyAdapter,
+  InvalidAdapterError,
+  JimpAdapter,
+  OperationNotSupportedError,
+  ProcessingError,
+  RemoteServiceError,
+  SharpAdapter,
+  UnsupportedFormatError,
+  convertFormat,
+  generateHeadlineCard,
+  generateThumbnail,
+  getAvailableAdapters,
+  getDimensions,
+  getImageHash,
+  getImageMetadata,
+  getImageProcessor,
+  resetFontCache,
+  resetProcessor,
+  resizeImage,
+  signImgproxyUrl
+};
+//# sourceMappingURL=index.js.map