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

package/dist/utils/struct-tree.js

@@ -0,0 +1,130 @@
+// Escapes a PDF literal string ( ... ) - the language tag is safe ASCII, but /Alt can carry arbitrary text.
+const esc = (s) => s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+// A structure role reaches the PDF as a raw name (/H1, /S /Table). Roles come from a controlled set,
+// but restrict them to a safe PDF-name token anyway (defence-in-depth) so a stray "/", whitespace, or
+// operator can never corrupt the content stream / object dictionary. Empty after stripping -> /Span.
+const roleName = (role) => role.replace(/[^A-Za-z0-9]/g, "") || "Span";
+/** Per-page tagging context: hands out page-local MCIDs and links them to their StructElem. */
+export class PageStructContext {
+    constructor(structParents, tree) {
+        this.structParents = structParents;
+        this.tree = tree;
+        this.mcid = 0;
+    }
+    /** Marked-content delimiters for one drawable node. Tagged content gets an MCID linked to its (already
+     *  registered) StructElem; untagged content becomes an Artifact (decoration, skipped by assistive tech). */
+    mark(tag) {
+        // Artifact = decoration, no properties -> BMC (BDC would need a second operand and is a syntax error).
+        if (!tag)
+            return { open: "/Artifact BMC\n", close: "EMC\n" };
+        const mcid = this.mcid++;
+        this.tree.linkMarkedContent(tag.key, this.structParents, mcid);
+        return { open: `/${roleName(tag.role)} <</MCID ${mcid}>> BDC\n`, close: "EMC\n" };
+    }
+}
+/** Builds the PDF structure tree for accessible tagging. One instance per document (held by the object manager). */
+export class StructTree {
+    constructor() {
+        this.enabled = false;
+        this.lang = "en-US";
+        this.counter = 0;
+        this.structParentsCounter = 0;
+        this.elems = new Map(); // insertion order = render order = reading order
+        this.byStructId = new Map(); // element structId -> element key (dedup across pages)
+        this.stack = []; // open containers; top is the current parent
+        this.pageObjByStructParents = 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
+     *  is the currently-open container, else the Document. Containers also push()/pop() around their children. */
+    openElement(structId, role, opts) {
+        const existing = this.byStructId.get(structId);
+        if (existing !== undefined)
+            return existing; // already opened on an earlier page/fragment
+        const key = this.counter++;
+        this.byStructId.set(structId, key);
+        this.elems.set(key, {
+            key,
+            role,
+            alt: opts?.alt,
+            parent: this.stack[this.stack.length - 1],
+            mc: [],
+        });
+        return key;
+    }
+    push(key) {
+        this.stack.push(key);
+    }
+    pop() {
+        this.stack.pop();
+    }
+    /** Begin a page: allocates its StructParents index (its slot in the ParentTree). */
+    beginPage() {
+        return new PageStructContext(this.structParentsCounter++, this);
+    }
+    /** Tie a page's StructParents index to its now-known page object number (for /Pg references). */
+    setPageObject(structParents, pageObjNum) {
+        this.pageObjByStructParents.set(structParents, pageObjNum);
+    }
+    /** 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 });
+    }
+    /** Emit the struct-tree objects and return the catalog additions (`/MarkInfo`, `/StructTreeRoot`, `/Lang`).
+     *  A no-op returning "" when disabled or nothing was tagged, so a plain document stays byte-identical. */
+    finalize(om) {
+        if (!this.enabled || this.elems.size === 0)
+            return "";
+        // Reserve object numbers first - root <-> Document <-> elements <-> ParentTree reference each other.
+        const rootNum = om.addObject("");
+        const docNum = om.addObject("");
+        const parentTreeNum = om.addObject("");
+        const objNum = new Map();
+        for (const key of this.elems.keys())
+            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
+        // One StructElem per registered element: /K = its child elements ++ its marked-content references.
+        for (const e of this.elems.values()) {
+            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} >>`),
+            ].join(" ");
+            const alt = e.alt ? ` /Alt (${esc(e.alt)})` : "";
+            // PDF/UA 7.5: a header cell needs a Scope so a reader can associate data cells with it. Our headers
+            // are a header ROW (the Table `header` option), so each TH is the head of its Column.
+            const attr = e.role === "TH" ? " /A << /O /Table /Scope /Column >>" : "";
+            const parentRef = e.parent !== undefined ? objNum.get(e.parent) : docNum;
+            om.replaceObject(objNum.get(e.key), `<< /Type /StructElem /S /${roleName(e.role)} /P ${parentRef} 0 R${alt}${attr} /K [ ${kids} ] >>`);
+        }
+        // The Document element wraps the top-level elements in reading order.
+        const docKids = childrenOf(undefined)
+            .map((e) => `${objNum.get(e.key)} 0 R`)
+            .join(" ");
+        om.replaceObject(docNum, `<< /Type /StructElem /S /Document /P ${rootNum} 0 R /K [ ${docKids} ] >>`);
+        // ParentTree: for each page (StructParents index), an array where [mcid] = the owning StructElem.
+        const byPage = new Map();
+        for (const e of this.elems.values()) {
+            for (const m of e.mc) {
+                const list = byPage.get(m.structParents) ?? [];
+                list.push({ mcid: m.mcid, key: e.key });
+                byPage.set(m.structParents, list);
+            }
+        }
+        const nums = [...byPage.keys()]
+            .sort((a, b) => a - b)
+            .map((sp) => {
+            const refs = byPage
+                .get(sp)
+                .slice()
+                .sort((a, b) => a.mcid - b.mcid)
+                .map((r) => `${objNum.get(r.key)} 0 R`)
+                .join(" ");
+            return `${sp} [ ${refs} ]`;
+        });
+        om.replaceObject(parentTreeNum, `<< /Nums [ ${nums.join(" ")} ] >>`);
+        om.replaceObject(rootNum, `<< /Type /StructTreeRoot /K ${docNum} 0 R /ParentTree ${parentTreeNum} 0 R ` +
+            `/ParentTreeNextKey ${this.structParentsCounter} >>`);
+        return `/MarkInfo << /Marked true >> /StructTreeRoot ${rootNum} 0 R /Lang (${esc(this.lang)})`;
+    }
+}

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

@@ -1,3 +1,52 @@
+export type GlyphPathCommand = {
+    type: "M";
+    x: number;
+    y: number;
+} | {
+    type: "L";
+    x: number;
+    y: number;
+} | {
+    type: "Q";
+    cx: number;
+    cy: number;
+    x: number;
+    y: number;
+} | {
+    type: "Z";
+};
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface ColorStop {
+    offset: number;
+    color: RGBA | null;
+}
+export type Paint = {
+    type: "solid";
+    color: RGBA | null;
+} | {
+    type: "linearGradient";
+    p0: [number, number];
+    p1: [number, number];
+    stops: ColorStop[];
+    extend: "pad" | "repeat" | "reflect";
+} | {
+    type: "radialGradient";
+    c0: [number, number, number];
+    c1: [number, number, number];
+    stops: ColorStop[];
+    extend: "pad" | "repeat" | "reflect";
+};
+export type Affine = [number, number, number, number, number, number];
+export interface ColorGlyphLayer {
+    glyphId: number;
+    paint: Paint;
+    transform?: Affine;
+}
 export declare class TTFParser {
     private data;
     unitsPerEm: number;
@@ -6,10 +55,16 @@ export declare class TTFParser {
     bbox: [number, number, number, number];
     private numGlyphs;
     private numHMetrics;
+    private indexToLocFormat;
     private advanceWidths;
     private cmap;
     private cmapGroups;
     private tables;
+    private colrBase;
+    private colrLayersOffset;
+    private palette;
+    private colrBaseV1;
+    private colrLayerListOffset;
     constructor(data: Uint8Array);
     getData(): Uint8Array;
     glyphCount(): number;
@@ -26,4 +81,22 @@ export declare class TTFParser {
     private readCmap;
     private readCmapFormat4;
     private readCmapFormat12;
+    hasGlyfOutlines(): boolean;
+    private glyfRange;
+    getGlyphPath(glyphId: number): GlyphPathCommand[];
+    private parseSimpleGlyph;
+    private readCoordinates;
+    private contourToCommands;
+    hasColorGlyphs(): boolean;
+    getColorGlyph(glyphId: number): ColorGlyphLayer[] | null;
+    private walkColrLayers;
+    private resolveFill;
+    private readColorLine;
+    private paletteColor;
+    private u24;
+    private f2dot14;
+    private i32;
+    private readAffine;
+    private readColr;
+    private readCpal;
 }