web-doc 0.9.0 → 0.10.0

package/dist/edit/pdf/engine/glyph-names.js

@@ -0,0 +1,163 @@
+/*
+ * Glyph names and the code points they stand for: the Adobe Glyph List For
+ * New Fonts 1.7 (aglfn.txt), and from the Adobe Glyph List 2.0
+ * (glyphlist.txt) the ligatures, superior figures and no-break space that
+ * font subsets commonly name, from https://github.com/adobe-type-tools/agl-aglfn.
+ * Each is listed as a name and its code point in hexadecimal.
+ *
+ * Copyright 2002-2019 Adobe (http://www.adobe.com/).
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the
+ * following conditions are met:
+ *
+ * Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * Neither the name of Adobe nor the names of its contributors
+ * may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+const AGLFN = `
+A 0041 AE 00C6 AEacute 01FC Aacute 00C1 Abreve 0102 Acircumflex 00C2
+Adieresis 00C4 Agrave 00C0 Alpha 0391 Alphatonos 0386 Amacron 0100
+Aogonek 0104 Aring 00C5 Aringacute 01FA Atilde 00C3 B 0042 Beta 0392 C 0043
+Cacute 0106 Ccaron 010C Ccedilla 00C7 Ccircumflex 0108 Cdotaccent 010A
+Chi 03A7 D 0044 Dcaron 010E Dcroat 0110 Delta 2206 E 0045 Eacute 00C9
+Ebreve 0114 Ecaron 011A Ecircumflex 00CA Edieresis 00CB Edotaccent 0116
+Egrave 00C8 Emacron 0112 Eng 014A Eogonek 0118 Epsilon 0395
+Epsilontonos 0388 Eta 0397 Etatonos 0389 Eth 00D0 Euro 20AC F 0046 G 0047
+Gamma 0393 Gbreve 011E Gcaron 01E6 Gcircumflex 011C Gdotaccent 0120 H 0048
+H18533 25CF H18543 25AA H18551 25AB H22073 25A1 Hbar 0126 Hcircumflex 0124
+I 0049 IJ 0132 Iacute 00CD Ibreve 012C Icircumflex 00CE Idieresis 00CF
+Idotaccent 0130 Ifraktur 2111 Igrave 00CC Imacron 012A Iogonek 012E
+Iota 0399 Iotadieresis 03AA Iotatonos 038A Itilde 0128 J 004A
+Jcircumflex 0134 K 004B Kappa 039A L 004C Lacute 0139 Lambda 039B
+Lcaron 013D Ldot 013F Lslash 0141 M 004D Mu 039C N 004E Nacute 0143
+Ncaron 0147 Ntilde 00D1 Nu 039D O 004F OE 0152 Oacute 00D3 Obreve 014E
+Ocircumflex 00D4 Odieresis 00D6 Ograve 00D2 Ohorn 01A0 Ohungarumlaut 0150
+Omacron 014C Omega 2126 Omegatonos 038F Omicron 039F Omicrontonos 038C
+Oslash 00D8 Oslashacute 01FE Otilde 00D5 P 0050 Phi 03A6 Pi 03A0 Psi 03A8
+Q 0051 R 0052 Racute 0154 Rcaron 0158 Rfraktur 211C Rho 03A1 S 0053
+SF010000 250C SF020000 2514 SF030000 2510 SF040000 2518 SF050000 253C
+SF060000 252C SF070000 2534 SF080000 251C SF090000 2524 SF100000 2500
+SF110000 2502 SF190000 2561 SF200000 2562 SF210000 2556 SF220000 2555
+SF230000 2563 SF240000 2551 SF250000 2557 SF260000 255D SF270000 255C
+SF280000 255B SF360000 255E SF370000 255F SF380000 255A SF390000 2554
+SF400000 2569 SF410000 2566 SF420000 2560 SF430000 2550 SF440000 256C
+SF450000 2567 SF460000 2568 SF470000 2564 SF480000 2565 SF490000 2559
+SF500000 2558 SF510000 2552 SF520000 2553 SF530000 256B SF540000 256A
+Sacute 015A Scaron 0160 Scedilla 015E Scircumflex 015C Sigma 03A3 T 0054
+Tau 03A4 Tbar 0166 Tcaron 0164 Theta 0398 Thorn 00DE U 0055 Uacute 00DA
+Ubreve 016C Ucircumflex 00DB Udieresis 00DC Ugrave 00D9 Uhorn 01AF
+Uhungarumlaut 0170 Umacron 016A Uogonek 0172 Upsilon 03A5 Upsilon1 03D2
+Upsilondieresis 03AB Upsilontonos 038E Uring 016E Utilde 0168 V 0056 W 0057
+Wacute 1E82 Wcircumflex 0174 Wdieresis 1E84 Wgrave 1E80 X 0058 Xi 039E
+Y 0059 Yacute 00DD Ycircumflex 0176 Ydieresis 0178 Ygrave 1EF2 Z 005A
+Zacute 0179 Zcaron 017D Zdotaccent 017B Zeta 0396 a 0061 aacute 00E1
+abreve 0103 acircumflex 00E2 acute 00B4 acutecomb 0301 adieresis 00E4
+ae 00E6 aeacute 01FD agrave 00E0 aleph 2135 alpha 03B1 alphatonos 03AC
+amacron 0101 ampersand 0026 angle 2220 angleleft 2329 angleright 232A
+anoteleia 0387 aogonek 0105 approxequal 2248 aring 00E5 aringacute 01FB
+arrowboth 2194 arrowdblboth 21D4 arrowdbldown 21D3 arrowdblleft 21D0
+arrowdblright 21D2 arrowdblup 21D1 arrowdown 2193 arrowleft 2190
+arrowright 2192 arrowup 2191 arrowupdn 2195 arrowupdnbse 21A8
+asciicircum 005E asciitilde 007E asterisk 002A asteriskmath 2217 at 0040
+atilde 00E3 b 0062 backslash 005C bar 007C beta 03B2 block 2588
+braceleft 007B braceright 007D bracketleft 005B bracketright 005D breve 02D8
+brokenbar 00A6 bullet 2022 c 0063 cacute 0107 caron 02C7 carriagereturn 21B5
+ccaron 010D ccedilla 00E7 ccircumflex 0109 cdotaccent 010B cedilla 00B8
+cent 00A2 chi 03C7 circle 25CB circlemultiply 2297 circleplus 2295
+circumflex 02C6 club 2663 colon 003A colonmonetary 20A1 comma 002C
+congruent 2245 copyright 00A9 currency 00A4 d 0064 dagger 2020
+daggerdbl 2021 dcaron 010F dcroat 0111 degree 00B0 delta 03B4 diamond 2666
+dieresis 00A8 dieresistonos 0385 divide 00F7 dkshade 2593 dnblock 2584
+dollar 0024 dong 20AB dotaccent 02D9 dotbelowcomb 0323 dotlessi 0131
+dotmath 22C5 e 0065 eacute 00E9 ebreve 0115 ecaron 011B ecircumflex 00EA
+edieresis 00EB edotaccent 0117 egrave 00E8 eight 0038 element 2208
+ellipsis 2026 emacron 0113 emdash 2014 emptyset 2205 endash 2013 eng 014B
+eogonek 0119 epsilon 03B5 epsilontonos 03AD equal 003D equivalence 2261
+estimated 212E eta 03B7 etatonos 03AE eth 00F0 exclam 0021 exclamdbl 203C
+exclamdown 00A1 existential 2203 f 0066 female 2640 figuredash 2012
+filledbox 25A0 filledrect 25AC five 0035 fiveeighths 215D florin 0192
+four 0034 fraction 2044 franc 20A3 g 0067 gamma 03B3 gbreve 011F gcaron 01E7
+gcircumflex 011D gdotaccent 0121 germandbls 00DF gradient 2207 grave 0060
+gravecomb 0300 greater 003E greaterequal 2265 guillemotleft 00AB
+guillemotright 00BB guilsinglleft 2039 guilsinglright 203A h 0068 hbar 0127
+hcircumflex 0125 heart 2665 hookabovecomb 0309 house 2302 hungarumlaut 02DD
+hyphen 002D i 0069 iacute 00ED ibreve 012D icircumflex 00EE idieresis 00EF
+igrave 00EC ij 0133 imacron 012B infinity 221E integral 222B integralbt 2321
+integraltp 2320 intersection 2229 invbullet 25D8 invcircle 25D9
+invsmileface 263B iogonek 012F iota 03B9 iotadieresis 03CA
+iotadieresistonos 0390 iotatonos 03AF itilde 0129 j 006A jcircumflex 0135
+k 006B kappa 03BA kgreenlandic 0138 l 006C lacute 013A lambda 03BB
+lcaron 013E ldot 0140 less 003C lessequal 2264 lfblock 258C lira 20A4
+logicaland 2227 logicalnot 00AC logicalor 2228 longs 017F lozenge 25CA
+lslash 0142 ltshade 2591 m 006D macron 00AF male 2642 minus 2212 minute 2032
+mu 00B5 multiply 00D7 musicalnote 266A musicalnotedbl 266B n 006E
+nacute 0144 napostrophe 0149 ncaron 0148 nine 0039 notelement 2209
+notequal 2260 notsubset 2284 ntilde 00F1 nu 03BD numbersign 0023 o 006F
+oacute 00F3 obreve 014F ocircumflex 00F4 odieresis 00F6 oe 0153 ogonek 02DB
+ograve 00F2 ohorn 01A1 ohungarumlaut 0151 omacron 014D omega 03C9
+omega1 03D6 omegatonos 03CE omicron 03BF omicrontonos 03CC one 0031
+onedotenleader 2024 oneeighth 215B onehalf 00BD onequarter 00BC
+onethird 2153 openbullet 25E6 ordfeminine 00AA ordmasculine 00BA
+orthogonal 221F oslash 00F8 oslashacute 01FF otilde 00F5 p 0070
+paragraph 00B6 parenleft 0028 parenright 0029 partialdiff 2202 percent 0025
+period 002E periodcentered 00B7 perpendicular 22A5 perthousand 2030
+peseta 20A7 phi 03C6 phi1 03D5 pi 03C0 plus 002B plusminus 00B1
+prescription 211E product 220F propersubset 2282 propersuperset 2283
+proportional 221D psi 03C8 q 0071 question 003F questiondown 00BF
+quotedbl 0022 quotedblbase 201E quotedblleft 201C quotedblright 201D
+quoteleft 2018 quotereversed 201B quoteright 2019 quotesinglbase 201A
+quotesingle 0027 r 0072 racute 0155 radical 221A rcaron 0159
+reflexsubset 2286 reflexsuperset 2287 registered 00AE revlogicalnot 2310
+rho 03C1 ring 02DA rtblock 2590 s 0073 sacute 015B scaron 0161 scedilla 015F
+scircumflex 015D second 2033 section 00A7 semicolon 003B seven 0037
+seveneighths 215E shade 2592 sigma 03C3 sigma1 03C2 similar 223C six 0036
+slash 002F smileface 263A space 0020 spade 2660 sterling 00A3 suchthat 220B
+summation 2211 sun 263C t 0074 tau 03C4 tbar 0167 tcaron 0165 therefore 2234
+theta 03B8 theta1 03D1 thorn 00FE three 0033 threeeighths 215C
+threequarters 00BE tilde 02DC tildecomb 0303 tonos 0384 trademark 2122
+triagdn 25BC triaglf 25C4 triagrt 25BA triagup 25B2 two 0032
+twodotenleader 2025 twothirds 2154 u 0075 uacute 00FA ubreve 016D
+ucircumflex 00FB udieresis 00FC ugrave 00F9 uhorn 01B0 uhungarumlaut 0171
+umacron 016B underscore 005F underscoredbl 2017 union 222A universal 2200
+uogonek 0173 upblock 2580 upsilon 03C5 upsilondieresis 03CB
+upsilondieresistonos 03B0 upsilontonos 03CD uring 016F utilde 0169 v 0076
+w 0077 wacute 1E83 wcircumflex 0175 wdieresis 1E85 weierstrass 2118
+wgrave 1E81 x 0078 xi 03BE y 0079 yacute 00FD ycircumflex 0177
+ydieresis 00FF yen 00A5 ygrave 1EF3 z 007A zacute 017A zcaron 017E
+zdotaccent 017C zero 0030 zeta 03B6
+`;
+const AGL_EXTRAS = `
+fi FB01 fl FB02 ff FB00 ffi FB03 ffl FB04 onesuperior 00B9 twosuperior 00B2
+threesuperior 00B3 nbspace 00A0
+`;
+/** Code points by glyph name. */
+export const GLYPH_UNICODE = new Map(`${AGLFN} ${AGL_EXTRAS}`
+    .trim()
+    .split(/\s+/)
+    .flatMap((word, index, words) => index % 2 === 0
+    ? [[word, Number.parseInt(words[index + 1], 16)]]
+    : []));

package/dist/edit/pdf/engine/handler.js

@@ -94,6 +94,8 @@ export function createPdfEditHandler(host) {
                 const { pageIndex, elementIds, scale } = payload;
                 return engine().renderPageWithout(pageIndex, elementIds, scale);
             }
+            case "edit-text-font":
+                return engine().textFont(payload.id);
             case "edit-page-layout":
                 return engine().pageLayout(payload.pageIndex);
             case "edit-dispose":

package/dist/edit/pdf/engine/opentype.d.ts

@@ -0,0 +1,14 @@
+import { type CffFont } from "./cff.js";
+/**
+ * The OpenType file, or `undefined` when no glyph has a code point or the
+ * program's name cannot be made one a browser accepts.
+ */
+export declare function cffOpenType(program: Uint8Array, font: CffFont, unicode: ReadonlyMap<number, number>): Uint8Array | undefined;
+/**
+ * An embedded TrueType or OpenType program with the OS/2, name and post
+ * tables it lacks, laid out on four-byte boundaries; `undefined` when its
+ * table directory or core tables are broken.
+ */
+export declare function completeSfnt(program: Uint8Array, fontName: string): Uint8Array | undefined;
+/** The sfnt file maps Unicode: a cmap subtable for platform 0, or for Windows Unicode BMP or full repertoire. */
+export declare function hasUnicodeCmap(program: Uint8Array): boolean;

package/dist/edit/pdf/engine/opentype.js

@@ -0,0 +1,317 @@
+import { cffWithSafeName } from "./cff.js";
+/*
+ * Fonts a browser loads with `FontFace`. A PDF's CFF program gets a minimal
+ * OpenType font around it: the CFF table as the PDF holds it, a Unicode cmap,
+ * and the tables a font loader requires (head, hhea, hmtx, maxp, name, OS/2,
+ * post), filled from what the CFF says. A PDF's TrueType program keeps its
+ * tables; subsetting tools leave out the OS/2, name and post tables and pack
+ * tables off four-byte boundaries, which browsers refuse, so those tables are
+ * added and the file laid out again. Nothing in a program's tables changes.
+ */
+const SFNT_TRUETYPE = 0x00010000;
+const SFNT_CFF = 0x4f54544f; // "OTTO"
+/**
+ * The OpenType file, or `undefined` when no glyph has a code point or the
+ * program's name cannot be made one a browser accepts.
+ */
+export function cffOpenType(program, font, unicode) {
+    const safe = cffWithSafeName(program);
+    if (unicode.size === 0 || !safe)
+        return undefined;
+    const em = font.unitsPerEm;
+    const [xMin, yMin, xMax, yMax] = fontBox(font.bbox, em);
+    const glyphCount = font.widths.length;
+    const widths = font.widths.map((width) => Math.max(0, Math.min(0xffff, Math.round(width))));
+    const codes = [...unicode.keys()].sort((a, b) => a - b);
+    const tables = new Map([
+        ["CFF ", safe],
+        ["OS/2", os2(em, widths, codes, yMin, yMax)],
+        ["cmap", cmap(unicode, codes)],
+        ["head", head(em, xMin, yMin, xMax, yMax)],
+        ["hhea", hhea(widths, glyphCount, xMin, yMin, xMax, yMax)],
+        ["hmtx", concat(widths.map((width) => bytes(u16(width), i16(0))))],
+        ["maxp", bytes(u32(0x00005000), u16(glyphCount))],
+        ["name", names(postScriptName(font.name))],
+        ["post", post(em)],
+    ]);
+    return assemble(tables, SFNT_CFF);
+}
+/**
+ * The font box in int16 font units, in order; a font without one, which CFF
+ * allows, gets a box of the usual proportions so its line has a height.
+ */
+function fontBox(box, em) {
+    const clamp = (value) => Math.max(-0x8000, Math.min(0x7fff, Math.round(value)));
+    const [x0 = 0, y0 = 0, x1 = 0, y1 = 0] = box.map(clamp);
+    if (y1 <= y0)
+        return [0, clamp(-em * 0.2), clamp(em), clamp(em * 0.8)];
+    return [Math.min(x0, x1), y0, Math.max(x0, x1), y1];
+}
+/**
+ * An embedded TrueType or OpenType program with the OS/2, name and post
+ * tables it lacks, laid out on four-byte boundaries; `undefined` when its
+ * table directory or core tables are broken.
+ */
+export function completeSfnt(program, fontName) {
+    const tables = sfntTables(program);
+    const headTable = tables?.get("head");
+    const hheaTable = tables?.get("hhea");
+    const maxpTable = tables?.get("maxp");
+    const hmtxTable = tables?.get("hmtx");
+    if (!tables ||
+        !tables.has("cmap") ||
+        !headTable ||
+        headTable.length < 54 ||
+        !hheaTable ||
+        hheaTable.length < 36 ||
+        !maxpTable ||
+        maxpTable.length < 6 ||
+        !hmtxTable)
+        return undefined;
+    const view = (table) => new DataView(table.buffer, table.byteOffset, table.byteLength);
+    const headView = view(headTable);
+    const em = headView.getUint16(18);
+    const yMin = headView.getInt16(38);
+    const yMax = headView.getInt16(42);
+    // The adjustment is the file's, so it is worked out again.
+    const ownHead = headTable.slice();
+    ownHead.fill(0, 8, 12);
+    tables.set("head", ownHead);
+    if (!tables.has("OS/2")) {
+        const metrics = view(hheaTable).getUint16(34);
+        const widths = Array.from({ length: Math.min(metrics, hmtxTable.length >> 2) }, (_, glyph) => view(hmtxTable).getUint16(glyph * 4));
+        tables.set("OS/2", os2(em, widths, [], yMin, yMax));
+    }
+    if (!tables.has("name"))
+        tables.set("name", names(postScriptName(fontName)));
+    if (!tables.has("post"))
+        tables.set("post", post(em));
+    const version = view(program).getUint32(0);
+    return assemble(tables, version === SFNT_CFF ? SFNT_CFF : SFNT_TRUETYPE);
+}
+/** The sfnt file maps Unicode: a cmap subtable for platform 0, or for Windows Unicode BMP or full repertoire. */
+export function hasUnicodeCmap(program) {
+    const table = sfntTables(program)?.get("cmap");
+    if (!table || table.length < 4)
+        return false;
+    const view = new DataView(table.buffer, table.byteOffset, table.byteLength);
+    const count = Math.min(view.getUint16(2), (table.length - 4) >> 3);
+    for (let index = 0; index < count; index += 1) {
+        const platform = view.getUint16(4 + index * 8);
+        const encoding = view.getUint16(6 + index * 8);
+        if (platform === 0 ||
+            (platform === 3 && (encoding === 1 || encoding === 10)))
+            return true;
+    }
+    return false;
+}
+/** The tables of an sfnt file by tag, or `undefined` when its directory is broken. */
+function sfntTables(program) {
+    if (program.length < 12)
+        return undefined;
+    const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+    const count = view.getUint16(4);
+    if (count === 0 || 12 + count * 16 > program.length)
+        return undefined;
+    const tables = new Map();
+    for (let index = 0; index < count; index += 1) {
+        const record = 12 + index * 16;
+        const tag = String.fromCharCode(...program.subarray(record, record + 4));
+        const offset = view.getUint32(record + 8);
+        const length = view.getUint32(record + 12);
+        if (tables.has(tag) || offset + length > program.length)
+            return undefined;
+        tables.set(tag, program.subarray(offset, offset + length));
+    }
+    return tables;
+}
+/** The PostScript name without a subset tag, in the characters a name table takes. */
+function postScriptName(name) {
+    return (name
+        .replace(/^[A-Z]{6}\+/, "")
+        .replace(/[^\x21-\x7e]|[[\](){}<>/%]/g, "")
+        .slice(0, 63) || "Embedded");
+}
+function post(em) {
+    // Version 3: no glyph names.
+    return bytes(u32(0x00030000), u32(0), i16(-Math.round(em / 10)), i16(Math.round(em / 20)), u32(0), u32(0), u32(0), u32(0), u32(0));
+}
+function head(em, xMin, yMin, xMax, yMax) {
+    return bytes(u32(0x00010000), u32(0x00010000), u32(0), // checkSumAdjustment, set once the font is assembled
+    u32(0x5f0f3cf5), u16(0x000b), u16(em), u32(0), u32(0), u32(0), u32(0), i16(xMin), i16(yMin), i16(xMax), i16(yMax), u16(0), u16(8), i16(2), i16(0), i16(0));
+}
+function hhea(widths, glyphCount, xMin, yMin, xMax, yMax) {
+    return bytes(u32(0x00010000), i16(yMax), i16(yMin), i16(0), u16(widths.reduce((most, width) => Math.max(most, width), 0)), i16(xMin), i16(0), i16(xMax), i16(1), i16(0), i16(0), i16(0), i16(0), i16(0), i16(0), i16(0), u16(glyphCount));
+}
+function os2(em, widths, codes, yMin, yMax) {
+    const scaled = (fraction) => Math.round(em * fraction);
+    const drawn = widths.filter((width) => width > 0);
+    const average = drawn.length
+        ? Math.round(drawn.reduce((sum, width) => sum + width, 0) / drawn.length)
+        : 0;
+    return bytes(u16(4), i16(average), u16(400), u16(5), u16(0), i16(scaled(0.65)), i16(scaled(0.6)), i16(0), i16(scaled(0.075)), i16(scaled(0.65)), i16(scaled(0.6)), i16(0), i16(scaled(0.35)), i16(scaled(0.05)), i16(scaled(0.25)), i16(0), new Array(10).fill(0), u32(0), u32(0), u32(0), u32(0), [0x57, 0x44, 0x4f, 0x43], // "WDOC"
+    u16(0x0040), // regular
+    u16(Math.min(codes[0] ?? 0x20, 0xffff)), u16(Math.min(codes.at(-1) ?? 0xffff, 0xffff)), i16(yMax), i16(yMin), i16(0), u16(Math.max(0, yMax)), u16(Math.max(0, -yMin)), u32(1), u32(0), i16(scaled(0.5)), i16(scaled(0.7)), u16(0), u16(32), u16(0));
+}
+/**
+ * Format 4 for the BMP, and format 12 as well when a code point lies beyond
+ * it or the BMP takes more segments than format 4 holds. Records are in
+ * platform and encoding order, as the specification requires.
+ */
+function cmap(unicode, codes) {
+    const basic = codes.filter((code) => code <= 0xffff);
+    const format4 = cmapFormat4(unicode, basic);
+    const format12 = !format4 || codes.length > basic.length
+        ? cmapFormat12(unicode, codes)
+        : undefined;
+    const subtables = [
+        ...(format4 ? [{ platform: 0, encoding: 3, data: format4 }] : []),
+        ...(format12 ? [{ platform: 0, encoding: 4, data: format12 }] : []),
+        ...(format4 ? [{ platform: 3, encoding: 1, data: format4 }] : []),
+        ...(format12 ? [{ platform: 3, encoding: 10, data: format12 }] : []),
+    ];
+    // Subtables shared by two records are written once.
+    const unique = [...new Set(subtables.map((subtable) => subtable.data))];
+    const headerSize = 4 + subtables.length * 8;
+    const offsets = new Map();
+    let offset = headerSize;
+    for (const data of unique) {
+        offsets.set(data, offset);
+        offset += data.length;
+    }
+    return concat([
+        bytes(u16(0), u16(subtables.length)),
+        ...subtables.map(({ platform, encoding, data }) => bytes(u16(platform), u16(encoding), u32(offsets.get(data)))),
+        ...unique,
+    ]);
+}
+/** `undefined` when the segments overflow the subtable's 16-bit length. */
+function cmapFormat4(unicode, codes) {
+    // Runs of consecutive code points on consecutive glyphs share one delta.
+    const segments = [];
+    for (const code of codes) {
+        const glyph = unicode.get(code);
+        const last = segments.at(-1);
+        if (last &&
+            code === last.end + 1 &&
+            glyph === last.glyph + (code - last.start))
+            last.end = code;
+        else
+            segments.push({ start: code, end: code, glyph });
+    }
+    segments.push({ start: 0xffff, end: 0xffff, glyph: 0 });
+    const count = segments.length;
+    if (16 + count * 8 > 0xffff)
+        return undefined;
+    const searchRange = 2 * 2 ** Math.floor(Math.log2(count));
+    const delta = (segment) => segment.start === 0xffff ? 1 : (segment.glyph - segment.start) & 0xffff;
+    return bytes(u16(4), u16(16 + count * 8), u16(0), u16(count * 2), u16(searchRange), u16(Math.floor(Math.log2(count))), u16(count * 2 - searchRange), segments.flatMap((segment) => u16(segment.end)), u16(0), segments.flatMap((segment) => u16(segment.start)), segments.flatMap((segment) => u16(delta(segment))), segments.flatMap(() => u16(0)));
+}
+function cmapFormat12(unicode, codes) {
+    const groups = [];
+    for (const code of codes) {
+        const glyph = unicode.get(code);
+        const last = groups.at(-1);
+        if (last &&
+            code === last.end + 1 &&
+            glyph === last.glyph + (code - last.start))
+            last.end = code;
+        else
+            groups.push({ start: code, end: code, glyph });
+    }
+    return bytes(u16(12), u16(0), u32(16 + groups.length * 12), u32(0), u32(groups.length), groups.flatMap((group) => [
+        ...u32(group.start),
+        ...u32(group.end),
+        ...u32(group.glyph),
+    ]));
+}
+function names(postScript) {
+    const records = [
+        [1, postScript],
+        [2, "Regular"],
+        [3, `${postScript}-web-doc`],
+        [4, postScript],
+        [5, "Version 1.0"],
+        [6, postScript],
+    ];
+    const strings = records.map(([, text]) => [...text].flatMap((character) => u16(character.charCodeAt(0))));
+    let offset = 0;
+    const entries = records.map(([id], index) => {
+        const entry = [
+            ...u16(3),
+            ...u16(1),
+            ...u16(0x0409),
+            ...u16(id),
+            ...u16(strings[index].length),
+            ...u16(offset),
+        ];
+        offset += strings[index].length;
+        return entry;
+    });
+    return bytes(u16(0), u16(records.length), u16(6 + records.length * 12), entries.flat(), strings.flat());
+}
+/** The table directory, the tables padded to four bytes, and the head checksum adjustment. */
+function assemble(tables, version) {
+    const tags = [...tables.keys()].sort();
+    const count = tags.length;
+    const selector = Math.floor(Math.log2(count));
+    const headerSize = 12 + count * 16;
+    let offset = headerSize;
+    const placed = tags.map((tag) => {
+        const data = tables.get(tag);
+        const at = offset;
+        offset += (data.length + 3) & ~3;
+        return { tag, data, at };
+    });
+    const font = new Uint8Array(offset);
+    font.set(bytes(u32(version), u16(count), u16(2 ** selector * 16), u16(selector), u16(count * 16 - 2 ** selector * 16), placed.flatMap(({ tag, data, at }) => [
+        ...[...tag].map((character) => character.charCodeAt(0)),
+        ...u32(checksum(data)),
+        ...u32(at),
+        ...u32(data.length),
+    ])));
+    for (const { data, at } of placed)
+        font.set(data, at);
+    const head = placed.find((table) => table.tag === "head");
+    const adjustment = (0xb1b0afba - checksum(font)) >>> 0;
+    font.set(u32(adjustment), head.at + 8);
+    return font;
+}
+function checksum(data) {
+    let sum = 0;
+    for (let offset = 0; offset < data.length; offset += 4)
+        sum =
+            (sum +
+                (((data[offset] ?? 0) << 24) |
+                    ((data[offset + 1] ?? 0) << 16) |
+                    ((data[offset + 2] ?? 0) << 8) |
+                    (data[offset + 3] ?? 0))) >>>
+                0;
+    return sum;
+}
+function u16(value) {
+    return [(value >> 8) & 0xff, value & 0xff];
+}
+function i16(value) {
+    return u16(value < 0 ? value + 0x10000 : value);
+}
+function u32(value) {
+    return [
+        (value >>> 24) & 0xff,
+        (value >>> 16) & 0xff,
+        (value >>> 8) & 0xff,
+        value & 0xff,
+    ];
+}
+function bytes(...parts) {
+    return concat(parts.map((part) => Uint8Array.from(part)));
+}
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}

package/dist/edit/pdf/engine/text-font.d.ts

@@ -0,0 +1,4 @@
+import type { TextFont } from "../types.js";
+import type { Pdfium } from "./pdfium.js";
+export type TextFace = Omit<TextFont, "elementId">;
+export declare function textFaceOf(pdfium: Pdfium, object: number, cache: Map<string, TextFace>): TextFace;

package/dist/edit/pdf/engine/text-font.js

@@ -0,0 +1,81 @@
+import { glyphUnicode, readCff } from "./cff.js";
+import { textStyle } from "./elements.js";
+import { cffOpenType, completeSfnt, hasUnicodeCmap } from "./opentype.js";
+export function textFaceOf(pdfium, object, cache) {
+    const { lib } = pdfium;
+    const font = lib.FPDFTextObj_GetFont(object);
+    const family = textStyle(pdfium, object).fontFamily;
+    const baseName = pdfium.readUtf8String((buffer, bytes) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes));
+    if (!lib.FPDFFont_GetIsEmbedded(font))
+        return { key: `name:${baseName}`, family, missing: "not-embedded" };
+    // A Type 3 font is embedded as drawings, with no program to read.
+    const program = fontProgram(pdfium, font);
+    if (!program)
+        return { key: `embedded:${baseName}`, family, missing: "unreadable" };
+    const key = `${baseName}#${fnv1a(program).toString(16)}`;
+    const known = cache.get(key);
+    if (known)
+        return { ...known, family };
+    const face = { key, family, ...faceOf(program, baseName) };
+    cache.set(key, face);
+    return face;
+}
+function faceOf(program, baseName) {
+    const tag = String.fromCharCode(...program.subarray(0, 4));
+    const truetype = tag === "true" ||
+        (program[0] === 0 &&
+            program[1] === 1 &&
+            program[2] === 0 &&
+            program[3] === 0);
+    if (truetype || tag === "OTTO") {
+        if (!hasUnicodeCmap(program))
+            return { missing: "no-unicode" };
+        const data = completeSfnt(program, baseName);
+        return data
+            ? { face: { data, format: truetype ? "truetype" : "opentype" } }
+            : { missing: "unreadable" };
+    }
+    // Type 1 programs start with "%!" in clear text, or with a PFB segment.
+    if (tag.startsWith("%!") || program[0] === 0x80)
+        return { missing: "type1" };
+    const cff = readCff(program);
+    if (!cff)
+        return { missing: "unreadable" };
+    if (cff.cid)
+        return { missing: "cid-keyed" };
+    const unicode = new Map();
+    cff.glyphNames.forEach((name, glyph) => {
+        const code = glyphUnicode(name);
+        if (code !== undefined && !unicode.has(code))
+            unicode.set(code, glyph);
+    });
+    const data = cffOpenType(program, cff, unicode);
+    return data
+        ? { face: { data, format: "opentype" } }
+        : { missing: "no-unicode" };
+}
+/** The font program a PDF font object embeds, or `undefined` for a font it does not embed. */
+function fontProgram(pdfium, font) {
+    const { lib } = pdfium;
+    const size = pdfium.readNumbers(1, "i32", ([out]) => lib.FPDFFont_GetFontData(font, 0, 0, out))?.[0];
+    if (!size)
+        return undefined;
+    const buffer = pdfium.malloc(size);
+    const out = pdfium.malloc(4);
+    try {
+        return lib.FPDFFont_GetFontData(font, buffer, size, out)
+            ? pdfium.readBytes(buffer, size)
+            : undefined;
+    }
+    finally {
+        pdfium.free(out);
+        pdfium.free(buffer);
+    }
+}
+/** FNV-1a over the program: a cheap, stable key for one font. */
+function fnv1a(bytes) {
+    let hash = 0x811c9dc5;
+    for (const byte of bytes)
+        hash = Math.imul(hash ^ byte, 0x01000193);
+    return hash >>> 0;
+}

package/dist/edit/pdf/provider.d.ts

@@ -2,10 +2,11 @@ import { type WorkerLike } from "../../worker-client.js";
 import type { EditEngineContext } from "../engine.js";
 import type { PagePoint, PageRect, TextPosition, TextRange } from "../types.js";
 import { WorkerEngineClient } from "../worker-engine.js";
-import type { PageBitmap, PageLayout, TextLayout } from "./types.js";
+import type { PageBitmap, PageLayout, TextFont, TextLayout } from "./types.js";
 /** The reads behind the overlay primitives, beyond the core engine interface. */
 export interface PdfEngineReads {
     textLayout(id: string, signal: AbortSignal): Promise<TextLayout | undefined>;
+    textFont(id: string, signal: AbortSignal): Promise<TextFont | undefined>;
     positionAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<TextPosition | undefined>;
     rangeRects(range: TextRange, signal: AbortSignal): Promise<readonly PageRect[]>;
     renderWithout(pageIndex: number, elementIds: readonly string[], scale: number, signal: AbortSignal): Promise<PageBitmap>;
@@ -28,6 +29,7 @@ export declare class PdfEditEngineClient extends WorkerEngineClient implements P
     readonly schemas: import("../types.js").OperationSchemaSet;
     start(original: Uint8Array, options: PdfEditProviderOptions): Promise<void>;
     textLayout(id: string, signal: AbortSignal): Promise<TextLayout | undefined>;
+    textFont(id: string, signal: AbortSignal): Promise<TextFont | undefined>;
     positionAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<TextPosition | undefined>;
     rangeRects(range: TextRange, signal: AbortSignal): Promise<readonly PageRect[]>;
     renderWithout(pageIndex: number, elementIds: readonly string[], scale: number, signal: AbortSignal): Promise<PageBitmap>;

package/dist/edit/pdf/provider.js

@@ -53,6 +53,9 @@ export class PdfEditEngineClient extends WorkerEngineClient {
     textLayout(id, signal) {
         return this.request("edit-text-layout", { id }, signal);
     }
+    textFont(id, signal) {
+        return this.request("edit-text-font", { id }, signal);
+    }
     positionAt(pageIndex, point, signal) {
         return this.request("edit-position-at", { pageIndex, point }, signal);
     }

package/dist/edit/pdf/session.d.ts

@@ -2,7 +2,7 @@ import type { TextSelection } from "../../contracts.js";
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
 import type { EditSessionCore } from "../engine.js";
 import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextPosition, TextRange, TextTarget } from "../types.js";
-import type { DeleteElementOperation, DeletePageOperation, Fields, InsertImageOperation, InsertPageOperation, InsertShapeOperation, InsertTableOperation, InsertTextBoxOperation, MoveElementOperation, MovePageOperation, PdfEditSession, PdfElement, PdfOperation, PdfSaveOptions, ReplaceTextOperation, ResizeElementOperation, RotatePageOperation, SetShapeStyleOperation, SetTableCellOperation, PageBitmap, PageLayout, RenderOptions, SetTextStyleOperation, TextLayout } from "./types.js";
+import type { DeleteElementOperation, DeletePageOperation, Fields, InsertImageOperation, InsertPageOperation, InsertShapeOperation, InsertTableOperation, InsertTextBoxOperation, MoveElementOperation, MovePageOperation, PdfEditSession, PdfElement, PdfOperation, PdfSaveOptions, ReplaceTextOperation, ResizeElementOperation, RotatePageOperation, SetShapeStyleOperation, SetTableCellOperation, PageBitmap, PageLayout, RenderOptions, SetTextStyleOperation, TextFont, TextLayout } from "./types.js";
 /**
  * The PDF session: the core session narrowed to PDF operations and elements.
  * Typed methods are added here as their operations ship; each is `apply()`
@@ -39,6 +39,7 @@ export declare class PdfSession implements PdfEditSession {
     get tools(): ToolSet;
     callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
     getTextLayout(elementId: string, options?: ReadOptions): Promise<ReadItem<TextLayout>>;
+    getTextFont(elementId: string, options?: ReadOptions): Promise<ReadItem<TextFont>>;
     positionAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadItem<TextPosition>>;
     rangeRects(range: TextRange, options?: ReadOptions): Promise<ReadResult<PageRect>>;
     getPageLayout(pageIndex: number, options?: ReadOptions): Promise<ReadItem<PageLayout>>;

package/dist/edit/pdf/session.js

@@ -198,6 +198,9 @@ export class PdfSession {
     getTextLayout(elementId, options) {
         return this.#core.readItem(options, (engine, signal) => pdfReads(engine).textLayout(elementId, signal));
     }
+    getTextFont(elementId, options) {
+        return this.#core.readItem(options, (engine, signal) => pdfReads(engine).textFont(elementId, signal));
+    }
     positionAt(pageIndex, point, options) {
         return this.#core.readItem(options, (engine, signal) => pdfReads(engine).positionAt(pageIndex, point, signal));
     }