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

package/dist/common/color.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Color = void 0;
-class Color {
+export class Color {
     constructor(r, g, b, alpha = 1) {
         this.r = this.clampColorValue(r, "r");
         this.g = this.clampColorValue(g, "g");
@@ -59,4 +56,3 @@ class Color {
         return `${(r / 255).toFixed(3)} ${(g / 255).toFixed(3)} ${(b / 255).toFixed(3)}`;
     }
 }
-exports.Color = Color;

package/dist/constants/page-sizes.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pageFormats = exports.PageSize = void 0;
 // Definition of all possible page sizes
-var PageSize;
+export var PageSize;
 (function (PageSize) {
     PageSize["A0"] = "a0";
     PageSize["A1"] = "a1";
@@ -45,9 +42,9 @@ var PageSize;
     PageSize["LEDGER"] = "ledger";
     PageSize["TABLOID"] = "tabloid";
     PageSize["CREDIT_CARD"] = "credit-card";
-})(PageSize || (exports.PageSize = PageSize = {}));
+})(PageSize || (PageSize = {}));
 // Definition of page formats
-exports.pageFormats = {
+export const pageFormats = {
     [PageSize.A0]: [2383.94, 3370.39],
     [PageSize.A1]: [1683.78, 2383.94],
     [PageSize.A2]: [1190.55, 1683.78],

package/dist/constants/pdf-parts.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PDF_PARTS = void 0;
-exports.PDF_PARTS = {
+export const PDF_PARTS = {
     HEADER: "%PDF-1.3",
     TRAILER: (size) => `trailer\n<< /Size ${size} >>\nstartxref\n%%EOF`,
     XREF: "xref", // Placeholder for xref elements

package/dist/crypto/security-handler.d.ts

@@ -0,0 +1,46 @@
+/** A handler encrypts/decrypts the strings + streams of a document and describes itself as an `/Encrypt` dict. */
+export interface SecurityHandler {
+    /** The `/Encrypt` dictionary body (between `<<` and `>>`). Its own strings are never encrypted. */
+    encryptDict(): string;
+    /** Encrypt one string/stream. `ref` is unused for V5/R6 (one file key) but kept for future per-object schemes. */
+    encrypt(data: Uint8Array, ref?: {
+        num: number;
+        gen: number;
+    }): Promise<Uint8Array>;
+    /** Decrypt one string/stream (the groundwork the future "open/edit existing PDF" path reuses). */
+    decrypt(data: Uint8Array, ref?: {
+        num: number;
+        gen: number;
+    }): Promise<Uint8Array>;
+}
+/** What the user grants; everything defaults to allowed. Maps to the `/P` bitfield (ISO 32000-2 Table 22). */
+export interface Permissions {
+    printing?: boolean;
+    copying?: boolean;
+    modifying?: boolean;
+    annotating?: boolean;
+}
+export interface EncryptOptions {
+    /** Only "aes-256" today - the seam for future algorithms. */
+    algorithm?: "aes-256";
+    userPassword: string;
+    /** Full-rights password; defaults to the user password if omitted. */
+    ownerPassword?: string;
+    permissions?: Permissions;
+}
+declare class StandardAes256 implements SecurityHandler {
+    private readonly fileKey;
+    private readonly dict;
+    private constructor();
+    static create(opts: EncryptOptions): Promise<StandardAes256>;
+    encryptDict(): string;
+    encrypt(data: Uint8Array): Promise<Uint8Array>;
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    /** Recover the file key from a password as a reader does: validate it against /U FIRST (so a wrong
+     *  password is rejected, not silently turned into a garbage key), then decrypt /UE. The groundwork the
+     *  future "open/edit existing PDF" path reuses. Throws on a wrong password. */
+    static recoverFileKey(userPassword: string, u: Uint8Array, ue: Uint8Array): Promise<Uint8Array>;
+}
+/** The factory = the seam. Today it always returns the AES-256 handler. */
+export declare function createSecurityHandler(opts: EncryptOptions): Promise<SecurityHandler>;
+export { StandardAes256 };

package/dist/crypto/security-handler.js

@@ -0,0 +1,129 @@
+// PDF Standard security handler. The PDFObjectManager talks to the `SecurityHandler` interface, never to a
+// concrete algorithm - so adding another scheme later (a new revision, or per-object RC4/AES-128) is just a
+// second implementation + a factory branch, with the writer untouched. Today we ship exactly one:
+// `StandardAes256` = AES-256, V5/R6 (ISO 32000-2 / PDF 2.0), the newest standard PDF encryption.
+import { aesCbcDecrypt, aesCbcDecryptNoPad, aesCbcEncrypt, aesCbcEncryptNoPad, randomBytes, sha, } from "./webcrypto.js";
+const utf8 = (s) => new TextEncoder().encode(s).subarray(0, 127); // R6 truncates passwords to 127 bytes
+const concat = (...parts) => {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+};
+const toHex = (a) => [...a].map((b) => b.toString(16).padStart(2, "0")).join("");
+// Constant-time-ish equality for password validation (no early-out on the first differing byte).
+const bytesEqual = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+        diff |= a[i] ^ b[i];
+    return diff === 0;
+};
+// ISO 32000-2 Algorithm 2.B: the hardened password hash. Loops AES-128-CBC + SHA-256/384/512 until the
+// stopping rule. `udata` is the 48-byte /U for the owner computations, empty for the user ones.
+async function hash2B(password, salt, udata) {
+    let k = await sha(256, concat(password, salt, udata));
+    let e = new Uint8Array(0);
+    // At least 64 rounds; then stop once the last byte of E <= round - 32 (ISO 32000-2 Algorithm 2.B).
+    for (let round = 0; round < 64 || e[e.length - 1] > round - 32; round++) {
+        const block = concat(password, k, udata);
+        const k1 = new Uint8Array(block.length * 64);
+        for (let i = 0; i < 64; i++)
+            k1.set(block, i * block.length);
+        e = await aesCbcEncryptNoPad(k.subarray(0, 16), k.subarray(16, 32), k1);
+        let sum = 0;
+        for (let i = 0; i < 16; i++)
+            sum += e[i]; // big-endian 128-bit mod 3 == byte-sum mod 3 (256 ≡ 1 mod 3)
+        k = await sha([256, 384, 512][sum % 3], e);
+    }
+    return k.subarray(0, 32);
+}
+function permissionBits(p = {}) {
+    const { printing = true, copying = true, modifying = true, annotating = true } = p;
+    let bits = 0xfffff000 | 0b11000000; // reserved-1 bits (positions 7-8 and 13-32)
+    if (printing)
+        bits |= 4 | 2048;
+    if (modifying)
+        bits |= 8 | 1024;
+    if (copying)
+        bits |= 16 | 512;
+    if (annotating)
+        bits |= 32 | 256;
+    return bits | 0; // int32
+}
+class StandardAes256 {
+    constructor(fileKey, dict) {
+        this.fileKey = fileKey;
+        this.dict = dict;
+    }
+    static async create(opts) {
+        const user = utf8(opts.userPassword);
+        const owner = utf8(opts.ownerPassword ?? opts.userPassword);
+        const fileKey = randomBytes(32);
+        const p = permissionBits(opts.permissions);
+        // Algorithm 8: /U and /UE.
+        const uVS = randomBytes(8);
+        const uKS = randomBytes(8);
+        const empty = new Uint8Array(0);
+        const u = concat(await hash2B(user, uVS, empty), uVS, uKS); // 48 bytes
+        const ue = await aesCbcEncryptNoPad(await hash2B(user, uKS, empty), new Uint8Array(16), fileKey);
+        // Algorithm 9: /O and /OE (these also fold in /U).
+        const oVS = randomBytes(8);
+        const oKS = randomBytes(8);
+        const o = concat(await hash2B(owner, oVS, u), oVS, oKS); // 48 bytes
+        const oe = await aesCbcEncryptNoPad(await hash2B(owner, oKS, u), new Uint8Array(16), fileKey);
+        // Algorithm 10: /Perms (a 16-byte block, ECB == single-block CBC with a zero IV).
+        const perms = new Uint8Array(16);
+        perms[0] = p & 0xff;
+        perms[1] = (p >> 8) & 0xff;
+        perms[2] = (p >> 16) & 0xff;
+        perms[3] = (p >> 24) & 0xff;
+        perms[4] = perms[5] = perms[6] = perms[7] = 0xff;
+        perms[8] = 0x46; // 'F' - metadata (XMP) stays unencrypted (standard; keeps it indexer-readable)
+        perms[9] = 0x61; // 'a'
+        perms[10] = 0x64; // 'd'
+        perms[11] = 0x62; // 'b'
+        perms.set(randomBytes(4), 12);
+        const permsEnc = await aesCbcEncryptNoPad(fileKey, new Uint8Array(16), perms);
+        const dict = `/Filter /Standard /V 5 /R 6 /Length 256 /P ${p} /EncryptMetadata false ` +
+            `/CF << /StdCF << /CFM /AESV3 /AuthEvent /DocOpen /Length 32 >> >> /StmF /StdCF /StrF /StdCF ` +
+            `/U <${toHex(u)}> /UE <${toHex(ue)}> /O <${toHex(o)}> /OE <${toHex(oe)}> /Perms <${toHex(permsEnc)}>`;
+        return new StandardAes256(fileKey, dict);
+    }
+    encryptDict() {
+        return this.dict;
+    }
+    async encrypt(data) {
+        const iv = randomBytes(16);
+        const ct = await aesCbcEncrypt(this.fileKey, iv, data);
+        return concat(iv, ct);
+    }
+    async decrypt(data) {
+        return aesCbcDecrypt(this.fileKey, data.subarray(0, 16), data.subarray(16));
+    }
+    /** Recover the file key from a password as a reader does: validate it against /U FIRST (so a wrong
+     *  password is rejected, not silently turned into a garbage key), then decrypt /UE. The groundwork the
+     *  future "open/edit existing PDF" path reuses. Throws on a wrong password. */
+    static async recoverFileKey(userPassword, u, ue) {
+        const pw = utf8(userPassword);
+        // Algorithm 11: hash(password + validation salt) must equal the first 32 bytes of /U.
+        const check = await hash2B(pw, u.subarray(32, 40), new Uint8Array(0));
+        if (!bytesEqual(check, u.subarray(0, 32))) {
+            throw new Error("@jasy/pdf: wrong password.");
+        }
+        const intermediate = await hash2B(pw, u.subarray(40, 48), new Uint8Array(0));
+        return aesCbcDecryptNoPad(intermediate, new Uint8Array(16), ue);
+    }
+}
+/** The factory = the seam. Today it always returns the AES-256 handler. */
+export async function createSecurityHandler(opts) {
+    if (opts.algorithm && opts.algorithm !== "aes-256") {
+        throw new Error(`@jasy/pdf: unsupported encryption algorithm "${opts.algorithm}" (only "aes-256").`);
+    }
+    return StandardAes256.create(opts);
+}
+export { StandardAes256 };

package/dist/crypto/webcrypto.d.ts

@@ -0,0 +1,11 @@
+export declare function randomBytes(n: number): Uint8Array;
+export declare function sha(bits: 256 | 384 | 512, data: Uint8Array): Promise<Uint8Array>;
+/** AES-CBC with PKCS#7 padding (the AESV3 mode for PDF strings/streams). */
+export declare function aesCbcEncrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+export declare function aesCbcDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+/** AES-CBC WITHOUT padding (`data.length` must be a multiple of 16). WebCrypto pads unconditionally, so we
+ *  encrypt and drop the extra full pad block - the leading blocks are the true unpadded CBC. */
+export declare function aesCbcEncryptNoPad(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+/** AES-CBC no-padding DECRYPT (`data` a multiple of 16). We append one cipher block crafted to decrypt to a
+ *  full 0x10 PKCS#7 pad (so WebCrypto accepts and strips it), leaving the original. */
+export declare function aesCbcDecryptNoPad(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;

package/dist/crypto/webcrypto.js

@@ -0,0 +1,62 @@
+// Isomorphic crypto via the platform WebCrypto (`globalThis.crypto.subtle`) - native in the browser AND in
+// Node 20+, with zero dependencies. This is the primitive layer the PDF Standard security handler (AES-256,
+// R6) builds on. Everything is async (so is `render()`), so that is no constraint.
+//
+// One wrinkle: WebCrypto's AES-CBC ALWAYS applies PKCS#7 padding and offers no raw/no-pad mode. The PDF R6
+// key derivation (Algorithm 2.B, /UE, /OE, /Perms) needs UNPADDED AES, so we synthesize it from the padded
+// primitive (encrypt: drop the trailing pad block; decrypt: append a block that decrypts to a full pad, then
+// let WebCrypto strip it). Document strings/streams use the padded primitive directly - that IS AESV3.
+const subtle = () => {
+    const c = globalThis.crypto;
+    if (!c?.subtle) {
+        throw new Error("@jasy/pdf: PDF encryption needs WebCrypto (globalThis.crypto.subtle), unavailable here.");
+    }
+    return c.subtle;
+};
+export function randomBytes(n) {
+    const b = new Uint8Array(n);
+    globalThis.crypto.getRandomValues(b);
+    return b;
+}
+// WebCrypto's types want a BufferSource backed by ArrayBuffer; our Uint8Arrays are ArrayBuffer-backed, so
+// this cast at the platform boundary is safe (TS 5.7+ just can't prove it isn't a SharedArrayBuffer).
+const buf = (a) => a;
+export async function sha(bits, data) {
+    return new Uint8Array(await subtle().digest(`SHA-${bits}`, buf(data)));
+}
+async function aesKey(key, usage) {
+    return subtle().importKey("raw", buf(key), { name: "AES-CBC" }, false, [usage]);
+}
+/** AES-CBC with PKCS#7 padding (the AESV3 mode for PDF strings/streams). */
+export async function aesCbcEncrypt(key, iv, data) {
+    return new Uint8Array(await subtle().encrypt({ name: "AES-CBC", iv: buf(iv) }, await aesKey(key, "encrypt"), buf(data)));
+}
+export async function aesCbcDecrypt(key, iv, data) {
+    return new Uint8Array(await subtle().decrypt({ name: "AES-CBC", iv: buf(iv) }, await aesKey(key, "decrypt"), buf(data)));
+}
+/** AES-CBC WITHOUT padding (`data.length` must be a multiple of 16). WebCrypto pads unconditionally, so we
+ *  encrypt and drop the extra full pad block - the leading blocks are the true unpadded CBC. */
+export async function aesCbcEncryptNoPad(key, iv, data) {
+    if (data.length % 16 !== 0)
+        throw new Error("aesCbcEncryptNoPad: data must be a multiple of 16 bytes.");
+    return (await aesCbcEncrypt(key, iv, data)).subarray(0, data.length);
+}
+const xor16 = (a, b) => {
+    const o = new Uint8Array(16);
+    for (let i = 0; i < 16; i++)
+        o[i] = a[i] ^ b[i];
+    return o;
+};
+/** AES-CBC no-padding DECRYPT (`data` a multiple of 16). We append one cipher block crafted to decrypt to a
+ *  full 0x10 PKCS#7 pad (so WebCrypto accepts and strips it), leaving the original. */
+export async function aesCbcDecryptNoPad(key, iv, data) {
+    if (data.length === 0 || data.length % 16 !== 0)
+        throw new Error("aesCbcDecryptNoPad: data must be a non-zero multiple of 16 bytes.");
+    const prev = data.length >= 16 ? data.subarray(data.length - 16) : iv;
+    // ECB(x) == first block of CBC(iv=0, x); we want the appended block to decrypt to 0x10*16 after the CBC xor.
+    const appended = await aesCbcEncryptNoPad(key, new Uint8Array(16), xor16(new Uint8Array(16).fill(16), prev));
+    const withPad = new Uint8Array(data.length + 16);
+    withPad.set(data);
+    withPad.set(appended, data.length);
+    return aesCbcDecrypt(key, iv, withPad);
+}

package/dist/elements/container-element.d.ts

@@ -1,7 +1,7 @@
-import { MainAlign, CrossAlign } from "../utils/flex-layout";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { Fragmentable, FragmentResult } from "../layout/fragmentation";
-import { LayoutContext, SizedElement, SizedPDFElement, WithChildren } from "./pdf-element";
+import { MainAlign, CrossAlign } from "../utils/flex-layout.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
+import { LayoutContext, SizedElement, SizedPDFElement, WithChildren } from "./pdf-element.js";
 interface ContainerElementParams extends SizedElement, WithChildren {
     /** Space between children. */
     gap?: number;

package/dist/elements/container-element.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerElement = void 0;
-const flex_layout_1 = require("../utils/flex-layout");
-const fragmentation_1 = require("../layout/fragmentation");
-const pdf_element_1 = require("./pdf-element");
-class ContainerElement extends pdf_element_1.SizedPDFElement {
+import { FlexLayoutHelper, VERTICAL_AXIS } from "../utils/flex-layout.js";
+import { packChildren } from "../layout/fragmentation.js";
+import { SizedPDFElement, } from "./pdf-element.js";
+export class ContainerElement extends SizedPDFElement {
     constructor({ x, y, width, height, children, gap, main, cross }) {
         super({ x, y, width, height });
         this.children = children;
-        this.gap = gap !== null && gap !== void 0 ? gap : 0;
-        this.main = main !== null && main !== void 0 ? main : "start";
-        this.cross = cross !== null && cross !== void 0 ? cross : "stretch";
+        this.gap = gap ?? 0;
+        this.main = main ?? "start";
+        this.cross = cross ?? "stretch";
     }
     /**
      * Splits the vertical stack across pages. Children are measured against the content
@@ -24,7 +21,7 @@ class ContainerElement extends pdf_element_1.SizedPDFElement {
      * in that case we don't fragment and hand the whole container back as `fitted`.
      */
     fragment(maxHeight, width, ctx) {
-        const { fitted, remainder } = (0, fragmentation_1.packChildren)(this.children, maxHeight, width, ctx, this.gap);
+        const { fitted, remainder } = packChildren(this.children, maxHeight, width, ctx, this.gap);
         // Fits as one region: hand the whole container back so the page renders unchanged
         // (its normal layout distributes flex / fills the page).
         if (remainder.length === 0)
@@ -64,7 +61,7 @@ class ContainerElement extends pdf_element_1.SizedPDFElement {
             // Vertical flex stack (main = height, cross = width). The shared helper measures
             // fixed children, distributes the leftover to flex children, and places everything
             // in source order.
-            result = flex_layout_1.FlexLayoutHelper.layout(this.children, flex_layout_1.VERTICAL_AXIS, mainAvail, crossAvail, this.y, this.x, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
+            result = FlexLayoutHelper.layout(this.children, VERTICAL_AXIS, mainAvail, crossAvail, this.y, this.x, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
         }
         // Bounded: fill the offered extent. Unbounded: shrink to the children (height = the
         // stack, width = the widest child). Top-left coordinates; the container draws nothing,
@@ -88,4 +85,3 @@ class ContainerElement extends pdf_element_1.SizedPDFElement {
         };
     }
 }
-exports.ContainerElement = ContainerElement;

package/dist/elements/image-element.d.ts

@@ -1,5 +1,5 @@
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { LayoutContext, SizedPDFElement } from "./pdf-element";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { LayoutContext, SizedPDFElement } from "./pdf-element.js";
 export declare enum BoxFit {
     none = "NONE",
     contain = "CONTAIN",
@@ -29,6 +29,22 @@ export declare class CustomLocalImage extends CustomImage {
         height: number;
     }>;
 }
+/**
+ * An image straight from raw bytes (a browser upload / fetch, no filesystem). The PDF filter is sniffed
+ * from the magic bytes: JPEG embeds raw (DCTDecode, no decode step), PNG is decoded to RGB (FlateDecode).
+ */
+export declare class CustomBytesImage extends CustomImage {
+    private bytes;
+    private fileRawData;
+    constructor(bytes: Uint8Array);
+    init(): Promise<void>;
+    getImageType(): Promise<string>;
+    getFileData(): string;
+    getImageDimensions(): Promise<{
+        width: number;
+        height: number;
+    }>;
+}
 interface ImageElementParams {
     image: CustomImage;
     width?: number;

package/dist/elements/image-element.js

@@ -1,131 +1,108 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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.ImageElement = exports.CustomLocalImage = exports.CustomImage = exports.BoxFit = void 0;
-const image_helper_1 = require("../utils/image-helper");
-const pdf_element_1 = require("./pdf-element");
-var BoxFit;
+import { getImageDimensions } from "../utils/image-helper.js";
+import { latin1FromBytes } from "../utils/bytes.js";
+import { readFileBytesAsync } from "../platform/node-fs.js";
+import { SizedPDFElement } from "./pdf-element.js";
+// path.extname without node:path (browser-safe): the substring from the last dot, if it sits after the
+// last slash (so a dot in a directory name does not count). Enough for image file extensions.
+function extname(p) {
+    const dot = p.lastIndexOf(".");
+    const slash = p.lastIndexOf("/");
+    return dot > slash + 1 ? p.slice(dot) : "";
+}
+export var BoxFit;
 (function (BoxFit) {
     BoxFit["none"] = "NONE";
     BoxFit["contain"] = "CONTAIN";
     BoxFit["cover"] = "COVER";
     BoxFit["fill"] = "FILL";
-})(BoxFit || (exports.BoxFit = BoxFit = {}));
-class CustomImage {
+})(BoxFit || (BoxFit = {}));
+export class CustomImage {
 }
-exports.CustomImage = CustomImage;
-class CustomLocalImage extends CustomImage {
+export class CustomLocalImage extends CustomImage {
     constructor(imagePath) {
         super();
         this.imagePath = imagePath;
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Loading image and convert it to base64
-                yield this.loadImage(this.imagePath);
-            }
-            catch (error) {
-                console.error("Error loading image:", error);
-            }
-        });
+    async init() {
+        try {
+            // Loading image and convert it to base64
+            await this.loadImage(this.imagePath);
+        }
+        catch (error) {
+            console.error("Error loading image:", error);
+        }
+    }
+    async getImageType() {
+        const ext = extname(this.imagePath).toLowerCase();
+        switch (ext) {
+            case ".jpg":
+            case ".jpeg":
+                return "DCTDecode"; // For JPEG
+            case ".png":
+                return "FlateDecode"; // For PNG
+            case ".bmp":
+                throw new Error("BMP is not directly supported. Please convert to PNG or JPEG.");
+            case ".webp":
+                throw new Error("WebP is not directly supported. Please convert to PNG or JPEG.");
+            default:
+                throw new Error(`Unsupported image format: ${ext}`);
+        }
+    }
+    async loadImage(imagePath) {
+        const result = await readFileBytesAsync(imagePath);
+        //const result = await convertImageToGrayscaleBuffer(imagePath);
+        this.fileBuffer = result;
+        this.fileRawData = latin1FromBytes(result);
+        return result;
     }
-    getImageType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = yield Promise.resolve().then(() => __importStar(require("path"))); // Dynamic import
-            const ext = path.extname(this.imagePath).toLowerCase();
-            switch (ext) {
-                case ".jpg":
-                case ".jpeg":
-                    return "DCTDecode"; // For JPEG
-                case ".png":
-                    return "FlateDecode"; // For PNG
-                case ".bmp":
-                    throw new Error("BMP is not directly supported. Please convert to PNG or JPEG.");
-                case ".webp":
-                    throw new Error("WebP is not directly supported. Please convert to PNG or JPEG.");
-                default:
-                    throw new Error(`Unsupported image format: ${ext}`);
-            }
-        });
+    getFileData() {
+        return this.fileRawData;
+    }
+    async getImageDimensions() {
+        if (!this.fileBuffer) {
+            throw new Error("You must first call the `loadAndConvertImage` method");
+        }
+        // Since now (30.09.2024) we using "Jimp" - So we don't need our custom method to get the image dimension.
+        // But at the moment I let it still here...
+        const dimensions = await getImageDimensions(this.fileBuffer);
+        return dimensions;
+    }
+}
+/**
+ * An image straight from raw bytes (a browser upload / fetch, no filesystem). The PDF filter is sniffed
+ * from the magic bytes: JPEG embeds raw (DCTDecode, no decode step), PNG is decoded to RGB (FlateDecode).
+ */
+export class CustomBytesImage extends CustomImage {
+    constructor(bytes) {
+        super();
+        this.bytes = bytes;
+        this.fileRawData = latin1FromBytes(bytes);
     }
-    loadImage(imagePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fs = yield Promise.resolve().then(() => __importStar(require("fs/promises"))); // Dynamic import
-            const result = yield fs.readFile(imagePath);
-            //const result = await convertImageToGrayscaleBuffer(imagePath);
-            this.fileBuffer = result;
-            this.fileRawData = result.toString("binary");
-            return result;
-        });
+    async init() { }
+    async getImageType() {
+        const b = this.bytes;
+        if (b[0] === 0xff && b[1] === 0xd8)
+            return "DCTDecode"; // JPEG
+        if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47)
+            return "FlateDecode"; // PNG
+        throw new Error("Unsupported image bytes (only JPEG and PNG are supported).");
     }
     getFileData() {
         return this.fileRawData;
     }
-    getImageDimensions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.fileBuffer) {
-                throw new Error("You must first call the `loadAndConvertImage` method");
-            }
-            // Since now (30.09.2024) we using "Jimp" - So we don't need our custom method to get the image dimension.
-            // But at the moment I let it still here...
-            const dimensions = yield (0, image_helper_1.getImageDimensions)(this.fileBuffer);
-            return dimensions;
-        });
+    async getImageDimensions() {
+        return getImageDimensions(this.bytes);
     }
 }
-exports.CustomLocalImage = CustomLocalImage;
-class ImageElement extends pdf_element_1.SizedPDFElement {
+export class ImageElement extends SizedPDFElement {
     constructor({ image, width, height, fit = BoxFit.none, radius }) {
         super({ x: 0, y: 0, width });
         this.image = image;
         this.height = height;
         this.fit = fit;
-        this.radius = radius !== null && radius !== void 0 ? radius : 0;
+        this.radius = radius ?? 0;
     }
     calculateLayout(constraints, offset, _ctx) {
-        var _a, _b;
         this.x = offset.x;
         this.y = offset.y;
         // A bounded axis overrides the intrinsic/explicit size; otherwise keep our own.
@@ -134,7 +111,7 @@ class ImageElement extends pdf_element_1.SizedPDFElement {
         if (constraints.hasBoundedHeight)
             this.height = constraints.maxHeight;
         // Top-left coordinates; the fit logic (renderer) and the Y-flip (seam) run later.
-        return { width: (_a = this.width) !== null && _a !== void 0 ? _a : 0, height: (_b = this.height) !== null && _b !== void 0 ? _b : 0 };
+        return { width: this.width ?? 0, height: this.height ?? 0 };
     }
     getProps() {
         return {
@@ -148,4 +125,3 @@ class ImageElement extends pdf_element_1.SizedPDFElement {
         };
     }
 }
-exports.ImageElement = ImageElement;

package/dist/elements/index.d.ts

@@ -1,11 +1,12 @@
-export { PDFElement } from "./pdf-element";
-export * from "./text-element";
-export * from "./pdf-document-element";
-export * from "./page-element";
-export * from "./rectangle-element";
-export * from "./image-element";
-export * from "./layout/expanded-element";
-export * from "./layout/padding-element";
-export * from "./layout/positioned-element";
-export * from "./line-element";
-export * from "./row-element";
+export { PDFElement } from "./pdf-element.js";
+export * from "./text-element.js";
+export * from "./pdf-document-element.js";
+export * from "./page-element.js";
+export * from "./rectangle-element.js";
+export * from "./image-element.js";
+export * from "./layout/expanded-element.js";
+export * from "./layout/padding-element.js";
+export * from "./layout/default-text-style-element.js";
+export * from "./layout/positioned-element.js";
+export * from "./line-element.js";
+export * from "./row-element.js";