@jasy/pdf 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/utils/pdf-object-manager.js

@@ -26,6 +26,7 @@ export function featureKey(f) {
 }
 const features = (ligatures) => ligatures ? LATIN_FEATURES : NO_FEATURES;
 import { getArrayBuffer, isWindows1252 } from "./utf8-to-windows1252-encoder.js";
+import { encodePdfText, isPlainPdfText } from "../text/pdf-text-string.js";
 import { isEmojiCodePoint } from "../text/emoji-codepoints.js";
 import { StructTree } from "./struct-tree.js";
 import { OutlineBuilder } from "./outline.js";
@@ -34,6 +35,14 @@ import { AcroFormCollector } from "../forms/acroform.js";
 // Enums come from the leaf config module (never in a cycle); the config type is
 // erased at runtime so it can come from the cyclic module safely.
 import { ColorMode, Orientation } from "../renderer/pdf-config.js";
+import { Diagnostics } from "../common/diagnostics.js";
+import { JpegFormatError } from "./image-helper.js";
+/** The PDF color space of each image color space, and its channel count (for `/Decode`). */
+const IMAGE_COLOR_SPACE = {
+    gray: { name: "DeviceGray", channels: 1 },
+    rgb: { name: "DeviceRGB", channels: 3 },
+    cmyk: { name: "DeviceCMYK", channels: 4 },
+};
 export var FontStyle;
 (function (FontStyle) {
     FontStyle["Normal"] = "normal";
@@ -184,8 +193,8 @@ export class PDFObjectManager {
         /** Shaped runs, cached face -> feature set -> text. Nested, not one map under a composed key: that
          *  key would carry the whole run's text, so every lookup would copy it into a fresh string. */
         this.shapeCache = new Map();
-        /** Bumped by every font registration; `runAdvance` watches it to drop memoised widths, since a
-         *  family name can mean a different face afterwards. */
+        /** Bumped when a face is really ADDED (a repeat registration returns early, untouched); every
+         *  memoised measurement watches it, since a family name can mean a different face afterwards. */
         this.fontEpoch = 0;
         // Per font, glyph -> the code points it stands for. A shaped glyph is often absent from the cmap (a
         // ligature) or maps back to a presentation form, so `ToUnicode` cannot come from the cmap alone.
@@ -220,10 +229,11 @@ export class PDFObjectManager {
          * character went missing instead of a server log nobody reads.
          */
         this.missingGlyphs = new Set();
+        /** The render's diagnostics channel (`onDiagnostic`); see `common/diagnostics.ts`. */
+        this.diagnostics = new Diagnostics();
         // Whether to kern. Document-level: measuring (via `runAdvance`, which reads this off the metrics)
-        // and drawing (the backend emits a `TJ`) both consult it, so they can never disagree. OFF while the
-        // embedded-font path (kern/GPOS) is unbuilt - a standard-14-only kerning would set the 14 system
-        // fonts finer than a user's own font, which is worse than none. Flip to on when GPOS lands.
+        // and drawing (the backend emits a `TJ`) both consult it, so they can never disagree. The default
+        // here is off; `renderPdf` turns it on unless the document says `kerning: false`.
         this.kerningEnabled = false;
         if (pageSize)
             this.pageFormat = pageFormats[pageSize];
@@ -247,9 +257,18 @@ export class PDFObjectManager {
     setCompress(on) {
         this.compress = on;
     }
-    reportMissingGlyph(codePoints) {
+    reportMissingGlyph(codePoints, about, page) {
         for (const cp of codePoints)
             this.missingGlyphs.add(cp);
+        const chars = codePoints.map((cp) => String.fromCodePoint(cp)).join("");
+        this.diagnostics.report({
+            code: "missing-glyphs",
+            severity: "warning",
+            message: `No font can draw ${JSON.stringify(chars)}; removed (PDF/A forbids .notdef).`,
+            about,
+            page,
+            fallback: "silent",
+        });
     }
     /** The dropped code points, in the order first seen. Empty for a document that hit none. */
     getMissingGlyphs() {
@@ -263,7 +282,7 @@ export class PDFObjectManager {
     }
     // A unique, binary-safe placeholder for a stream's bytes, swapped for ciphertext in finalizeEncryption().
     encToken(id) {
-        return `
JENC:${id}
`;
+        return `\x00\x01JENC:${id}\x01\x00`;
     }
     // The same trick for a literal STRING. A separate marker because the two are swapped differently: a
     // stream keeps its delimiters and only the payload changes, a string is replaced whole by a hex one.
@@ -282,15 +301,28 @@ export class PDFObjectManager {
      * A string INSIDE a content stream needs none of this - the stream is enciphered as a whole.
      */
     pdfString(text) {
+        // A TEXT string: PDFDocEncoding where it can say everything, else UTF-16BE (text/pdf-text-string.ts).
+        const bytes = encodePdfText(text);
         if (!this.security) {
-            return `(${text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)")})`;
+            // Plain Latin-1 comes out of the Windows-1252 page encoder as the same bytes PDFDocEncoding reads
+            // back, so it stays a readable literal; anything else is written as hex, past that encoder.
+            if (isPlainPdfText(text)) {
+                return `(${text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)")})`;
+            }
+            return `<${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}>`;
         }
         // Encrypt the bytes the unencrypted path would have written, so a viewer decrypts to the same value.
         // No escaping is applied: the result is emitted as a HEX string, which has no escapes to get wrong.
-        const bytes = new Uint8Array(getArrayBuffer(text));
         const id = this.strJobs.push(bytes) - 1;
         return this.strToken(id);
     }
+    /**
+     * A URI: 7-bit ASCII by definition, so anything else is percent-encoded as UTF-8 - the way a browser
+     * writes the link - rather than squeezed into a text encoding.
+     */
+    pdfUri(uri) {
+        return this.pdfString(uri.replace(/[^\x20-\x7e]/gu, (c) => encodeURIComponent(c)));
+    }
     // The single encryption choke-point every stream emitter routes through (stream(), registerImage). Without
     // a security handler: the bytes as a latin1 string + their length. With one: register the raw bytes for the
     // finalize pass and return a placeholder + the pre-computable encrypted length (16-byte IV + PKCS#7 padding).
@@ -371,7 +403,7 @@ export class PDFObjectManager {
         return this.parentObjectNumber;
     }
     // Registers an image
-    registerImage(width, height, imageType, imageData, smaskData) {
+    registerImage(width, height, imageType, imageData, smaskData, color = { space: "rgb" }) {
         // A transparent PNG carries its alpha as a separate DeviceGray /SMask image the viewer composites with.
         let smaskEntry = "";
         if (smaskData) {
@@ -389,14 +421,23 @@ ${s.body}
 endstream`;
             smaskEntry = `    /SMask ${this.addObject(smaskObject)} 0 R\n`;
         }
+        // PDF/A: the sRGB output intent forbids DeviceCMYK.
+        if (color.space === "cmyk" && this.outputIntent !== undefined) {
+            throw new JpegFormatError("a CMYK JPEG in a PDF/A document: its sRGB output intent forbids DeviceCMYK. " +
+                "Convert the image to RGB first.");
+        }
+        const space = IMAGE_COLOR_SPACE[color.space];
+        const decode = color.inverted
+            ? `    /Decode [${Array.from({ length: space.channels }, () => "1 0").join(" ")}]\n`
+            : "";
         const img = this.streamPayload(bytesFromLatin1(imageData));
         const imageObject = `<< /Type /XObject
     /Subtype /Image
     /Width ${width}
     /Height ${height}
-    /ColorSpace /DeviceRGB
+    /ColorSpace /${space.name}
     /BitsPerComponent 8
-    /Filter /${imageType}
+${decode}    /Filter /${imageType}
 ${smaskEntry}    /Length ${img.length} >>
 stream
 ${img.body}
@@ -473,7 +514,7 @@ endstream`;
     async finalizeEncryption() {
         if (!this.security)
             return;
-        if (this.outputIntent !== undefined || this.attachments.length > 0) {
+        if (this.outputIntent !== undefined) {
             throw new Error("@jasy/pdf: cannot encrypt a PDF/A document - PDF/A forbids encryption.");
         }
         for (let id = 0; id < this.encJobs.length; id++) {
@@ -565,10 +606,10 @@ endstream`;
     }
     // Registers a font
     registerFont(fontName, fontStyle = FontStyle.Normal, fullName = fontName) {
-        this.fontEpoch++;
         if (this.fonts.hasFont(fontName, fontStyle)) {
             return this.fonts.getFont(fontName, fontStyle); // Already exists? Return it!
         }
+        this.fontEpoch++;
         this.verticalsCache.delete(fontName);
         this.decorationCache.delete(fontName);
         const data = STANDARD_AFM[fullName];
@@ -596,7 +637,6 @@ endstream`;
     // metrics and emits its PDF font objects. All variants share the family `name`; bold/italic are
     // separate .ttf files registered under the same name with a different style.
     registerCustomFont(name, data, style = FontStyle.Normal) {
-        this.fontEpoch++;
         let byStyle = this.customFonts.get(name);
         if (!byStyle) {
             byStyle = new Map();
@@ -616,6 +656,7 @@ endstream`;
                 "is loaded asynchronously, so it happens one step earlier in renderPdf.");
         }
         byStyle.set(style, new TTFParser(isWoff(data) ? woffToSfnt(data) : data));
+        this.fontEpoch++; // only once the face is really there: a font that fails to parse adds nothing
         this.verticalsCache.delete(name); // this family now answers from the .ttf, not from an AFM
         this.decorationCache.delete(name);
         // Emission (the PDF font objects + page resource) is DEFERRED to first use via ensureEmitted(),
@@ -742,7 +783,7 @@ endstream`;
         return isWindows1252(codePoint);
     }
     /**
-     * Whether the document draws this code point through the colour-emoji path instead of the text
+     * Whether the document draws this code point through the color-emoji path instead of the text
      * font - a fallback emoji FONT, or an image source (`Document({ emoji })`). Such a code point is
      * missing from the text font ON PURPOSE, so glyph coverage must leave it alone. Mirrors exactly
      * what `getCharWidth` measures it as, or a dropped emoji would have been measured and not drawn.
@@ -873,7 +914,9 @@ endstream`;
         const all = ttf.glyphWidths();
         const w = [...used]
             .sort((a, b) => a - b)
-            .map((g) => `${g} [${all[g] ?? 1000}]`)
+            // Four decimals: a 2048-unit font's widths are not whole thousandths, and rounding them drew every
+            // line a fraction wider or narrower than it was measured. A 1000-unit font stays byte-identical.
+            .map((g) => `${g} [${Number((all[g] ?? 1000).toFixed(4))}]`)
             .join(" ");
         return (`<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${pdfName(name)} ` +
             `/CIDSystemInfo << /Registry ${this.pdfString("Adobe")} /Ordering ${this.pdfString("Identity")} /Supplement 0 >> ` +
@@ -972,14 +1015,20 @@ endstream`;
      * `GPOS` tables are unparsed), so it returns zeros - never a wrong value, just no adjustment.
      */
     /** Kerning between adjacent GLYPHS - what a shaped run needs, and what the backend already holds.
-     *  Same lookup as the character path; `getKerning` is keyed by glyph id either way. */
+     *  Same lookup as the character path; `getKerning` is keyed by glyph id either way. A pair that
+     *  touches a space is never kerned, as on the character path: the line breaker measures words and
+     *  spaces apart, so a pair across a space would be drawn but never measured. */
     getGlyphKernPairs(glyphs, fontFamily, fontStyle) {
         const ttf = this.getCustomFont(fontFamily, fontStyle);
         if (!ttf)
             return [];
+        const space = ttf.getGlyphIndex(0x20);
+        const noBreakSpace = ttf.getGlyphIndex(0xa0);
+        const isSpace = (g) => g !== 0 && (g === space || g === noBreakSpace); // 0 = no such glyph
         const pairs = [];
         for (let i = 0; i < glyphs.length - 1; i++) {
-            pairs.push(ttf.getKerning(glyphs[i], glyphs[i + 1]));
+            const [a, b] = [glyphs[i], glyphs[i + 1]];
+            pairs.push(isSpace(a) || isSpace(b) ? 0 : ttf.getKerning(a, b));
         }
         return pairs;
     }
@@ -1004,7 +1053,8 @@ endstream`;
         for (let i = 0; i < chars.length - 1; i++) {
             const a = chars[i];
             const b = chars[i + 1];
-            if (a === " " || b === " ") {
+            // A no-break space is a space: never kerned (the AFM names it `space`, with pairs of its own).
+            if (a === " " || b === " " || a === "\u00a0" || b === "\u00a0") {
                 out.push(0);
             }
             else if (ttf) {

package/dist/utils/renderer-registry.d.ts

@@ -1,3 +1,33 @@
+import type { Offset } from "../layout/box-constraints.js";
+import type { IRNode } from "../ir/display-list.js";
+import type { PDFObjectManager } from "./pdf-object-manager.js";
+/**
+ * Where an element is drawn. `origin` is the ABSOLUTE top-left that the element's own offset is
+ * relative to; a renderer adds it to its position and hands its children the origin THEY are relative
+ * to. `frame` is the absolute top-left of the nearest positioning frame (the page's content box, or a
+ * `relative` Box): a `Positioned` is laid out relative to it and draws from there, at its own place in
+ * the tree - tree order is paint order.
+ */
+export interface RenderScope {
+    origin: Offset;
+    frame: Offset;
+    /** Where a `Positioned` with a `zIndex` hands its drawing, for the nearest stacking context to sort.
+     *  It still RENDERS at its own place, so everything it registers there (its tag's parent) is right. */
+    stacked?: {
+        zIndex: number;
+        nodes: IRNode[];
+    }[];
+}
+/** The scope for the children of an element at `offset` (relative to `scope.origin`). */
+export declare function within(scope: RenderScope, offset: {
+    x?: number;
+    y?: number;
+}): RenderScope;
+/**
+ * Renders one element to IR. Typed so that a call which forgets to pass the scope on does not
+ * compile - a forgotten origin draws at the page corner without a word.
+ */
+export type ElementRenderer = (element: any, objectManager: PDFObjectManager, scope: RenderScope) => Promise<IRNode[]>;
 /**
  * Thrown when an element reaches the render pass with no registered renderer.
  *
@@ -10,9 +40,26 @@ export declare class MissingRendererError extends Error {
     readonly elementName: string;
     constructor(elementName: string);
 }
+/**
+ * Thrown when one element INSTANCE is drawn twice on the same page. An element holds one position - the
+ * place its last layout gave it - so both copies would land there and one would silently go missing.
+ */
+export declare class ElementReusedError extends Error {
+    readonly elementName: string;
+    constructor(elementName: string);
+}
 export declare class RendererRegistry {
     private static renderers;
-    static register(elementClass: Function, renderer: Function): void;
-    static getRenderer(element: object): Function;
+    private static drawnOnPage;
+    static register(elementClass: Function, renderer: ElementRenderer): void;
+    static getRenderer(element: object): ElementRenderer;
+    /** A new page starts for this document: nothing is drawn on it yet. */
+    static beginPage(objectManager: PDFObjectManager): void;
+    /**
+     * Draws `element` with its renderer. Every draw goes through here, so it is where reuse is caught - for
+     * an element that DRAWS something: one that draws nothing (a Spacer) has no place to land wrongly, and
+     * reusing it stays harmless.
+     */
+    static render(element: object, objectManager: PDFObjectManager, scope: RenderScope): Promise<IRNode[]>;
     static isRendererAsync(renderer: Function): boolean;
 }

package/dist/utils/renderer-registry.js

@@ -1,3 +1,10 @@
+/** The scope for the children of an element at `offset` (relative to `scope.origin`). */
+export function within(scope, offset) {
+    return {
+        ...scope,
+        origin: { x: scope.origin.x + (offset.x ?? 0), y: scope.origin.y + (offset.y ?? 0) },
+    };
+}
 /**
  * Thrown when an element reaches the render pass with no registered renderer.
  *
@@ -15,6 +22,18 @@ export class MissingRendererError extends Error {
         this.elementName = elementName;
     }
 }
+/**
+ * Thrown when one element INSTANCE is drawn twice on the same page. An element holds one position - the
+ * place its last layout gave it - so both copies would land there and one would silently go missing.
+ */
+export class ElementReusedError extends Error {
+    constructor(elementName) {
+        super(`@jasy/pdf: the same ${elementName} element is used twice on one page. An element has ONE ` +
+            `position, so both copies would be drawn in the same place. Create it twice instead - call the ` +
+            `factory again (e.g. a function \`const divider = () => Divider()\`) or place \`element.clone()\`.`);
+        this.elementName = elementName;
+    }
+}
 export class RendererRegistry {
     static register(elementClass, renderer) {
         if (!RendererRegistry.renderers.has(elementClass)) {
@@ -29,8 +48,29 @@ export class RendererRegistry {
             throw new MissingRendererError(element.constructor.name);
         return renderer;
     }
+    /** A new page starts for this document: nothing is drawn on it yet. */
+    static beginPage(objectManager) {
+        RendererRegistry.drawnOnPage.set(objectManager, new WeakSet());
+    }
+    /**
+     * Draws `element` with its renderer. Every draw goes through here, so it is where reuse is caught - for
+     * an element that DRAWS something: one that draws nothing (a Spacer) has no place to land wrongly, and
+     * reusing it stays harmless.
+     */
+    static async render(element, objectManager, scope) {
+        const nodes = await RendererRegistry.getRenderer(element)(element, objectManager, scope);
+        const drawn = RendererRegistry.drawnOnPage.get(objectManager);
+        if (drawn && nodes.length > 0) {
+            if (drawn.has(element))
+                throw new ElementReusedError(element.constructor.name);
+            drawn.add(element);
+        }
+        return nodes;
+    }
     static isRendererAsync(renderer) {
         return renderer.constructor.name === "AsyncFunction";
     }
 }
 RendererRegistry.renderers = new Map();
+// What each document has drawn on its current page (keyed per document: two can render at once).
+RendererRegistry.drawnOnPage = new WeakMap();

package/dist/utils/struct-tree.d.ts

@@ -24,18 +24,42 @@ export declare class StructTree {
     private byStructId;
     private stack;
     private pageObjByStructParents;
+    private annotParents;
+    private carried;
     /** Register a structure element for a logical element (keyed by its stable `structId`, so a paragraph or
      *  table split across pages resolves to the SAME element - MCIDs then accrue from every page). Its parent
      *  is the currently-open container, else the Document. Containers also push()/pop() around their children. */
     openElement(structId: number, role: string, opts?: {
         alt?: string;
     }): number;
+    /**
+     * An element no layout element stands behind - an inline link inside a paragraph: a child of `parent`,
+     * new every time (nothing to deduplicate).
+     */
+    addElement(role: string, parent: number, opts?: {
+        alt?: string;
+    }): number;
+    /** A piece of paragraph `owner` ended inside link element `key`: its next piece may continue it. */
+    carryLink(owner: number, target: string, key: number): void;
+    /** The link the previous piece of `owner` ended in. Taken by the next piece, whether it continues it. */
+    takeCarriedLink(owner: number): {
+        target: string;
+        key: number;
+    } | undefined;
     push(key: number): void;
     pop(): void;
     /** Begin a page: allocates its StructParents index (its slot in the ParentTree). */
     beginPage(): PageStructContext;
     /** Tie a page's StructParents index to its now-known page object number (for /Pg references). */
     setPageObject(structParents: number, pageObjNum: number): void;
+    /**
+     * PDF/UA 7.18: an annotation belongs to a structure element (a link to its `/Link`, a widget to its
+     * `/Form`). Returns the `/StructParent` the annotation dictionary carries - its own slot in the
+     * ParentTree, numbered alongside the pages'.
+     */
+    annotationParent(key: number): number;
+    /** The annotation object, once written: an `/OBJR` kid of its element, on the page that lists it. */
+    linkAnnotation(key: number, obj: number, pageStructParents: number): void;
     /** Link a page-local MCID to an element (called by the backend while serializing). */
     linkMarkedContent(key: number, structParents: number, mcid: number): void;
     /** Emit the struct-tree objects and return the catalog additions (`/MarkInfo`, `/StructTreeRoot`, `/Lang`).

package/dist/utils/struct-tree.js

@@ -32,6 +32,9 @@ export class StructTree {
         this.byStructId = new Map(); // element structId -> element key (dedup across pages)
         this.stack = []; // open containers; top is the current parent
         this.pageObjByStructParents = new Map();
+        this.annotParents = new Map(); // an annotation's /StructParent -> its element key
+        // An inline link a page break cut: paragraph structId -> the link it ended in, for its next piece.
+        this.carried = new Map();
     }
     /** Register a structure element for a logical element (keyed by its stable `structId`, so a paragraph or
      *  table split across pages resolves to the SAME element - MCIDs then accrue from every page). Its parent
@@ -48,9 +51,29 @@ export class StructTree {
             alt: opts?.alt,
             parent: this.stack[this.stack.length - 1],
             mc: [],
+            annots: [],
         });
         return key;
     }
+    /**
+     * An element no layout element stands behind - an inline link inside a paragraph: a child of `parent`,
+     * new every time (nothing to deduplicate).
+     */
+    addElement(role, parent, opts) {
+        const key = this.counter++;
+        this.elems.set(key, { key, role, alt: opts?.alt, parent, mc: [], annots: [] });
+        return key;
+    }
+    /** A piece of paragraph `owner` ended inside link element `key`: its next piece may continue it. */
+    carryLink(owner, target, key) {
+        this.carried.set(owner, { target, key });
+    }
+    /** The link the previous piece of `owner` ended in. Taken by the next piece, whether it continues it. */
+    takeCarriedLink(owner) {
+        const carried = this.carried.get(owner);
+        this.carried.delete(owner);
+        return carried;
+    }
     push(key) {
         this.stack.push(key);
     }
@@ -65,6 +88,20 @@ export class StructTree {
     setPageObject(structParents, pageObjNum) {
         this.pageObjByStructParents.set(structParents, pageObjNum);
     }
+    /**
+     * PDF/UA 7.18: an annotation belongs to a structure element (a link to its `/Link`, a widget to its
+     * `/Form`). Returns the `/StructParent` the annotation dictionary carries - its own slot in the
+     * ParentTree, numbered alongside the pages'.
+     */
+    annotationParent(key) {
+        const structParent = this.structParentsCounter++;
+        this.annotParents.set(structParent, key);
+        return structParent;
+    }
+    /** The annotation object, once written: an `/OBJR` kid of its element, on the page that lists it. */
+    linkAnnotation(key, obj, pageStructParents) {
+        this.elems.get(key)?.annots.push({ obj, structParents: pageStructParents });
+    }
     /** Link a page-local MCID to an element (called by the backend while serializing). */
     linkMarkedContent(key, structParents, mcid) {
         this.elems.get(key)?.mc.push({ structParents, mcid });
@@ -83,11 +120,24 @@ export class StructTree {
             objNum.set(key, om.addObject(""));
         const pg = (structParents) => this.pageObjByStructParents.get(structParents);
         const childrenOf = (parent) => [...this.elems.values()].filter((e) => e.parent === parent); // Map order = reading order
+        const before = (a, b) => a.structParents - b.structParents || a.mcid - b.mcid;
+        const firstOf = (e) => [...e.mc, ...childrenOf(e.key).flatMap((c) => firstOf(c) ?? [])].sort(before)[0];
+        const mcr = (m) => `<< /Type /MCR /Pg ${pg(m.structParents)} 0 R /MCID ${m.mcid} >>`;
         // One StructElem per registered element: /K = its child elements ++ its marked-content references.
+        // An element holding BOTH (a paragraph with an inline link) interleaves them in reading order.
         for (const e of this.elems.values()) {
+            const children = childrenOf(e.key);
+            const content = children.length > 0 && e.mc.length > 0
+                ? [
+                    ...children.map((c) => ({ at: firstOf(c), ref: `${objNum.get(c.key)} 0 R` })),
+                    ...e.mc.map((m) => ({ at: m, ref: mcr(m) })),
+                ]
+                    .sort((a, b) => (a.at && b.at ? before(a.at, b.at) : 0))
+                    .map((k) => k.ref)
+                : [...children.map((c) => `${objNum.get(c.key)} 0 R`), ...e.mc.map(mcr)];
             const kids = [
-                ...childrenOf(e.key).map((c) => `${objNum.get(c.key)} 0 R`),
-                ...e.mc.map((m) => `<< /Type /MCR /Pg ${pg(m.structParents)} 0 R /MCID ${m.mcid} >>`),
+                ...content,
+                ...e.annots.map((a) => `<< /Type /OBJR /Pg ${pg(a.structParents)} 0 R /Obj ${a.obj} 0 R >>`),
             ].join(" ");
             const alt = e.alt ? ` /Alt ${om.pdfString(e.alt)}` : "";
             // PDF/UA 7.5: a header cell needs a Scope so a reader can associate data cells with it. Our headers
@@ -110,17 +160,19 @@ export class StructTree {
                 byPage.set(m.structParents, list);
             }
         }
-        const nums = [...byPage.keys()]
-            .sort((a, b) => a - b)
-            .map((sp) => {
-            const refs = byPage
-                .get(sp)
+        // A page's entry is an array indexed by MCID; an annotation's is its element itself.
+        const entries = new Map();
+        for (const [sp, list] of byPage) {
+            const refs = list
                 .slice()
                 .sort((a, b) => a.mcid - b.mcid)
                 .map((r) => `${objNum.get(r.key)} 0 R`)
                 .join(" ");
-            return `${sp} [ ${refs} ]`;
-        });
+            entries.set(sp, `[ ${refs} ]`);
+        }
+        for (const [sp, key] of this.annotParents)
+            entries.set(sp, `${objNum.get(key)} 0 R`);
+        const nums = [...entries.keys()].sort((a, b) => a - b).map((sp) => `${sp} ${entries.get(sp)}`);
         om.replaceObject(parentTreeNum, `<< /Nums [ ${nums.join(" ")} ] >>`);
         om.replaceObject(rootNum, `<< /Type /StructTreeRoot /K ${docNum} 0 R /ParentTree ${parentTreeNum} 0 R ` +
             `/ParentTreeNextKey ${this.structParentsCounter} >>`);

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

@@ -51,6 +51,10 @@ export interface ColorGlyphLayer {
 }
 /** Sorts x-intervals and unions the overlapping ones. */
 export declare function mergeSpans(spans: Array<[number, number]>): Array<[number, number]>;
+/** Thrown when font bytes are a format jasy cannot embed - said by name, never embedded broken. */
+export declare class FontFormatError extends Error {
+    constructor(message: string);
+}
 export declare class TTFParser {
     private data;
     unitsPerEm: number;

package/dist/utils/ttf-parser.js

@@ -46,6 +46,12 @@ function applyAffine(m, x, y) {
 function detScale(m) {
     return Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
 }
+/** Thrown when font bytes are a format jasy cannot embed - said by name, never embedded broken. */
+export class FontFormatError extends Error {
+    constructor(message) {
+        super(`@jasy/pdf: ${message}`);
+    }
+}
 export class TTFParser {
     constructor(data) {
         this.data = data;
@@ -88,6 +94,17 @@ export class TTFParser {
         // subtables (coverage + classDef) per pair, and a long document repeats the same pairs thousands
         // of times, so the first lookup of a pair pays; the rest are O(1).
         this.kernCache = new Map();
+        // Every font path meets here (bytes, a file, a URL, an unwrapped WOFF/WOFF2). A CFF font has the
+        // same tables up front and measured fine, then went into the PDF as a TrueType program it is not.
+        const tag = String.fromCharCode(...data.subarray(0, 4));
+        if (tag === "OTTO") {
+            throw new FontFormatError("this is an OpenType font with PostScript (CFF) outlines, which jasy does not embed yet - " +
+                "use its TrueType-flavoured version (.ttf, or a .woff/.woff2 made from one)");
+        }
+        if (tag === "ttcf") {
+            throw new FontFormatError("this is a TrueType Collection (.ttc), which jasy does not read yet - extract the one face " +
+                "you need into a .ttf");
+        }
         this.readTableDirectory();
         const head = this.table("head").offset;
         this.unitsPerEm = u16(this.data, head + 18);
@@ -132,11 +149,12 @@ export class TTFParser {
     glyphCount() {
         return this.numGlyphs;
     }
-    // Advance width of every glyph in PDF glyph space (the /W array of the CIDFont).
+    // Advance width of every glyph in PDF glyph space (the /W array of the CIDFont), NOT rounded: layout
+    // measures the exact width, so the drawn one must be the same number.
     glyphWidths() {
         const out = [];
         for (let g = 0; g < this.numGlyphs; g++) {
-            out.push(this.toGlyphSpace(this.getAdvanceWidth(g)));
+            out.push((this.getAdvanceWidth(g) * 1000) / this.unitsPerEm);
         }
         return out;
     }
@@ -392,17 +410,23 @@ export class TTFParser {
         }
         if (kernLookups.size === 0)
             return;
-        // The PairPos subtables of those lookups (a lookup of another type in the set is ignored).
+        // The PairPos subtables of those lookups (a lookup of another type in the set is ignored). A large
+        // font wraps its lookups in Extension subtables (type 9) for their 32-bit offsets - read through.
         const lookupCount = u16(this.data, lookupListOffset);
         for (const idx of kernLookups) {
             if (idx >= lookupCount)
                 continue;
             const lookup = lookupListOffset + u16(this.data, lookupListOffset + 2 + idx * 2);
-            if (u16(this.data, lookup) !== 2)
-                continue; // lookupType 2 = pair adjustment
+            const type = u16(this.data, lookup);
+            if (type !== 2 && type !== 9)
+                continue; // 2 = pair adjustment, 9 = extension
             const subTableCount = u16(this.data, lookup + 4);
             for (let s = 0; s < subTableCount; s++) {
-                this.gposPairPos.push(lookup + u16(this.data, lookup + 6 + s * 2));
+                const sub = lookup + u16(this.data, lookup + 6 + s * 2);
+                if (type === 2)
+                    this.gposPairPos.push(sub);
+                else if (u16(this.data, sub + 2) === 2)
+                    this.gposPairPos.push(sub + u32(this.data, sub + 4));
             }
         }
         if (this.gposPairPos.length > 0)

package/dist/validators/element-validator.js

@@ -1,3 +1,4 @@
+import { flexibleOf } from "../layout/flex-item.js";
 import { PDFDocumentElement } from "../elements/pdf-document-element.js";
 import { FlexiblePDFElement, hasChildProp, SizedPDFElement, } from "../elements/pdf-element.js";
 export class Validator {
@@ -58,7 +59,7 @@ export class Validator {
         }
         // Ensure a flexible element does not contain another flexible element
         if (hasChildProp(element)) {
-            if (element.child instanceof FlexiblePDFElement) {
+            if (flexibleOf(element.child) !== undefined) {
                 throw new Error(`Flexible element ${element.constructor.name} cannot hold another flexible element`);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasy/pdf",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "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",

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

@@ -1,14 +0,0 @@
-import { SizedElement, WithChildren, SizedPDFElement, LayoutContext } from "../pdf-element.js";
-import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
-interface ContainerElementParams extends SizedElement, WithChildren {
-    color?: [number, number, number];
-    backgroundColor?: [number, number, number];
-    borderWidth?: number;
-}
-export declare class SizedContainerElement extends SizedPDFElement {
-    private children;
-    constructor({ width, height, children }: ContainerElementParams);
-    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
-    getProps(): ContainerElementParams;
-}
-export {};