@jasy/pdf 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/utils/afm-parser.js

@@ -1,12 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AFMParser = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-class AFMParser {
+import { AGL } from "../assets/font-data.js";
+export class AFMParser {
     constructor(afmData) {
         this.advanceWidths = {};
         this.kerningPairs = {};
@@ -15,9 +8,7 @@ class AFMParser {
         this.loadGlyphList();
     }
     loadGlyphList() {
-        const afmFilePath = path_1.default.resolve(__dirname, "../", "assets/agl.txt");
-        const fileContent = fs_1.default.readFileSync(afmFilePath, "utf-8");
-        const lines = fileContent.split("\n");
+        const lines = AGL.split("\n");
         for (const line of lines) {
             const parts = line.trim().split(";");
             if (parts.length >= 2) {
@@ -88,4 +79,3 @@ class AFMParser {
         return this.kerningPairs[pair] || 0;
     }
 }
-exports.AFMParser = AFMParser;

package/dist/utils/bytes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A `Uint8Array` → a latin1 (ISO-8859-1) string: each byte 0x00-0xFF maps 1:1 to the same code point.
+ * This matches `Buffer.toString("latin1")` exactly. NOTE: do NOT use `TextDecoder("latin1")` here - per
+ * the encoding spec that label is really windows-1252, which mangles 0x80-0x9F; we need a true 1:1 pass
+ * so arbitrary binary (e.g. a compressed stream) rides through unchanged. The PDF body is assembled as
+ * such a binary string and the final encoder passes 0x00-0xFF through.
+ */
+export declare function latin1FromBytes(bytes: Uint8Array): string;
+/**
+ * A latin1 (ISO-8859-1) string → a `Uint8Array`: each char's low byte. Matches `Buffer.from(str,
+ * "latin1")` / `"binary"`. Use for the binary strings the engine assembles char-by-char (CMaps, object
+ * bodies) before they become a stream.
+ */
+export declare function bytesFromLatin1(str: string): Uint8Array;
+export declare function u8(b: Uint8Array, o: number): number;
+export declare function u16(b: Uint8Array, o: number): number;
+export declare function u32(b: Uint8Array, o: number): number;
+export declare function i16(b: Uint8Array, o: number): number;
+export declare function wu16(b: Uint8Array, value: number, offset: number): void;
+export declare function wu32(b: Uint8Array, value: number, offset: number): void;
+export declare function wi16(b: Uint8Array, value: number, offset: number): void;
+export declare function writeLatin1(b: Uint8Array, str: string, offset: number): void;
+/** Concatenate Uint8Arrays into one (mirrors Buffer.concat). */
+export declare function concatBytes(parts: Uint8Array[]): Uint8Array;

package/dist/utils/bytes.js

@@ -0,0 +1,76 @@
+// Byte helpers for an isomorphic engine (Node + browser). Kept tiny + dependency-free; as the engine
+// moves off Node-only APIs, the Node `Buffer` conveniences are replaced by these.
+/**
+ * A `Uint8Array` → a latin1 (ISO-8859-1) string: each byte 0x00-0xFF maps 1:1 to the same code point.
+ * This matches `Buffer.toString("latin1")` exactly. NOTE: do NOT use `TextDecoder("latin1")` here - per
+ * the encoding spec that label is really windows-1252, which mangles 0x80-0x9F; we need a true 1:1 pass
+ * so arbitrary binary (e.g. a compressed stream) rides through unchanged. The PDF body is assembled as
+ * such a binary string and the final encoder passes 0x00-0xFF through.
+ */
+export function latin1FromBytes(bytes) {
+    let out = "";
+    const CHUNK = 0x8000; // chunk the apply() to stay under the argument-count limit on big streams
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        out += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
+    }
+    return out;
+}
+/**
+ * A latin1 (ISO-8859-1) string → a `Uint8Array`: each char's low byte. Matches `Buffer.from(str,
+ * "latin1")` / `"binary"`. Use for the binary strings the engine assembles char-by-char (CMaps, object
+ * bodies) before they become a stream.
+ */
+export function bytesFromLatin1(str) {
+    const u8a = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++)
+        u8a[i] = str.charCodeAt(i) & 0xff;
+    return u8a;
+}
+// Big-endian integer reads from a Uint8Array (TrueType + PDF are big-endian), mirroring
+// Buffer.readUInt8 / readUInt16BE / readUInt32BE / readInt16BE without needing a Buffer.
+export function u8(b, o) {
+    return b[o];
+}
+export function u16(b, o) {
+    return (b[o] << 8) | b[o + 1];
+}
+export function u32(b, o) {
+    // Multiply the top byte (a left shift by 24 would go negative in 32-bit signed math).
+    return b[o] * 0x1000000 + ((b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]);
+}
+export function i16(b, o) {
+    const v = (b[o] << 8) | b[o + 1];
+    return v & 0x8000 ? v - 0x10000 : v;
+}
+// Big-endian integer + latin1-string writes into a Uint8Array, mirroring Buffer.writeUInt16BE /
+// writeUInt32BE / writeInt16BE / write(str, off, len, "latin1"). Arg order matches Buffer: (value, offset).
+export function wu16(b, value, offset) {
+    b[offset] = (value >>> 8) & 0xff;
+    b[offset + 1] = value & 0xff;
+}
+export function wu32(b, value, offset) {
+    b[offset] = (value >>> 24) & 0xff;
+    b[offset + 1] = (value >>> 16) & 0xff;
+    b[offset + 2] = (value >>> 8) & 0xff;
+    b[offset + 3] = value & 0xff;
+}
+export function wi16(b, value, offset) {
+    wu16(b, value & 0xffff, offset);
+}
+export function writeLatin1(b, str, offset) {
+    for (let i = 0; i < str.length; i++)
+        b[offset + i] = str.charCodeAt(i) & 0xff;
+}
+/** Concatenate Uint8Arrays into one (mirrors Buffer.concat). */
+export function concatBytes(parts) {
+    let len = 0;
+    for (const p of parts)
+        len += p.length;
+    const out = new Uint8Array(len);
+    let off = 0;
+    for (const p of parts) {
+        out.set(p, off);
+        off += p.length;
+    }
+    return out;
+}

package/dist/utils/flex-layout.d.ts

@@ -1,5 +1,5 @@
-import { PDFElement, LayoutContext } from "../elements/pdf-element";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { PDFElement, LayoutContext } from "../elements/pdf-element.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
 /** Distribution of the children ALONG the stacking (main) axis when there is leftover
  *  space and no flex child to absorb it. */
 export type MainAlign = "start" | "center" | "end" | "between" | "around";

package/dist/utils/flex-layout.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlexLayoutHelper = exports.HORIZONTAL_AXIS = exports.VERTICAL_AXIS = void 0;
-const pdf_element_1 = require("../elements/pdf-element");
-const box_constraints_1 = require("../layout/box-constraints");
-exports.VERTICAL_AXIS = {
+import { FlexiblePDFElement } from "../elements/pdf-element.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
+export const VERTICAL_AXIS = {
     mainOf: (s) => s.height,
     crossOf: (s) => s.width,
-    measureConstraints: (crossAvail) => box_constraints_1.BoxConstraints.loose(crossAvail, Infinity),
-    flexConstraints: (mainExtent, crossAvail) => box_constraints_1.BoxConstraints.loose(crossAvail, mainExtent),
+    measureConstraints: (crossAvail) => BoxConstraints.loose(crossAvail, Infinity),
+    flexConstraints: (mainExtent, crossAvail) => BoxConstraints.loose(crossAvail, mainExtent),
     offsetAt: (mainPos, crossPos) => ({ x: crossPos, y: mainPos }),
 };
-exports.HORIZONTAL_AXIS = {
+export const HORIZONTAL_AXIS = {
     mainOf: (s) => s.width,
     crossOf: (s) => s.height,
-    measureConstraints: (crossAvail) => box_constraints_1.BoxConstraints.loose(Infinity, crossAvail),
-    flexConstraints: (mainExtent, crossAvail) => box_constraints_1.BoxConstraints.loose(mainExtent, crossAvail),
+    measureConstraints: (crossAvail) => BoxConstraints.loose(Infinity, crossAvail),
+    flexConstraints: (mainExtent, crossAvail) => BoxConstraints.loose(mainExtent, crossAvail),
     offsetAt: (mainPos, crossPos) => ({ x: mainPos, y: crossPos }),
 };
 /** Cross-axis offset of a child of size `childCross` within `crossExtent`. */
@@ -25,7 +22,7 @@ function crossOffset(align, crossExtent, childCross) {
         return Math.max(0, crossExtent - childCross);
     return 0; // start, stretch (stretch fills, so no offset)
 }
-class FlexLayoutHelper {
+export class FlexLayoutHelper {
     /**
      * Lays out a flex line along `axis`, IN SOURCE ORDER, and places every child.
      * Fixed children take their natural main extent; flex (`ExpandedElement`) children
@@ -36,10 +33,9 @@ class FlexLayoutHelper {
      * previous Column layout exactly.
      */
     static layout(children, axis, mainAvail, crossAvail, mainStart, crossOrigin, options, ctx) {
-        var _a, _b, _c;
-        const gap = (_a = options.gap) !== null && _a !== void 0 ? _a : 0;
-        const main = (_b = options.main) !== null && _b !== void 0 ? _b : "start";
-        const cross = (_c = options.cross) !== null && _c !== void 0 ? _c : "stretch";
+        const gap = options.gap ?? 0;
+        const main = options.main ?? "start";
+        const cross = options.cross ?? "stretch";
         const count = children.length;
         // Pass 1: measure the fixed children (main extent + cross size) and total the flex.
         let fixedMain = 0;
@@ -47,7 +43,7 @@ class FlexLayoutHelper {
         let crossUsed = 0;
         const fixedSize = new Map();
         for (const child of children) {
-            if (child instanceof pdf_element_1.FlexiblePDFElement) {
+            if (child instanceof FlexiblePDFElement) {
                 totalFlex += child.getFlex();
             }
             else {
@@ -80,7 +76,7 @@ class FlexLayoutHelper {
         // toward the line's cross extent - they're placed in pass 2, but crossExtent needs them now.
         if (totalFlex > 0) {
             for (const child of children) {
-                if (child instanceof pdf_element_1.FlexiblePDFElement) {
+                if (child instanceof FlexiblePDFElement) {
                     const mainExtent = (child.getFlex() / totalFlex) * remaining;
                     const size = child.calculateLayout(axis.flexConstraints(mainExtent, crossAvail), axis.offsetAt(mainStart, crossOrigin), ctx);
                     crossUsed = Math.max(crossUsed, axis.crossOf(size));
@@ -98,7 +94,7 @@ class FlexLayoutHelper {
         let placedCross = 0;
         children.forEach((child, index) => {
             let mainExtent;
-            if (child instanceof pdf_element_1.FlexiblePDFElement) {
+            if (child instanceof FlexiblePDFElement) {
                 mainExtent = (child.getFlex() / totalFlex) * remaining;
                 const size = child.calculateLayout(axis.flexConstraints(mainExtent, stretch ? crossExtent : crossAvail), axis.offsetAt(mainPos, crossOrigin), ctx);
                 placedCross = Math.max(placedCross, axis.crossOf(size));
@@ -116,4 +112,3 @@ class FlexLayoutHelper {
         return { mainUsed: mainPos - mainStart, crossUsed: placedCross };
     }
 }
-exports.FlexLayoutHelper = FlexLayoutHelper;

package/dist/utils/font-metrics.d.ts

@@ -1,4 +1,4 @@
-import type { FontStyle } from "./pdf-object-manager";
+import type { FontStyle } from "./pdf-object-manager.js";
 /**
  * Read-only font measurement - the slice of the object manager that the layout pass
  * needs. Keeping layout (and, later, fragmentation) behind this interface means those

package/dist/utils/font-metrics.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/utils/font-path.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFontPath = getFontPath;
-const os = require("os");
-const path = require("path");
-function getFontPath(fontName) {
+import os from "node:os";
+import path from "node:path";
+export function getFontPath(fontName) {
     const platform = os.platform();
     let fontPath = "";
     if (platform === "win32") {

package/dist/utils/image-helper.d.ts

@@ -7,7 +7,7 @@ interface ImageDimensions {
     width: number;
     height: number;
 }
-export declare function getImageDimensions(buffer: Buffer): Promise<ImageDimensions>;
+export declare function getImageDimensions(buffer: Uint8Array): Promise<ImageDimensions>;
 /**
  * Converts the given image to grayscale and returns its binary data.
  * @param imagePath Path to the input image file.
@@ -16,15 +16,16 @@ export declare function getImageDimensions(buffer: Buffer): Promise<ImageDimensi
 /**
  * Decodes a PNG into raw DeviceRGB samples, Flate-compressed, ready to embed as a PDF
  * image XObject. A PNG file is NOT a valid `/FlateDecode` stream (it's a signature plus
- * chunks of filtered, zlib-compressed scanlines), so it must be decoded first. PDF has
- * no alpha channel for DeviceRGB, so transparent pixels are composited over white.
+ * chunks of filtered, zlib-compressed scanlines), so it must be decoded first. DeviceRGB has
+ * no alpha itself, so any transparency rides alongside as a DeviceGray `/SMask` (the return's `smask`).
  */
-export declare function decodePngToRgbFlate(pngBuffer: Buffer): Promise<{
+export declare function decodePngToRgbFlate(pngBuffer: Uint8Array): Promise<{
     data: string;
+    smask?: string;
     width: number;
     height: number;
 }>;
-export declare function convertImageToGrayscaleBuffer(imagePath: string): Promise<Buffer>;
+export declare function convertImageToGrayscaleBuffer(imagePath: string): Promise<Uint8Array>;
 export interface FitResult {
     width: number;
     height: number;

package/dist/utils/image-helper.js

@@ -1,23 +1,6 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getImageDimensions = getImageDimensions;
-exports.decodePngToRgbFlate = decodePngToRgbFlate;
-exports.convertImageToGrayscaleBuffer = convertImageToGrayscaleBuffer;
-exports.applyContainFit = applyContainFit;
-exports.applyCoverFit = applyCoverFit;
-exports.applyFillFit = applyFillFit;
-exports.applyFitNone = applyFitNone;
-const jimp_1 = require("jimp");
-const zlib_1 = require("zlib");
+import { zlibSync } from "fflate";
+import { latin1FromBytes } from "./bytes.js";
+import { pngToRgba } from "../platform/node-image.js";
 // Implement the method to handle 24-bit integers
 DataView.prototype.getUint24 = function (byteOffset, littleEndian = false) {
     const b1 = this.getUint8(byteOffset);
@@ -25,61 +8,59 @@ DataView.prototype.getUint24 = function (byteOffset, littleEndian = false) {
     const b3 = this.getUint8(byteOffset + 2);
     return littleEndian ? (b3 << 16) | (b2 << 8) | b1 : (b1 << 16) | (b2 << 8) | b3;
 };
-function getImageDimensions(buffer) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const dataView = new DataView(buffer.buffer);
-        // Check for JPEG (0xFFD8 is the start of JPEG file)
-        if (dataView.getUint16(0) === 0xffd8) {
-            let offset = 2;
-            while (offset < buffer.byteLength) {
-                const marker = dataView.getUint16(offset, false);
-                offset += 2;
-                if (marker === 0xffc0 || marker === 0xffc2) {
-                    // SOF0 or SOF2
-                    return {
-                        height: dataView.getUint16(offset + 3, false),
-                        width: dataView.getUint16(offset + 5, false),
-                    };
-                }
-                else {
-                    offset += dataView.getUint16(offset, false);
-                }
+export async function getImageDimensions(buffer) {
+    const dataView = new DataView(buffer.buffer);
+    // Check for JPEG (0xFFD8 is the start of JPEG file)
+    if (dataView.getUint16(0) === 0xffd8) {
+        let offset = 2;
+        while (offset < buffer.byteLength) {
+            const marker = dataView.getUint16(offset, false);
+            offset += 2;
+            if (marker === 0xffc0 || marker === 0xffc2) {
+                // SOF0 or SOF2
+                return {
+                    height: dataView.getUint16(offset + 3, false),
+                    width: dataView.getUint16(offset + 5, false),
+                };
+            }
+            else {
+                offset += dataView.getUint16(offset, false);
             }
         }
-        // Check for PNG (0x89504E47 is the PNG signature)
-        if (dataView.getUint32(0) === 0x89504e47) {
+    }
+    // Check for PNG (0x89504E47 is the PNG signature)
+    if (dataView.getUint32(0) === 0x89504e47) {
+        return {
+            width: dataView.getUint32(16, false),
+            height: dataView.getUint32(20, false),
+        };
+    }
+    // Check for BMP (0x424D is the BMP signature)
+    if (dataView.getUint16(0) === 0x424d) {
+        return {
+            width: dataView.getUint32(18, true),
+            height: dataView.getUint32(22, true),
+        };
+    }
+    // Check for WebP (0x52494646 is the WebP signature 'RIFF')
+    if (dataView.getUint32(0) === 0x52494646 && dataView.getUint32(8) === 0x57454250) {
+        // 'WEBP'
+        if (dataView.getUint32(12) === 0x56503820) {
+            // 'VP8 '
             return {
-                width: dataView.getUint32(16, false),
-                height: dataView.getUint32(20, false),
+                width: dataView.getUint16(26, true),
+                height: dataView.getUint16(28, true),
             };
         }
-        // Check for BMP (0x424D is the BMP signature)
-        if (dataView.getUint16(0) === 0x424d) {
+        else if (dataView.getUint32(12) === 0x56503858) {
+            // 'VP8X'
             return {
-                width: dataView.getUint32(18, true),
-                height: dataView.getUint32(22, true),
+                width: dataView.getUint24(24, true) + 1,
+                height: dataView.getUint24(27, true) + 1,
             };
         }
-        // Check for WebP (0x52494646 is the WebP signature 'RIFF')
-        if (dataView.getUint32(0) === 0x52494646 && dataView.getUint32(8) === 0x57454250) {
-            // 'WEBP'
-            if (dataView.getUint32(12) === 0x56503820) {
-                // 'VP8 '
-                return {
-                    width: dataView.getUint16(26, true),
-                    height: dataView.getUint16(28, true),
-                };
-            }
-            else if (dataView.getUint32(12) === 0x56503858) {
-                // 'VP8X'
-                return {
-                    width: dataView.getUint24(24, true) + 1,
-                    height: dataView.getUint24(27, true) + 1,
-                };
-            }
-        }
-        throw new Error("Unsupported image format");
-    });
+    }
+    throw new Error("Unsupported image format");
 }
 /**
  * Converts the given image to grayscale and returns its binary data.
@@ -89,50 +70,59 @@ function getImageDimensions(buffer) {
 /**
  * Decodes a PNG into raw DeviceRGB samples, Flate-compressed, ready to embed as a PDF
  * image XObject. A PNG file is NOT a valid `/FlateDecode` stream (it's a signature plus
- * chunks of filtered, zlib-compressed scanlines), so it must be decoded first. PDF has
- * no alpha channel for DeviceRGB, so transparent pixels are composited over white.
+ * chunks of filtered, zlib-compressed scanlines), so it must be decoded first. DeviceRGB has
+ * no alpha itself, so any transparency rides alongside as a DeviceGray `/SMask` (the return's `smask`).
  */
-function decodePngToRgbFlate(pngBuffer) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const image = yield jimp_1.Jimp.fromBuffer(pngBuffer);
-        const { width, height, data: rgba } = image.bitmap;
-        const rgb = Buffer.allocUnsafe(width * height * 3);
-        for (let i = 0, j = 0; i < rgba.length; i += 4, j += 3) {
-            const alpha = rgba[i + 3] / 255;
-            rgb[j] = Math.round(rgba[i] * alpha + 255 * (1 - alpha));
-            rgb[j + 1] = Math.round(rgba[i + 1] * alpha + 255 * (1 - alpha));
-            rgb[j + 2] = Math.round(rgba[i + 2] * alpha + 255 * (1 - alpha));
-        }
-        // Compress so the existing `/Filter /FlateDecode` XObject path embeds it correctly.
-        return { data: (0, zlib_1.deflateSync)(rgb).toString("binary"), width, height };
-    });
+export async function decodePngToRgbFlate(pngBuffer) {
+    // The decode (PNG bytes → RGBA) is platform-specific: jimp on Node, an OffscreenCanvas in the browser
+    // (`platform/{node,browser}-image.ts`, swapped by the package `browser` field). The split below is shared.
+    const { width, height, rgba } = await pngToRgba(pngBuffer);
+    // Raw DeviceRGB samples + (only when the PNG actually has transparency) a DeviceGray alpha channel that
+    // rides as the XObject's /SMask. An opaque PNG yields the same raw RGB as before and no SMask, so it stays
+    // byte-identical; a transparent one now composites correctly over whatever sits behind it.
+    const rgb = new Uint8Array(width * height * 3);
+    const alpha = new Uint8Array(width * height);
+    let hasAlpha = false;
+    for (let i = 0, j = 0, k = 0; i < rgba.length; i += 4, j += 3, k++) {
+        rgb[j] = rgba[i];
+        rgb[j + 1] = rgba[i + 1];
+        rgb[j + 2] = rgba[i + 2];
+        alpha[k] = rgba[i + 3];
+        if (rgba[i + 3] !== 255)
+            hasAlpha = true;
+    }
+    return {
+        data: latin1FromBytes(zlibSync(rgb)),
+        smask: hasAlpha ? latin1FromBytes(zlibSync(alpha)) : undefined,
+        width,
+        height,
+    };
 }
-function convertImageToGrayscaleBuffer(imagePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // We get the image from the buffer
-        const image = yield jimp_1.Jimp.read(imagePath);
-        // Get MIME type. If emtpy throw error
-        const mime = image.mime;
-        if (!mime)
-            throw new Error("Cannot read MIME type");
-        // We need to check the MIME type (the exact union `getBuffer` accepts).
-        let mimeType;
-        switch (mime) {
-            case jimp_1.JimpMime.png:
-            case jimp_1.JimpMime.jpeg:
-            case jimp_1.JimpMime.bmp:
-                mimeType = mime;
-                break;
-            default:
-                throw new Error("Unsupported MIME type");
-        }
-        image.greyscale();
-        // Convert the image back to buffer with current MIME type
-        const grayscaleBuffer = yield image.getBuffer(mimeType);
-        return grayscaleBuffer;
-    });
+export async function convertImageToGrayscaleBuffer(imagePath) {
+    // We get the image from the buffer (jimp lazily loaded - see decodePngToRgbFlate).
+    const { Jimp, JimpMime } = await import("jimp");
+    const image = await Jimp.read(imagePath);
+    // Get MIME type. If emtpy throw error
+    const mime = image.mime;
+    if (!mime)
+        throw new Error("Cannot read MIME type");
+    // We need to check the MIME type (the exact union `getBuffer` accepts).
+    let mimeType;
+    switch (mime) {
+        case JimpMime.png:
+        case JimpMime.jpeg:
+        case JimpMime.bmp:
+            mimeType = mime;
+            break;
+        default:
+            throw new Error("Unsupported MIME type");
+    }
+    image.greyscale();
+    // Convert the image back to buffer with current MIME type
+    const grayscaleBuffer = await image.getBuffer(mimeType);
+    return grayscaleBuffer;
 }
-function applyContainFit(imageWidth, imageHeight, containerWidth, containerHeight) {
+export function applyContainFit(imageWidth, imageHeight, containerWidth, containerHeight) {
     const imageAspectRatio = imageWidth / imageHeight;
     const containerAspectRatio = containerWidth / containerHeight;
     let width, height, offsetX, offsetY;
@@ -159,7 +149,7 @@ function applyContainFit(imageWidth, imageHeight, containerWidth, containerHeigh
         offsetY,
     };
 }
-function applyCoverFit(imageWidth, imageHeight, containerWidth, containerHeight) {
+export function applyCoverFit(imageWidth, imageHeight, containerWidth, containerHeight) {
     const imageAspectRatio = imageWidth / imageHeight;
     const containerAspectRatio = containerWidth / containerHeight;
     let width, height, offsetX, offsetY;
@@ -186,7 +176,7 @@ function applyCoverFit(imageWidth, imageHeight, containerWidth, containerHeight)
         offsetY,
     };
 }
-function applyFillFit(containerWidth, containerHeight) {
+export function applyFillFit(containerWidth, containerHeight) {
     return {
         width: containerWidth,
         height: containerHeight,
@@ -194,7 +184,7 @@ function applyFillFit(containerWidth, containerHeight) {
         offsetY: 0,
     };
 }
-function applyFitNone(imageWidth, imageHeight, containerWidth, containerHeight) {
+export function applyFitNone(imageWidth, imageHeight, containerWidth, containerHeight) {
     const offsetX = (containerWidth - imageWidth) / 2; // Center horizontally
     const offsetY = (containerHeight - imageHeight) / 2; // Center vertically
     return {

package/dist/utils/md5.d.ts

@@ -0,0 +1,4 @@
+/** The raw 16-byte MD5 digest of `input`. */
+export declare function md5(input: Uint8Array): Uint8Array;
+/** Lowercase hex of the MD5 digest (matches `digest("hex")`). */
+export declare function md5Hex(input: Uint8Array): string;

package/dist/utils/md5.js

@@ -0,0 +1,79 @@
+// MD5 (RFC 1321), vendored + isomorphic - so the font subset tag and the documentId /ID hash work in the
+// browser too: Node `crypto` is absent there, and Web Crypto has no MD5 and is async. Verified byte-for-byte
+// identical to Node's `createHash("md5")`. Operates on bytes; callers UTF-8-encode strings (TextEncoder),
+// matching `hash.update(string)`'s default encoding.
+// Per-round left-rotate amounts.
+const S = [
+    7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14,
+    20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6,
+    10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
+];
+// Per-round constants K[i] = floor(abs(sin(i+1)) * 2^32).
+const K = new Int32Array(64);
+for (let i = 0; i < 64; i++)
+    K[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32) | 0;
+/** The raw 16-byte MD5 digest of `input`. */
+export function md5(input) {
+    const len = input.length;
+    // Pad to a multiple of 64: message + 0x80 + zeros + 64-bit little-endian bit length.
+    const total = (((len + 8) >> 6) + 1) << 6;
+    const b = new Uint8Array(total);
+    b.set(input);
+    b[len] = 0x80;
+    const bits = len * 8;
+    b[total - 8] = bits & 0xff;
+    b[total - 7] = (bits >>> 8) & 0xff;
+    b[total - 6] = (bits >>> 16) & 0xff;
+    b[total - 5] = (bits >>> 24) & 0xff;
+    // High 32 bits of the length stay 0 (inputs are well under 512 MB).
+    let a0 = 0x67452301, b0 = 0xefcdab89, c0 = 0x98badcfe, d0 = 0x10325476;
+    const M = new Int32Array(16);
+    for (let off = 0; off < total; off += 64) {
+        for (let i = 0; i < 16; i++) {
+            const j = off + i * 4;
+            M[i] = b[j] | (b[j + 1] << 8) | (b[j + 2] << 16) | (b[j + 3] << 24);
+        }
+        let A = a0, B = b0, C = c0, D = d0;
+        for (let i = 0; i < 64; i++) {
+            let f, g;
+            if (i < 16) {
+                f = (B & C) | (~B & D);
+                g = i;
+            }
+            else if (i < 32) {
+                f = (D & B) | (~D & C);
+                g = (5 * i + 1) % 16;
+            }
+            else if (i < 48) {
+                f = B ^ C ^ D;
+                g = (3 * i + 5) % 16;
+            }
+            else {
+                f = C ^ (B | ~D);
+                g = (7 * i) % 16;
+            }
+            f = (f + A + K[i] + M[g]) | 0;
+            A = D;
+            D = C;
+            C = B;
+            B = (B + ((f << S[i]) | (f >>> (32 - S[i])) | 0)) | 0;
+        }
+        a0 = (a0 + A) | 0;
+        b0 = (b0 + B) | 0;
+        c0 = (c0 + C) | 0;
+        d0 = (d0 + D) | 0;
+    }
+    const out = new Uint8Array(16);
+    const w = [a0, b0, c0, d0];
+    for (let i = 0; i < 4; i++) {
+        out[i * 4] = w[i] & 0xff;
+        out[i * 4 + 1] = (w[i] >>> 8) & 0xff;
+        out[i * 4 + 2] = (w[i] >>> 16) & 0xff;
+        out[i * 4 + 3] = (w[i] >>> 24) & 0xff;
+    }
+    return out;
+}
+/** Lowercase hex of the MD5 digest (matches `digest("hex")`). */
+export function md5Hex(input) {
+    return [...md5(input)].map((x) => x.toString(16).padStart(2, "0")).join("");
+}