pagyra-js 0.0.13 → 0.0.15

package/dist/src/pdf/font/font-subset.js

@@ -1,71 +1,90 @@
 import { createToUnicodeCMapText } from "./to-unicode.js";
+import { BinaryWriter } from "./binary-writer.js";
+import { LocaTableReader } from "./loca-reader.js";
+import { DefaultDataViewReader } from "./ttf-table-provider.js";
 /**
  * Creates a PDF font subset for TTF fonts.
  */
 export function createPdfFontSubset(options) {
     const { baseName, fontMetrics, fontProgram, usedGlyphIds } = options;
     const encoding = options.encoding ?? "identity";
-    const glyphIds = Array.from(usedGlyphIds).sort((a, b) => a - b);
-    if (!glyphIds.includes(0)) {
-        glyphIds.unshift(0);
+    // 1. Compute closure of used glyphs (checking composite glyphs)
+    const initialGids = Array.from(usedGlyphIds);
+    if (!initialGids.includes(0)) {
+        initialGids.push(0); // Always include .notdef
     }
-    const gidToCharCode = new Map();
-    if (encoding === "identity") {
-        for (const gid of glyphIds) {
-            gidToCharCode.set(gid, gid);
-        }
-    }
-    else {
-        for (let i = 0; i < glyphIds.length; i++) {
-            gidToCharCode.set(glyphIds[i], i);
-        }
-    }
-    const firstChar = encoding === "identity" ? Math.min(...glyphIds) : 0;
-    const lastChar = encoding === "identity" ? Math.max(...glyphIds) : glyphIds.length - 1;
+    const { glyphIds, gidMap } = computeSubsetClosure(fontProgram, initialGids);
     const unitsPerEm = fontMetrics.metrics.unitsPerEm;
     const widths = [];
-    if (encoding === "identity") {
+    const usedGidSet = new Set(glyphIds);
+    let firstChar;
+    let lastChar;
+    if (encoding === "sequential") {
+        firstChar = 0;
+        lastChar = glyphIds.length - 1;
         for (const gid of glyphIds) {
             const glyphMetric = fontMetrics.glyphMetrics.get(gid);
             const advanceWidth = glyphMetric?.advanceWidth ?? 0;
-            const pdfWidth = Math.round((advanceWidth / unitsPerEm) * 1000);
-            widths.push(pdfWidth);
+            widths.push(Math.round((advanceWidth / unitsPerEm) * 1000));
         }
     }
     else {
-        for (const gid of glyphIds) {
-            const glyphMetric = fontMetrics.glyphMetrics.get(gid);
+        // Identity: CIDs = Original GIDs.
+        // We use a sparse range from 0 to maxGid to ensure stability.
+        const maxGid = Math.max(...glyphIds);
+        firstChar = 0;
+        lastChar = maxGid;
+        for (let i = 0; i <= maxGid; i++) {
+            const glyphMetric = fontMetrics.glyphMetrics.get(i);
             const advanceWidth = glyphMetric?.advanceWidth ?? 0;
-            const pdfWidth = Math.round((advanceWidth / unitsPerEm) * 1000);
-            widths.push(pdfWidth);
+            widths.push(Math.round((advanceWidth / unitsPerEm) * 1000));
         }
     }
+    // Generate ToUnicode CMap
+    // we map CID -> Unicode.
     const cmapEntries = [];
     const unicodeMap = fontMetrics.cmap.unicodeMap;
-    for (const gid of glyphIds) {
-        const unicodes = [];
-        for (const [cp, mappedGid] of unicodeMap.entries()) {
-            if (mappedGid === gid) {
-                unicodes.push(cp);
+    const gidToUnicodes = new Map();
+    for (const [cp, mappedGid] of unicodeMap.entries()) {
+        const list = gidToUnicodes.get(mappedGid) || [];
+        list.push(cp);
+        gidToUnicodes.set(mappedGid, list);
+    }
+    if (encoding === "sequential") {
+        for (let i = 0; i < glyphIds.length; i++) {
+            const originalGid = glyphIds[i];
+            const unicodes = gidToUnicodes.get(originalGid);
+            if (unicodes) {
+                for (const u of unicodes) {
+                    cmapEntries.push({ gid: i, unicode: u });
+                }
             }
         }
-        if (unicodes.length > 0) {
-            const cid = gidToCharCode.get(gid);
-            if (cid !== undefined) {
-                for (const unicode of unicodes) {
-                    cmapEntries.push({ gid: cid, unicode });
+    }
+    else {
+        // Identity: CID = Original GID
+        for (const gid of glyphIds) {
+            const unicodes = gidToUnicodes.get(gid);
+            if (unicodes) {
+                for (const u of unicodes) {
+                    cmapEntries.push({ gid: gid, unicode: u });
                 }
             }
         }
     }
     const toUnicodeCMap = createToUnicodeCMapText(cmapEntries);
-    const fontFile = extractFontFile(fontProgram);
+    // Generate the binary TTF
+    const fontFile = subsetFont(fontProgram, glyphIds, encoding);
     const encodeGlyph = (gid) => {
-        const charCode = gidToCharCode.get(gid);
-        if (charCode === undefined) {
-            throw new Error(`Glyph ID ${gid} not found in subset`);
+        if (encoding === "sequential") {
+            const index = gidMap.get(gid);
+            if (index === undefined)
+                throw new Error(`Glyph ID ${gid} not found in subset`);
+            return index;
+        }
+        else {
+            return gid;
         }
-        return charCode;
     };
     return {
         name: `/${baseName}`,
@@ -76,113 +95,299 @@ export function createPdfFontSubset(options) {
         fontFile,
         encodeGlyph,
         glyphIds,
+        gidMap
     };
 }
-/**
- * Extracts the font file from FontProgram.
- * Builds a complete TTF with all available tables.
- */
-function extractFontFile(fontProgram) {
-    if (fontProgram.getRawTableData) {
-        return buildTtfFromTables(fontProgram);
+function computeSubsetClosure(fontProgram, initialGids) {
+    const reader = new DefaultDataViewReader();
+    const glyfData = fontProgram.getRawTableData?.("glyf");
+    const locaData = fontProgram.getRawTableData?.("loca");
+    const headData = fontProgram.getRawTableData?.("head");
+    const used = new Set(initialGids);
+    const stack = [...initialGids];
+    if (!glyfData || !locaData || !headData) {
+        const sorted = Array.from(used).sort((a, b) => a - b);
+        const map = new Map();
+        sorted.forEach((gid, i) => map.set(gid, i));
+        return { glyphIds: sorted, gidMap: map };
+    }
+    const headView = new DataView(headData.buffer, headData.byteOffset, headData.byteLength);
+    const locaView = new DataView(locaData.buffer, locaData.byteOffset, locaData.byteLength);
+    const glyfView = new DataView(glyfData.buffer, glyfData.byteOffset, glyfData.byteLength);
+    const indexToLocFormat = reader.getUint16(headView, 50);
+    const locaReader = new LocaTableReader(locaView, indexToLocFormat, reader);
+    while (stack.length > 0) {
+        const gid = stack.pop();
+        const offset = locaReader.getGlyphOffset(gid);
+        if (!offset || offset.start === offset.end)
+            continue;
+        if (offset.start + 2 > glyfView.byteLength)
+            continue;
+        const numberOfContours = reader.getInt16(glyfView, offset.start);
+        if (numberOfContours < 0) {
+            let pos = offset.start + 10;
+            let flags;
+            do {
+                if (pos + 4 > glyfView.byteLength)
+                    break;
+                flags = reader.getUint16(glyfView, pos);
+                const componentGid = reader.getUint16(glyfView, pos + 2);
+                if (!used.has(componentGid)) {
+                    used.add(componentGid);
+                    stack.push(componentGid);
+                }
+                pos += 4;
+                const arg1And2AreWords = (flags & 0x0001) !== 0;
+                if (arg1And2AreWords)
+                    pos += 4;
+                else
+                    pos += 2;
+                const weHaveAScale = (flags & 0x0008) !== 0;
+                const weHaveAnXAndYScale = (flags & 0x0040) !== 0;
+                const weHaveATwoByTwo = (flags & 0x0080) !== 0;
+                if (weHaveAScale)
+                    pos += 2;
+                else if (weHaveAnXAndYScale)
+                    pos += 4;
+                else if (weHaveATwoByTwo)
+                    pos += 8;
+            } while (flags & 0x0020);
+        }
     }
-    console.warn("Font subsetting not fully implemented; no raw table data available");
-    return new Uint8Array(0);
+    const sorted = Array.from(used).sort((a, b) => a - b);
+    const map = new Map();
+    sorted.forEach((gid, i) => map.set(gid, i));
+    return { glyphIds: sorted, gidMap: map };
 }
-/**
- * Builds a complete TTF file from available tables in FontProgram.
- */
-function buildTtfFromTables(fontProgram) {
-    const tableTags = [
-        'head', 'hhea', 'maxp', 'OS/2', 'hmtx', 'cmap',
-        'loca', 'glyf', 'name', 'post', 'cvt ', 'fpgm', 'prep'
-    ];
-    const tables = new Map();
-    for (const tag of tableTags) {
-        const data = fontProgram.getRawTableData(tag);
-        if (data && data.length > 0) {
-            tables.set(tag, data);
+function subsetFont(fontProgram, glyphIds, encoding) {
+    const reader = new DefaultDataViewReader();
+    const getTable = (tag) => fontProgram.getRawTableData?.(tag);
+    const head = getTable("head");
+    const hhea = getTable("hhea");
+    const maxp = getTable("maxp");
+    const hmtx = getTable("hmtx");
+    const loca = getTable("loca");
+    const glyf = getTable("glyf");
+    const OS2 = getTable("OS/2");
+    if (!head || !hhea || !maxp || !hmtx || !loca || !glyf) {
+        throw new Error("Missing required tables for subsetting");
+    }
+    const headView = new DataView(head.buffer, head.byteOffset, head.byteLength);
+    const locaView = new DataView(loca.buffer, loca.byteOffset, loca.byteLength);
+    const glyfView = new DataView(glyf.buffer, glyf.byteOffset, glyf.byteLength);
+    const hmtxView = new DataView(hmtx.buffer, hmtx.byteOffset, hmtx.byteLength);
+    const hheaView = new DataView(hhea.buffer, hhea.byteOffset, hhea.byteLength);
+    const indexToLocFormat = reader.getUint16(headView, 50);
+    const locaReader = new LocaTableReader(locaView, indexToLocFormat, reader);
+    const numberOfHMetrics = reader.getUint16(hheaView, 34);
+    const newLoca = new BinaryWriter();
+    const newGlyf = new BinaryWriter();
+    const usedGidSet = new Set(glyphIds);
+    let maxGidToEmit;
+    if (encoding === "sequential") {
+        maxGidToEmit = glyphIds.length - 1;
+        const gidMap = new Map();
+        glyphIds.forEach((gid, i) => gidMap.set(gid, i));
+        for (const originalGid of glyphIds) {
+            newLoca.writeUint32(newGlyf.byteLength());
+            const range = locaReader.getGlyphOffset(originalGid);
+            if (range && range.end > range.start) {
+                const glyphData = new Uint8Array(glyf.buffer, glyf.byteOffset + range.start, range.end - range.start);
+                const numberOfContours = reader.getInt16(new DataView(glyphData.buffer, glyphData.byteOffset, glyphData.byteLength), 0);
+                if (numberOfContours < 0) {
+                    const newGlyphData = new Uint8Array(glyphData);
+                    const view = new DataView(newGlyphData.buffer);
+                    let pos = 10;
+                    let flags;
+                    do {
+                        flags = reader.getUint16(view, pos);
+                        const oldCompGid = reader.getUint16(view, pos + 2);
+                        view.setUint16(pos + 2, gidMap.get(oldCompGid) ?? 0, false);
+                        pos += 4;
+                        const arg1And2AreWords = (flags & 0x0001) !== 0;
+                        if (arg1And2AreWords)
+                            pos += 4;
+                        else
+                            pos += 2;
+                        const weHaveAScale = (flags & 0x0008) !== 0;
+                        const weHaveAnXAndYScale = (flags & 0x0040) !== 0;
+                        const weHaveATwoByTwo = (flags & 0x0080) !== 0;
+                        if (weHaveAScale)
+                            pos += 2;
+                        else if (weHaveAnXAndYScale)
+                            pos += 4;
+                        else if (weHaveATwoByTwo)
+                            pos += 8;
+                    } while (flags & 0x0020);
+                    newGlyf.writeBytes(newGlyphData);
+                }
+                else {
+                    newGlyf.writeBytes(glyphData);
+                }
+            }
+        }
+    }
+    else {
+        // Identity Mode: Sparse TTF
+        maxGidToEmit = Math.max(...glyphIds);
+        for (let gid = 0; gid <= maxGidToEmit; gid++) {
+            newLoca.writeUint32(newGlyf.byteLength());
+            if (usedGidSet.has(gid)) {
+                const range = locaReader.getGlyphOffset(gid);
+                if (range && range.end > range.start) {
+                    const glyphData = new Uint8Array(glyf.buffer, glyf.byteOffset + range.start, range.end - range.start);
+                    newGlyf.writeBytes(glyphData);
+                }
+            }
+        }
+    }
+    newLoca.writeUint32(newGlyf.byteLength());
+    // 2. MAXP
+    const newMaxp = new BinaryWriter();
+    newMaxp.writeBytes(new Uint8Array(maxp.buffer, maxp.byteOffset, 6));
+    const maxpView = new DataView(newMaxp.getData().buffer);
+    maxpView.setUint16(4, maxGidToEmit + 1, false);
+    if (maxp.byteLength > 6) {
+        newMaxp.writeBytes(new Uint8Array(maxp.buffer, maxp.byteOffset + 6, Math.min(maxp.byteLength - 6, 26)));
+    }
+    // 3. HMTX
+    const newHmtx = new BinaryWriter();
+    if (encoding === "sequential") {
+        for (const originalGid of glyphIds) {
+            let advance = 0, lsb = 0;
+            if (originalGid < numberOfHMetrics) {
+                advance = reader.getUint16(hmtxView, originalGid * 4);
+                lsb = reader.getInt16(hmtxView, originalGid * 4 + 2);
+            }
+            else {
+                advance = reader.getUint16(hmtxView, (numberOfHMetrics - 1) * 4);
+                const lsbOffset = numberOfHMetrics * 4 + (originalGid - numberOfHMetrics) * 2;
+                if (lsbOffset + 2 <= hmtxView.byteLength)
+                    lsb = reader.getInt16(hmtxView, lsbOffset);
+            }
+            newHmtx.writeUint16(advance);
+            newHmtx.writeInt16(lsb);
         }
     }
-    if (tables.size === 0) {
-        console.warn("No TTF tables available for font subsetting");
-        return new Uint8Array(0);
+    else {
+        for (let gid = 0; gid <= maxGidToEmit; gid++) {
+            let advance = 0, lsb = 0;
+            if (gid < numberOfHMetrics) {
+                advance = reader.getUint16(hmtxView, gid * 4);
+                lsb = reader.getInt16(hmtxView, gid * 4 + 2);
+            }
+            else {
+                advance = reader.getUint16(hmtxView, (numberOfHMetrics - 1) * 4);
+                const lsbOffset = numberOfHMetrics * 4 + (gid - numberOfHMetrics) * 2;
+                if (lsbOffset + 2 <= hmtxView.byteLength)
+                    lsb = reader.getInt16(hmtxView, lsbOffset);
+            }
+            newHmtx.writeUint16(advance);
+            newHmtx.writeInt16(lsb);
+        }
     }
-    const numTables = tables.size;
+    // 4. HHEA
+    const newHhea = new BinaryWriter();
+    newHhea.writeBytes(new Uint8Array(hhea));
+    const newHheaView = new DataView(newHhea.getData().buffer);
+    newHheaView.setUint16(34, maxGidToEmit + 1, false);
+    // 5. CMAP (Minimal Dummy)
+    const newCmap = new BinaryWriter();
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(1);
+    newCmap.writeUint16(3);
+    newCmap.writeUint16(1);
+    newCmap.writeUint32(12);
+    const startCmap = newCmap.byteLength();
+    newCmap.writeUint16(4);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0xFFFF);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    newCmap.writeUint16(0);
+    const endCmap = newCmap.byteLength();
+    const cmapView = new DataView(newCmap.getData().buffer);
+    cmapView.setUint16(startCmap + 2, endCmap - startCmap, false);
+    // 6. HEAD
+    const newHead = new BinaryWriter();
+    newHead.writeBytes(new Uint8Array(head));
+    const newHeadView = new DataView(newHead.getData().buffer);
+    newHeadView.setUint16(50, 1, false);
+    newHeadView.setUint32(8, 0, false);
+    const tables = [
+        ["head", newHead.getData()],
+        ["hhea", newHhea.getData()],
+        ["maxp", newMaxp.getData()],
+        ["hmtx", newHmtx.getData()],
+        ["loca", newLoca.getData()],
+        ["glyf", newGlyf.getData()],
+        ["cmap", newCmap.getData()]
+    ];
+    if (OS2)
+        tables.push(["OS/2", new Uint8Array(OS2)]);
+    tables.sort((a, b) => a[0].localeCompare(b[0]));
+    const numTables = tables.length;
     const searchRange = Math.pow(2, Math.floor(Math.log2(numTables))) * 16;
     const entrySelector = Math.floor(Math.log2(numTables));
     const rangeShift = numTables * 16 - searchRange;
-    const headerSize = 12;
-    const directorySize = numTables * 16;
-    let dataSize = 0;
-    for (const data of tables.values()) {
-        dataSize += data.length + (4 - (data.length % 4)) % 4;
-    }
-    const totalSize = headerSize + directorySize + dataSize;
-    const buffer = new ArrayBuffer(totalSize);
-    const view = new DataView(buffer);
-    const bytes = new Uint8Array(buffer);
-    view.setUint32(0, 0x00010000, false);
-    view.setUint16(4, numTables, false);
-    view.setUint16(6, searchRange, false);
-    view.setUint16(8, entrySelector, false);
-    view.setUint16(10, rangeShift, false);
-    let directoryOffset = 12;
-    let dataOffset = headerSize + directorySize;
+    const fullTtf = new BinaryWriter();
+    fullTtf.writeUint32(0x00010000);
+    fullTtf.writeUint16(numTables);
+    fullTtf.writeUint16(searchRange);
+    fullTtf.writeUint16(entrySelector);
+    fullTtf.writeUint16(rangeShift);
+    let offset = 12 + numTables * 16;
     for (const [tag, data] of tables) {
-        const tagBytes = new TextEncoder().encode(tag.padEnd(4));
-        bytes.set(tagBytes.slice(0, 4), directoryOffset);
-        const checksum = calculateTableChecksum(data);
-        view.setUint32(directoryOffset + 4, checksum, false);
-        view.setUint32(directoryOffset + 8, dataOffset, false);
-        view.setUint32(directoryOffset + 12, data.length, false);
-        bytes.set(data, dataOffset);
-        const paddedLength = data.length + (4 - (data.length % 4)) % 4;
-        directoryOffset += 16;
-        dataOffset += paddedLength;
-    }
-    updateHeadChecksum(bytes, view, tables);
-    return bytes;
+        fullTtf.writeBytes(new TextEncoder().encode(tag.padEnd(4)).slice(0, 4));
+        fullTtf.writeUint32(calculateChecksum(data));
+        fullTtf.writeUint32(offset);
+        fullTtf.writeUint32(data.length);
+        let paddedLength = data.length;
+        if (data.length % 4 !== 0)
+            paddedLength += 4 - (data.length % 4);
+        offset += paddedLength;
+    }
+    for (const [_, data] of tables) {
+        fullTtf.writeBytes(data);
+        const padding = (4 - (data.length % 4)) % 4;
+        for (let k = 0; k < padding; k++)
+            fullTtf.writeUint8(0);
+    }
+    const ttfBytes = fullTtf.getData();
+    const ttfView = new DataView(ttfBytes.buffer);
+    const fileChecksum = calculateChecksum(ttfBytes);
+    const adjustment = (0xB1B0AFBA - fileChecksum) >>> 0;
+    let headOffset = 0;
+    for (let i = 0; i < numTables; i++) {
+        const tag = new TextDecoder().decode(ttfBytes.slice(12 + i * 16, 12 + i * 16 + 4));
+        if (tag === "head") {
+            headOffset = ttfView.getUint32(12 + i * 16 + 8, false);
+            break;
+        }
+    }
+    if (headOffset > 0)
+        ttfView.setUint32(headOffset + 8, adjustment, false);
+    return ttfBytes;
 }
-/**
- * Calculate TTF table checksum
- */
-function calculateTableChecksum(data) {
+function calculateChecksum(data) {
     let sum = 0;
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
     const nLongs = Math.floor(data.length / 4);
-    for (let i = 0; i < nLongs; i++) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    for (let i = 0; i < nLongs; i++)
         sum = (sum + view.getUint32(i * 4, false)) >>> 0;
-    }
     const remaining = data.length % 4;
     if (remaining > 0) {
         let last = 0;
-        for (let i = 0; i < remaining; i++) {
+        for (let i = 0; i < remaining; i++)
             last = (last << 8) | data[nLongs * 4 + i];
-        }
         last = last << ((4 - remaining) * 8);
         sum = (sum + last) >>> 0;
     }
     return sum >>> 0;
 }
-/**
- * Update the checkSumAdjustment field in the head table
- */
-function updateHeadChecksum(bytes, view, tables) {
-    const numTables = tables.size;
-    let headOffset = -1;
-    for (let i = 0; i < numTables; i++) {
-        const dirOffset = 12 + i * 16;
-        const tag = new TextDecoder().decode(bytes.slice(dirOffset, dirOffset + 4));
-        if (tag.trim() === 'head') {
-            headOffset = view.getUint32(dirOffset + 8, false);
-            break;
-        }
-    }
-    if (headOffset === -1)
-        return;
-    view.setUint32(headOffset + 8, 0, false);
-    const fileChecksum = calculateTableChecksum(bytes);
-    const adjustment = (0xB1B0AFBA - fileChecksum) >>> 0;
-    view.setUint32(headOffset + 8, adjustment, false);
-}

package/dist/src/pdf/font/managers/subset-resource-manager.js

@@ -62,12 +62,24 @@ export class SubsetResourceManager {
                 scaleTo1000(metrics.headBBox[3]),
             ]
             : [-1000, -1000, 1000, 1000];
-        const fontFile = font.embedded?.subset ?? subset.fontFile;
+        // Ensure we use the subset font file if available, falling back to full font only if subset is empty
+        const fontFile = (subset.fontFile && subset.fontFile.length > 0) ? subset.fontFile : (font.embedded?.subset ?? new Uint8Array(0));
         if (!fontFile || fontFile.length === 0) {
             log("font", "warn", "missing-font-file-for-subset", { baseFont: font.baseFont, alias: subset.name });
             return font.ref;
         }
-        const { DW, W } = computeWidths(metrics);
+        // Use widths from subset if available, otherwise compute from metrics
+        let DW = 1000;
+        let W = [];
+        if (subset.widths && subset.widths.length > 0) {
+            // For sequential subsets starting at CID 0
+            W = [subset.firstChar, subset.widths];
+        }
+        else {
+            const result = computeWidths(metrics);
+            DW = result.DW;
+            W = result.W;
+        }
         const subsetTag = subset.name.startsWith("/") ? subset.name.slice(1) : subset.name;
         const subsetBaseName = `${subsetTag}+${font.baseFont}`;
         const fontFileRef = this.doc.registerStream(fontFile, {});

package/dist/src/pdf/font/ttf-lite.js

@@ -26,7 +26,8 @@ export function parseTtfBuffer(buffer) {
     const cmap = new CmapParser(parser, cmapTable);
     const kerning = mergeKerningMaps(parseKerningTable(parser), parseGposKerning(parser));
     const glyfProvider = createGlyfOutlineProvider(parser);
-    return new TtfFontMetrics(metrics, glyphMetrics, cmap, headBBox, glyfProvider, kerning);
+    const getRawTableData = (tag) => parser.getRawTableDataString(tag);
+    return new TtfFontMetrics(metrics, glyphMetrics, cmap, headBBox, glyfProvider, kerning, getRawTableData);
 }
 /**
  * Parse the 'kern' table (format 0) into a nested map of adjustments in font units.

package/dist/src/pdf/font/ttf-table-parser.d.ts

@@ -22,4 +22,5 @@ export declare class TtfTableParser {
     getInt8(table: DataView, offset: number): number;
     getUint8(table: DataView, offset: number): number;
     getUint32(table: DataView, offset: number): number;
+    getRawTableDataString(tagStr: string): Uint8Array | null;
 }

package/dist/src/pdf/font/ttf-table-parser.js

@@ -107,4 +107,11 @@ export class TtfTableParser {
             throw new Error("Read beyond table bounds (getUint32)");
         return table.getUint32(offset, false); // big-endian
     }
+    getRawTableDataString(tagStr) {
+        const tag = tagStr.split('').reduce((acc, char) => (acc << 8) | char.charCodeAt(0), 0) >>> 0;
+        const entry = this.tableDirectory.get(tag);
+        if (!entry)
+            return null;
+        return new Uint8Array(this.dataView.buffer, this.dataView.byteOffset + entry.offset, entry.length);
+    }
 }

package/dist/src/pdf/renderers/text-renderer.js

@@ -103,22 +103,6 @@ export class TextRenderer {
         const wordSpacingPx = run.wordSpacing ?? 0;
         const wordSpacingPt = this.coordinateTransformer.convertPxToPt(wordSpacingPx);
         const appliedWordSpacing = wordSpacingPx !== 0 && wordSpacingPt !== 0;
-        // Shadows use the base font resource (non-subset) for compatibility with Identity-H encoding
-        this.registerFont(font);
-        if (run.textShadows && run.textShadows.length > 0) {
-            const shadowCommands = await this.shadowRenderer.render({
-                run,
-                font,
-                encoded,
-                Tm: run.lineMatrix ?? { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 },
-                fontSizePt,
-                fontSizePx: run.fontSize,
-                wordSpacingPt,
-                appliedWordSpacing,
-                fontResourceName: font.resourceName,
-            });
-            this.commands.push(...shadowCommands);
-        }
         const subsetResource = this.fontRegistry.ensureSubsetForGlyphRun(glyphRun, font);
         this.registerSubsetFont(subsetResource.alias, subsetResource.ref);
         const gradientBackground = run.textGradient;
@@ -153,6 +137,22 @@ export class TextRenderer {
                 }
             }
         }
+        if (run.textShadows && run.textShadows.length > 0) {
+            const shadowCommands = await this.shadowRenderer.render({
+                run,
+                font,
+                encoded,
+                Tm: run.lineMatrix ?? { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 },
+                fontSizePt,
+                fontSizePx: run.fontSize,
+                wordSpacingPt,
+                appliedWordSpacing,
+                fontResourceName: font.resourceName,
+                subset: subsetResource.subset,
+                subsetAlias: subsetResource.alias
+            });
+            this.commands.push(...shadowCommands);
+        }
         const glyphCommands = drawGlyphRun(glyphRun, subsetResource.subset, 0, 0, fontSizePt, color, this.graphicsStateManager, wordSpacingPt, { tm: textMatrix });
         this.commands.push(...glyphCommands);
         if (run.decorations) {
@@ -276,6 +276,7 @@ function buildUnifiedFontFromResource(run, font) {
             unitsPerEm: metrics.metrics.unitsPerEm,
             glyphCount: metrics.glyphMetrics.size,
             getGlyphOutline: metrics.getGlyphOutline,
+            getRawTableData: metrics.getRawTableData,
         },
         css: {
             family: run.fontFamily,

package/dist/src/pdf/renderers/text-shadow-renderer.d.ts

@@ -13,6 +13,10 @@ export interface TextShadowRenderContext {
     wordSpacingPt: number;
     appliedWordSpacing: boolean;
     fontResourceName?: string;
+    subset?: {
+        gidMap: Map<number, number>;
+    };
+    subsetAlias?: string;
 }
 export declare class TextShadowRenderer {
     private readonly coordinateTransformer;