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

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.3",
   "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",