@embedpdf/engines 1.0.10 → 1.0.12

package/dist/lib/converters/index.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});exports.browserImageDataToBlobConverter=(e,t="image/webp")=>{if("undefined"==typeof OffscreenCanvas)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 a=new OffscreenCanvas(e.width,e.height);return a.getContext("2d").putImageData(e,0,0),a.convertToBlob({type:t})},exports.createCustomImageDataToBlobConverter=function(e){return async(t,a="image/webp")=>{const r=await e(t);return new Blob([r],{type:a})}},exports.createCustomImageDataToBufferConverter=function(e){return async(t,a="image/webp")=>await e(t,a)},exports.createNodeCanvasImageDataToBlobConverter=function(e){return async(t,a="image/webp")=>{const{width:r,height:o}=t,n=e(r,o);let i;switch(n.getContext("2d").putImageData(t,0,0),a){case"image/webp":i=n.toBuffer("image/webp");break;case"image/png":i=n.toBuffer("image/png");break;case"image/jpeg":i=n.toBuffer("image/jpeg");break;default:throw new Error(`Unsupported image type: ${a}`)}return i}},exports.createNodeImageDataToBufferConverter=function(e){return async(t,a="image/webp")=>{const{width:r,height:o,data:n}=t;let i,s=e(Buffer.from(n),{raw:{width:r,height:o,channels:4}});switch(a){case"image/webp":i=await s.webp().toBuffer();break;case"image/png":i=await s.png().toBuffer();break;case"image/jpeg":i=await s.flatten({background:{r:255,g:255,b:255}}).jpeg().toBuffer();break;default:throw new Error(`Unsupported image type: ${a}`)}return i}};
+//# sourceMappingURL=index.cjs.map

package/dist/lib/converters/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.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> = (\n  imageData: ImageData,\n  imageType?: ImageConversionTypes,\n) => 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  imageType: ImageConversionTypes = 'image/webp',\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: imageType });\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): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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): ImageDataConverter {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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, imageType: ImageConversionTypes) => Promise<Buffer>,\n): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): Promise<Buffer> => {\n    return await processor(imageData, imageType);\n  };\n}\n"],"names":["imageData","imageType","OffscreenCanvas","Error","off","width","height","getContext","putImageData","convertToBlob","type","processor","async","buffer","Blob","createCanvas","canvas","toBuffer","sharp","data","sharpInstance","Buffer","from","raw","channels","webp","png","flatten","background","r","g","b","jpeg"],"mappings":"wHAemE,CACjEA,EACAC,EAAkC,gBAG9B,GAA2B,oBAApBC,gBACT,MAAM,IAAIC,MACR,qNAMJ,MAAMC,EAAM,IAAIF,gBAAgBF,EAAUK,MAAOL,EAAUM,QAE3D,OADAF,EAAIG,WAAW,MAAOC,aAAaR,EAAW,EAAG,GAC1CI,EAAIK,cAAc,CAAEC,KAAMT,GAAW,+CAuHvC,SACLU,GAEO,OAAAC,MACLZ,EACAC,EAAkC,gBAE5B,MAAAY,QAAeF,EAAUX,GACxB,OAAA,IAAIc,KAAK,CAACD,GAAS,CAAEH,KAAMT,GAAW,CAEjD,iDAQO,SACLU,GAEO,OAAAC,MACLZ,EACAC,EAAkC,qBAErBU,EAAUX,EAAWC,EAEtC,mDA1EO,SACLc,GAEO,OAAAH,MACLZ,EACAC,EAAkC,gBAE5B,MAAAI,MAAEA,EAAOC,OAAAA,GAAWN,EAGpBgB,EAASD,EAAaV,EAAOC,GAK/B,IAAAO,EACJ,OALYG,EAAOT,WAAW,MAC1BC,aAAaR,EAAW,EAAG,GAIvBC,GACN,IAAK,aACMY,EAAAG,EAAOC,SAAS,cACzB,MACF,IAAK,YACMJ,EAAAG,EAAOC,SAAS,aACzB,MACF,IAAK,aACMJ,EAAAG,EAAOC,SAAS,cACzB,MACF,QACE,MAAM,IAAId,MAAM,2BAA2BF,KAGxC,OAAAY,CAAA,CAEX,+CAxFO,SACLK,GAEO,OAAAN,MACLZ,EACAC,EAAkC,gBAElC,MAAMI,MAAEA,EAAAC,OAAOA,EAAQa,KAAAA,GAASnB,EAIhC,IASIa,EATAO,EAAgBF,EAAMG,OAAOC,KAAKH,GAAO,CAC3CI,IAAK,CACHlB,QACAC,SACAkB,SAAU,KAMd,OAAQvB,GACN,IAAK,aACHY,QAAeO,EAAcK,OAAOR,WACpC,MACF,IAAK,YACHJ,QAAeO,EAAcM,MAAMT,WACnC,MACF,IAAK,aAEHJ,QAAeO,EACZO,QAAQ,CAAEC,WAAY,CAAEC,EAAG,IAAKC,EAAG,IAAKC,EAAG,OAC3CC,OACAf,WACH,MACF,QACE,MAAM,IAAId,MAAM,2BAA2BF,KAGxC,OAAAY,CAAA,CAEX"}

package/dist/{converters.d.ts → lib/converters/index.d.ts}

@@ -3,13 +3,13 @@
  * In browser: uses OffscreenCanvas
  * In Node.js: can use Sharp or other image processing libraries
  */
-type ImageDataConverter<T = Blob> = (imageData: ImageData, imageType?: ImageConversionTypes) => Promise<T>;
-type ImageConversionTypes = 'image/webp' | 'image/png' | 'image/jpeg';
+export type ImageDataConverter<T = Blob> = (imageData: ImageData, imageType?: ImageConversionTypes) => Promise<T>;
+export type ImageConversionTypes = 'image/webp' | 'image/png' | 'image/jpeg';
 /**
  * Browser implementation using OffscreenCanvas
  * This is the default implementation used in browser environments
  */
-declare const browserImageDataToBlobConverter: ImageDataConverter;
+export declare const browserImageDataToBlobConverter: ImageDataConverter;
 /**
  * Node.js implementation using Sharp
  * This requires the 'sharp' package to be installed
@@ -23,7 +23,7 @@ declare const browserImageDataToBlobConverter: ImageDataConverter;
  * const engine = new PdfiumEngine(pdfiumModule, logger, converter);
  * ```
  */
-declare function createNodeImageDataToBufferConverter(sharp: any): ImageDataConverter<Buffer>;
+export declare function createNodeImageDataToBufferConverter(sharp: any): ImageDataConverter<Buffer>;
 /**
  * Alternative Node.js implementation using canvas (node-canvas)
  * This requires the 'canvas' package to be installed
@@ -37,7 +37,7 @@ declare function createNodeImageDataToBufferConverter(sharp: any): ImageDataConv
  * const engine = new PdfiumEngine(pdfiumModule, logger, converter);
  * ```
  */
-declare function createNodeCanvasImageDataToBlobConverter(createCanvas: any): ImageDataConverter<Buffer>;
+export declare function createNodeCanvasImageDataToBlobConverter(createCanvas: any): ImageDataConverter<Buffer>;
 /**
  * Generic Node.js implementation that works with any image processing library
  * that can handle raw RGBA data
@@ -51,14 +51,11 @@ declare function createNodeCanvasImageDataToBlobConverter(createCanvas: any): Im
  * });
  * ```
  */
-declare function createCustomImageDataToBlobConverter(processor: (imageData: ImageData) => Promise<Buffer>): ImageDataConverter;
+export declare function createCustomImageDataToBlobConverter(processor: (imageData: ImageData) => Promise<Buffer>): ImageDataConverter;
 /**
  * Create a custom converter that returns a Buffer
  * @param processor - function to process the image data
  * @param imageType - image type
  * @returns ImageDataToBlobConverter<Buffer>
  */
-declare function createCustomImageDataToBufferConverter(processor: (imageData: ImageData, imageType: ImageConversionTypes) => Promise<Buffer>): ImageDataConverter<Buffer>;
-
-export { browserImageDataToBlobConverter, createCustomImageDataToBlobConverter, createCustomImageDataToBufferConverter, createNodeCanvasImageDataToBlobConverter, createNodeImageDataToBufferConverter };
-export type { ImageConversionTypes, ImageDataConverter };
+export declare function createCustomImageDataToBufferConverter(processor: (imageData: ImageData, imageType: ImageConversionTypes) => Promise<Buffer>): ImageDataConverter<Buffer>;

package/dist/lib/converters/index.js

@@ -0,0 +1,80 @@
+const browserImageDataToBlobConverter = (imageData, imageType = "image/webp") => {
+  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) {
+  return async (imageData, imageType = "image/webp") => {
+    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;
+  };
+}
+function createNodeCanvasImageDataToBlobConverter(createCanvas) {
+  return async (imageData, imageType = "image/webp") => {
+    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;
+  };
+}
+function createCustomImageDataToBlobConverter(processor) {
+  return async (imageData, imageType = "image/webp") => {
+    const buffer = await processor(imageData);
+    return new Blob([buffer], { type: imageType });
+  };
+}
+function createCustomImageDataToBufferConverter(processor) {
+  return async (imageData, imageType = "image/webp") => {
+    return await processor(imageData, imageType);
+  };
+}
+export {
+  browserImageDataToBlobConverter,
+  createCustomImageDataToBlobConverter,
+  createCustomImageDataToBufferConverter,
+  createNodeCanvasImageDataToBlobConverter,
+  createNodeImageDataToBufferConverter
+};
+//# sourceMappingURL=index.js.map

package/dist/{converters.cjs.map → lib/converters/index.js.map}

@@ -1 +1 @@
-{"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> = (\n  imageData: ImageData,\n  imageType?: ImageConversionTypes,\n) => 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  imageType: ImageConversionTypes = 'image/webp',\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: imageType });\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): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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): ImageDataConverter {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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, imageType: ImageConversionTypes) => Promise<Buffer>,\n): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): Promise<Buffer> => {\n    return await processor(imageData, imageType);\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","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> = (\n  imageData: ImageData,\n  imageType?: ImageConversionTypes,\n) => 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  imageType: ImageConversionTypes = 'image/webp',\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: imageType });\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): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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): ImageDataConverter {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): 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, imageType: ImageConversionTypes) => Promise<Buffer>,\n): ImageDataConverter<Buffer> {\n  return async (\n    imageData: ImageData,\n    imageType: ImageConversionTypes = 'image/webp',\n  ): Promise<Buffer> => {\n    return await processor(imageData, imageType);\n  };\n}\n"],"names":[],"mappings":"AAeO,MAAM,kCAAsD,CACjE,WACA,YAAkC,iBAChB;AAEd,MAAA,OAAO,oBAAoB,aAAa;AAC1C,UAAM,IAAI;AAAA,MACR;AAAA,IAGF;AAAA,EAAA;AAGF,QAAM,MAAM,IAAI,gBAAgB,UAAU,OAAO,UAAU,MAAM;AACjE,MAAI,WAAW,IAAI,EAAG,aAAa,WAAW,GAAG,CAAC;AAClD,SAAO,IAAI,cAAc,EAAE,MAAM,WAAW;AAC9C;AAeO,SAAS,qCACd,OAC4B;AACrB,SAAA,OACL,WACA,YAAkC,iBACd;AACpB,UAAM,EAAE,OAAO,QAAQ,KAAS,IAAA;AAIhC,QAAI,gBAAgB,MAAM,OAAO,KAAK,IAAI,GAAG;AAAA,MAC3C,KAAK;AAAA,QACH;AAAA,QACA;AAAA,QACA,UAAU;AAAA;AAAA,MAAA;AAAA,IACZ,CACD;AAGG,QAAA;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,EAAG,CAAA,EAClD,OACA,SAAS;AACZ;AAAA,MACF;AACE,cAAM,IAAI,MAAM,2BAA2B,SAAS,EAAE;AAAA,IAAA;AAGnD,WAAA;AAAA,EACT;AACF;AAeO,SAAS,yCACd,cAC4B;AACrB,SAAA,OACL,WACA,YAAkC,iBACd;AACd,UAAA,EAAE,OAAO,OAAA,IAAW;AAGpB,UAAA,SAAS,aAAa,OAAO,MAAM;AACnC,UAAA,MAAM,OAAO,WAAW,IAAI;AAC9B,QAAA,aAAa,WAAW,GAAG,CAAC;AAG5B,QAAA;AACJ,YAAQ,WAAW;AAAA,MACjB,KAAK;AACM,iBAAA,OAAO,SAAS,YAAY;AACrC;AAAA,MACF,KAAK;AACM,iBAAA,OAAO,SAAS,WAAW;AACpC;AAAA,MACF,KAAK;AACM,iBAAA,OAAO,SAAS,YAAY;AACrC;AAAA,MACF;AACE,cAAM,IAAI,MAAM,2BAA2B,SAAS,EAAE;AAAA,IAAA;AAGnD,WAAA;AAAA,EACT;AACF;AAeO,SAAS,qCACd,WACoB;AACb,SAAA,OACL,WACA,YAAkC,iBAChB;AACZ,UAAA,SAAS,MAAM,UAAU,SAAS;AACjC,WAAA,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,MAAM,WAAW;AAAA,EAC/C;AACF;AAQO,SAAS,uCACd,WAC4B;AACrB,SAAA,OACL,WACA,YAAkC,iBACd;AACb,WAAA,MAAM,UAAU,WAAW,SAAS;AAAA,EAC7C;AACF;"}

package/dist/lib/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Docs for `@embedpdf/engines` module
+ * @packageDocumentation
+ */
+export * from './pdfium';
+export * from './webworker';
+export * from './mock';

package/dist/lib/mock/index.d.ts

@@ -0,0 +1,25 @@
+import { PdfDocumentObject, PdfEngine, PdfFile } from '@embedpdf/models';
+/**
+ * Create mock of pdf engine
+ * @param partialEngine - partial configuration of engine
+ * @returns - mock of pdf engine
+ *
+ * @public
+ */
+export declare function createMockPdfEngine(partialEngine?: Partial<PdfEngine>): PdfEngine;
+/**
+ * Create mock of pdf document
+ * @param doc - partial configuration of document
+ * @returns mock of pdf document
+ *
+ * @public
+ */
+export declare function createMockPdfDocument(doc?: Partial<PdfDocumentObject>): PdfDocumentObject;
+/**
+ * Create mock of pdf file
+ * @param file - partial configuration of file
+ * @returns mock of pdf file
+ *
+ * @public
+ */
+export declare function createMockPdfFile(file?: Partial<PdfFile>): PdfFile;

package/dist/lib/pdfium/cache.d.ts

@@ -0,0 +1,62 @@
+import { WrappedPdfiumModule } from '@embedpdf/pdfium';
+export declare class PdfCache {
+    private readonly pdfium;
+    private readonly docs;
+    constructor(pdfium: WrappedPdfiumModule);
+    /** Open (or re-use) a document */
+    setDocument(id: string, filePtr: number, docPtr: number): void;
+    /** Retrieve the DocumentContext for a given PdfDocumentObject */
+    getContext(docId: string): DocumentContext | undefined;
+    /** Close & fully release a document and all its pages */
+    closeDocument(docId: string): boolean;
+}
+export declare class DocumentContext {
+    readonly filePtr: number;
+    readonly docPtr: number;
+    private readonly pageCache;
+    constructor(filePtr: number, docPtr: number, pdfium: WrappedPdfiumModule);
+    /** Main accessor for pages */
+    acquirePage(pageIdx: number): PageContext;
+    /** Tear down all pages + this document */
+    dispose(): void;
+}
+export declare class PageCache {
+    readonly pdf: WrappedPdfiumModule;
+    private readonly docPtr;
+    private readonly cache;
+    constructor(pdf: WrappedPdfiumModule, docPtr: number);
+    acquire(pageIdx: number): PageContext;
+    forceReleaseAll(): void;
+}
+export declare class PageContext {
+    private readonly pdf;
+    readonly docPtr: number;
+    readonly pageIdx: number;
+    readonly pagePtr: number;
+    private readonly onFinalDispose;
+    private refCount;
+    private expiryTimer?;
+    private disposed;
+    private textPagePtr?;
+    private formInfoPtr?;
+    private formHandle?;
+    constructor(pdf: WrappedPdfiumModule, docPtr: number, pageIdx: number, pagePtr: number, onFinalDispose: () => void);
+    /** Called by PageCache.acquire() */
+    bumpRefCount(): void;
+    /** Called by PageCache.acquire() */
+    clearExpiryTimer(): void;
+    /** Called by PageCache.release() internally */
+    release(): void;
+    /** Tear down _all_ sub-pointers & the page. */
+    disposeImmediate(): void;
+    /** Always safe: opens (once) and returns the text-page ptr. */
+    getTextPage(): number;
+    /** Always safe: opens (once) and returns the form-fill handle. */
+    getFormHandle(): number;
+    /**
+     * Safely execute `fn` with an annotation pointer.
+     * Pointer is ALWAYS closed afterwards.
+     */
+    withAnnotation<T>(annotIdx: number, fn: (annotPtr: number) => T): T;
+    private ensureAlive;
+}

package/dist/{pdfium-direct-engine.d.ts → lib/pdfium/engine.d.ts}

@@ -1,16 +1,71 @@
-import { PdfEngine, Logger, Task, PdfErrorReason, PdfFileUrl, PdfUrlOptions, PdfDocumentObject, PdfFile, PdfFileLoader, PdfSignatureObject, PdfBookmarkObject, PdfPageObject, Rotation, PdfRenderOptions, ImageConversionTypes, PdfTask, Rect, PdfAnnotationObject, PdfTextRectObject, PdfAttachmentObject, PdfWidgetAnnoObject, FormFieldValue, PdfPageFlattenFlag, PdfPageFlattenResult, PageTextSlice, PdfInkAnnoObject, PdfHighlightAnnoObject, PdfUnderlineAnnoObject, PdfStrikeOutAnnoObject, PdfSquigglyAnnoObject, PdfStampAnnoObjectContents, Position, PdfPageGeometry, PdfGlyphObject, AppearanceMode, PdfAnnotationObjectBase, WebAlphaColor, MatchFlag, SearchAllPagesResult, PdfImage } from '@embedpdf/models';
+import { PdfAnnotationObject, PdfTextRectObject, PdfWidgetAnnoObject, Logger, SearchTarget, MatchFlag, PdfBookmarkObject, PdfDocumentObject, PdfEngine, PdfPageObject, Rotation, Rect, PdfAttachmentObject, PdfSignatureObject, PdfRenderOptions, PdfInkAnnoObject, Position, PdfSquigglyAnnoObject, PdfStrikeOutAnnoObject, PdfUnderlineAnnoObject, PdfFile, AppearanceMode, PdfHighlightAnnoObject, PdfStampAnnoObjectContents, FormFieldValue, PdfPageFlattenFlag, PdfPageFlattenResult, PdfTask, PdfFileLoader, SearchAllPagesResult, PdfUrlOptions, PdfFileUrl, Task, PdfErrorReason, PdfGlyphObject, PdfPageGeometry, PdfImage, ImageConversionTypes, PdfAnnotationObjectBase, PageTextSlice, WebAlphaColor } from '@embedpdf/models';
 import { WrappedPdfiumModule } from '@embedpdf/pdfium';
-
+/**
+ * Format of bitmap
+ */
+export declare enum BitmapFormat {
+    Bitmap_Gray = 1,
+    Bitmap_BGR = 2,
+    Bitmap_BGRx = 3,
+    Bitmap_BGRA = 4
+}
+/**
+ * Pdf rendering flag
+ */
+export declare enum RenderFlag {
+    ANNOT = 1,// Set if annotations are to be rendered.
+    LCD_TEXT = 2,// Set if using text rendering optimized for LCD display.
+    NO_NATIVETEXT = 4,// Don't use the native text output available on some platforms
+    GRAYSCALE = 8,// Grayscale output.
+    DEBUG_INFO = 128,// Set if you want to get some debug info. Please discuss with Foxit first if you need to collect debug info.
+    NO_CATCH = 256,// Set if you don't want to catch exception.
+    RENDER_LIMITEDIMAGECACHE = 512,// Limit image cache size.
+    RENDER_FORCEHALFTONE = 1024,// Always use halftone for image stretching.
+    PRINTING = 2048,// Render for printing.
+    REVERSE_BYTE_ORDER = 16
+}
+/**
+ * Context used for searching
+ */
+export interface SearchContext {
+    /**
+     * search target
+     */
+    target: SearchTarget;
+    /**
+     * current page index
+     */
+    currPageIndex: number;
+    /**
+     * index of text in the current pdf page,  -1 means reach the end
+     */
+    startIndex: number;
+}
+/**
+ * Error code of pdfium library
+ */
+export declare enum PdfiumErrorCode {
+    Success = 0,
+    Unknown = 1,
+    File = 2,
+    Format = 3,
+    Password = 4,
+    Security = 5,
+    Page = 6,
+    XFALoad = 7,
+    XFALayout = 8
+}
 /**
  * Function type for converting ImageData to Blob
  * In browser: uses OffscreenCanvas
  * In Node.js: can use Sharp or other image processing libraries
  */
-type ImageDataConverter<T = Blob> = (imageData: PdfImage, imageType?: ImageConversionTypes) => Promise<T>;
+export type ImageDataConverter<T = Blob> = (imageData: PdfImage, imageType?: ImageConversionTypes) => Promise<T>;
+export declare const browserImageDataToBlobConverter: ImageDataConverter<Blob>;
 /**
  * Pdf engine that based on pdfium wasm
  */
-declare class PdfiumEngine<T = Blob> implements PdfEngine<T> {
+export declare class PdfiumEngine<T = Blob> implements PdfEngine<T> {
     private pdfiumModule;
     private logger;
     private imageDataConverter;
@@ -853,6 +908,20 @@ declare class PdfiumEngine<T = Blob> implements PdfEngine<T> {
      * @private
      */
     private getAnnotString;
+    /**
+     * Fetches the /IT (Intent) name from an annotation as a UTF-8 JS string.
+     *
+     * Mirrors getAnnotString(): calls EPDFAnnot_GetIntent twice (length probe + copy).
+     * Returns `undefined` if no intent present.
+     */
+    private getAnnotIntent;
+    /**
+     * Returns the rich‑content string stored in the annotation’s `/RC` entry.
+     *
+     * Works like `getAnnotIntent()`: first probe for length, then copy.
+     * `undefined` when the annotation has no rich content.
+     */
+    private getAnnotRichContent;
     /**
      * Set a string value (`/T`, `/M`, `/State`, …) to an annotation.
      *
@@ -1085,7 +1154,3 @@ declare class PdfiumEngine<T = Blob> implements PdfEngine<T> {
      */
     private searchAllInPage;
 }
-
-declare function createPdfiumEngine(wasmUrl: string, logger?: Logger): Promise<PdfiumEngine>;
-
-export { createPdfiumEngine };

package/dist/lib/pdfium/helper.d.ts

@@ -0,0 +1,21 @@
+import { PdfiumRuntimeMethods, PdfiumModule } from '@embedpdf/pdfium';
+/**
+ * Read string from WASM heap
+ * @param wasmModule - pdfium wasm module instance
+ * @param readChars - function to read chars
+ * @param parseChars - function to parse chars
+ * @param defaultLength - default length of chars that needs to read
+ * @returns string from the heap
+ *
+ * @public
+ */
+export declare function readString(wasmModule: PdfiumRuntimeMethods & PdfiumModule, readChars: (buffer: number, bufferLength: number) => number, parseChars: (buffer: number) => string, defaultLength?: number): string;
+/**
+ * Read arraybyffer from WASM heap
+ * @param wasmModule - pdfium wasm module instance
+ * @param readChars - function to read chars
+ * @returns arraybuffer from the heap
+ *
+ * @public
+ */
+export declare function readArrayBuffer(wasmModule: PdfiumRuntimeMethods & PdfiumModule, readChars: (buffer: number, bufferLength: number) => number): ArrayBuffer;

package/dist/lib/pdfium/index.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../../engine-B7CS6Qyp.cjs"),e=require("../../runner-BcS-WEof.cjs");exports.BitmapFormat=r.BitmapFormat,exports.PdfiumEngine=r.PdfiumEngine,exports.PdfiumErrorCode=r.PdfiumErrorCode,exports.RenderFlag=r.RenderFlag,exports.browserImageDataToBlobConverter=r.browserImageDataToBlobConverter,exports.readArrayBuffer=r.readArrayBuffer,exports.readString=r.readString,exports.PdfiumEngineRunner=e.PdfiumEngineRunner;
+//# sourceMappingURL=index.cjs.map

package/dist/lib/pdfium/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/lib/pdfium/index.d.ts

@@ -0,0 +1,3 @@
+export * from './engine';
+export * from './helper';
+export * from './runner';

package/dist/lib/pdfium/index.js

@@ -0,0 +1,13 @@
+import { B, a, P, R, b, c, r } from "../../engine-M0_XZhss.js";
+import { P as P2 } from "../../runner-DUp_7Uu_.js";
+export {
+  B as BitmapFormat,
+  a as PdfiumEngine,
+  P2 as PdfiumEngineRunner,
+  P as PdfiumErrorCode,
+  R as RenderFlag,
+  b as browserImageDataToBlobConverter,
+  c as readArrayBuffer,
+  r as readString
+};
+//# sourceMappingURL=index.js.map

package/dist/lib/pdfium/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/lib/pdfium/runner.d.ts

@@ -0,0 +1,16 @@
+import { EngineRunner } from '../webworker/runner';
+/**
+ * EngineRunner for pdfium-based wasm engine
+ */
+export declare class PdfiumEngineRunner extends EngineRunner {
+    private wasmBinary;
+    /**
+     * Create an instance of PdfiumEngineRunner
+     * @param wasmBinary - wasm binary that contains the pdfium wasm file
+     */
+    constructor(wasmBinary: ArrayBuffer);
+    /**
+     * Initialize runner
+     */
+    prepare(): Promise<void>;
+}

package/dist/lib/pdfium/web/direct-engine.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("@embedpdf/pdfium"),i=require("../../../engine-B7CS6Qyp.cjs");exports.createPdfiumEngine=async function(t,n){const r=await fetch(t),a=await r.arrayBuffer(),u=await e.init({wasmBinary:a});return new i.PdfiumEngine(u,n)};
+//# sourceMappingURL=direct-engine.cjs.map

package/dist/lib/pdfium/web/direct-engine.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-engine.cjs","sources":["../../../../src/lib/pdfium/web/direct-engine.ts"],"sourcesContent":["import { Logger } from '@embedpdf/models';\nimport { init } from '@embedpdf/pdfium';\n\nimport { PdfiumEngine } from '../engine';\n\nexport async function createPdfiumEngine(wasmUrl: string, logger?: Logger): Promise<PdfiumEngine> {\n  const response = await fetch(wasmUrl);\n  const wasmBinary = await response.arrayBuffer();\n  const wasmModule = await init({ wasmBinary });\n  return new PdfiumEngine(wasmModule, logger);\n}\n"],"names":["async","wasmUrl","logger","response","fetch","wasmBinary","arrayBuffer","wasmModule","init","PdfiumEngine"],"mappings":"yLAKsBA,eAAmBC,EAAiBC,GAClD,MAAAC,QAAiBC,MAAMH,GACvBI,QAAmBF,EAASG,cAC5BC,QAAmBC,OAAK,CAAEH,eACzB,OAAA,IAAII,EAAAA,aAAaF,EAAYL,EACtC"}

package/dist/lib/pdfium/web/direct-engine.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from '@embedpdf/models';
+import { PdfiumEngine } from '../engine';
+export declare function createPdfiumEngine(wasmUrl: string, logger?: Logger): Promise<PdfiumEngine>;

package/dist/lib/pdfium/web/direct-engine.js

@@ -0,0 +1,12 @@
+import { init } from "@embedpdf/pdfium";
+import { a as PdfiumEngine } from "../../../engine-M0_XZhss.js";
+async function createPdfiumEngine(wasmUrl, logger) {
+  const response = await fetch(wasmUrl);
+  const wasmBinary = await response.arrayBuffer();
+  const wasmModule = await init({ wasmBinary });
+  return new PdfiumEngine(wasmModule, logger);
+}
+export {
+  createPdfiumEngine
+};
+//# sourceMappingURL=direct-engine.js.map

package/dist/lib/pdfium/web/direct-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-engine.js","sources":["../../../../src/lib/pdfium/web/direct-engine.ts"],"sourcesContent":["import { Logger } from '@embedpdf/models';\nimport { init } from '@embedpdf/pdfium';\n\nimport { PdfiumEngine } from '../engine';\n\nexport async function createPdfiumEngine(wasmUrl: string, logger?: Logger): Promise<PdfiumEngine> {\n  const response = await fetch(wasmUrl);\n  const wasmBinary = await response.arrayBuffer();\n  const wasmModule = await init({ wasmBinary });\n  return new PdfiumEngine(wasmModule, logger);\n}\n"],"names":[],"mappings":";;AAKsB,eAAA,mBAAmB,SAAiB,QAAwC;AAC1F,QAAA,WAAW,MAAM,MAAM,OAAO;AAC9B,QAAA,aAAa,MAAM,SAAS,YAAY;AAC9C,QAAM,aAAa,MAAM,KAAK,EAAE,YAAY;AACrC,SAAA,IAAI,aAAa,YAAY,MAAM;AAC5C;"}