@doccloak/core 0.12.1 → 0.13.0

package/dist/pdf/fonts.js

@@ -0,0 +1,465 @@
+/**
+ * @doccloak/core/pdf - font model (T209).
+ *
+ * A LoadedFont turns the bytes of a text-showing operand into glyphs (code,
+ * Unicode, advance width) and, in the other direction, tells whether a
+ * placeholder can be written with the same font and how to encode it.
+ *
+ * Decoding order (as pdf.js and the spec, 9.10.2): ToUnicode CMap first,
+ * then the encoding (base encoding + /Differences) through the Adobe Glyph
+ * List, then for composite fonts the CID-to-Unicode of Identity orderings is
+ * unknown, so a code with no ToUnicode entry yields '' (notdef for our
+ * purposes) and the page is later cross-checked against pdf.js.
+ *
+ * Encodability (placeholders in the original font): a character is
+ * showable when a code maps to it AND that code is known to have a glyph:
+ * either the code was shown somewhere in the document with this font (the
+ * subset contains it) or the font is a non-embedded standard 14 face whose
+ * AFM lists the glyph. This rule never guesses about subset contents.
+ */
+import { PDFName, PDFNumber, PDFArray, PDFStream, PDFDict, decodeStream, getArray, getDict, getName, getNumber, getStream, itemsOf, numbersOf, refKey, refOf, resolve, } from "./objects.js";
+import { STANDARD_ENCODING, WIN_ANSI_ENCODING, MAC_ROMAN_ENCODING, SYMBOL_ENCODING, ZAPF_DINGBATS_ENCODING, encodingByName, } from "./encodings.js";
+import { glyphNameToUnicode, unicodeToGlyphName } from "./glyphlist.js";
+import { parseCMap, predefinedCMap, splitCodes, cidOf, unicodeOf, CMapParseError } from "./cmap.js";
+import { foldGlyphText } from "./oracle.js";
+import { loadStandardMetrics, standardFontFor } from "./standard-metrics.js";
+import { styleFromFontName } from "./fallback-fonts.js";
+const STANDARD_SUBTYPES = new Set(['Type1', 'MMType1', 'TrueType', 'Type3', 'Type0']);
+/** Load (and cache by ref) the font at /Resources /Font /<name>. */
+export function loadFont(ctx, fontsDict, resourceName, cache) {
+    if (!fontsDict)
+        return undefined;
+    const ref = refOf(fontsDict, resourceName);
+    const dictObj = resolve(ctx, fontsDict.get(PDFName.of(resourceName)));
+    const dict = dictObj instanceof PDFStream ? dictObj.dict : dictObj;
+    if (!(dict && typeof dict.get === 'function'))
+        return undefined;
+    const key = ref ? refKey(ref) : `direct:${resourceName}:${dict.toString()}`;
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const font = buildFont(ctx, dict, key);
+    cache.set(key, font);
+    return font;
+}
+function buildFont(ctx, dict, key) {
+    const subtypeName = getName(ctx, dict, 'Subtype') ?? '';
+    const subtype = STANDARD_SUBTYPES.has(subtypeName) ? subtypeName : 'unknown';
+    const baseFont = getName(ctx, dict, 'BaseFont') ?? '';
+    const problems = [];
+    if (subtype === 'unknown')
+        problems.push({ code: 'unknown-subtype', message: `font subtype /${subtypeName || '?'} is not supported` });
+    const composite = subtype === 'Type0';
+    const type3 = subtype === 'Type3';
+    const descendant = composite ? firstDescendant(ctx, dict) : undefined;
+    const descriptor = getDict(ctx, descendant ?? dict, 'FontDescriptor');
+    const flags = getNumber(ctx, descriptor, 'Flags') ?? 0;
+    const symbolic = (flags & 4) !== 0 && (flags & 32) === 0;
+    const embedded = !!(descriptor && (getStream(ctx, descriptor, 'FontFile') || getStream(ctx, descriptor, 'FontFile2') || getStream(ctx, descriptor, 'FontFile3')));
+    const style = styleFromFontName(baseFont, flags, getNumber(ctx, descriptor, 'ItalicAngle'), getNumber(ctx, descriptor, 'StemV'), getNumber(ctx, descriptor, 'FontWeight'));
+    const ascent = getNumber(ctx, descriptor, 'Ascent') ?? 750;
+    const descent = getNumber(ctx, descriptor, 'Descent') ?? -250;
+    // ToUnicode
+    let toUnicode = null;
+    const tuStream = getStream(ctx, dict, 'ToUnicode');
+    if (tuStream) {
+        try {
+            toUnicode = parseCMap(decodeStream(ctx, tuStream));
+        }
+        catch (err) {
+            const usecmap = err instanceof CMapParseError && /usecmap/.test(err.message);
+            problems.push({ code: usecmap ? 'usecmap' : 'bad-cmap', message: `ToUnicode CMap unreadable: ${err.message}` });
+            toUnicode = null;
+        }
+    }
+    // A Type3 font draws its glyphs from /CharProcs, whatever its /BaseFont says: standard-14 metrics never apply.
+    const standard = !embedded && !type3 ? standardFontFor(baseFont) : undefined;
+    const metrics = standard ? loadStandardMetrics(standard) : undefined;
+    if (composite) {
+        return buildCompositeFont(ctx, dict, descendant, key, { subtype, baseFont, problems, style, embedded, symbolic, toUnicode, ascent, descent, flags, metrics });
+    }
+    // ---- simple fonts (Type1, TrueType, Type3) ----
+    const fontMatrix = type3 ? matrixOf(numbersOf(ctx, getArray(ctx, dict, 'FontMatrix'))) : null;
+    const builtin = symbolic && embedded && (subtype === 'Type1' || subtype === 'MMType1') ? type1BuiltinEncoding(ctx, descriptor) : undefined;
+    const { names: encodingNames, base: baseEncodingNames } = simpleEncoding(ctx, dict, { subtype, symbolic, nonsymbolic: (flags & 32) !== 0, embedded, baseFont, metrics, type3, builtin });
+    // Widths
+    const firstChar = getNumber(ctx, dict, 'FirstChar');
+    const widthsArr = numbersOf(ctx, getArray(ctx, dict, 'Widths'));
+    const missingWidth = getNumber(ctx, descriptor, 'MissingWidth') ?? 0;
+    const scale = type3 && fontMatrix ? fontMatrix[0] * 1000 : 1;
+    // AFM width of the glyph at a code; a /Differences name the AFM does not know (/.notdef, /gNN)
+    // advances like the base encoding's glyph at that code, as pdf.js draws it.
+    const metricWidth = (code) => {
+        if (!metrics)
+            return undefined;
+        const g = encodingNames[code];
+        const w = g ? metrics.widthOfGlyph(g) : undefined;
+        if (w !== undefined)
+            return w;
+        const b = baseEncodingNames[code];
+        return b ? metrics.widthOfGlyph(b) : undefined;
+    };
+    const widthOfCode = (code) => {
+        if (widthsArr.length > 0 && firstChar !== undefined) {
+            const i = code - firstChar;
+            if (i >= 0 && i < widthsArr.length) {
+                const w = widthsArr[i];
+                // Some producers write zero widths for glyphs they never use; keep zero (spec: advance 0).
+                return w * scale;
+            }
+            if (type3)
+                return 0;
+            if (metrics)
+                return metricWidth(code) ?? missingWidth;
+            return missingWidth;
+        }
+        if (metrics)
+            return metricWidth(code) ?? missingWidth;
+        return missingWidth * scale || 0;
+    };
+    const unicodeForCode = (code) => {
+        if (toUnicode) {
+            // An empty destination (<41> <>) is no mapping: pdf.js falls through to the encoding.
+            const u = unicodeOf(toUnicode, code);
+            if (u !== undefined && u !== '')
+                return foldGlyphText(u);
+        }
+        const g = encodingNames[code];
+        if (g) {
+            const u = glyphNameToUnicode(g);
+            if (u !== undefined)
+                return foldGlyphText(u);
+        }
+        // Non-symbolic fonts without an entry: codes in the printable ASCII range mean themselves.
+        if (!symbolic && !toUnicode && code >= 0x20 && code <= 0x7e && encodingNames[code] === undefined) {
+            return String.fromCharCode(code);
+        }
+        return '';
+    };
+    const usedCodes = new Set();
+    const decode = (bytes) => {
+        const out = [];
+        for (let i = 0; i < bytes.length; i++) {
+            const code = bytes[i];
+            out.push({ code, length: 1, offset: i, unicode: unicodeForCode(code), width: widthOfCode(code), isSpaceCode: code === 32, notdef: encodingNames[code] === '.notdef' });
+        }
+        return out;
+    };
+    // Reverse map for encoding placeholders: unicode -> code, lowest code wins. A viewer draws a
+    // code through the ENCODING (glyph name), never through ToUnicode, so the reverse map is built
+    // from the glyph names; a code whose ToUnicode entry disagrees with its glyph is never reused
+    // (the placeholder would read one way in the text layer and look another way on the page).
+    const consistent = (code, u) => {
+        if (!toUnicode)
+            return true;
+        const tu = unicodeOf(toUnicode, code);
+        return tu === undefined || tu === '' || tu === u;
+    };
+    const reverse = new Map();
+    for (let code = 0; code < 256; code++) {
+        const g = encodingNames[code];
+        const u = g ? glyphNameToUnicode(g) : undefined;
+        if (!u || !consistent(code, u))
+            continue;
+        if (!reverse.has(u))
+            reverse.set(u, code);
+    }
+    const glyphKnown = (code) => {
+        if (usedCodes.has(code))
+            return true;
+        if (metrics && !embedded) {
+            const g = encodingNames[code];
+            return !!g && metrics.hasGlyph(g);
+        }
+        return false;
+    };
+    const encode = (text) => {
+        const codes = [];
+        let width = 0;
+        for (const ch of text) {
+            let code = reverse.get(ch);
+            if (code === undefined && metrics && !embedded) {
+                // Non-embedded standard font: any glyph of the AFM reachable through the encoding.
+                const g = unicodeToGlyphName(ch);
+                if (g) {
+                    const idx = encodingNames.indexOf(g);
+                    if (idx >= 0 && consistent(idx, ch))
+                        code = idx;
+                }
+            }
+            if (code === undefined || !glyphKnown(code))
+                return null;
+            // A code the font advances by nothing (a /Widths hole) would pile the placeholder up.
+            const w = widthOfCode(code);
+            if (w <= 0 && !/\p{M}/u.test(ch))
+                return null;
+            codes.push(code);
+            width += w;
+        }
+        return { bytes: Uint8Array.from(codes), width, codes };
+    };
+    return {
+        key, dict, subtype, baseFont, composite: false, type3, fontMatrix, style, embedded, symbolic, vertical: false,
+        problems, usedCodes, encodingNames, toUnicode, decode, widthOfCode, encode, codeLength: () => 1, ascent, descent,
+    };
+}
+function buildCompositeFont(ctx, dict, descendant, key, c) {
+    const { problems, toUnicode } = c;
+    // Encoding CMap: name (predefined) or stream (embedded)
+    const encObj = resolve(ctx, dict.get(PDFName.of('Encoding')));
+    let cmap = null;
+    if (encObj instanceof PDFName) {
+        const name = encObj.decodeText();
+        cmap = predefinedCMap(name) ?? null;
+        if (!cmap)
+            problems.push({ code: 'predefined-cmap', message: `predefined CMap /${name} is not available` });
+    }
+    else if (encObj instanceof PDFStream) {
+        try {
+            cmap = parseCMap(decodeStream(ctx, encObj));
+        }
+        catch (err) {
+            const usecmap = err instanceof CMapParseError && /usecmap/.test(err.message);
+            problems.push({ code: usecmap ? 'usecmap' : 'bad-cmap', message: `encoding CMap unreadable: ${err.message}` });
+        }
+    }
+    else {
+        problems.push({ code: 'bad-cmap', message: 'Type0 font without /Encoding' });
+    }
+    if (cmap?.vertical)
+        problems.push({ code: 'vertical', message: 'vertical writing mode is not supported' });
+    // Widths: /W [ c [w1 w2 ...] | cfirst clast w ], /DW default 1000
+    const dw = getNumber(ctx, descendant, 'DW') ?? 1000;
+    const widthByCid = new Map();
+    const wArr = getArray(ctx, descendant, 'W');
+    if (wArr) {
+        const items = itemsOf(ctx, wArr);
+        let i = 0;
+        while (i < items.length) {
+            const a = items[i];
+            if (!(a instanceof PDFNumber)) {
+                i++;
+                continue;
+            }
+            const b = items[i + 1];
+            if (b instanceof PDFArray) {
+                const ws = numbersOf(ctx, b);
+                const start = a.asNumber();
+                for (let k = 0; k < ws.length; k++)
+                    widthByCid.set(start + k, ws[k]);
+                i += 2;
+            }
+            else if (b instanceof PDFNumber && items[i + 2] instanceof PDFNumber) {
+                const first = a.asNumber();
+                const last = b.asNumber();
+                const w = items[i + 2].asNumber();
+                if (last - first <= 65535)
+                    for (let cid = first; cid <= last; cid++)
+                        widthByCid.set(cid, w);
+                i += 3;
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    const widthOfCode = (code) => {
+        if (!cmap)
+            return dw;
+        const cid = cidOf(cmap, code);
+        return widthByCid.get(cid) ?? dw;
+    };
+    const unicodeForCode = (code) => {
+        if (toUnicode) {
+            const u = unicodeOf(toUnicode, code);
+            if (u !== undefined && u !== '')
+                return foldGlyphText(u);
+        }
+        return '';
+    };
+    if (!toUnicode)
+        problems.push({ code: 'no-unicode', message: 'composite font without ToUnicode: its text cannot be read' });
+    const usedCodes = new Set();
+    const decode = (bytes) => {
+        if (!cmap) {
+            // Unknown code length: treat as 2-byte (the overwhelmingly common case) but the font is already flagged.
+            const out = [];
+            for (let i = 0; i + 1 < bytes.length; i += 2) {
+                const code = (bytes[i] << 8) | bytes[i + 1];
+                out.push({ code, length: 2, offset: i, unicode: unicodeForCode(code), width: dw, isSpaceCode: false });
+            }
+            return out;
+        }
+        return splitCodes(cmap, bytes).map((d) => ({
+            code: d.code,
+            length: d.length,
+            offset: d.offset,
+            unicode: unicodeForCode(d.code),
+            width: widthOfCode(d.code),
+            isSpaceCode: d.length === 1 && d.code === 32,
+        }));
+    };
+    // Reverse ToUnicode: unicode -> (code, length). Lowest code wins. The byte length of a code is
+    // the encoding CMap's (Identity-H: always 2), never the ToUnicode CMap's, which some producers
+    // declare with a 1-byte codespace.
+    const reverse = new Map();
+    if (toUnicode?.unicodeMap && cmap) {
+        const entries = [...toUnicode.unicodeMap.entries()].sort((x, y) => x[0] - y[0]);
+        for (const [code, u] of entries) {
+            if (u && !reverse.has(u))
+                reverse.set(u, { code, length: codeLengthFor(cmap, code) });
+        }
+    }
+    const encode = (text) => {
+        if (!cmap)
+            return null;
+        const bytes = [];
+        const codes = [];
+        let width = 0;
+        for (const ch of text) {
+            const hit = reverse.get(ch);
+            if (!hit || !usedCodes.has(hit.code))
+                return null;
+            const w = widthOfCode(hit.code);
+            if (w <= 0 && !/\p{M}/u.test(ch))
+                return null;
+            for (let k = hit.length - 1; k >= 0; k--)
+                bytes.push((hit.code >> (8 * k)) & 0xff);
+            codes.push(hit.code);
+            width += w;
+        }
+        return { bytes: Uint8Array.from(bytes), width, codes };
+    };
+    return {
+        key, dict, subtype: c.subtype, baseFont: c.baseFont, composite: true, type3: false, fontMatrix: null, style: c.style,
+        embedded: c.embedded, symbolic: c.symbolic, vertical: !!cmap?.vertical, problems, usedCodes, encodingNames: null,
+        toUnicode, decode, widthOfCode, encode, ascent: c.ascent, descent: c.descent,
+        codeLength: (code) => (cmap ? codeLengthFor(cmap, code) : toUnicode ? codeLengthFor(toUnicode, code) : 2),
+    };
+}
+function codeLengthFor(cmap, code) {
+    for (const r of cmap.codespace) {
+        if (code >= r.low && code <= r.high)
+            return r.numBytes;
+    }
+    if (cmap.codeLengths.size === 1)
+        return [...cmap.codeLengths][0];
+    return code > 0xff ? 2 : 1;
+}
+function firstDescendant(ctx, dict) {
+    const arr = getArray(ctx, dict, 'DescendantFonts');
+    const first = arr ? resolve(ctx, arr.get(0)) : undefined;
+    if (first instanceof PDFStream)
+        return first.dict;
+    return first && typeof first.get === 'function' ? first : undefined;
+}
+function matrixOf(nums) {
+    if (nums.length !== 6 || nums.some((n) => !Number.isFinite(n)))
+        return null;
+    return [nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]];
+}
+/**
+ * The /Encoding of a Type1 font program's cleartext part (before `eexec`): either
+ * `/Encoding StandardEncoding def` or a list of `dup <code> /<name> put`. pdfTeX embeds its
+ * Computer Modern fonts this way with no /Encoding in the font dictionary, so without this the
+ * text of most LaTeX documents would be unreadable to us.
+ */
+function type1BuiltinEncoding(ctx, descriptor) {
+    const file = getStream(ctx, descriptor, 'FontFile');
+    if (!file)
+        return undefined;
+    let bytes;
+    try {
+        bytes = decodeStream(ctx, file);
+    }
+    catch {
+        return undefined;
+    }
+    // PFB segment header (0x80 0x01 <len32>) before the cleartext, if the producer left it in.
+    let start = 0;
+    if (bytes[0] === 0x80 && bytes[1] === 0x01)
+        start = 6;
+    const limit = Math.min(bytes.length, start + 65536);
+    let text = '';
+    for (let i = start; i < limit; i++)
+        text += String.fromCharCode(bytes[i]);
+    const eexec = text.indexOf('eexec');
+    if (eexec >= 0)
+        text = text.slice(0, eexec);
+    const encAt = text.indexOf('/Encoding');
+    if (encAt < 0)
+        return undefined;
+    const section = text.slice(encAt);
+    if (/^\/Encoding\s+StandardEncoding\s+def/.test(section))
+        return STANDARD_ENCODING;
+    const table = new Array(256).fill(undefined);
+    let any = false;
+    const re = /dup\s+(\d+)\s*\/([^\s/]+)\s+put/g;
+    for (let m = re.exec(section); m !== null; m = re.exec(section)) {
+        const code = Number(m[1]);
+        if (code >= 0 && code < 256) {
+            table[code] = m[2];
+            any = true;
+        }
+    }
+    return any ? table : undefined;
+}
+/**
+ * Code -> glyph name table for a simple font: base encoding (named, or the
+ * font's built-in one, or Standard) overlaid with /Differences.
+ */
+function simpleEncoding(ctx, dict, c) {
+    const table = new Array(256).fill(undefined);
+    const std = c.metrics?.name;
+    let base;
+    if (std === 'Symbol')
+        base = SYMBOL_ENCODING;
+    else if (std === 'ZapfDingbats')
+        base = ZAPF_DINGBATS_ENCODING;
+    const encObj = resolve(ctx, dict.get(PDFName.of('Encoding')));
+    let differences = [];
+    if (encObj instanceof PDFName) {
+        base = encodingByName(encObj.decodeText()) ?? base;
+    }
+    else if (encObj && typeof encObj.get === 'function') {
+        const encDict = encObj;
+        const baseName = getName(ctx, encDict, 'BaseEncoding');
+        if (baseName)
+            base = encodingByName(baseName) ?? base;
+        differences = itemsOf(ctx, getArray(ctx, encDict, 'Differences'));
+    }
+    if (!base) {
+        // No /Encoding: the defaults pdf.js applies (evaluator.js extractDataStructures). Standard;
+        // TrueType without the Nonsymbolic flag: WinAnsi; Symbolic flag: MacRoman for non-embedded
+        // fonts (Symbol / ZapfDingbats by name), and the font's built-in encoding, unknown to us,
+        // for embedded ones (the page is then cross-checked against pdf.js).
+        if (c.type3)
+            base = [];
+        else if (c.symbolic && c.embedded && c.subtype !== 'TrueType')
+            base = c.builtin ?? []; // Type1 built-in encoding, read from the font program when it is Type1 cleartext
+        else if (std === 'Symbol')
+            base = SYMBOL_ENCODING;
+        else if (std === 'ZapfDingbats')
+            base = ZAPF_DINGBATS_ENCODING;
+        else if (c.symbolic)
+            base = MAC_ROMAN_ENCODING;
+        else if (c.subtype === 'TrueType' && !c.nonsymbolic)
+            base = WIN_ANSI_ENCODING;
+        else
+            base = STANDARD_ENCODING;
+    }
+    for (let i = 0; i < 256; i++)
+        table[i] = base[i];
+    const baseNames = [...table];
+    let code = 0;
+    for (const item of differences) {
+        if (item instanceof PDFNumber)
+            code = item.asNumber();
+        else if (item instanceof PDFName) {
+            if (code >= 0 && code < 256)
+                table[code] = item.decodeText();
+            code++;
+        }
+    }
+    return { names: table, base: baseNames };
+}

package/dist/pdf/glyphlist.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @doccloak/core/pdf - Adobe Glyph List (T207).
+ *
+ * Glyph name -> Unicode for simple fonts whose encoding is expressed as glyph
+ * names (Annex D tables, /Differences arrays, Type 1 built-in encodings), and
+ * the reverse lookup used to check whether a placeholder can be encoded in a
+ * document font.
+ *
+ * The table is a subset of the Adobe Glyph List 2.0 (aglfn + AGL) chosen for
+ * European text: Basic Latin, Latin-1, Latin Extended-A/B and Additional,
+ * spacing modifiers, Greek, Cyrillic (afii names), general punctuation,
+ * super/subscripts, currency, letterlike, number forms, arrows, mathematical
+ * operators, technical, blocks, geometric shapes, miscellaneous symbols and
+ * dingbats, the fi/fl/ff/ffi/ffl/st presentation forms, the Adobe corporate
+ * use area (small caps, superiors, Symbol font extenders), every name used by
+ * the Annex D encodings, and the ITC Zapf Dingbats list (a1..a191). Hebrew,
+ * Arabic, Thai, CJK and Hangul names are left out on purpose.
+ *
+ * Name resolution follows the AGL specification (section 3 "Mapping glyph
+ * names to Unicode"): strip everything from the first period, split ligature
+ * components on underscore, then per component: AGL lookup, `uniXXXX[YYYY...]`
+ * (4-digit groups, BMP, no surrogates), `uXXXX`..`uXXXXXX`. Anything else
+ * (`g12`, `cid12`, `glyph12`, `G12`, `.notdef`) yields undefined.
+ */
+/**
+ * Maps a glyph name to the text it represents, or undefined when the name
+ * carries no Unicode meaning. The result may be several code points
+ * (`uni00660069`, `f_i`).
+ */
+export declare function glyphNameToUnicode(name: string): string | undefined;
+/**
+ * Reverse of the AGL table for a single code point: the glyph name a simple
+ * font is expected to use for `ch`. Names used by the Annex D encodings take
+ * precedence, then the first AGL name in list order. Undefined for input that
+ * is not exactly one code point or has no AGL name.
+ */
+export declare function unicodeToGlyphName(ch: string): string | undefined;