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

package/dist/utils/ttf-parser.js

@@ -1,7 +1,35 @@
 // 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.
-import { i16, latin1FromBytes, u16, u32 } from "./bytes.js";
+import { i16, latin1FromBytes, u8, u16, u32 } from "./bytes.js";
+const IDENTITY = [1, 0, 0, 1, 0, 0];
+function isIdentity(m) {
+    return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
+}
+// compose(m, n): the transform that applies n first, then m (the matrix product m . n).
+function compose(m, n) {
+    return [
+        m[0] * n[0] + m[2] * n[1],
+        m[1] * n[0] + m[3] * n[1],
+        m[0] * n[2] + m[2] * n[3],
+        m[1] * n[2] + m[3] * n[3],
+        m[0] * n[4] + m[2] * n[5] + m[4],
+        m[1] * n[4] + m[3] * n[5] + m[5],
+    ];
+}
+// A transform applied about a center point: translate(c) . t . translate(-c).
+function aroundCenter(t, cx, cy) {
+    return compose([1, 0, 0, 1, cx, cy], compose(t, [1, 0, 0, 1, -cx, -cy]));
+}
+// Applies an affine to a point (font units).
+function applyAffine(m, x, y) {
+    return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+// The affine's mean scale factor sqrt(|det|), used to scale a gradient radius (a circle can only
+// stay a circle under uniform scaling; this is the best single-radius approximation otherwise).
+function detScale(m) {
+    return Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+}
 export class TTFParser {
     constructor(data) {
         this.data = data;
@@ -12,10 +40,19 @@ export class TTFParser {
         this.bbox = [0, 0, 0, 0];
         this.numGlyphs = 0;
         this.numHMetrics = 0;
+        this.indexToLocFormat = 0; // head[50]: 0 = short loca (offsets/2), 1 = long loca
         this.advanceWidths = []; // per glyph id, in font units
         this.cmap = new Map(); // codepoint → glyph id (format 4)
         this.cmapGroups = []; // format 12, searched on lookup
         this.tables = {};
+        // COLR v0: base glyph id → its slice of the layer-record array. Empty when the font has no
+        // v0 color layers, so getColorGlyph falls back to v1 or to normal (monochrome) drawing.
+        this.colrBase = new Map();
+        this.colrLayersOffset = 0; // byte offset of the v0 layer-record array in the COLR table
+        this.palette = []; // CPAL palette 0, indexed by palette entry
+        // COLR v1: base glyph id → the absolute offset of its Paint table (a recursive paint graph).
+        this.colrBaseV1 = new Map();
+        this.colrLayerListOffset = 0; // absolute offset of the v1 LayerList (paint-offset array)
         this.readTableDirectory();
         const head = this.table("head").offset;
         this.unitsPerEm = u16(this.data, head + 18);
@@ -30,8 +67,13 @@ export class TTFParser {
         const hhea = this.table("hhea").offset;
         this.ascent = this.toGlyphSpace(i16(this.data, hhea + 4));
         this.descent = this.toGlyphSpace(i16(this.data, hhea + 6));
+        this.indexToLocFormat = i16(this.data, head + 50);
         this.readHmtx();
         this.readCmap();
+        if (this.tables["COLR"] && this.tables["CPAL"]) {
+            this.readColr();
+            this.readCpal();
+        }
     }
     // The raw font bytes, for the /FontFile2 stream.
     getData() {
@@ -120,28 +162,26 @@ export class TTFParser {
     readCmap() {
         const base = this.table("cmap").offset;
         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;
+        // Read EVERY Unicode subtable, not just one: fonts commonly ship a (3,1) format-4 for the BMP
+        // AND a (3,10) format-12 for astral code points (emoji, CJK-ext). Reading only the first would
+        // drop astral coverage. Format-4 fills the direct map; format-12 groups are searched on lookup,
+        // and getGlyphIndex checks the map first, so an overlapping BMP entry stays correct.
         let p = base + 4;
         for (let i = 0; i < numTables; i++) {
             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;
-                if (platform === 3 && encoding === 1)
-                    break; // best fit, stop looking
-            }
             p += 8;
+            const unicode = (platform === 3 && (encoding === 1 || encoding === 10)) || platform === 0;
+            if (!unicode)
+                continue;
+            const subtable = base + offset;
+            const format = u16(this.data, subtable);
+            if (format === 4)
+                this.readCmapFormat4(subtable);
+            else if (format === 12)
+                this.readCmapFormat12(subtable);
         }
-        if (subtable < 0)
-            return;
-        const format = u16(this.data, subtable);
-        if (format === 4)
-            this.readCmapFormat4(subtable);
-        else if (format === 12)
-            this.readCmapFormat12(subtable);
     }
     // 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.
@@ -184,4 +224,404 @@ export class TTFParser {
             p += 12;
         }
     }
+    // True when the font carries glyph outlines we can draw (a `glyf`+`loca` pair). CFF/OTF fonts
+    // and bitmap-only fonts return false - color layers need vector outlines.
+    hasGlyfOutlines() {
+        return this.tables["glyf"] !== undefined && this.tables["loca"] !== undefined;
+    }
+    // Byte range of glyph `glyphId` inside the glyf table, via the loca offset array. An empty range
+    // (start === end) means the glyph has no outline (e.g. the space) - returns null.
+    glyfRange(glyphId) {
+        const loca = this.table("loca").offset;
+        let start;
+        let end;
+        if (this.indexToLocFormat === 0) {
+            // short loca stores offsets divided by two
+            start = u16(this.data, loca + glyphId * 2) * 2;
+            end = u16(this.data, loca + (glyphId + 1) * 2) * 2;
+        }
+        else {
+            start = u32(this.data, loca + glyphId * 4);
+            end = u32(this.data, loca + (glyphId + 1) * 4);
+        }
+        return end > start ? { start, end } : null;
+    }
+    // Glyph outline as drawing commands in font units. Empty for glyphs without an outline. Composite
+    // glyphs (numberOfContours < 0) are not assembled yet - they return empty (a follow-up sub-step).
+    getGlyphPath(glyphId) {
+        if (!this.hasGlyfOutlines())
+            return [];
+        const range = this.glyfRange(glyphId);
+        if (!range)
+            return [];
+        const g = this.table("glyf").offset + range.start;
+        const numberOfContours = i16(this.data, g);
+        if (numberOfContours < 0)
+            return []; // composite: deferred
+        return this.parseSimpleGlyph(g, numberOfContours);
+    }
+    // Simple-glyph body: end-point indices per contour, then flags, then delta-encoded x/y runs.
+    parseSimpleGlyph(g, numberOfContours) {
+        let p = g + 10; // past numberOfContours + the four bbox int16s
+        const endPts = [];
+        for (let i = 0; i < numberOfContours; i++) {
+            endPts.push(u16(this.data, p));
+            p += 2;
+        }
+        const numPoints = numberOfContours === 0 ? 0 : endPts[endPts.length - 1] + 1;
+        const instructionLength = u16(this.data, p);
+        p += 2 + instructionLength; // skip hinting instructions
+        // Flags, with the REPEAT bit (0x08) run-length-encoding a flag byte.
+        const flags = [];
+        while (flags.length < numPoints) {
+            const flag = u8(this.data, p++);
+            flags.push(flag);
+            if (flag & 0x08) {
+                let repeat = u8(this.data, p++);
+                while (repeat-- > 0)
+                    flags.push(flag);
+            }
+        }
+        // X then Y coordinates, each a delta from the previous. Short (1 byte, sign in a flag bit) or
+        // long (int16), or "same as previous" (delta 0) when the short bit is clear but the same bit set.
+        const xs = this.readCoordinates(flags, p, 0x02, 0x10);
+        p = xs.next;
+        const ys = this.readCoordinates(flags, p, 0x04, 0x20);
+        const points = flags.map((flag, i) => ({
+            x: xs.values[i],
+            y: ys.values[i],
+            on: (flag & 0x01) !== 0,
+        }));
+        const commands = [];
+        let contourStart = 0;
+        for (const endPt of endPts) {
+            this.contourToCommands(points.slice(contourStart, endPt + 1), commands);
+            contourStart = endPt + 1;
+        }
+        return commands;
+    }
+    // Decodes one delta-encoded coordinate axis. `shortBit` = value is a single unsigned byte;
+    // `sameBit` = (short) its sign, or (long) repeat the previous value (delta 0).
+    readCoordinates(flags, start, shortBit, sameBit) {
+        let p = start;
+        let value = 0;
+        const values = [];
+        for (const flag of flags) {
+            if (flag & shortBit) {
+                const delta = u8(this.data, p++);
+                value += flag & sameBit ? delta : -delta;
+            }
+            else if (!(flag & sameBit)) {
+                value += i16(this.data, p);
+                p += 2;
+            }
+            // else: sameBit set without shortBit => delta 0, value unchanged
+            values.push(value);
+        }
+        return { values, next: p };
+    }
+    // Converts one TrueType contour (mixed on/off-curve points) into path commands. Between two
+    // consecutive off-curve control points TrueType implies an on-curve midpoint; we insert those,
+    // rotate the contour to begin on an on-curve anchor, then emit quads (off->on) and lines (on->on).
+    contourToCommands(raw, out) {
+        const n = raw.length;
+        if (n === 0)
+            return;
+        const pts = [];
+        for (let i = 0; i < n; i++) {
+            const cur = raw[i];
+            pts.push(cur);
+            const next = raw[(i + 1) % n];
+            if (!cur.on && !next.on) {
+                pts.push({ x: (cur.x + next.x) / 2, y: (cur.y + next.y) / 2, on: true });
+            }
+        }
+        const firstOn = pts.findIndex((pt) => pt.on);
+        if (firstOn < 0)
+            return; // degenerate: no anchor even after inserting midpoints
+        const loop = [...pts.slice(firstOn), ...pts.slice(0, firstOn)]; // starts on an on-curve anchor
+        const start = loop[0];
+        out.push({ type: "M", x: start.x, y: start.y });
+        let i = 1;
+        while (i < loop.length) {
+            const cur = loop[i];
+            if (cur.on) {
+                out.push({ type: "L", x: cur.x, y: cur.y });
+                i += 1;
+            }
+            else {
+                // An off-curve control is always followed by an on-curve point (real or implied); at the
+                // end of the loop that closing anchor is the start point itself.
+                const end = i + 1 < loop.length ? loop[i + 1] : start;
+                out.push({ type: "Q", cx: cur.x, cy: cur.y, x: end.x, y: end.y });
+                i += 2;
+            }
+        }
+        out.push({ type: "Z" });
+    }
+    // True when the font has color glyphs we can render: COLR base glyphs (v0 or v1) plus a CPAL
+    // palette to color them.
+    hasColorGlyphs() {
+        return (this.colrBase.size > 0 || this.colrBaseV1.size > 0) && this.palette.length > 0;
+    }
+    // The color layers of a base glyph, back-to-front (first drawn underneath), or null when the glyph
+    // has no COLR entry (draw it as a normal monochrome glyph then). Prefers the richer v1 paint graph
+    // when present, else reads the v0 records; both resolve to the same `ColorGlyphLayer` shape.
+    getColorGlyph(glyphId) {
+        const v1 = this.colrBaseV1.get(glyphId);
+        if (v1 !== undefined)
+            return this.walkColrLayers(v1, IDENTITY, new Set());
+        const rec = this.colrBase.get(glyphId);
+        if (!rec)
+            return null;
+        const layers = [];
+        for (let i = 0; i < rec.count; i++) {
+            const o = this.colrLayersOffset + (rec.first + i) * 4;
+            const paletteIndex = u16(this.data, o + 2);
+            layers.push({
+                glyphId: u16(this.data, o),
+                paint: { type: "solid", color: this.paletteColor(paletteIndex, 1) },
+            });
+        }
+        return layers;
+    }
+    // Walks a v1 paint (sub)tree into the flat list of glyph-clipped layers it draws, carrying the
+    // accumulated affine `m` down the graph. Handles the structural paints: PaintColrLayers (a list),
+    // PaintGlyph (a glyph + its fill), PaintColrGlyph (a reference), the transform paints (compose
+    // into `m`), and PaintComposite (backdrop under source). Unhandled paints (rotate/skew, the
+    // variable variants) are skipped. `seen` guards against cyclic references.
+    walkColrLayers(paintOffset, m, seen) {
+        const key = paintOffset;
+        if (seen.has(key))
+            return [];
+        seen.add(key);
+        const format = u8(this.data, paintOffset);
+        const child = () => paintOffset + this.u24(paintOffset + 1);
+        const descend = (t) => this.walkColrLayers(child(), compose(m, t), seen);
+        switch (format) {
+            case 1: {
+                // PaintColrLayers: numLayers (u8) starting at firstLayerIndex (u32) into the LayerList.
+                const numLayers = u8(this.data, paintOffset + 1);
+                const first = u32(this.data, paintOffset + 2);
+                const out = [];
+                for (let i = 0; i < numLayers; i++) {
+                    const layerPaint = this.colrLayerListOffset +
+                        u32(this.data, this.colrLayerListOffset + 4 + (first + i) * 4);
+                    out.push(...this.walkColrLayers(layerPaint, m, new Set(seen)));
+                }
+                return out;
+            }
+            case 10: {
+                // PaintGlyph: paint (Offset24 to the fill) + glyphID (u16). The fill paints inside the glyph.
+                const fill = this.resolveFill(paintOffset + this.u24(paintOffset + 1), IDENTITY);
+                if (!fill)
+                    return [];
+                const layer = { glyphId: u16(this.data, paintOffset + 4), paint: fill };
+                if (!isIdentity(m))
+                    layer.transform = m;
+                return [layer];
+            }
+            case 11: {
+                // PaintColrGlyph: draw another base glyph's paint graph under the current transform.
+                const ref = this.colrBaseV1.get(u16(this.data, paintOffset + 1));
+                return ref !== undefined ? this.walkColrLayers(ref, m, new Set(seen)) : [];
+            }
+            case 12: // PaintTransform: child + an Affine2x3 (six Fixed 16.16 values).
+                return descend(this.readAffine(paintOffset + this.u24(paintOffset + 4)));
+            case 14: // PaintTranslate: dx, dy (FWORD).
+                return descend([
+                    1,
+                    0,
+                    0,
+                    1,
+                    i16(this.data, paintOffset + 4),
+                    i16(this.data, paintOffset + 6),
+                ]);
+            case 16: // PaintScale: scaleX, scaleY (F2Dot14).
+                return descend([this.f2dot14(paintOffset + 4), 0, 0, this.f2dot14(paintOffset + 6), 0, 0]);
+            case 18: // PaintScaleAroundCenter: scaleX, scaleY, centerX, centerY.
+                return descend(aroundCenter([this.f2dot14(paintOffset + 4), 0, 0, this.f2dot14(paintOffset + 6), 0, 0], i16(this.data, paintOffset + 8), i16(this.data, paintOffset + 10)));
+            case 20: {
+                // PaintScaleUniform: a single scale for both axes.
+                const s = this.f2dot14(paintOffset + 4);
+                return descend([s, 0, 0, s, 0, 0]);
+            }
+            case 22: {
+                // PaintScaleUniformAroundCenter: uniform scale about a center.
+                const s = this.f2dot14(paintOffset + 4);
+                return descend(aroundCenter([s, 0, 0, s, 0, 0], i16(this.data, paintOffset + 6), i16(this.data, paintOffset + 8)));
+            }
+            case 32: {
+                // PaintComposite: sourcePaint, mode (u8), backdropPaint. We treat every mode as source-over:
+                // draw the backdrop underneath, then the source on top (correct for the common case).
+                const source = paintOffset + this.u24(paintOffset + 1);
+                const backdrop = paintOffset + this.u24(paintOffset + 5);
+                return [
+                    ...this.walkColrLayers(backdrop, m, new Set(seen)),
+                    ...this.walkColrLayers(source, m, new Set(seen)),
+                ];
+            }
+            default:
+                return []; // a bare fill with no glyph, or a paint format not supported yet
+        }
+    }
+    // Resolves the fill under a PaintGlyph to a solid or gradient `Paint`, descending through any
+    // transform paints and baking the accumulated affine `t` into the gradient's coordinates (so the
+    // renderer only has to apply the OUTER glyph transform). Returns null for a still-unsupported fill.
+    resolveFill(paintOffset, t) {
+        const format = u8(this.data, paintOffset);
+        const child = () => paintOffset + this.u24(paintOffset + 1);
+        const p = (x, y) => applyAffine(t, x, y);
+        switch (format) {
+            case 2: {
+                // PaintSolid: paletteIndex (u16) + alpha (F2Dot14). A solid fill ignores the transform.
+                const paletteIndex = u16(this.data, paintOffset + 1);
+                return {
+                    type: "solid",
+                    color: this.paletteColor(paletteIndex, this.f2dot14(paintOffset + 3)),
+                };
+            }
+            case 4: {
+                // PaintLinearGradient: a color line + p0/p1 (a rotation point p2 we treat axially).
+                const line = this.readColorLine(paintOffset + this.u24(paintOffset + 1));
+                return {
+                    type: "linearGradient",
+                    p0: p(i16(this.data, paintOffset + 4), i16(this.data, paintOffset + 6)),
+                    p1: p(i16(this.data, paintOffset + 8), i16(this.data, paintOffset + 10)),
+                    stops: line.stops,
+                    extend: line.extend,
+                };
+            }
+            case 6: {
+                // PaintRadialGradient: a color line + two circles. Radii scale by the affine's mean scale.
+                const line = this.readColorLine(paintOffset + this.u24(paintOffset + 1));
+                const rScale = detScale(t);
+                const [c0x, c0y] = p(i16(this.data, paintOffset + 4), i16(this.data, paintOffset + 6));
+                const [c1x, c1y] = p(i16(this.data, paintOffset + 10), i16(this.data, paintOffset + 12));
+                return {
+                    type: "radialGradient",
+                    c0: [c0x, c0y, u16(this.data, paintOffset + 8) * rScale],
+                    c1: [c1x, c1y, u16(this.data, paintOffset + 14) * rScale],
+                    stops: line.stops,
+                    extend: line.extend,
+                };
+            }
+            // Transform paints wrapping the fill: compose into `t` and descend to the actual gradient.
+            case 12:
+                return this.resolveFill(child(), compose(t, this.readAffine(paintOffset + this.u24(paintOffset + 4))));
+            case 14:
+                return this.resolveFill(child(), compose(t, [
+                    1,
+                    0,
+                    0,
+                    1,
+                    i16(this.data, paintOffset + 4),
+                    i16(this.data, paintOffset + 6),
+                ]));
+            case 16:
+                return this.resolveFill(child(), compose(t, [this.f2dot14(paintOffset + 4), 0, 0, this.f2dot14(paintOffset + 6), 0, 0]));
+            case 18:
+                return this.resolveFill(child(), compose(t, aroundCenter([this.f2dot14(paintOffset + 4), 0, 0, this.f2dot14(paintOffset + 6), 0, 0], i16(this.data, paintOffset + 8), i16(this.data, paintOffset + 10))));
+            case 20: {
+                const s = this.f2dot14(paintOffset + 4);
+                return this.resolveFill(child(), compose(t, [s, 0, 0, s, 0, 0]));
+            }
+            case 22: {
+                const s = this.f2dot14(paintOffset + 4);
+                return this.resolveFill(child(), compose(t, aroundCenter([s, 0, 0, s, 0, 0], i16(this.data, paintOffset + 6), i16(this.data, paintOffset + 8))));
+            }
+            default:
+                return null;
+        }
+    }
+    // A ColorLine: an extend mode then color stops (position + palette color).
+    readColorLine(o) {
+        const extend = ["pad", "repeat", "reflect"][u8(this.data, o)] ?? "pad";
+        const numStops = u16(this.data, o + 1);
+        const stops = [];
+        for (let i = 0; i < numStops; i++) {
+            const p = o + 3 + i * 6;
+            stops.push({
+                offset: this.f2dot14(p),
+                color: this.paletteColor(u16(this.data, p + 2), this.f2dot14(p + 4)),
+            });
+        }
+        return { stops, extend };
+    }
+    // A CPAL palette color scaled by a gradient/solid alpha (0..1). paletteIndex 0xFFFF is the spec's
+    // "use the text foreground color" sentinel -> null.
+    paletteColor(paletteIndex, alpha) {
+        if (paletteIndex === 0xffff)
+            return null;
+        const c = this.palette[paletteIndex];
+        if (!c)
+            return null;
+        return { r: c.r, g: c.g, b: c.b, a: Math.round(c.a * alpha) };
+    }
+    // A big-endian 24-bit offset (used for a paint's sub-offsets).
+    u24(o) {
+        return (u8(this.data, o) << 16) | (u8(this.data, o + 1) << 8) | u8(this.data, o + 2);
+    }
+    // An F2Dot14 fixed-point number (signed, 2 integer + 14 fraction bits) as a float.
+    f2dot14(o) {
+        return i16(this.data, o) / 16384;
+    }
+    // A signed 32-bit big-endian integer.
+    i32(o) {
+        const v = u32(this.data, o);
+        return v >= 0x80000000 ? v - 0x100000000 : v;
+    }
+    // An Affine2x3 struct: six Fixed (16.16) values xx, yx, xy, yy, dx, dy -> [a, b, c, d, e, f].
+    readAffine(o) {
+        const fixed = (p) => this.i32(p) / 65536;
+        return [fixed(o), fixed(o + 4), fixed(o + 8), fixed(o + 12), fixed(o + 16), fixed(o + 20)];
+    }
+    // COLR header (v0 and v1). v0: base-glyph + layer records (solid). v1 (version >= 1): additionally
+    // a BaseGlyphList of paint graphs + a LayerList they index into.
+    readColr() {
+        const o = this.table("COLR").offset;
+        const version = u16(this.data, o);
+        const numBaseGlyphs = u16(this.data, o + 2);
+        const baseOffset = o + u32(this.data, o + 4);
+        this.colrLayersOffset = o + u32(this.data, o + 8);
+        for (let i = 0; i < numBaseGlyphs; i++) {
+            const p = baseOffset + i * 6;
+            this.colrBase.set(u16(this.data, p), {
+                first: u16(this.data, p + 2),
+                count: u16(this.data, p + 4),
+            });
+        }
+        if (version < 1)
+            return;
+        // v1 fields follow the v0 ones: BaseGlyphList (glyphID -> paint offset) + LayerList.
+        const baseGlyphListOffset = u32(this.data, o + 14);
+        const layerListOffset = u32(this.data, o + 18);
+        if (layerListOffset)
+            this.colrLayerListOffset = o + layerListOffset;
+        if (baseGlyphListOffset) {
+            const listStart = o + baseGlyphListOffset;
+            const numRecords = u32(this.data, listStart);
+            for (let i = 0; i < numRecords; i++) {
+                const p = listStart + 4 + i * 6;
+                this.colrBaseV1.set(u16(this.data, p), listStart + u32(this.data, p + 2));
+            }
+        }
+    }
+    // CPAL: reads palette 0 into `palette`. Color records are BGRA bytes; colorRecordIndices[0] is
+    // where palette 0 starts in the shared record array.
+    readCpal() {
+        const o = this.table("CPAL").offset;
+        const numPaletteEntries = u16(this.data, o + 2);
+        const recordsOffset = o + u32(this.data, o + 8);
+        const firstRecord = u16(this.data, o + 12); // colorRecordIndices[0], the start of palette 0
+        for (let i = 0; i < numPaletteEntries; i++) {
+            const p = recordsOffset + (firstRecord + i) * 4;
+            this.palette.push({
+                b: u8(this.data, p),
+                g: u8(this.data, p + 1),
+                r: u8(this.data, p + 2),
+                a: u8(this.data, p + 3),
+            });
+        }
+    }
 }

package/dist/utils/ua-xmp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * XMP metadata packet that identifies the document as PDF/UA-1 (accessible). A fully conformant PDF/UA file
+ * also needs a displayed title (the /ViewerPreferences /DisplayDocTitle flag + this dc:title) and embedded
+ * fonts - the same font rule PDF/A has, so the standard-14 fonts do not qualify. Language is declared once
+ * in the catalog `/Lang`, not here (the dc:title uses `x-default`), so this takes only the title.
+ */
+export declare function uaXmp(opts?: {
+    title?: string;
+}): string;

package/dist/utils/ua-xmp.js

@@ -0,0 +1,32 @@
+// Escapes text for XML AND keeps the packet ASCII-safe: XML metacharacters become entities, and any
+// non-ASCII / control character becomes a numeric character reference. The PDF writer emits the
+// metadata stream one byte per char (Latin-1), so a raw non-ASCII title like "R\u00E9sum\u00E9" would corrupt
+// the UTF-8 XMP (and misalign /Length); escaping keeps every char <= 0x7e.
+const esc = (s) => s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/[^ -~]/gu, (c) => `&#${c.codePointAt(0)};`); // any non printable-ASCII char
+/**
+ * XMP metadata packet that identifies the document as PDF/UA-1 (accessible). A fully conformant PDF/UA file
+ * also needs a displayed title (the /ViewerPreferences /DisplayDocTitle flag + this dc:title) and embedded
+ * fonts - the same font rule PDF/A has, so the standard-14 fonts do not qualify. Language is declared once
+ * in the catalog `/Lang`, not here (the dc:title uses `x-default`), so this takes only the title.
+ */
+export function uaXmp(opts = {}) {
+    const title = esc(opts.title ?? "");
+    return (
+    // The xpacket marker is the 3-byte UTF-8 BOM (EF BB BF) written as Latin-1 chars so the
+    // single-byte writer emits it verbatim - a literal U+FEFF would be mangled to "?".
+    `<?xpacket begin="\u00EF\u00BB\u00BF" id="W5M0MpCehiHzreSzNTczkc9d"?>` +
+        `<x:xmpmeta xmlns:x="adobe:ns:meta/">` +
+        `<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">` +
+        `<rdf:Description rdf:about="" xmlns:pdfuaid="http://www.aiim.org/pdfua/ns/id/">` +
+        `<pdfuaid:part>1</pdfuaid:part>` +
+        `</rdf:Description>` +
+        `<rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">` +
+        `<dc:title><rdf:Alt><rdf:li xml:lang="x-default">${title}</rdf:li></rdf:Alt></dc:title>` +
+        `</rdf:Description>` +
+        `</rdf:RDF></x:xmpmeta>` +
+        `<?xpacket end="w"?>`);
+}

package/package.json

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