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

package/dist/utils/pdf-object-manager.d.ts

@@ -1,5 +1,7 @@
-import type { PDFConfig } from "../renderer/pdf-document-class";
-import type { FontMetrics } from "./font-metrics";
+import type { OverflowPolicy } from "../layout/fragmentation.js";
+import type { SecurityHandler } from "../crypto/security-handler.js";
+import type { PDFConfig } from "../renderer/pdf-document-class.js";
+import type { FontMetrics } from "./font-metrics.js";
 interface FontIndexes {
     fontIndex: number;
     resourceIndex: number;
@@ -30,10 +32,18 @@ export declare class PDFObjectManager implements FontMetrics {
     private pdfVersion;
     private documentId;
     private compress;
+    private overflowPolicy;
+    private security?;
+    private encJobs;
+    private encryptObjNum?;
     constructor();
     addObject(content: string): number;
     replaceObject(objectNumber: number, content: string): void;
     setCompress(on: boolean): void;
+    setOverflowPolicy(policy: OverflowPolicy): void;
+    getOverflowPolicy(): OverflowPolicy;
+    private encToken;
+    private streamPayload;
     private stream;
     addContentStream(content: string): number;
     changePDFConfig(config: PDFConfig): void;
@@ -42,8 +52,8 @@ export declare class PDFObjectManager implements FontMetrics {
     private getCurrentByteLength;
     setParentObjectNumber(number: number): void;
     getParentObjectNumber(): number;
-    registerImage(width: number, height: number, imageType: string, imageData: string): number;
-    attachFile(name: string, data: Buffer, opts?: {
+    registerImage(width: number, height: number, imageType: string, imageData: string, smaskData?: string): number;
+    attachFile(name: string, data: Uint8Array, opts?: {
         relationship?: string;
         mimeType?: string;
         description?: string;
@@ -54,7 +64,7 @@ export declare class PDFObjectManager implements FontMetrics {
     }[];
     setXmpMetadata(xml: string): void;
     getXmpMetadata(): string | undefined;
-    setOutputIntent(icc: Buffer, opts?: {
+    setOutputIntent(icc: Uint8Array, opts?: {
         identifier?: string;
         info?: string;
     }): void;
@@ -63,10 +73,12 @@ export declare class PDFObjectManager implements FontMetrics {
     getPdfVersion(): string;
     getHeader(): string;
     enableDocumentId(): void;
+    setSecurityHandler(handler: SecurityHandler): void;
+    finalizeEncryption(): Promise<void>;
     registerExtGState(fillAlpha: number, strokeAlpha: number): string;
     getAllExtGStatesRaw(): Map<string, number>;
     registerFont(fontName: string, fontStyle?: FontStyle, fullName?: string): FontIndexes;
-    registerCustomFont(name: string, data: Buffer, style?: FontStyle): void;
+    registerCustomFont(name: string, data: Uint8Array, style?: FontStyle): void;
     private ensureEmitted;
     finalizeCustomFonts(): void;
     private subsetTag;

package/dist/utils/renderer-registry.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RendererRegistry = void 0;
-class RendererRegistry {
+export class RendererRegistry {
     static register(elementClass, renderer) {
         if (!RendererRegistry.renderers.has(elementClass)) {
             RendererRegistry.renderers.set(elementClass, renderer);
@@ -15,5 +12,4 @@ class RendererRegistry {
         return renderer.constructor.name === "AsyncFunction";
     }
 }
-exports.RendererRegistry = RendererRegistry;
 RendererRegistry.renderers = new Map();

package/dist/utils/ttf-parser.d.ts

@@ -10,8 +10,8 @@ export declare class TTFParser {
     private cmap;
     private cmapGroups;
     private tables;
-    constructor(data: Buffer);
-    getData(): Buffer;
+    constructor(data: Uint8Array);
+    getData(): Uint8Array;
     glyphCount(): number;
     glyphWidths(): number[];
     reverseCmap(): Map<number, number>;

package/dist/utils/ttf-parser.js

@@ -1,10 +1,8 @@
-"use strict";
 // Parses the metric tables of a TrueType (.ttf) font - the binary counterpart to AFMParser.
 // Slice 1: glyph advance widths (hmtx) + the Unicode→glyph map (cmap), enough to compute
 // text width the same way AFMParser does for the standard-14. Embedding/subsetting come later.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TTFParser = void 0;
-class TTFParser {
+import { i16, latin1FromBytes, u16, u32 } from "./bytes.js";
+export class TTFParser {
     constructor(data) {
         this.data = data;
         this.unitsPerEm = 1000;
@@ -20,18 +18,18 @@ class TTFParser {
         this.tables = {};
         this.readTableDirectory();
         const head = this.table("head").offset;
-        this.unitsPerEm = this.data.readUInt16BE(head + 18);
-        this.numGlyphs = this.data.readUInt16BE(this.table("maxp").offset + 4);
-        this.numHMetrics = this.data.readUInt16BE(this.table("hhea").offset + 34);
+        this.unitsPerEm = u16(this.data, head + 18);
+        this.numGlyphs = u16(this.data, this.table("maxp").offset + 4);
+        this.numHMetrics = u16(this.data, this.table("hhea").offset + 34);
         this.bbox = [
-            this.toGlyphSpace(this.data.readInt16BE(head + 36)), // xMin
-            this.toGlyphSpace(this.data.readInt16BE(head + 38)), // yMin
-            this.toGlyphSpace(this.data.readInt16BE(head + 40)), // xMax
-            this.toGlyphSpace(this.data.readInt16BE(head + 42)), // yMax
+            this.toGlyphSpace(i16(this.data, head + 36)), // xMin
+            this.toGlyphSpace(i16(this.data, head + 38)), // yMin
+            this.toGlyphSpace(i16(this.data, head + 40)), // xMax
+            this.toGlyphSpace(i16(this.data, head + 42)), // yMax
         ];
         const hhea = this.table("hhea").offset;
-        this.ascent = this.toGlyphSpace(this.data.readInt16BE(hhea + 4));
-        this.descent = this.toGlyphSpace(this.data.readInt16BE(hhea + 6));
+        this.ascent = this.toGlyphSpace(i16(this.data, hhea + 4));
+        this.descent = this.toGlyphSpace(i16(this.data, hhea + 6));
         this.readHmtx();
         this.readCmap();
     }
@@ -76,9 +74,8 @@ class TTFParser {
     }
     // Advance width of a glyph in font units. Glyphs past numHMetrics reuse the last advance.
     getAdvanceWidth(glyphIndex) {
-        var _a;
         const i = Math.min(glyphIndex, this.numHMetrics - 1);
-        return (_a = this.advanceWidths[i]) !== null && _a !== void 0 ? _a : 0;
+        return this.advanceWidths[i] ?? 0;
     }
     // Char width at fontSize, scaled from font units (em = unitsPerEm) to points.
     getCharWidth(char, fontSize) {
@@ -99,13 +96,13 @@ class TTFParser {
         return t;
     }
     readTableDirectory() {
-        const numTables = this.data.readUInt16BE(4);
+        const numTables = u16(this.data, 4);
         let p = 12; // after the offset table (sfntVersion + numTables + 3 fields)
         for (let i = 0; i < numTables; i++) {
-            const tag = this.data.toString("latin1", p, p + 4);
+            const tag = latin1FromBytes(this.data.subarray(p, p + 4));
             this.tables[tag] = {
-                offset: this.data.readUInt32BE(p + 8),
-                length: this.data.readUInt32BE(p + 12),
+                offset: u32(this.data, p + 8),
+                length: u32(this.data, p + 12),
             };
             p += 16;
         }
@@ -116,20 +113,20 @@ class TTFParser {
         let last = 0;
         for (let i = 0; i < this.numGlyphs; i++) {
             if (i < this.numHMetrics)
-                last = this.data.readUInt16BE(o + i * 4);
+                last = u16(this.data, o + i * 4);
             this.advanceWidths.push(last);
         }
     }
     readCmap() {
         const base = this.table("cmap").offset;
-        const numTables = this.data.readUInt16BE(base + 2);
+        const numTables = u16(this.data, base + 2);
         // Prefer the Windows Unicode BMP subtable (3,1); accept full-Unicode (3,10) or any (0,x).
         let subtable = -1;
         let p = base + 4;
         for (let i = 0; i < numTables; i++) {
-            const platform = this.data.readUInt16BE(p);
-            const encoding = this.data.readUInt16BE(p + 2);
-            const offset = this.data.readUInt32BE(p + 4);
+            const platform = u16(this.data, p);
+            const encoding = u16(this.data, p + 2);
+            const offset = u32(this.data, p + 4);
             const unicode = (platform === 3 && (encoding === 1 || encoding === 10)) || platform === 0;
             if (unicode) {
                 subtable = base + offset;
@@ -140,7 +137,7 @@ class TTFParser {
         }
         if (subtable < 0)
             return;
-        const format = this.data.readUInt16BE(subtable);
+        const format = u16(this.data, subtable);
         if (format === 4)
             this.readCmapFormat4(subtable);
         else if (format === 12)
@@ -149,23 +146,23 @@ class TTFParser {
     // Format 4: segment mapping. Four parallel arrays keyed by segment; the glyph comes either
     // from idDelta or, when idRangeOffset != 0, from the glyphIdArray it points into.
     readCmapFormat4(o) {
-        const segCountX2 = this.data.readUInt16BE(o + 6);
+        const segCountX2 = u16(this.data, o + 6);
         const endCodes = o + 14;
         const startCodes = endCodes + segCountX2 + 2; // +2 reservedPad
         const idDeltas = startCodes + segCountX2;
         const idRangeOffsets = idDeltas + segCountX2;
         for (let i = 0; i < segCountX2 / 2; i++) {
-            const end = this.data.readUInt16BE(endCodes + i * 2);
-            const start = this.data.readUInt16BE(startCodes + i * 2);
-            const delta = this.data.readUInt16BE(idDeltas + i * 2);
-            const rangeOffset = this.data.readUInt16BE(idRangeOffsets + i * 2);
+            const end = u16(this.data, endCodes + i * 2);
+            const start = u16(this.data, startCodes + i * 2);
+            const delta = u16(this.data, idDeltas + i * 2);
+            const rangeOffset = u16(this.data, idRangeOffsets + i * 2);
             for (let c = start; c <= end && c !== 0xffff; c++) {
                 let glyph;
                 if (rangeOffset === 0) {
                     glyph = (c + delta) & 0xffff;
                 }
                 else {
-                    glyph = this.data.readUInt16BE(idRangeOffsets + i * 2 + rangeOffset + (c - start) * 2);
+                    glyph = u16(this.data, idRangeOffsets + i * 2 + rangeOffset + (c - start) * 2);
                     if (glyph !== 0)
                         glyph = (glyph + delta) & 0xffff;
                 }
@@ -176,16 +173,15 @@ class TTFParser {
     }
     // Format 12: sequential groups for full Unicode (incl. astral). Kept un-expanded.
     readCmapFormat12(o) {
-        const nGroups = this.data.readUInt32BE(o + 12);
+        const nGroups = u32(this.data, o + 12);
         let p = o + 16;
         for (let i = 0; i < nGroups; i++) {
             this.cmapGroups.push({
-                start: this.data.readUInt32BE(p),
-                end: this.data.readUInt32BE(p + 4),
-                startGlyph: this.data.readUInt32BE(p + 8),
+                start: u32(this.data, p),
+                end: u32(this.data, p + 4),
+                startGlyph: u32(this.data, p + 8),
             });
             p += 12;
         }
     }
 }
-exports.TTFParser = TTFParser;

package/dist/utils/ttf-subsetter.d.ts

@@ -1 +1 @@
-export declare function subsetTTF(data: Buffer, used: Set<number>): Buffer;
+export declare function subsetTTF(data: Uint8Array, used: Set<number>): Uint8Array;

package/dist/utils/ttf-subsetter.js

@@ -1,32 +1,30 @@
-"use strict";
 // Builds a subset TrueType font that KEEPS the original glyph ids: the PDF content stream emits
 // original gids and /W + CIDToGIDMap=Identity stay valid, so only the font program shrinks. We drop
 // the `glyf` outlines of unused glyphs (the bulk of the file) and rebuild `loca`; every other table
 // is copied verbatim. The used-glyph set is closed over composite-glyph components first, so a glyph
 // built from others (e.g. "ä") keeps its parts. Fonts without `glyf`/`loca` (CFF/OTF) pass through.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.subsetTTF = subsetTTF;
-const u32 = (n) => n >>> 0;
+import { concatBytes, i16, latin1FromBytes, u16, u32, wi16, wu16, wu32, writeLatin1, } from "./bytes.js";
+const wrap32 = (n) => n >>> 0;
 /** TrueType table checksum: sum of big-endian uint32 over the 4-byte-padded table data. */
 function checksum(buf) {
     let sum = 0;
     for (let i = 0; i < buf.length; i += 4)
-        sum = u32(sum + buf.readUInt32BE(i));
+        sum = wrap32(sum + u32(buf, i));
     return sum;
 }
 /** Right-pad to a 4-byte boundary (table data is aligned in the sfnt). */
 function pad4(buf) {
     const rem = buf.length % 4;
-    return rem === 0 ? buf : Buffer.concat([buf, Buffer.alloc(4 - rem)]);
+    return rem === 0 ? buf : concatBytes([buf, new Uint8Array(4 - rem)]);
 }
-function subsetTTF(data, used) {
-    const numTables = data.readUInt16BE(4);
+export function subsetTTF(data, used) {
+    const numTables = u16(data, 4);
     const dir = new Map();
     let p = 12;
     for (let i = 0; i < numTables; i++) {
-        dir.set(data.toString("latin1", p, p + 4), {
-            offset: data.readUInt32BE(p + 8),
-            length: data.readUInt32BE(p + 12),
+        dir.set(latin1FromBytes(data.subarray(p, p + 4)), {
+            offset: u32(data, p + 8),
+            length: u32(data, p + 12),
         });
         p += 16;
     }
@@ -34,14 +32,14 @@ function subsetTTF(data, used) {
     if (!dir.has("glyf") || !dir.has("loca") || !dir.has("head") || !dir.has("maxp"))
         return data;
     const headOff = dir.get("head").offset;
-    const longLoca = data.readInt16BE(headOff + 50) === 1;
-    const numGlyphs = data.readUInt16BE(dir.get("maxp").offset + 4);
+    const longLoca = i16(data, headOff + 50) === 1;
+    const numGlyphs = u16(data, dir.get("maxp").offset + 4);
     const locaOff = dir.get("loca").offset;
     const glyfOff = dir.get("glyf").offset;
     // Original glyph offsets (numGlyphs + 1 entries; short loca stores half-offsets).
     const loca = [];
     for (let g = 0; g <= numGlyphs; g++) {
-        loca.push(longLoca ? data.readUInt32BE(locaOff + g * 4) : data.readUInt16BE(locaOff + g * 2) * 2);
+        loca.push(longLoca ? u32(data, locaOff + g * 4) : u16(data, locaOff + g * 2) * 2);
     }
     const glyphBytes = (g) => data.subarray(glyfOff + loca[g], glyfOff + loca[g + 1]);
     // Close the used set over composite components (and always keep .notdef = gid 0).
@@ -53,12 +51,12 @@ function subsetTTF(data, used) {
             continue;
         keep.add(g);
         const gd = glyphBytes(g);
-        if (gd.length >= 10 && gd.readInt16BE(0) < 0) {
+        if (gd.length >= 10 && i16(gd, 0) < 0) {
             // Composite glyph: walk the component records to collect the referenced gids.
             let q = 10; // numberOfContours(2) + xMin/yMin/xMax/yMax(8)
             for (;;) {
-                const flags = gd.readUInt16BE(q);
-                stack.push(gd.readUInt16BE(q + 2));
+                const flags = u16(gd, q);
+                stack.push(u16(gd, q + 2));
                 q += 4 + (flags & 0x0001 ? 4 : 2); // ARG_1_AND_2_ARE_WORDS
                 if (flags & 0x0008)
                     q += 2; // WE_HAVE_A_SCALE
@@ -73,24 +71,24 @@ function subsetTTF(data, used) {
     }
     // Rebuild glyf (kept glyphs only, original numbering) + a long-format loca.
     const parts = [];
-    const newLoca = Buffer.alloc((numGlyphs + 1) * 4);
+    const newLoca = new Uint8Array((numGlyphs + 1) * 4);
     let off = 0;
     for (let g = 0; g < numGlyphs; g++) {
-        newLoca.writeUInt32BE(off, g * 4);
+        wu32(newLoca, off, g * 4);
         if (keep.has(g)) {
-            let gd = Buffer.from(glyphBytes(g));
+            let gd = glyphBytes(g).slice(); // copy: padded + concatenated, must not view `data`
             if (gd.length % 2 === 1)
-                gd = Buffer.concat([gd, Buffer.alloc(1)]); // keep offsets even
+                gd = concatBytes([gd, new Uint8Array(1)]); // keep offsets even
             parts.push(gd);
             off += gd.length;
         }
     }
-    newLoca.writeUInt32BE(off, numGlyphs * 4);
-    const newGlyf = Buffer.concat(parts);
+    wu32(newLoca, off, numGlyphs * 4);
+    const newGlyf = concatBytes(parts);
     // head copy with indexToLocFormat = 1 (long); checkSumAdjustment zeroed, fixed up at the end.
-    const newHead = Buffer.from(data.subarray(headOff, headOff + dir.get("head").length));
-    newHead.writeInt16BE(1, 50);
-    newHead.writeUInt32BE(0, 8);
+    const newHead = data.slice(headOff, headOff + dir.get("head").length);
+    wi16(newHead, 1, 50);
+    wu32(newHead, 0, 8);
     // Tables a PDF-embedded CIDFontType2 doesn't need - layout (GSUB/GPOS…), hinting hints and the
     // signature are dead weight; dropping them is most of the size win. `post` is reduced to format 3
     // (header only, no glyph names). cmap/name/OS-2 are kept for a still-valid standalone font.
@@ -119,8 +117,8 @@ function subsetTTF(data, used) {
             body = newHead;
         else if (tag === "post") {
             // Keep the 32-byte header, force version 3.0 (drops the per-glyph name list).
-            body = Buffer.from(data.subarray(dir.get("post").offset, dir.get("post").offset + 32));
-            body.writeUInt32BE(0x00030000, 0);
+            body = data.slice(dir.get("post").offset, dir.get("post").offset + 32);
+            wu32(body, 0x00030000, 0);
         }
         else {
             const d = dir.get(tag);
@@ -132,30 +130,30 @@ function subsetTTF(data, used) {
     const n = tables.length;
     const maxPow2 = 1 << Math.floor(Math.log2(n));
     const out = [];
-    const offsetTable = Buffer.alloc(12);
-    offsetTable.writeUInt32BE(data.readUInt32BE(0), 0); // sfntVersion
-    offsetTable.writeUInt16BE(n, 4);
-    offsetTable.writeUInt16BE(maxPow2 * 16, 6); // searchRange
-    offsetTable.writeUInt16BE(Math.floor(Math.log2(n)), 8); // entrySelector
-    offsetTable.writeUInt16BE(n * 16 - maxPow2 * 16, 10); // rangeShift
+    const offsetTable = new Uint8Array(12);
+    wu32(offsetTable, u32(data, 0), 0); // sfntVersion
+    wu16(offsetTable, n, 4);
+    wu16(offsetTable, maxPow2 * 16, 6); // searchRange
+    wu16(offsetTable, Math.floor(Math.log2(n)), 8); // entrySelector
+    wu16(offsetTable, n * 16 - maxPow2 * 16, 10); // rangeShift
     out.push(offsetTable);
-    const dirBuf = Buffer.alloc(n * 16);
+    const dirBuf = new Uint8Array(n * 16);
     let tableOffset = 12 + n * 16;
     const dataBufs = [];
     tables.forEach((t, i) => {
         const padded = pad4(t.body);
-        dirBuf.write(t.tag, i * 16, 4, "latin1");
-        dirBuf.writeUInt32BE(checksum(padded), i * 16 + 4);
-        dirBuf.writeUInt32BE(tableOffset, i * 16 + 8);
-        dirBuf.writeUInt32BE(t.length, i * 16 + 12); // real (unpadded) length
+        writeLatin1(dirBuf, t.tag, i * 16);
+        wu32(dirBuf, checksum(padded), i * 16 + 4);
+        wu32(dirBuf, tableOffset, i * 16 + 8);
+        wu32(dirBuf, t.length, i * 16 + 12); // real (unpadded) length
         tableOffset += padded.length;
         dataBufs.push(padded);
     });
     out.push(dirBuf, ...dataBufs);
-    const font = Buffer.concat(out);
+    const font = concatBytes(out);
     // head.checkSumAdjustment = 0xB1B0AFBA - checksum(whole font). Locate head in the assembled font.
     const headIdx = tables.findIndex((t) => t.tag === "head");
-    const headPos = dirBuf.readUInt32BE(headIdx * 16 + 8);
-    font.writeUInt32BE(u32(0xb1b0afba - checksum(font)), headPos + 8);
+    const headPos = u32(dirBuf, headIdx * 16 + 8);
+    wu32(font, wrap32(0xb1b0afba - checksum(font)), headPos + 8);
     return font;
 }

package/dist/utils/utf8-to-windows1252-encoder.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getArrayBuffer = getArrayBuffer;
 // Windows-1252 equals Latin-1 (codepoint == byte) EXCEPT in 0x80-0x9F, where it carries
 // printable punctuation - the Euro sign, smart quotes, dashes, ellipsis, ... - instead of
 // C1 controls. Those glyphs sit at Unicode codepoints far outside 0x00-0xFF, so a naive
@@ -37,7 +34,7 @@ const CP1252_FROM_UNICODE = {
     0x0178: 0x9f, // Ÿ Y diaeresis
 };
 /** Encodes a JavaScript string to a Windows-1252 byte buffer (the PDF text encoding). */
-function getArrayBuffer(data) {
+export function getArrayBuffer(data) {
     const u8 = new Uint8Array(data.length);
     for (let i = 0; i < data.length; i++) {
         const code = data.charCodeAt(i);

package/dist/validators/element-validator.d.ts

@@ -1,5 +1,5 @@
-import { PDFDocumentElement } from "../elements/pdf-document-element";
-import { PDFElement, FlexiblePDFElement, SizedPDFElement } from "../elements/pdf-element";
+import { PDFDocumentElement } from "../elements/pdf-document-element.js";
+import { PDFElement, FlexiblePDFElement, SizedPDFElement } from "../elements/pdf-element.js";
 export declare class Validator {
     static validateDocument(document: PDFDocumentElement): void;
     static validateElement(element: PDFElement): void;

package/dist/validators/element-validator.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-const pdf_document_element_1 = require("../elements/pdf-document-element");
-const pdf_element_1 = require("../elements/pdf-element");
-class Validator {
+import { PDFDocumentElement } from "../elements/pdf-document-element.js";
+import { FlexiblePDFElement, hasChildProp, SizedPDFElement, } from "../elements/pdf-element.js";
+export class Validator {
     static validateDocument(document) {
         // More validation will be added later...
         document.getProps().children.forEach((page) => {
             page.getProps().children.forEach((element) => {
-                if (element instanceof pdf_document_element_1.PDFDocumentElement) {
+                if (element instanceof PDFDocumentElement) {
                     throw new Error("PDFDocument cannot be nested inside another element.");
                 }
             });
@@ -16,11 +13,11 @@ class Validator {
     }
     static validateElement(element) {
         // Structural validation
-        if (element instanceof pdf_document_element_1.PDFDocumentElement) {
+        if (element instanceof PDFDocumentElement) {
             throw new Error("PDFDocument cannot be nested inside another element.");
         }
         // Layout validation: geometry comes from the typed getSize(), not the props bag.
-        if (element instanceof pdf_element_1.SizedPDFElement) {
+        if (element instanceof SizedPDFElement) {
             const { width, height } = element.getSize();
             // Negative coordinates are allowed: a `Positioned` child overflows its frame on purpose,
             // and the page clips anything past its edge. 0 size is legitimate (a hairline divider, an
@@ -30,7 +27,7 @@ class Validator {
             }
         }
         // Logical validation: Flexible and fixed elements
-        if (element instanceof pdf_element_1.FlexiblePDFElement) {
+        if (element instanceof FlexiblePDFElement) {
             this.validateFlexElement(element);
         }
     }
@@ -49,11 +46,10 @@ class Validator {
             throw new Error(`Flexible element ${element.constructor.name} has invalid flex value`);
         }
         // Ensure a flexible element does not contain another flexible element
-        if ((0, pdf_element_1.hasChildProp)(element)) {
-            if (element.child instanceof pdf_element_1.FlexiblePDFElement) {
+        if (hasChildProp(element)) {
+            if (element.child instanceof FlexiblePDFElement) {
                 throw new Error(`Flexible element ${element.constructor.name} cannot hold another flexible element`);
             }
         }
     }
 }
-exports.Validator = Validator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasy/pdf",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "description": "Declarative, component-based PDF generation in pure TypeScript - Flutter-style components, real AFM font metrics, a hand-rolled PDF writer. No headless browser, no Java.",
   "keywords": [
     "declarative",
@@ -19,9 +19,21 @@
   "files": [
     "dist"
   ],
+  "type": "module",
   "main": "dist/index.js",
+  "browser": {
+    "./dist/platform/node-fs.js": "./dist/platform/browser-fs.js",
+    "./dist/platform/node-image.js": "./dist/platform/browser-image.js"
+  },
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "dependencies": {
+    "fflate": "^0.8.3",
     "jimp": "^1.6.0"
   },
   "devDependencies": {
@@ -41,7 +53,7 @@
     "play": "pnpm --filter @jasy/playground play",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
-    "build": "tsc && pnpm run copy-assets",
+    "build": "tsc && node scripts/fix-dts-ext.mjs && pnpm run copy-assets",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",