@embedpdf/engines 1.0.3 → 1.0.4

package/dist/converters.cjs

@@ -1,124 +1,158 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/converters/index.ts
-var converters_exports = {};
-__export(converters_exports, {
-  browserImageDataToBlobConverter: () => browserImageDataToBlobConverter,
-  createBrowserImageDataToBlobConverter: () => createBrowserImageDataToBlobConverter,
-  createCustomImageDataToBlobConverter: () => createCustomImageDataToBlobConverter,
-  createCustomImageDataToBufferConverter: () => createCustomImageDataToBufferConverter,
-  createNodeCanvasImageDataToBlobConverter: () => createNodeCanvasImageDataToBlobConverter,
-  createNodeImageDataToBufferConverter: () => createNodeImageDataToBufferConverter
-});
-module.exports = __toCommonJS(converters_exports);
-var browserImageDataToBlobConverter = (imageData) => {
-  if (typeof OffscreenCanvas === "undefined") {
-    throw new Error(
-      "OffscreenCanvas is not available in this environment. This converter is intended for browser use only. Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js."
-    );
-  }
-  const off = new OffscreenCanvas(imageData.width, imageData.height);
-  off.getContext("2d").putImageData(imageData, 0, 0);
-  return off.convertToBlob({ type: "image/webp" });
-};
-function createBrowserImageDataToBlobConverter(imageType = "image/webp") {
-  return (imageData) => {
-    if (typeof OffscreenCanvas === "undefined") {
-      throw new Error(
-        "OffscreenCanvas is not available in this environment. This converter is intended for browser use only. Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js."
-      );
+/**
+ * Browser implementation using OffscreenCanvas
+ * This is the default implementation used in browser environments
+ */
+const browserImageDataToBlobConverter = (imageData) => {
+    // Check if we're in a browser environment
+    if (typeof OffscreenCanvas === 'undefined') {
+        throw new Error('OffscreenCanvas is not available in this environment. ' +
+            'This converter is intended for browser use only. ' +
+            'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.');
     }
     const off = new OffscreenCanvas(imageData.width, imageData.height);
-    off.getContext("2d").putImageData(imageData, 0, 0);
-    return off.convertToBlob({ type: imageType });
-  };
+    off.getContext('2d').putImageData(imageData, 0, 0);
+    return off.convertToBlob({ type: 'image/webp' });
+};
+/**
+ * Create a browser implementation with custom image type
+ */
+function createBrowserImageDataToBlobConverter(imageType = 'image/webp') {
+    return (imageData) => {
+        // Check if we're in a browser environment
+        if (typeof OffscreenCanvas === 'undefined') {
+            throw new Error('OffscreenCanvas is not available in this environment. ' +
+                'This converter is intended for browser use only. ' +
+                'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.');
+        }
+        const off = new OffscreenCanvas(imageData.width, imageData.height);
+        off.getContext('2d').putImageData(imageData, 0, 0);
+        return off.convertToBlob({ type: imageType });
+    };
 }
-function createNodeImageDataToBufferConverter(sharp, imageType = "image/webp") {
-  return async (imageData) => {
-    const { width, height, data } = imageData;
-    let sharpInstance = sharp(Buffer.from(data), {
-      raw: {
-        width,
-        height,
-        channels: 4
-        // RGBA
-      }
-    });
-    let buffer;
-    switch (imageType) {
-      case "image/webp":
-        buffer = await sharpInstance.webp().toBuffer();
-        break;
-      case "image/png":
-        buffer = await sharpInstance.png().toBuffer();
-        break;
-      case "image/jpeg":
-        buffer = await sharpInstance.flatten({ background: { r: 255, g: 255, b: 255 } }).jpeg().toBuffer();
-        break;
-      default:
-        throw new Error(`Unsupported image type: ${imageType}`);
-    }
-    return buffer;
-  };
+/**
+ * Node.js implementation using Sharp
+ * This requires the 'sharp' package to be installed
+ *
+ * @example
+ * ```typescript
+ * import sharp from 'sharp';
+ * import { createNodeImageDataToBufferConverter } from '@embedpdf/engines/pdfium/image-converters';
+ *
+ * const converter = createNodeImageDataToBufferConverter(sharp);
+ * const engine = new PdfiumEngine(pdfiumModule, logger, converter);
+ * ```
+ */
+function createNodeImageDataToBufferConverter(sharp, // Using 'any' to avoid requiring sharp as a dependency
+imageType = 'image/webp') {
+    return async (imageData) => {
+        const { width, height, data } = imageData;
+        // Convert ImageData to Sharp format
+        // ImageData uses RGBA format, Sharp expects the same
+        let sharpInstance = sharp(Buffer.from(data), {
+            raw: {
+                width,
+                height,
+                channels: 4, // RGBA
+            },
+        });
+        // Apply the appropriate format conversion based on imageType
+        let buffer;
+        switch (imageType) {
+            case 'image/webp':
+                buffer = await sharpInstance.webp().toBuffer();
+                break;
+            case 'image/png':
+                buffer = await sharpInstance.png().toBuffer();
+                break;
+            case 'image/jpeg':
+                // JPEG doesn't support transparency, so we need to composite onto a white background
+                buffer = await sharpInstance
+                    .flatten({ background: { r: 255, g: 255, b: 255 } }) // Remove alpha channel with white background
+                    .jpeg()
+                    .toBuffer();
+                break;
+            default:
+                throw new Error(`Unsupported image type: ${imageType}`);
+        }
+        return buffer;
+    };
 }
-function createNodeCanvasImageDataToBlobConverter(createCanvas, imageType = "image/webp") {
-  return async (imageData) => {
-    const { width, height } = imageData;
-    const canvas = createCanvas(width, height);
-    const ctx = canvas.getContext("2d");
-    ctx.putImageData(imageData, 0, 0);
-    let buffer;
-    switch (imageType) {
-      case "image/webp":
-        buffer = canvas.toBuffer("image/webp");
-        break;
-      case "image/png":
-        buffer = canvas.toBuffer("image/png");
-        break;
-      case "image/jpeg":
-        buffer = canvas.toBuffer("image/jpeg");
-        break;
-      default:
-        throw new Error(`Unsupported image type: ${imageType}`);
-    }
-    return buffer;
-  };
+/**
+ * Alternative Node.js implementation using canvas (node-canvas)
+ * This requires the 'canvas' package to be installed
+ *
+ * @example
+ * ```typescript
+ * import { createCanvas } from 'canvas';
+ * import { createNodeCanvasImageDataToBlobConverter } from '@embedpdf/engines/pdfium/image-converters';
+ *
+ * const converter = createNodeCanvasImageDataToBlobConverter(createCanvas, 'image/png');
+ * const engine = new PdfiumEngine(pdfiumModule, logger, converter);
+ * ```
+ */
+function createNodeCanvasImageDataToBlobConverter(createCanvas, // Using 'any' to avoid requiring canvas as a dependency
+imageType = 'image/webp') {
+    return async (imageData) => {
+        const { width, height } = imageData;
+        // Create a canvas and put the image data
+        const canvas = createCanvas(width, height);
+        const ctx = canvas.getContext('2d');
+        ctx.putImageData(imageData, 0, 0);
+        // Convert to buffer and create blob based on the requested type
+        let buffer;
+        switch (imageType) {
+            case 'image/webp':
+                buffer = canvas.toBuffer('image/webp');
+                break;
+            case 'image/png':
+                buffer = canvas.toBuffer('image/png');
+                break;
+            case 'image/jpeg':
+                buffer = canvas.toBuffer('image/jpeg');
+                break;
+            default:
+                throw new Error(`Unsupported image type: ${imageType}`);
+        }
+        return buffer;
+    };
 }
-function createCustomImageDataToBlobConverter(processor, imageType = "image/webp") {
-  return async (imageData) => {
-    const buffer = await processor(imageData);
-    return new Blob([buffer], { type: imageType });
-  };
+/**
+ * Generic Node.js implementation that works with any image processing library
+ * that can handle raw RGBA data
+ *
+ * @example
+ * ```typescript
+ * const converter = createCustomImageDataToBlobConverter(async (imageData) => {
+ *   // Your custom image processing logic here
+ *   // Return a Buffer that will be wrapped in a Blob
+ *   return processImageWithYourLibrary(imageData);
+ * });
+ * ```
+ */
+function createCustomImageDataToBlobConverter(processor, imageType = 'image/webp') {
+    return async (imageData) => {
+        const buffer = await processor(imageData);
+        return new Blob([buffer], { type: imageType });
+    };
 }
+/**
+ * Create a custom converter that returns a Buffer
+ * @param processor - function to process the image data
+ * @param imageType - image type
+ * @returns ImageDataToBlobConverter<Buffer>
+ */
 function createCustomImageDataToBufferConverter(processor) {
-  return async (imageData) => {
-    return await processor(imageData);
-  };
+    return async (imageData) => {
+        return await processor(imageData);
+    };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  browserImageDataToBlobConverter,
-  createBrowserImageDataToBlobConverter,
-  createCustomImageDataToBlobConverter,
-  createCustomImageDataToBufferConverter,
-  createNodeCanvasImageDataToBlobConverter,
-  createNodeImageDataToBufferConverter
-});
-//# sourceMappingURL=converters.cjs.map
+
+exports.browserImageDataToBlobConverter = browserImageDataToBlobConverter;
+exports.createBrowserImageDataToBlobConverter = createBrowserImageDataToBlobConverter;
+exports.createCustomImageDataToBlobConverter = createCustomImageDataToBlobConverter;
+exports.createCustomImageDataToBufferConverter = createCustomImageDataToBufferConverter;
+exports.createNodeCanvasImageDataToBlobConverter = createNodeCanvasImageDataToBlobConverter;
+exports.createNodeImageDataToBufferConverter = createNodeImageDataToBufferConverter;
+//# sourceMappingURL=converters.cjs.map

package/dist/converters.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/converters/index.ts"],"sourcesContent":["/**\n * Function type for converting ImageData to Blob\n * In browser: uses OffscreenCanvas\n * In Node.js: can use Sharp or other image processing libraries\n */\nexport type ImageDataConverter<T = Blob> = (imageData: ImageData) => Promise<T>;\n\nexport type ImageConversionTypes = 'image/webp' | 'image/png' | 'image/jpeg';\n/**\n * Browser implementation using OffscreenCanvas\n * This is the default implementation used in browser environments\n */\nexport const browserImageDataToBlobConverter: ImageDataConverter = (\n  imageData: ImageData,\n): Promise<Blob> => {\n  // Check if we're in a browser environment\n  if (typeof OffscreenCanvas === 'undefined') {\n    throw new Error(\n      'OffscreenCanvas is not available in this environment. ' +\n        'This converter is intended for browser use only. ' +\n        'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.',\n    );\n  }\n\n  const off = new OffscreenCanvas(imageData.width, imageData.height);\n  off.getContext('2d')!.putImageData(imageData, 0, 0);\n  return off.convertToBlob({ type: 'image/webp' });\n};\n\n/**\n * Create a browser implementation with custom image type\n */\nexport function createBrowserImageDataToBlobConverter(\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter {\n  return (imageData: ImageData): Promise<Blob> => {\n    // Check if we're in a browser environment\n    if (typeof OffscreenCanvas === 'undefined') {\n      throw new Error(\n        'OffscreenCanvas is not available in this environment. ' +\n          'This converter is intended for browser use only. ' +\n          'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.',\n      );\n    }\n\n    const off = new OffscreenCanvas(imageData.width, imageData.height);\n    off.getContext('2d')!.putImageData(imageData, 0, 0);\n    return off.convertToBlob({ type: imageType });\n  };\n}\n\n/**\n * Node.js implementation using Sharp\n * This requires the 'sharp' package to be installed\n *\n * @example\n * ```typescript\n * import sharp from 'sharp';\n * import { createNodeImageDataToBufferConverter } from '@embedpdf/engines/pdfium/image-converters';\n *\n * const converter = createNodeImageDataToBufferConverter(sharp);\n * const engine = new PdfiumEngine(pdfiumModule, logger, converter);\n * ```\n */\nexport function createNodeImageDataToBufferConverter(\n  sharp: any, // Using 'any' to avoid requiring sharp as a dependency\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter<Buffer> {\n  return async (imageData: ImageData): Promise<Buffer> => {\n    const { width, height, data } = imageData;\n\n    // Convert ImageData to Sharp format\n    // ImageData uses RGBA format, Sharp expects the same\n    let sharpInstance = sharp(Buffer.from(data), {\n      raw: {\n        width,\n        height,\n        channels: 4, // RGBA\n      },\n    });\n\n    // Apply the appropriate format conversion based on imageType\n    let buffer: Buffer;\n    switch (imageType) {\n      case 'image/webp':\n        buffer = await sharpInstance.webp().toBuffer();\n        break;\n      case 'image/png':\n        buffer = await sharpInstance.png().toBuffer();\n        break;\n      case 'image/jpeg':\n        // JPEG doesn't support transparency, so we need to composite onto a white background\n        buffer = await sharpInstance\n          .flatten({ background: { r: 255, g: 255, b: 255 } }) // Remove alpha channel with white background\n          .jpeg()\n          .toBuffer();\n        break;\n      default:\n        throw new Error(`Unsupported image type: ${imageType}`);\n    }\n\n    return buffer;\n  };\n}\n\n/**\n * Alternative Node.js implementation using canvas (node-canvas)\n * This requires the 'canvas' package to be installed\n *\n * @example\n * ```typescript\n * import { createCanvas } from 'canvas';\n * import { createNodeCanvasImageDataToBlobConverter } from '@embedpdf/engines/pdfium/image-converters';\n *\n * const converter = createNodeCanvasImageDataToBlobConverter(createCanvas, 'image/png');\n * const engine = new PdfiumEngine(pdfiumModule, logger, converter);\n * ```\n */\nexport function createNodeCanvasImageDataToBlobConverter(\n  createCanvas: any, // Using 'any' to avoid requiring canvas as a dependency\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter<Buffer> {\n  return async (imageData: ImageData): Promise<Buffer> => {\n    const { width, height } = imageData;\n\n    // Create a canvas and put the image data\n    const canvas = createCanvas(width, height);\n    const ctx = canvas.getContext('2d');\n    ctx.putImageData(imageData, 0, 0);\n\n    // Convert to buffer and create blob based on the requested type\n    let buffer: Buffer;\n    switch (imageType) {\n      case 'image/webp':\n        buffer = canvas.toBuffer('image/webp');\n        break;\n      case 'image/png':\n        buffer = canvas.toBuffer('image/png');\n        break;\n      case 'image/jpeg':\n        buffer = canvas.toBuffer('image/jpeg');\n        break;\n      default:\n        throw new Error(`Unsupported image type: ${imageType}`);\n    }\n\n    return buffer;\n  };\n}\n\n/**\n * Generic Node.js implementation that works with any image processing library\n * that can handle raw RGBA data\n *\n * @example\n * ```typescript\n * const converter = createCustomImageDataToBlobConverter(async (imageData) => {\n *   // Your custom image processing logic here\n *   // Return a Buffer that will be wrapped in a Blob\n *   return processImageWithYourLibrary(imageData);\n * });\n * ```\n */\nexport function createCustomImageDataToBlobConverter(\n  processor: (imageData: ImageData) => Promise<Buffer>,\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter {\n  return async (imageData: ImageData): Promise<Blob> => {\n    const buffer = await processor(imageData);\n    return new Blob([buffer], { type: imageType });\n  };\n}\n\n/**\n * Create a custom converter that returns a Buffer\n * @param processor - function to process the image data\n * @param imageType - image type\n * @returns ImageDataToBlobConverter<Buffer>\n */\nexport function createCustomImageDataToBufferConverter(\n  processor: (imageData: ImageData) => Promise<Buffer>,\n): ImageDataConverter<Buffer> {\n  return async (imageData: ImageData): Promise<Buffer> => {\n    return await processor(imageData);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,IAAM,kCAAsD,CACjE,cACkB;AAElB,MAAI,OAAO,oBAAoB,aAAa;AAC1C,UAAM,IAAI;AAAA,MACR;AAAA,IAGF;AAAA,EACF;AAEA,QAAM,MAAM,IAAI,gBAAgB,UAAU,OAAO,UAAU,MAAM;AACjE,MAAI,WAAW,IAAI,EAAG,aAAa,WAAW,GAAG,CAAC;AAClD,SAAO,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AACjD;AAKO,SAAS,sCACd,YAAkC,cACd;AACpB,SAAO,CAAC,cAAwC;AAE9C,QAAI,OAAO,oBAAoB,aAAa;AAC1C,YAAM,IAAI;AAAA,QACR;AAAA,MAGF;AAAA,IACF;AAEA,UAAM,MAAM,IAAI,gBAAgB,UAAU,OAAO,UAAU,MAAM;AACjE,QAAI,WAAW,IAAI,EAAG,aAAa,WAAW,GAAG,CAAC;AAClD,WAAO,IAAI,cAAc,EAAE,MAAM,UAAU,CAAC;AAAA,EAC9C;AACF;AAeO,SAAS,qCACd,OACA,YAAkC,cACN;AAC5B,SAAO,OAAO,cAA0C;AACtD,UAAM,EAAE,OAAO,QAAQ,KAAK,IAAI;AAIhC,QAAI,gBAAgB,MAAM,OAAO,KAAK,IAAI,GAAG;AAAA,MAC3C,KAAK;AAAA,QACH;AAAA,QACA;AAAA,QACA,UAAU;AAAA;AAAA,MACZ;AAAA,IACF,CAAC;AAGD,QAAI;AACJ,YAAQ,WAAW;AAAA,MACjB,KAAK;AACH,iBAAS,MAAM,cAAc,KAAK,EAAE,SAAS;AAC7C;AAAA,MACF,KAAK;AACH,iBAAS,MAAM,cAAc,IAAI,EAAE,SAAS;AAC5C;AAAA,MACF,KAAK;AAEH,iBAAS,MAAM,cACZ,QAAQ,EAAE,YAAY,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,EAAE,CAAC,EAClD,KAAK,EACL,SAAS;AACZ;AAAA,MACF;AACE,cAAM,IAAI,MAAM,2BAA2B,SAAS,EAAE;AAAA,IAC1D;AAEA,WAAO;AAAA,EACT;AACF;AAeO,SAAS,yCACd,cACA,YAAkC,cACN;AAC5B,SAAO,OAAO,cAA0C;AACtD,UAAM,EAAE,OAAO,OAAO,IAAI;AAG1B,UAAM,SAAS,aAAa,OAAO,MAAM;AACzC,UAAM,MAAM,OAAO,WAAW,IAAI;AAClC,QAAI,aAAa,WAAW,GAAG,CAAC;AAGhC,QAAI;AACJ,YAAQ,WAAW;AAAA,MACjB,KAAK;AACH,iBAAS,OAAO,SAAS,YAAY;AACrC;AAAA,MACF,KAAK;AACH,iBAAS,OAAO,SAAS,WAAW;AACpC;AAAA,MACF,KAAK;AACH,iBAAS,OAAO,SAAS,YAAY;AACrC;AAAA,MACF;AACE,cAAM,IAAI,MAAM,2BAA2B,SAAS,EAAE;AAAA,IAC1D;AAEA,WAAO;AAAA,EACT;AACF;AAeO,SAAS,qCACd,WACA,YAAkC,cACd;AACpB,SAAO,OAAO,cAAwC;AACpD,UAAM,SAAS,MAAM,UAAU,SAAS;AACxC,WAAO,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,MAAM,UAAU,CAAC;AAAA,EAC/C;AACF;AAQO,SAAS,uCACd,WAC4B;AAC5B,SAAO,OAAO,cAA0C;AACtD,WAAO,MAAM,UAAU,SAAS;AAAA,EAClC;AACF;","names":[]}
+{"version":3,"file":"converters.cjs","sources":["../src/lib/converters/index.ts"],"sourcesContent":["/**\n * Function type for converting ImageData to Blob\n * In browser: uses OffscreenCanvas\n * In Node.js: can use Sharp or other image processing libraries\n */\nexport type ImageDataConverter<T = Blob> = (imageData: ImageData) => Promise<T>;\n\nexport type ImageConversionTypes = 'image/webp' | 'image/png' | 'image/jpeg';\n/**\n * Browser implementation using OffscreenCanvas\n * This is the default implementation used in browser environments\n */\nexport const browserImageDataToBlobConverter: ImageDataConverter = (\n  imageData: ImageData,\n): Promise<Blob> => {\n  // Check if we're in a browser environment\n  if (typeof OffscreenCanvas === 'undefined') {\n    throw new Error(\n      'OffscreenCanvas is not available in this environment. ' +\n        'This converter is intended for browser use only. ' +\n        'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.',\n    );\n  }\n\n  const off = new OffscreenCanvas(imageData.width, imageData.height);\n  off.getContext('2d')!.putImageData(imageData, 0, 0);\n  return off.convertToBlob({ type: 'image/webp' });\n};\n\n/**\n * Create a browser implementation with custom image type\n */\nexport function createBrowserImageDataToBlobConverter(\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter {\n  return (imageData: ImageData): Promise<Blob> => {\n    // Check if we're in a browser environment\n    if (typeof OffscreenCanvas === 'undefined') {\n      throw new Error(\n        'OffscreenCanvas is not available in this environment. ' +\n          'This converter is intended for browser use only. ' +\n          'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.',\n      );\n    }\n\n    const off = new OffscreenCanvas(imageData.width, imageData.height);\n    off.getContext('2d')!.putImageData(imageData, 0, 0);\n    return off.convertToBlob({ type: imageType });\n  };\n}\n\n/**\n * Node.js implementation using Sharp\n * This requires the 'sharp' package to be installed\n *\n * @example\n * ```typescript\n * import sharp from 'sharp';\n * import { createNodeImageDataToBufferConverter } from '@embedpdf/engines/pdfium/image-converters';\n *\n * const converter = createNodeImageDataToBufferConverter(sharp);\n * const engine = new PdfiumEngine(pdfiumModule, logger, converter);\n * ```\n */\nexport function createNodeImageDataToBufferConverter(\n  sharp: any, // Using 'any' to avoid requiring sharp as a dependency\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter<Buffer> {\n  return async (imageData: ImageData): Promise<Buffer> => {\n    const { width, height, data } = imageData;\n\n    // Convert ImageData to Sharp format\n    // ImageData uses RGBA format, Sharp expects the same\n    let sharpInstance = sharp(Buffer.from(data), {\n      raw: {\n        width,\n        height,\n        channels: 4, // RGBA\n      },\n    });\n\n    // Apply the appropriate format conversion based on imageType\n    let buffer: Buffer;\n    switch (imageType) {\n      case 'image/webp':\n        buffer = await sharpInstance.webp().toBuffer();\n        break;\n      case 'image/png':\n        buffer = await sharpInstance.png().toBuffer();\n        break;\n      case 'image/jpeg':\n        // JPEG doesn't support transparency, so we need to composite onto a white background\n        buffer = await sharpInstance\n          .flatten({ background: { r: 255, g: 255, b: 255 } }) // Remove alpha channel with white background\n          .jpeg()\n          .toBuffer();\n        break;\n      default:\n        throw new Error(`Unsupported image type: ${imageType}`);\n    }\n\n    return buffer;\n  };\n}\n\n/**\n * Alternative Node.js implementation using canvas (node-canvas)\n * This requires the 'canvas' package to be installed\n *\n * @example\n * ```typescript\n * import { createCanvas } from 'canvas';\n * import { createNodeCanvasImageDataToBlobConverter } from '@embedpdf/engines/pdfium/image-converters';\n *\n * const converter = createNodeCanvasImageDataToBlobConverter(createCanvas, 'image/png');\n * const engine = new PdfiumEngine(pdfiumModule, logger, converter);\n * ```\n */\nexport function createNodeCanvasImageDataToBlobConverter(\n  createCanvas: any, // Using 'any' to avoid requiring canvas as a dependency\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter<Buffer> {\n  return async (imageData: ImageData): Promise<Buffer> => {\n    const { width, height } = imageData;\n\n    // Create a canvas and put the image data\n    const canvas = createCanvas(width, height);\n    const ctx = canvas.getContext('2d');\n    ctx.putImageData(imageData, 0, 0);\n\n    // Convert to buffer and create blob based on the requested type\n    let buffer: Buffer;\n    switch (imageType) {\n      case 'image/webp':\n        buffer = canvas.toBuffer('image/webp');\n        break;\n      case 'image/png':\n        buffer = canvas.toBuffer('image/png');\n        break;\n      case 'image/jpeg':\n        buffer = canvas.toBuffer('image/jpeg');\n        break;\n      default:\n        throw new Error(`Unsupported image type: ${imageType}`);\n    }\n\n    return buffer;\n  };\n}\n\n/**\n * Generic Node.js implementation that works with any image processing library\n * that can handle raw RGBA data\n *\n * @example\n * ```typescript\n * const converter = createCustomImageDataToBlobConverter(async (imageData) => {\n *   // Your custom image processing logic here\n *   // Return a Buffer that will be wrapped in a Blob\n *   return processImageWithYourLibrary(imageData);\n * });\n * ```\n */\nexport function createCustomImageDataToBlobConverter(\n  processor: (imageData: ImageData) => Promise<Buffer>,\n  imageType: ImageConversionTypes = 'image/webp',\n): ImageDataConverter {\n  return async (imageData: ImageData): Promise<Blob> => {\n    const buffer = await processor(imageData);\n    return new Blob([buffer], { type: imageType });\n  };\n}\n\n/**\n * Create a custom converter that returns a Buffer\n * @param processor - function to process the image data\n * @param imageType - image type\n * @returns ImageDataToBlobConverter<Buffer>\n */\nexport function createCustomImageDataToBufferConverter(\n  processor: (imageData: ImageData) => Promise<Buffer>,\n): ImageDataConverter<Buffer> {\n  return async (imageData: ImageData): Promise<Buffer> => {\n    return await processor(imageData);\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/converters.d.ts

@@ -66,4 +66,5 @@ declare function createCustomImageDataToBlobConverter(processor: (imageData: Ima
  */
 declare function createCustomImageDataToBufferConverter(processor: (imageData: ImageData) => Promise<Buffer>): ImageDataConverter<Buffer>;
 
-export { type ImageConversionTypes, type ImageDataConverter, browserImageDataToBlobConverter, createBrowserImageDataToBlobConverter, createCustomImageDataToBlobConverter, createCustomImageDataToBufferConverter, createNodeCanvasImageDataToBlobConverter, createNodeImageDataToBufferConverter };
+export { browserImageDataToBlobConverter, createBrowserImageDataToBlobConverter, createCustomImageDataToBlobConverter, createCustomImageDataToBufferConverter, createNodeCanvasImageDataToBlobConverter, createNodeImageDataToBufferConverter };
+export type { ImageConversionTypes, ImageDataConverter };

package/dist/converters.js

@@ -1,94 +1,151 @@
-// src/converters/index.ts
-var browserImageDataToBlobConverter = (imageData) => {
-  if (typeof OffscreenCanvas === "undefined") {
-    throw new Error(
-      "OffscreenCanvas is not available in this environment. This converter is intended for browser use only. Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js."
-    );
-  }
-  const off = new OffscreenCanvas(imageData.width, imageData.height);
-  off.getContext("2d").putImageData(imageData, 0, 0);
-  return off.convertToBlob({ type: "image/webp" });
-};
-function createBrowserImageDataToBlobConverter(imageType = "image/webp") {
-  return (imageData) => {
-    if (typeof OffscreenCanvas === "undefined") {
-      throw new Error(
-        "OffscreenCanvas is not available in this environment. This converter is intended for browser use only. Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js."
-      );
+/**
+ * Browser implementation using OffscreenCanvas
+ * This is the default implementation used in browser environments
+ */
+const browserImageDataToBlobConverter = (imageData) => {
+    // Check if we're in a browser environment
+    if (typeof OffscreenCanvas === 'undefined') {
+        throw new Error('OffscreenCanvas is not available in this environment. ' +
+            'This converter is intended for browser use only. ' +
+            'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.');
     }
     const off = new OffscreenCanvas(imageData.width, imageData.height);
-    off.getContext("2d").putImageData(imageData, 0, 0);
-    return off.convertToBlob({ type: imageType });
-  };
+    off.getContext('2d').putImageData(imageData, 0, 0);
+    return off.convertToBlob({ type: 'image/webp' });
+};
+/**
+ * Create a browser implementation with custom image type
+ */
+function createBrowserImageDataToBlobConverter(imageType = 'image/webp') {
+    return (imageData) => {
+        // Check if we're in a browser environment
+        if (typeof OffscreenCanvas === 'undefined') {
+            throw new Error('OffscreenCanvas is not available in this environment. ' +
+                'This converter is intended for browser use only. ' +
+                'Please use createNodeImageDataToBlobConverter() or createNodeCanvasImageDataToBlobConverter() for Node.js.');
+        }
+        const off = new OffscreenCanvas(imageData.width, imageData.height);
+        off.getContext('2d').putImageData(imageData, 0, 0);
+        return off.convertToBlob({ type: imageType });
+    };
 }
-function createNodeImageDataToBufferConverter(sharp, imageType = "image/webp") {
-  return async (imageData) => {
-    const { width, height, data } = imageData;
-    let sharpInstance = sharp(Buffer.from(data), {
-      raw: {
-        width,
-        height,
-        channels: 4
-        // RGBA
-      }
-    });
-    let buffer;
-    switch (imageType) {
-      case "image/webp":
-        buffer = await sharpInstance.webp().toBuffer();
-        break;
-      case "image/png":
-        buffer = await sharpInstance.png().toBuffer();
-        break;
-      case "image/jpeg":
-        buffer = await sharpInstance.flatten({ background: { r: 255, g: 255, b: 255 } }).jpeg().toBuffer();
-        break;
-      default:
-        throw new Error(`Unsupported image type: ${imageType}`);
-    }
-    return buffer;
-  };
+/**
+ * Node.js implementation using Sharp
+ * This requires the 'sharp' package to be installed
+ *
+ * @example
+ * ```typescript
+ * import sharp from 'sharp';
+ * import { createNodeImageDataToBufferConverter } from '@embedpdf/engines/pdfium/image-converters';
+ *
+ * const converter = createNodeImageDataToBufferConverter(sharp);
+ * const engine = new PdfiumEngine(pdfiumModule, logger, converter);
+ * ```
+ */
+function createNodeImageDataToBufferConverter(sharp, // Using 'any' to avoid requiring sharp as a dependency
+imageType = 'image/webp') {
+    return async (imageData) => {
+        const { width, height, data } = imageData;
+        // Convert ImageData to Sharp format
+        // ImageData uses RGBA format, Sharp expects the same
+        let sharpInstance = sharp(Buffer.from(data), {
+            raw: {
+                width,
+                height,
+                channels: 4, // RGBA
+            },
+        });
+        // Apply the appropriate format conversion based on imageType
+        let buffer;
+        switch (imageType) {
+            case 'image/webp':
+                buffer = await sharpInstance.webp().toBuffer();
+                break;
+            case 'image/png':
+                buffer = await sharpInstance.png().toBuffer();
+                break;
+            case 'image/jpeg':
+                // JPEG doesn't support transparency, so we need to composite onto a white background
+                buffer = await sharpInstance
+                    .flatten({ background: { r: 255, g: 255, b: 255 } }) // Remove alpha channel with white background
+                    .jpeg()
+                    .toBuffer();
+                break;
+            default:
+                throw new Error(`Unsupported image type: ${imageType}`);
+        }
+        return buffer;
+    };
 }
-function createNodeCanvasImageDataToBlobConverter(createCanvas, imageType = "image/webp") {
-  return async (imageData) => {
-    const { width, height } = imageData;
-    const canvas = createCanvas(width, height);
-    const ctx = canvas.getContext("2d");
-    ctx.putImageData(imageData, 0, 0);
-    let buffer;
-    switch (imageType) {
-      case "image/webp":
-        buffer = canvas.toBuffer("image/webp");
-        break;
-      case "image/png":
-        buffer = canvas.toBuffer("image/png");
-        break;
-      case "image/jpeg":
-        buffer = canvas.toBuffer("image/jpeg");
-        break;
-      default:
-        throw new Error(`Unsupported image type: ${imageType}`);
-    }
-    return buffer;
-  };
+/**
+ * Alternative Node.js implementation using canvas (node-canvas)
+ * This requires the 'canvas' package to be installed
+ *
+ * @example
+ * ```typescript
+ * import { createCanvas } from 'canvas';
+ * import { createNodeCanvasImageDataToBlobConverter } from '@embedpdf/engines/pdfium/image-converters';
+ *
+ * const converter = createNodeCanvasImageDataToBlobConverter(createCanvas, 'image/png');
+ * const engine = new PdfiumEngine(pdfiumModule, logger, converter);
+ * ```
+ */
+function createNodeCanvasImageDataToBlobConverter(createCanvas, // Using 'any' to avoid requiring canvas as a dependency
+imageType = 'image/webp') {
+    return async (imageData) => {
+        const { width, height } = imageData;
+        // Create a canvas and put the image data
+        const canvas = createCanvas(width, height);
+        const ctx = canvas.getContext('2d');
+        ctx.putImageData(imageData, 0, 0);
+        // Convert to buffer and create blob based on the requested type
+        let buffer;
+        switch (imageType) {
+            case 'image/webp':
+                buffer = canvas.toBuffer('image/webp');
+                break;
+            case 'image/png':
+                buffer = canvas.toBuffer('image/png');
+                break;
+            case 'image/jpeg':
+                buffer = canvas.toBuffer('image/jpeg');
+                break;
+            default:
+                throw new Error(`Unsupported image type: ${imageType}`);
+        }
+        return buffer;
+    };
 }
-function createCustomImageDataToBlobConverter(processor, imageType = "image/webp") {
-  return async (imageData) => {
-    const buffer = await processor(imageData);
-    return new Blob([buffer], { type: imageType });
-  };
+/**
+ * Generic Node.js implementation that works with any image processing library
+ * that can handle raw RGBA data
+ *
+ * @example
+ * ```typescript
+ * const converter = createCustomImageDataToBlobConverter(async (imageData) => {
+ *   // Your custom image processing logic here
+ *   // Return a Buffer that will be wrapped in a Blob
+ *   return processImageWithYourLibrary(imageData);
+ * });
+ * ```
+ */
+function createCustomImageDataToBlobConverter(processor, imageType = 'image/webp') {
+    return async (imageData) => {
+        const buffer = await processor(imageData);
+        return new Blob([buffer], { type: imageType });
+    };
 }
+/**
+ * Create a custom converter that returns a Buffer
+ * @param processor - function to process the image data
+ * @param imageType - image type
+ * @returns ImageDataToBlobConverter<Buffer>
+ */
 function createCustomImageDataToBufferConverter(processor) {
-  return async (imageData) => {
-    return await processor(imageData);
-  };
+    return async (imageData) => {
+        return await processor(imageData);
+    };
 }
-export {
-  browserImageDataToBlobConverter,
-  createBrowserImageDataToBlobConverter,
-  createCustomImageDataToBlobConverter,
-  createCustomImageDataToBufferConverter,
-  createNodeCanvasImageDataToBlobConverter,
-  createNodeImageDataToBufferConverter
-};
-//# sourceMappingURL=converters.js.map
+
+export { browserImageDataToBlobConverter, createBrowserImageDataToBlobConverter, createCustomImageDataToBlobConverter, createCustomImageDataToBufferConverter, createNodeCanvasImageDataToBlobConverter, createNodeImageDataToBufferConverter };
+//# sourceMappingURL=converters.js.map