diff --git a/packages/documents.js/README.md b/packages/documents.js/README.md index 699dfccf49..d98b243622 100644 --- a/packages/documents.js/README.md +++ b/packages/documents.js/README.md @@ -959,7 +959,7 @@ To run a single test file: `pnpm vitest run src/path/to/file.test.ts`. - **Font resolution uses a real registry, standard 14 as last resort.** A family with no embedded/caller/vendored face (Aptos, third-party typefaces) renders through the nearest standard-14 face with a width-correction factor — expect a visual approximation, not line-identical output. MathML formula rendering is separate: it embeds STIX Two Math, not registry-resolvable. - **Justified paragraphs stretch inter-word gaps** in all three layout engines (`engine.ts`, `slides.ts`, `sheets.ts`). `justifyLineGapsPt` divides slack evenly across detected word gaps; final lines stay left-aligned. - **Encrypted PDFs and CCITT/JBIG2/JPX images are real capabilities** in pdf-codec — not scope boundaries. The permanent boundary is adversarial/malformed-input robustness. -- **PDF → docx/pptx/odt/odp table recovery requires drawn rules**: never text alignment alone (which would invent structure). Either a real gridline lattice, or a table ruled between its rows (`src/layout/ruled-rows.ts`): at least three horizontal rules of one span, with the columns taken from the gutters every row holding text in more than one place leaves, a heading row above the first rule read when its lines keep to the columns, a row crossing a gutter read as a spanning cell, a band whose every line fills its columns split into a row per line, and a band whose first line sets a group heading over sub-headings on the lines under it (two or more of them starting under the heading) read as two rows: the heading one cell from its own column up to where the first line's next run starts, over the sub-headings, and every other column one cell down both rows. Such a grid is refused when every column reads as running prose, when anything other than horizontal strokes and full-width shading is drawn inside it (a diagram), or when one row runs across a gap another row leaves between two places other than as such a group heading, since the columns would then read the text either side of that gap as one cell. A lattice with no text inside is rejected. A page that draws several tables reads each as a table of its own (`detectGridLattices`, `recoverTables` in `src/layout/reconstruct-tables.ts`): every ruled grid that closes into a rectangle, where a grid is the largest of them for the callers that read one grid per page (a worksheet, a slide: `detectGridLattice`). +- **PDF → docx/pptx/odt/odp table recovery requires drawn rules**: never text alignment alone (which would invent structure). Either a real gridline lattice, or a table ruled between its rows (`src/layout/ruled-rows.ts`): at least three horizontal rules of one span, with the columns taken from the gutters every row holding text in more than one place leaves, a heading row above the first rule read when its lines keep to the columns, a row crossing a gutter read as a spanning cell, a band whose every line fills its columns split into a row per line, and a band whose first line sets a group heading over sub-headings on the lines under it (two or more of them starting under the heading) read as two rows: the heading one cell from its own column up to where the first line's next run starts, over the sub-headings, and every other column one cell down both rows. Such a grid is refused when every column reads as running prose, when anything other than horizontal strokes and full-width shading is drawn inside it (a diagram), or when one row runs across a gap another row leaves between two places other than as such a group heading, since the columns would then read the text either side of that gap as one cell. A lattice with no text inside is rejected. A page that draws several tables reads each as a table of its own (`detectGridLattices`, `recoverTables` in `src/layout/reconstruct-tables.ts`): every ruled grid that closes into a rectangle, where a grid is the largest of them for the callers that read one grid per page (a worksheet, a slide: `detectGridLattice`). A table breaking across pages leaves a row open at the page's edge, its rule drawn under some columns or none and the side borders running on to it; a grid that does not close loses its top or bottom row boundary when that boundary does not span it, and is tested again, so the rows the page closes are still read as the table. - **Merged table cells round-trip as merged.** docx: horizontal merge collapses to one `w:tc` with `w:gridSpan`; vertical merge needs one `w:tc` per covered row with `w:vMerge`. ODF: one entry per grid position, covered cells get `table:covered-table-cell`. - **docx headers/footers/comments/footnotes/numbering are readable via `readDocxExtras`** — `readDocxContent` still drops them (`ContentDocument` has nowhere to put them). `PAGE`/`NUMPAGES` field substitution is never read (it's a render-time value). - **A docx inline image reads as a real `ContentImageBlock`** — `buildDocxPackage` recognises the flat docx reader's two-block pattern (empty-text paragraph + image) and writes it back as one paragraph, avoiding spurious blank paragraphs on round trip. diff --git a/packages/documents.js/src/layout/lattice-multiple.test.ts b/packages/documents.js/src/layout/lattice-multiple.test.ts index 4ef9909846..00d33f93f2 100644 --- a/packages/documents.js/src/layout/lattice-multiple.test.ts +++ b/packages/documents.js/src/layout/lattice-multiple.test.ts @@ -99,6 +99,75 @@ describe("detectGridLattices: a boundary drawn in pieces", () => { }); }); +describe("detectGridLattices: a table continuing onto the next page", () => { + // Three rows by three columns drawn cell by cell, the side borders one piece per row. The table's next row starts at the foot of the page: its first cell's top is the grid's bottom rule, its left border runs on below the grid as one more piece, and a rule under that first cell alone closes it there. + const table: LayoutItem[] = [100, 70, 40, 10].flatMap((y) => [ + line(0, y, 100, y), + line(100, y, 200, y), + line(200, y, 300, y), + ]); + for (const x of [0, 100, 200, 300]) { + for (const [low, high] of [ + [70, 100], + [40, 70], + [10, 40], + ] as const) { + table.push(line(x, low, x, high)); + } + } + const stub = [line(0, -5, 0, 10), line(0, -5, 100, -5)]; + + it("reads the grid the table closes, leaving out the stub under one cell", () => { + const [lattice] = detectGridLattices([...table, ...stub]); + + expect(lattice?.rowBoundariesDescPt).toEqual([100, 70, 40, 10]); + expect(lattice?.columnBoundariesAscPt).toEqual([0, 100, 200, 300]); + }); + + it("reads the stub's rule as no boundary of the table", () => { + const [lattice] = detectGridLattices([...table, ...stub]); + + expect(lattice?.sourceItems.has(stub[1]!)).toBe(false); + }); + + it("reads the grid above an open last row whose rule is drawn under its last cell alone", () => { + // Every border runs on down to the foot of the page and a rule closes only the last column there, as a table whose last column ends on this page and whose other cells continue on the next. + const open = [ + line(0, -5, 0, 10), + line(100, -5, 100, 10), + line(200, -5, 200, 10), + line(300, -5, 300, 10), + line(200, -5, 300, -5), + ]; + + const [lattice] = detectGridLattices([...table, ...open]); + + expect(lattice?.rowBoundariesDescPt).toEqual([100, 70, 40, 10]); + expect(lattice?.columnBoundariesAscPt).toEqual([0, 100, 200, 300]); + }); + + it("reads the grid below a first row the previous page opened, its rule drawn over one cell alone", () => { + const opened = [ + line(0, 100, 0, 115), + line(200, 100, 200, 115), + line(0, 115, 100, 115), + ]; + + const [lattice] = detectGridLattices([...table, ...opened]); + + expect(lattice?.rowBoundariesDescPt).toEqual([100, 70, 40, 10]); + }); + + it("takes off no column boundary, so a side border that stops short leaves the grid unclosed", () => { + const shortRight = table.filter( + (item) => + !(item.kind === "line" && item.x1Pt === 300 && item.y1Pt === 10), + ); + + expect(detectGridLattices(shortRight)).toHaveLength(0); + }); +}); + describe("a page drawing more strokes on one axis than clustering reads", () => { it("is read as having no lattice, rather than spending a pair test on every pair of its strokes", () => { const grid: LayoutItem[] = [ diff --git a/packages/documents.js/src/layout/lattice.ts b/packages/documents.js/src/layout/lattice.ts index 5c22b6a556..8d3acb279e 100644 --- a/packages/documents.js/src/layout/lattice.ts +++ b/packages/documents.js/src/layout/lattice.ts @@ -237,6 +237,51 @@ function hasClosedOuterRectangle( ); } +interface ClosedGrid { + readonly rowLines: readonly AxisLine[]; + readonly columnLines: readonly AxisLine[]; +} + +/** + * The closed grid a cluster of boundaries draws: the cluster itself when its outer rectangle closes, else the grid without its top or its bottom row boundary, or both, when that one closes, or undefined. + * + * A table breaking across pages leaves a row open at the page's edge: its last row at the foot of a page is closed by a rule drawn under some of its columns or none, the side borders running down to it, and its first row at the head of the next is opened the same way. Joined to the borders as one boundary (`segmentsTouchCollinearly`), that open row would otherwise leave the whole table unclosed and read as prose, every row of it. So an outer row boundary that does not span the grid is taken off, once at the top and once at the bottom, and the grid tested again; nothing else is, so a grid with a gap in a side border, or a drawing whose strokes close no rectangle, stays unclosed. + * @param rowLines - the cluster's row boundaries, top first + * @param columnLines - the cluster's column boundaries, left first + * @returns the boundaries of the closed grid, or undefined + */ +function closedGrid( + rowLines: readonly AxisLine[], + columnLines: readonly AxisLine[], +): ClosedGrid | undefined { + if (columnLines.length < MIN_GRIDLINE_COUNT_PER_AXIS) { + return undefined; + } + const leftXPt = columnLines[0]!.position; + const rightXPt = columnLines[columnLines.length - 1]!.position; + const spans = (line: AxisLine): boolean => + unionCoverageRatio(line.ranges, leftXPt, rightXPt) >= EDGE_COVERAGE_RATIO; + const openTop = rowLines[0] !== undefined && !spans(rowLines[0]); + const openBottom = + rowLines[rowLines.length - 1] !== undefined && + !spans(rowLines[rowLines.length - 1]!); + const candidates = [ + rowLines, + ...(openTop ? [rowLines.slice(1)] : []), + ...(openBottom ? [rowLines.slice(0, -1)] : []), + ...(openTop && openBottom ? [rowLines.slice(1, -1)] : []), + ]; + for (const rows of candidates) { + if ( + rows.length >= MIN_GRIDLINE_COUNT_PER_AXIS && + hasClosedOuterRectangle(rows, columnLines) + ) { + return { rowLines: rows, columnLines }; + } + } + return undefined; +} + // A rectangular region of the atomic grid (the finest grid the detected boundaries admit) that drawn strokes never actually divided — one real ContentTableCell, spanning more than one atomic row/column exactly when colSpan/rowSpan would (see reconstruct.ts's own recoverTable, which anchors one real cell at [rowStart, colStart] and a rowSpan continuation placeholder at the same column position in every row up to rowEnd, matching how ooxml.js's own docx/pptx table writers already expect a ContentTable to be shaped). export interface TableRegion { readonly rowStart: number; @@ -488,17 +533,14 @@ function latticeCandidates(items: readonly LayoutItem[]): LatticeCandidate[] { for (const cluster of clusterSegments(horizontal, vertical)) { const clusterHorizontal = cluster.filter((s) => s.axis === "horizontal"); const clusterVertical = cluster.filter((s) => s.axis === "vertical"); - const rowLines = dedupeAxisLines(clusterHorizontal, true); - const columnLines = dedupeAxisLines(clusterVertical, false); - if ( - rowLines.length < MIN_GRIDLINE_COUNT_PER_AXIS || - columnLines.length < MIN_GRIDLINE_COUNT_PER_AXIS - ) { - continue; - } - if (!hasClosedOuterRectangle(rowLines, columnLines)) { + const grid = closedGrid( + dedupeAxisLines(clusterHorizontal, true), + dedupeAxisLines(clusterVertical, false), + ); + if (grid === undefined) { continue; } + const { rowLines, columnLines } = grid; const regions = findCellRegions(rowLines, columnLines); if (regions === undefined) { continue; diff --git a/packages/pdf-codec/README.md b/packages/pdf-codec/README.md index 670742843a..78a967458e 100644 --- a/packages/pdf-codec/README.md +++ b/packages/pdf-codec/README.md @@ -334,9 +334,9 @@ A TrueType subset can lose its glyph names and its `cmap` both and keep nothing A `/ToUnicode` CMap that a producer writes for the Symbol font or one of the Windows dingbat fonts (Word does, for a bullet, a tick or an arrow it draws in them) gives each glyph the private-use code point its 8-bit code makes in the 0xF000 range, which identifies the glyph in that one font and nothing else: 0xFC is a check mark in Wingdings and a piece of a right brace in Symbol. `symbol-font-private-use.ts` reads such a code point as the character the named font draws at that code, applied to the text a `/ToUnicode` CMap gave for a Symbol, Wingdings, Wingdings 2, Wingdings 3 or Webdings font, by name (`Wingdings 2` and `Wingdings2` alike), and to no other font. Symbol is recognised as `Symbol`, `SymbolMT`, `SymbolOOEnc` and MathType's `EuclidSymbol` (read in Symbol's encoding on the evidence of three checked glyphs, the rest of its layout assumed), each also with an `-OV-` variant tag at the end (`SymbolMT-OV-JQGJHA`) or a mixed-case pseudo subset tag run straight onto the front with no `+` or separator (`SmmfqrSymbol`), which is looked past only when what follows it is one of those names, so `SymbolicSans`, `SegoeUISymbol` or `Lucida Symbol` is not taken for Symbol. A font whose `/BaseFont` names no symbol font is identified by its embedded program's own PostScript name instead, read only for text that holds a private-use code point. Every `/BaseFont` spelling of Symbol also gets Symbol's built-in encoding for a code no `/ToUnicode` covers; a font recognised only through its program's name does not, since that name is read only for `/ToUnicode` text. Symbol is read through its published encoding, and the four dingbat fonts through `wingdings-characters.ts` and `dingbat-characters.ts`, tables of Unicode's own Wingdings and Webdings document (WG2 N4384), whose source-reference list is vendored under `assets/unicode-wingdings/` and checked against every table entry. A code the font has no character at, and ZapfDingbats, stay as the producer wrote them. The pieces a tall bracket, parenthesis or brace is assembled from, the integral and arrow extensions and the serif and sans-serif copyright, registered and trade mark signs are glyphs the Adobe Glyph List gives private-use code points (`parenlefttp` is U+F8EB) although Unicode encodes them (U+239B): `glyph-names.ts` resolves those names to the Unicode characters on every route a glyph name takes (Symbol's built-in encoding, `/Differences`, an embedded program's glyph names), and a Symbol font's `/ToUnicode` value at one of the list's private-use code points is read as the same character. `radicalex`, which Unicode does not encode, keeps its private-use code point. -Two ways a producer names a core face other than the PostScript name the face's own tables carry are read through the same carried glyph order. A TrueType program Windows-era producers embed under the face's Windows name (`TimesNewRoman`, `Arial,Bold`) is the face `TimesNewRomanPSMT` or `Arial-BoldMT`, still accepted glyph by glyph against the program's own advance widths. And Adobe Acrobat's optimiser rewrites a TrueType face as a CFF subset that names each glyph `G` followed by its glyph id in the face (`G36` is the capital A of Times New Roman) under a font name carrying a size suffix (`Times.New.Roman092`, `Arial.Bold0133`): `coreFaceTextsOfNumberedGlyphs` reads those names through the face's order, but only for a font whose dictionary widths agree with the face's advances over at least five numbered glyphs and nine in ten of them, so a subset of another face, or one too small to tell, is read as before. The Symbol face and the Type 3 fonts such producers also write are not covered: the first has no carried order, and a Type 3 glyph is a drawing procedure with no character. +Two ways a producer names a core face other than the PostScript name the face's own tables carry are read through the same carried glyph order. A TrueType program Windows-era producers embed under the face's Windows name (`TimesNewRoman`, `Arial,Bold`) is the face `TimesNewRomanPSMT` or `Arial-BoldMT`, still accepted glyph by glyph against the program's own advance widths. And Adobe Acrobat's optimiser rewrites a TrueType face as a CFF subset that names each glyph `G` followed by its glyph id in the face (`G36` is the capital A of Times New Roman) under a font name carrying a size suffix (`Times.New.Roman092`, `Arial.Bold0133`), as Acrobat Distiller does with a lower-case `g` for Century Schoolbook, the face of many standards documents written in Word (`g36` under `CenturySchoolbook-Bold`), whose order is carried too: `coreFaceTextsOfNumberedGlyphs` reads those names through the face's order, but only for a font whose dictionary widths agree with the face's advances over at least five numbered glyphs and nine in ten of them, so a subset of another face, or one too small to tell, is read as before. The Symbol face and the Type 3 fonts such producers also write are not covered: the first has no carried order, and a Type 3 glyph is a drawing procedure with no character. -Some producers write the font dictionary's own tables wrong for a symbol subset: a typesetter's Type 1C math fonts give each glyph an arbitrary name, assign the names to codes with `/Differences`, and have a `/ToUnicode` CMap read each name as the character it spells, so an equals sign is read as `¼` and an omega as `!`, from tables that are valid and wrong. `verified-glyph-tables.ts` holds tables for the exact subsets whose glyphs were rendered from the embedded program and checked one by one (`docs/verified-glyph-tables/`), each keyed by the SHA-256 of the decoded font program; a glyph of such a subset is read as what it draws, before the font dictionary's tables, and every other subset, family and code is read as before. +Some producers write the font dictionary's own tables wrong for a symbol subset: a typesetter's Type 1C math fonts give each glyph an arbitrary name, assign the names to codes with `/Differences`, and have a `/ToUnicode` CMap read each name as the character it spells, so an equals sign is read as `¼` and an omega as `!`, from tables that are valid and wrong. `verified-glyph-tables.ts` holds tables for the exact subsets whose glyphs were rendered from the embedded program and checked one by one (`docs/verified-glyph-tables/`), each keyed by the SHA-256 of the decoded font program; a glyph of such a subset is read as what it draws, before the font dictionary's tables, and every other subset, family and code is read as before. The glyph a code selects is named by `/Differences`, else by the named base encoding, else, for a dictionary that names no base encoding, by the program's own built-in encoding, which is then the base encoding. **Where nothing states an answer, the answer is the replacement character plus a `text/unmapped-encoding` diagnostic, never a guess.** Cases that reach it in practice: a symbolic font with no embedded program and no `/ToUnicode`; a subsetted font that both strips its glyph names and maps its glyphs only from private-use code points; a nameless, `cmap`-less subset of a face whose glyph order this package does not carry, or of a carried face at a glyph its recorded releases do not number; and a composite font whose `/Encoding` is a CMap other than Identity-H or Identity-V, whose codes reach CIDs this reader does not map. A private-use code point identifies a glyph inside one font and says nothing about the character it draws, so it is treated as no answer rather than a wrong one. diff --git a/packages/pdf-codec/docs/verified-glyph-tables/README.md b/packages/pdf-codec/docs/verified-glyph-tables/README.md index 5ff7842cdd..881c17b73b 100644 --- a/packages/pdf-codec/docs/verified-glyph-tables/README.md +++ b/packages/pdf-codec/docs/verified-glyph-tables/README.md @@ -4,7 +4,7 @@ The glyph sheets behind `src/verified-glyph-tables.ts`: one per verified font su A table is added only for a subset whose glyphs were rendered from the embedded program and checked against the symbol they stand for, so a reviewer can re-check a table by comparing its cells to the shapes. A glyph whose symbol could not be settled from its outline is left unmapped. A table lists glyphs by the program's own glyph name, because these producers share one program between many font dictionaries that assign its glyphs to different codes; the name a dictionary's `/Differences` gives a code selects the glyph. -Both families of subset are the ones a textbook typeset with the Advent 3B2 system embeds: a symbol font laid out like TeX's math symbol font (`AdvMT_SY`, `AdvP4C4E74`), a math italic font (`AdvMT_MI`, `AdvP4C4E51`), a delimiter and large-operator font laid out like TeX's extension font (`AdvP4C4E46`) and a roman font with Greek capitals (`AdvP4C4E59`). A one-glyph subset that names its glyph through `/Encoding /WinAnsiEncoding` instead of `/Differences` (the f483 sheet) is read by the name that base encoding gives its code. The producer writes each glyph's name and `/ToUnicode` entry as if the name were what the glyph draws, so an equals sign is `/onequarter`, a left parenthesis is `/eth` and a size-3 left parenthesis is `/C16`. +Both families of subset are the ones a textbook typeset with the Advent 3B2 system embeds: a symbol font laid out like TeX's math symbol font (`AdvMT_SY`, `AdvP4C4E74`), a math italic font (`AdvMT_MI`, `AdvP4C4E51`), a delimiter and large-operator font laid out like TeX's extension font (`AdvP4C4E46`) and a roman font with Greek capitals (`AdvP4C4E59`). A one-glyph subset that names its glyph through `/Encoding /WinAnsiEncoding` instead of `/Differences` (the f483 sheet) is read by the name that base encoding gives its code, and a subset whose font dictionaries carry no `/Encoding` at all (the 78448 sheet, whose program's built-in encoding is StandardEncoding) by the name the program's own encoding gives it. The producer writes each glyph's name and `/ToUnicode` entry as if the name were what the glyph draws, so an equals sign is `/onequarter`, a left parenthesis is `/eth` and a size-3 left parenthesis is `/C16`. In `AdvP4C4E46` a size variant of a delimiter is read as the character it enlarges (every `(` size as `(`), the corners of an assembled bracket as the Unicode bracket corners, and the large sum, integral, intersection and conjunction as their Unicode n-ary operators. The pieces a tall brace, radical or bracket is assembled from other than the bracket corners, and the short bar `/ffi`, are left unmapped: a piece has no character of its own that the outline alone can settle. @@ -18,6 +18,7 @@ In `AdvP4C4E46` a size variant of a delimiter is read as the character it enlarg | [advp4c4e46-a8442ad73a.png](advp4c4e46-a8442ad73a.png) | AdvP4C4E46 | `a8442ad73af43eb9abec5cb790fe053953caf2cba069038689c1091a8bf1da57` | 22 | /colon, /eight, /equal, /ffi, /greater, /less, /nine, /semicolon, /seven, /six, /t, /u, /v | | [advp4c4e46-f2c12f17af.png](advp4c4e46-f2c12f17af.png) | AdvP4C4E46 | `f2c12f17afd97014ccf6002befb9a7fa5c9156788bb9a616a5f9d31f8b5aaedd` | 17 | /ffi, /t, /u, /v | | [advp4c4e51-93463c42e9.png](advp4c4e51-93463c42e9.png) | AdvP4C4E51 | `93463c42e9491b79f82f761b522ae2de72b6217efccd186930df7237ef8002ef` | 5 | none | +| [advp4c4e51-78448cb717.png](advp4c4e51-78448cb717.png) | AdvP4C4E51 | `78448cb71772342dba968e5467a55b5df184815aabe509ccf2f4ec7b923aebe4` | 5 | none | | [advp4c4e59-967c167a73.png](advp4c4e59-967c167a73.png) | AdvP4C4E59 | `967c167a737966cddc29a62e6f0601efc797d1f9453d0f3df558306b2d8b91e2` | 2 | /C22, /ampersand, /asciitilde, /percent, /period, /underscore | | [advp4c4e74-38c8aa8cce.png](advp4c4e74-38c8aa8cce.png) | AdvP4C4E74 | `38c8aa8ccee56512b9816a6c93c2e2b166166b672560b5f827eef19c43626bd3` | 14 | none | | [advp4c4e74-4061cae07e.png](advp4c4e74-4061cae07e.png) | AdvP4C4E74 | `4061cae07e31ac6441fef12114942a58d0bae5f64a0789932ee703654990a769` | 22 | none | diff --git a/packages/pdf-codec/docs/verified-glyph-tables/advp4c4e51-78448cb717.png b/packages/pdf-codec/docs/verified-glyph-tables/advp4c4e51-78448cb717.png new file mode 100644 index 0000000000..394c8fc47d Binary files /dev/null and b/packages/pdf-codec/docs/verified-glyph-tables/advp4c4e51-78448cb717.png differ diff --git a/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs b/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs index b4ff009bb2..11e4ed0cc2 100644 --- a/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs +++ b/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs @@ -20,7 +20,7 @@ const { readCmapSubtables } = await load('cmap-table'); const { parseHmtx } = await load('hmtx-table'); const { parseHead, parseName } = await load('font-tables'); -// The faces producers commonly embed as composite subsets that keep the face's own glyph numbering while dropping 'cmap' and 'post'. A reader applies a face's order to a glyph only where the embedded program's advance width for that glyph equals the one recorded here (see src/core-font-glyph-orders.ts). +// The faces producers commonly embed as composite subsets that keep the face's own glyph numbering while dropping 'cmap' and 'post', or convert to CFF subsets naming each glyph by its id in the face (Century Schoolbook, the face of many standards documents distilled from Word). A reader applies a face's order to a glyph only where the embedded program's advance width for that glyph equals the one recorded here (see src/core-font-glyph-orders.ts). const FACES = [ 'ArialMT', 'Arial-BoldMT', @@ -34,6 +34,10 @@ const FACES = [ 'CourierNewPS-BoldMT', 'CourierNewPS-ItalicMT', 'CourierNewPS-BoldItalicMT', + 'CenturySchoolbook', + 'CenturySchoolbook-Bold', + 'CenturySchoolbook-Italic', + 'CenturySchoolbook-BoldItalic', ]; const directories = process.argv.slice(2); diff --git a/packages/pdf-codec/src/builtin-encoding.ts b/packages/pdf-codec/src/builtin-encoding.ts index 95e788ed08..a6f92866b1 100644 --- a/packages/pdf-codec/src/builtin-encoding.ts +++ b/packages/pdf-codec/src/builtin-encoding.ts @@ -43,6 +43,8 @@ export interface BuiltinEncoding { glyphIdToUnicode: (glyphId: number) => string | undefined; // The glyph the program itself names `name`, through its 'post' table or CFF charset: how a /Differences name the Adobe Glyph List does not know (a subsetter's "g27") still reaches a glyph whose identity the program can state another way. glyphIdOfName: (name: string) => number | undefined; + // The program's own name for the glyph its built-in encoding draws at a code: the name a CFF or Type 1 encoding states for the code, or the charset's or 'post' table's name for the glyph the code reaches. How a font dictionary that names no encoding of its own still selects a glyph by name. + codeToGlyphName: (code: number) => string | undefined; } // The private-use planes, which name no character: reversing a Unicode subtable that maps only these (what a symbol font's own (3, 1) subtable usually is) yields a code point that identifies the glyph within that one font and nothing beyond it, so it is treated as no answer rather than a wrong one. @@ -109,6 +111,14 @@ function encodingFromSources( codeToUnicode: codeUnicode, glyphIdToUnicode: glyphUnicode, glyphIdOfName: (name) => nameToGlyphId?.(name), + codeToGlyphName: (code) => { + const name = codeToName?.(code); + if (name !== undefined) { + return name; + } + const glyphId = codeToGlyphId?.(code); + return glyphId === undefined ? undefined : glyphIdToName?.(glyphId); + }, } : undefined; } diff --git a/packages/pdf-codec/src/core-font-glyph-orders.ts b/packages/pdf-codec/src/core-font-glyph-orders.ts index 6aa1ef9094..825b5bf493 100644 --- a/packages/pdf-codec/src/core-font-glyph-orders.ts +++ b/packages/pdf-codec/src/core-font-glyph-orders.ts @@ -2,7 +2,7 @@ import { inflateSync } from "fflate"; import { base64ToBytes } from "byte-codec"; import { CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64 } from "./glyph-data/core-font-glyph-orders"; -// The glyph order of the core faces producers most often embed (the Arial, Times New Roman and Courier New families), for a program that keeps a face's own glyph numbering but carries nothing that says what any glyph draws: no 'cmap', no glyph names. A composite font's CIDs then address glyphs whose characters only the face's published order states, and readers such as Acrobat carry the same knowledge for the same reason. +// The glyph order of the core faces producers most often embed (the Arial, Times New Roman and Courier New families, and Century Schoolbook), for a program that keeps a face's own glyph numbering but carries nothing that says what any glyph draws: no 'cmap', no glyph names. A composite font's CIDs then address glyphs whose characters only the face's published order states, and readers such as Acrobat carry the same knowledge for the same reason. // // Knowing the order by the face's name alone would be a guess the first time a subsetter renumbered the glyphs, a producer embedded another face under that name, or a release of the face moved one glyph. So each glyph is accepted only where the program's own advance width for it equals the face's (in the same units per em), which every one of those cases breaks: a renumbered or foreign program puts other widths at those glyph ids, and a glyph a release redrew to a different width stops matching. Compared across two releases of each of these faces, a few glyph ids per face changed advance width and every other glyph kept both its id and its width, so the check refuses those few and costs nothing else. // @@ -114,6 +114,10 @@ const CORE_FACE_BY_SPELLING: ReadonlyMap = new Map([ ["couriernewpsitalicmt", "CourierNewPS-ItalicMT"], ["couriernewbolditalic", "CourierNewPS-BoldItalicMT"], ["couriernewpsbolditalicmt", "CourierNewPS-BoldItalicMT"], + ["centuryschoolbook", "CenturySchoolbook"], + ["centuryschoolbookbold", "CenturySchoolbook-Bold"], + ["centuryschoolbookitalic", "CenturySchoolbook-Italic"], + ["centuryschoolbookbolditalic", "CenturySchoolbook-BoldItalic"], ]); const ZERO_CODE = 48; // "0" @@ -166,8 +170,8 @@ export function coreFaceNameOfFontName(fontName: string): string | undefined { return CORE_FACE_BY_SPELLING.get(spelled); } -// Adobe Acrobat's optimiser converts a TrueType face to a CFF subset and names each glyph G followed by its glyph id in the face: G36 is the glyph the face numbers 36. -const NUMBERED_GLYPH_NAME = /^G(\d+)$/u; +// Adobe Acrobat's optimiser converts a TrueType face to a CFF subset and names each glyph G followed by its glyph id in the face: G36 is the glyph the face numbers 36. Acrobat Distiller does the same with a lower-case g (g36). +const NUMBERED_GLYPH_NAME = /^[Gg](\d+)$/u; // How far, in thousandths of an em, a font dictionary's width for a glyph may be from the face's advance for it and still agree: the dictionary's widths are the converted program's, which this producer rounds and hints, and measured against the face they differ by up to 22 (a 489 for a 500, a 507 for a 500); two core faces differ by far more on most letters (a capital G is 722 in Times New Roman and 778 in Arial). const WIDTH_AGREEMENT_TOLERANCE = 25; @@ -177,7 +181,7 @@ const MIN_AGREEING_SHARE = 0.9; const MIN_NUMBERED_GLYPHS = 5; /** - * What a core face draws at the glyphs of a CFF subset that names each `G`, accepted for the whole font only when the font dictionary's widths agree with the face's advances over at least `MIN_NUMBERED_GLYPHS` glyphs and `MIN_AGREEING_SHARE` of them, so a subset of any other face, or of another release of this one, is read as before. + * What a core face draws at the glyphs of a CFF subset that names each `G` or `g`, accepted for the whole font only when the font dictionary's widths agree with the face's advances over at least `MIN_NUMBERED_GLYPHS` glyphs and `MIN_AGREEING_SHARE` of them, so a subset of any other face, or of another release of this one, is read as before. * @param fontName - The font's `/BaseFont`. * @param glyphs - Each glyph of the font a `/Differences` array names, with the width, in thousandths of an em, the dictionary gives its code. * @returns The character each numbered glyph name draws, or `undefined` when the font is not taken for a core face. diff --git a/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts b/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts index 3b912a2e79..6abb356935 100644 --- a/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts +++ b/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts @@ -32,6 +32,8 @@ describe("coreFaceNameOfFontName", () => { ["EBLKKG+Arial086.75", "ArialMT"], ["ArialMT", "ArialMT"], ["CourierNewPS-BoldItalicMT", "CourierNewPS-BoldItalicMT"], + ["LHMEIK+CenturySchoolbook-Bold", "CenturySchoolbook-Bold"], + ["CenturySchoolbook,Italic", "CenturySchoolbook-Italic"], ])("reads %s as %s", (fontName, face) => { expect(coreFaceNameOfFontName(fontName)).toBe(face); }); @@ -117,3 +119,59 @@ describe("a CFF subset that numbers its glyphs after a core face", () => { ); }); }); + +describe("a CFF subset Acrobat Distiller numbers after Century Schoolbook", () => { + // Distiller names each glyph g, lower case. The glyphs of a made-up line in Century Schoolbook Bold, with the widths the face gives them: B, R, I, D, G, E, the space, T and S. + const DISTILLED = [ + { name: "g37", width: 778 }, + { name: "g53", width: 815 }, + { name: "g44", width: 444 }, + { name: "g39", width: 833 }, + { name: "g42", width: 833 }, + { name: "g40", width: 759 }, + { name: "g3", width: 287 }, + { name: "g55", width: 722 }, + { name: "g54", width: 667 }, + ] as const; + + function read( + baseFont: string, + codes: readonly number[], + ): string | undefined { + const fontDict = pdfDict({ + Type: pdfName("Font"), + Subtype: pdfName("Type1"), + BaseFont: pdfName(baseFont), + FirstChar: pdfNum(1), + LastChar: pdfNum(DISTILLED.length), + Widths: pdfArray(DISTILLED.map(({ width }) => pdfNum(width))), + Encoding: pdfDict({ + Differences: pdfArray([ + pdfNum(1), + ...DISTILLED.map(({ name }) => pdfName(name)), + ]), + }), + }); + const { resolve } = createFontResolver({ + resolver: makeResolver(new Map()), + sink: NO_DIAGNOSTICS, + }); + return resolve( + "F1", + pdfDict({ Font: pdfDict({ F1: fontDict }) }), + )?.decodeToUnicode(new Uint8Array(codes)); + } + + // Codes 1 to 9 are the glyphs in the order above. + const LINE = [1, 2, 3, 4, 5, 6, 7, 8, 6, 9, 8]; + + it("is read through the face's glyph order", () => { + expect(read("LHMEIK+CenturySchoolbook-Bold", LINE)).toBe("BRIDGE TEST"); + }); + + it("is refused under another face's name, whose advances disagree", () => { + expect(read("LHMEIK+CenturySchoolbook-Italic", LINE)).toBe( + "\uFFFD".repeat(LINE.length), + ); + }); +}); diff --git a/packages/pdf-codec/src/font-read.ts b/packages/pdf-codec/src/font-read.ts index c7c6028e36..703759aa05 100644 --- a/packages/pdf-codec/src/font-read.ts +++ b/packages/pdf-codec/src/font-read.ts @@ -384,7 +384,7 @@ function buildSimpleFont(fontDict: PdfDict, context: FontReadContext): PdfFont { const programEncoding = lazyFontProgram(descriptor, baseFont, context); // A code /Differences names is drawn with the glyph of that name, so only the name can say what it is: through the Adobe Glyph List, or, for a name the list does not know (a subsetter's "g27"), through the embedded program's own glyph of that name and whatever the program states about that glyph. The base encoding and the program's built-in encoding describe the glyph the code reached before /Differences replaced it, so neither is consulted for such a code; reading the code through them anyway would report the character the producer overrode. - // What the core face a CFF subset numbers its glyphs after draws at each of them, read once and only for a font that names glyphs `G`. + // What the core face a CFF subset numbers its glyphs after draws at each of them, read once and only for a font that names glyphs `G` or `g`. let numberedTexts: ReadonlyMap | undefined; const numberedCoreFaceTexts = (): ReadonlyMap => { numberedTexts ??= @@ -453,16 +453,26 @@ function buildSimpleFont(fontDict: PdfDict, context: FontReadContext): PdfFont { return undefined; }; + // The glyph a code selects, by name, in a font whose subset has a verified table: the name /Differences gives the code, else the name the named base encoding gives it, else, where the dictionary names no base encoding, the name the embedded program's own built-in encoding gives it, which is then the base encoding (ISO 32000-1 9.6.6.1). Asked only once the table exists, so no other font opens its program for this. + const verifiedTextOf = (code: number): string | undefined => { + const table = verifiedGlyphs(); + if (table === undefined) { + return undefined; + } + const glyphName = + differencesMap.get(code) ?? + (namedBaseGlyphName === undefined + ? programEncoding()?.codeToGlyphName(code) + : namedBaseGlyphName(code)); + return glyphName === undefined ? undefined : table.glyphs.get(glyphName); + }; + const decodeToUnicode = (codes: Uint8Array): string => { let out = ""; let unmapped = 0; for (const code of codes) { - // A glyph of a subset checked against its outlines is read as what it draws, by the name /Differences, or else the named base encoding, gives its code, before the font dictionary's own tables, which that subset's producer wrote wrong. - const glyphName = differencesMap.get(code) ?? namedBaseGlyphName?.(code); - const verified = - glyphName === undefined - ? undefined - : verifiedGlyphs()?.glyphs.get(glyphName); + // A glyph of a subset checked against its outlines is read as what it draws, before the font dictionary's own tables, which that subset's producer wrote wrong. + const verified = verifiedTextOf(code); if (verified !== undefined) { out += verified; continue; diff --git a/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts b/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts index 0d82f77c08..731e78e30b 100644 --- a/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts +++ b/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts @@ -3,4 +3,4 @@ // // Each face's glyph id -> text order and advance widths, DEFLATE-compressed (fflate's raw deflateSync) and base64-encoded; see the generator's header comment for the binary layout and src/core-font-glyph-orders.ts for the reader. export const CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64 = - '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'; + '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'; diff --git a/packages/pdf-codec/src/verified-glyph-tables.test.ts b/packages/pdf-codec/src/verified-glyph-tables.test.ts index 8e13749b8e..c7f3f577d5 100644 --- a/packages/pdf-codec/src/verified-glyph-tables.test.ts +++ b/packages/pdf-codec/src/verified-glyph-tables.test.ts @@ -13,6 +13,7 @@ import { pdfRef, pdfStream, } from "./objects"; +import { cffFontWithBuiltinEncoding } from "./test-support/cff"; import { VERIFIED_GLYPH_FAMILIES, VERIFIED_SOURCES, @@ -163,6 +164,78 @@ describe("a font subset with a verified glyph table", () => { }); }); +describe("a verified subset whose font dictionary names no encoding", () => { + // The math italic subset's shape: the program's own encoding puts its glyphs `colon` and `semicolon` at 0x3A and 0x3B, where they draw a full stop and a comma, the font dictionary carries no /Encoding, and /ToUnicode reads each code as the character the glyph's name spells. + const MATH_ITALIC = cffFontWithBuiltinEncoding({ + name: "ABCDEF+AdvP4C4E51", + glyphNames: ["colon", "semicolon"], + encoding: new Map([ + [0x3a, 1], + [0x3b, 2], + ]), + }); + const COLON_AND_SEMICOLON = [0x3a, 0x3b]; + + function readThroughBuiltinEncoding( + tables: ReadonlyMap, + ): string | undefined { + const objects = new Map([ + [ + 9, + pdfStream( + pdfDict({}), + new TextEncoder().encode( + "beginbfchar\n<3A> <003A>\n<3B> <003B>\nendbfchar", + ), + ), + ], + [ + 10, + pdfDict({ + Type: pdfName("FontDescriptor"), + FontName: pdfName("ABCDEF+AdvP4C4E51"), + Flags: pdfNum(4), + FontFile3: pdfRef(11, 0), + }), + ], + [11, pdfStream(pdfDict({ Subtype: pdfName("Type1C") }), MATH_ITALIC)], + ]); + const fontDict = pdfDict({ + Type: pdfName("Font"), + Subtype: pdfName("Type1"), + BaseFont: pdfName("ABCDEF+AdvP4C4E51"), + FirstChar: pdfNum(0x3a), + LastChar: pdfNum(0x3b), + Widths: pdfArray([pdfNum(278), pdfNum(278)]), + FontDescriptor: pdfRef(10, 0), + ToUnicode: pdfRef(9, 0), + }); + const { resolve } = createFontResolver({ + resolver: makeResolver(objects), + sink: NO_DIAGNOSTICS, + verifiedGlyphTables: tables, + }); + return resolve( + "F1", + pdfDict({ Font: pdfDict({ F1: fontDict }) }), + )?.decodeToUnicode(new Uint8Array(COLON_AND_SEMICOLON)); + } + + it("selects the glyph by the name the program's own encoding gives the code", () => { + const tables = new Map([ + [ + sha256Of(MATH_ITALIC), + { family: "AdvP4C4E51", glyphs: { colon: ".", semicolon: "," } }, + ], + ]); + expect(readThroughBuiltinEncoding(tables)).toBe(".,"); + }); + + it("reads the same program through /ToUnicode when no table lists it", () => { + expect(readThroughBuiltinEncoding(new Map())).toBe(":;"); + }); +}); + describe("many font dictionaries sharing one embedded program", () => { const SHARING_FONTS = 30; diff --git a/packages/pdf-codec/src/verified-glyph-tables.ts b/packages/pdf-codec/src/verified-glyph-tables.ts index cdecf4bdeb..e3a64d3616 100644 --- a/packages/pdf-codec/src/verified-glyph-tables.ts +++ b/packages/pdf-codec/src/verified-glyph-tables.ts @@ -268,6 +268,19 @@ export const VERIFIED_SOURCES: ReadonlyMap = }, }, ], + [ + "78448cb71772342dba968e5467a55b5df184815aabe509ccf2f4ec7b923aebe4", + { + family: "AdvP4C4E51", + glyphs: { + colon: ".", + equal: "/", + greater: ">", + less: "<", + semicolon: ",", + }, + }, + ], [ "967c167a737966cddc29a62e6f0601efc797d1f9453d0f3df558306b2d8b91e2", {