web-doc 0.8.0 → 0.10.0

package/dist/workers/pdf-edit-worker.js

@@ -3661,7 +3661,7 @@ var init_index_browser = __esm({
             // count: 1
           ];
           generateFuncType(sig, typeSectionBody);
-          var bytes = [
+          var bytes2 = [
             0,
             97,
             115,
@@ -3675,9 +3675,9 @@ var init_index_browser = __esm({
             1
             // Type section code
           ];
-          uleb128Encode(typeSectionBody.length, bytes);
-          bytes.push(...typeSectionBody);
-          bytes.push(
+          uleb128Encode(typeSectionBody.length, bytes2);
+          bytes2.push(...typeSectionBody);
+          bytes2.push(
             2,
             7,
             // import section
@@ -3699,7 +3699,7 @@ var init_index_browser = __esm({
             0,
             0
           );
-          var module = new WebAssembly.Module(new Uint8Array(bytes));
+          var module = new WebAssembly.Module(new Uint8Array(bytes2));
           var instance = new WebAssembly.Instance(module, { "e": { "f": func } });
           var wrappedFunc = instance.exports["f"];
           return wrappedFunc;
@@ -5850,13 +5850,16 @@ var pdfOperationSchemas = Object.freeze({
       },
       ["from", "to"]
     ),
+    // Exactly one of `rotation` (absolute) and `by` (a turn from the current
+    // angle); the handler reports a batch that gives both or neither.
     rotatePage: operation(
       "rotatePage",
       {
         pageIndex: { type: "integer", minimum: 0 },
-        rotation: { enum: [0, 90, 180, 270] }
+        rotation: { enum: [0, 90, 180, 270] },
+        by: { enum: [90, 180, 270] }
       },
-      ["pageIndex", "rotation"]
+      ["pageIndex"]
     ),
     insertShape: operation(
       "insertShape",
@@ -6375,15 +6378,15 @@ function readMark(pdfium, object) {
   for (let index = 0; index < lib.FPDFPageObj_CountMarks(object); index += 1) {
     const mark = lib.FPDFPageObj_GetMark(object, index);
     const name = pdfium.readWideStringOut(
-      (buffer, bytes, out) => lib.FPDFPageObjMark_GetName(mark, buffer, bytes, out)
+      (buffer, bytes2, out) => lib.FPDFPageObjMark_GetName(mark, buffer, bytes2, out)
     );
     if (name !== MARK_NAME) continue;
     const raw = pdfium.readWideStringOut(
-      (buffer, bytes, out) => lib.FPDFPageObjMark_GetParamStringValue(
+      (buffer, bytes2, out) => lib.FPDFPageObjMark_GetParamStringValue(
         mark,
         MARK_PARAM,
         buffer,
-        bytes,
+        bytes2,
         out
       )
     );
@@ -6532,17 +6535,21 @@ var TABLE_OPERATIONS = Object.freeze([
 ]);
 function textOf(pdfium, object, textPage) {
   return pdfium.readWideString(
-    (buffer, bytes) => pdfium.lib.FPDFTextObj_GetText(object, textPage, buffer, bytes)
+    (buffer, bytes2) => pdfium.lib.FPDFTextObj_GetText(object, textPage, buffer, bytes2)
   );
 }
+function textScale(matrix) {
+  const scale = matrix ? Math.hypot(matrix[2], matrix[3]) : 1;
+  return Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
 function textStyle(pdfium, object) {
   const { lib } = pdfium;
   const font = lib.FPDFTextObj_GetFont(object);
   const baseName = pdfium.readUtf8String(
-    (buffer, bytes) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes)
+    (buffer, bytes2) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes2)
   );
   const family = lib.FPDFFont_GetIsEmbedded(font) ? pdfium.readUtf8String(
-    (buffer, bytes) => lib.FPDFFont_GetFamilyName(font, buffer, bytes)
+    (buffer, bytes2) => lib.FPDFFont_GetFamilyName(font, buffer, bytes2)
   ) || declaredFamily(baseName) : declaredFamily(baseName);
   const flags = lib.FPDFFont_GetFlags(font);
   const weight = lib.FPDFFont_GetWeight(font);
@@ -6551,9 +6558,14 @@ function textStyle(pdfium, object) {
     "float",
     ([pointer]) => lib.FPDFTextObj_GetFontSize(object, pointer)
   )?.[0] ?? 0;
+  const matrix = pdfium.readNumbers(
+    6,
+    "float",
+    ([pointer]) => lib.FPDFPageObj_GetMatrix(object, pointer)
+  );
   return {
     fontFamily: family,
-    fontSize: round(size),
+    fontSize: round(size * textScale(matrix)),
     bold: weight >= 600 || (flags & FLAG_FORCE_BOLD) !== 0 || /bold|black|heavy/i.test(baseName),
     italic: (flags & FLAG_ITALIC) !== 0 || /italic|oblique/i.test(baseName),
     color: fillColor(pdfium, object) ?? "#000000"
@@ -6897,7 +6909,7 @@ var FontLibrary = class {
     if (this.#coveringRegistered(request)) return void 0;
     if (this.#fallback && this.#covers(this.#fallback, request.text))
       return void 0;
-    const bad = firstNonWinAnsi(request.text) ?? firstUncovered(request.text, this);
+    const bad = this.#fallback ? this.#firstMissing(this.#fallback, request.text) : firstNonWinAnsi(request.text);
     return {
       path: "/text",
       code: "font-unavailable",
@@ -6944,8 +6956,8 @@ var FontLibrary = class {
     for (const handle of handles.values()) pdfium.lib.FPDFFont_Close(handle);
     this.#handles.delete(document2);
   }
-  covers(bytes, text) {
-    return this.#covers(bytes, text);
+  covers(bytes2, text) {
+    return this.#covers(bytes2, text);
   }
   #coveringRegistered(request) {
     const candidates = this.#registered.filter((font) => sameFamily(font.family, request.family)).map((font) => ({ font, bytes: this.#loadedBytes(font) })).filter(
@@ -6954,33 +6966,37 @@ var FontLibrary = class {
     const score = (font) => (isBold(font) === request.bold ? 2 : 0) + (isItalic(font) === request.italic ? 1 : 0);
     return candidates.sort((a, b) => score(b.font) - score(a.font))[0];
   }
-  #covers(bytes, text) {
-    let coverage = this.#coverage.get(bytes);
+  #covers(bytes2, text) {
+    return this.#firstMissing(bytes2, text) === void 0;
+  }
+  /** The first character of `text` the font has no glyph for; layout handles line breaks and spaces. */
+  #firstMissing(bytes2, text) {
+    let coverage = this.#coverage.get(bytes2);
     if (!coverage) {
-      coverage = parseCmap(bytes);
-      this.#coverage.set(bytes, coverage);
+      coverage = parseCmap(bytes2);
+      this.#coverage.set(bytes2, coverage);
     }
     for (const character of text) {
       const code = character.codePointAt(0);
       if (code === 10 || code === 32) continue;
-      if (!coverage.has(code)) return false;
+      if (!coverage.has(code)) return character;
     }
-    return true;
+    return void 0;
   }
-  #load(pdfium, document2, bytes) {
+  #load(pdfium, document2, bytes2) {
     let handles = this.#handles.get(document2);
     if (!handles) {
       handles = /* @__PURE__ */ new Map();
       this.#handles.set(document2, handles);
     }
-    let handle = handles.get(bytes);
+    let handle = handles.get(bytes2);
     if (handle === void 0) {
-      const pointer = pdfium.writeBytes(bytes);
+      const pointer = pdfium.writeBytes(bytes2);
       try {
         handle = pdfium.lib.FPDFText_LoadFont(
           document2,
           pointer,
-          bytes.byteLength,
+          bytes2.byteLength,
           FONT_TRUETYPE,
           true
         );
@@ -6988,7 +7004,7 @@ var FontLibrary = class {
         pdfium.free(pointer);
       }
       if (!handle) throw new Error("PDFium could not load the font");
-      handles.set(bytes, handle);
+      handles.set(bytes2, handle);
     }
     return handle;
   }
@@ -6997,12 +7013,12 @@ var FontLibrary = class {
   }
   async #bytesOf(font) {
     const key = sourceKey(font);
-    let bytes = this.#bytes.get(key);
-    if (!bytes) {
-      bytes = typeof font.source === "string" ? await this.#fetch(font.source) : new Uint8Array(font.source);
-      this.#bytes.set(key, bytes);
+    let bytes2 = this.#bytes.get(key);
+    if (!bytes2) {
+      bytes2 = typeof font.source === "string" ? await this.#fetch(font.source) : new Uint8Array(font.source);
+      this.#bytes.set(key, bytes2);
     }
-    return bytes;
+    return bytes2;
   }
 };
 function sourceKey(font) {
@@ -7017,18 +7033,12 @@ function isBold(font) {
 function isItalic(font) {
   return font.style !== "normal";
 }
-function firstUncovered(text, library) {
-  void library;
-  for (const character of text)
-    if (character !== "\n" && character !== " ") return character;
-  return void 0;
-}
 function glyphOutlines(view, tables) {
-  const head = tables.get("head");
+  const head2 = tables.get("head");
   const maxp = tables.get("maxp");
   const loca = tables.get("loca");
-  if (!head || !maxp || !loca || !tables.has("glyf")) return void 0;
-  const longOffsets = view.getInt16(head.offset + 50) === 1;
+  if (!head2 || !maxp || !loca || !tables.has("glyf")) return void 0;
+  const longOffsets = view.getInt16(head2.offset + 50) === 1;
   const count = view.getUint16(maxp.offset + 4);
   return (glyph) => {
     if (glyph < 0 || glyph >= count) return false;
@@ -7038,8 +7048,8 @@ function glyphOutlines(view, tables) {
     return end > start;
   };
 }
-function parseCmap(bytes) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+function parseCmap(bytes2) {
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
   const ranges = [];
   const glyphs = /* @__PURE__ */ new Map();
   let outlines;
@@ -7050,10 +7060,10 @@ function parseCmap(bytes) {
     for (let index = 0; index < tables; index += 1) {
       const record = 12 + index * 16;
       const tag = String.fromCharCode(
-        bytes[record],
-        bytes[record + 1],
-        bytes[record + 2],
-        bytes[record + 3]
+        bytes2[record],
+        bytes2[record + 1],
+        bytes2[record + 2],
+        bytes2[record + 3]
       );
       offsets.set(tag, {
         offset: view.getUint32(record + 8),
@@ -7222,6 +7232,915 @@ var TextMeasurer = class {
   }
 };
 
+// src/edit/pdf/engine/glyph-names.ts
+var 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
+`;
+var AGL_EXTRAS = `
+fi FB01 fl FB02 ff FB00 ffi FB03 ffl FB04 onesuperior 00B9 twosuperior 00B2
+threesuperior 00B3 nbspace 00A0
+`;
+var GLYPH_UNICODE = new Map(
+  `${AGLFN} ${AGL_EXTRAS}`.trim().split(/\s+/).flatMap(
+    (word, index, words) => index % 2 === 0 ? [[word, Number.parseInt(words[index + 1], 16)]] : []
+  )
+);
+
+// src/edit/pdf/engine/cff.ts
+var ISO_ADOBE_NAMES = `
+.notdef space exclam quotedbl numbersign dollar percent ampersand
+quoteright parenleft parenright asterisk plus comma hyphen period slash
+zero one two three four five six seven eight nine colon semicolon less
+equal greater question at A B C D E F G H I J K L M N O P Q R S T U V W X Y
+Z bracketleft backslash bracketright asciicircum underscore quoteleft a b c
+d e f g h i j k l m n o p q r s t u v w x y z braceleft bar braceright
+asciitilde exclamdown cent sterling fraction yen florin section currency
+quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright fi fl
+endash dagger daggerdbl periodcentered paragraph bullet quotesinglbase
+quotedblbase quotedblright guillemotright ellipsis perthousand questiondown
+grave acute circumflex tilde macron breve dotaccent dieresis ring cedilla
+hungarumlaut ogonek caron emdash AE ordfeminine Lslash Oslash OE
+ordmasculine ae dotlessi lslash oslash oe germandbls onesuperior logicalnot
+mu trademark Eth onehalf plusminus Thorn onequarter divide brokenbar degree
+thorn threequarters twosuperior registered minus eth multiply threesuperior
+copyright Aacute Acircumflex Adieresis Agrave Aring Atilde Ccedilla Eacute
+Ecircumflex Edieresis Egrave Iacute Icircumflex Idieresis Igrave Ntilde
+Oacute Ocircumflex Odieresis Ograve Otilde Scaron Uacute Ucircumflex
+Udieresis Ugrave Yacute Ydieresis Zcaron aacute acircumflex adieresis
+agrave aring atilde ccedilla eacute ecircumflex edieresis egrave iacute
+icircumflex idieresis igrave ntilde oacute ocircumflex odieresis ograve
+otilde scaron uacute ucircumflex udieresis ugrave yacute ydieresis zcaron
+`.trim().split(/\s+/);
+function glyphUnicode(name) {
+  if (!name || name === ".notdef") return void 0;
+  const known = GLYPH_UNICODE.get(name);
+  if (known !== void 0) return known;
+  const match = /^uni([0-9A-F]{4})$|^u([0-9A-F]{4,6})$/.exec(name);
+  const hex2 = match?.[1] ?? match?.[2];
+  if (!hex2) return void 0;
+  const code = Number.parseInt(hex2, 16);
+  const surrogate = code >= 55296 && code <= 57343;
+  const nonCharacter = (code & 65534) === 65534;
+  return code <= 1114111 && !surrogate && !nonCharacter ? code : void 0;
+}
+var OP = {
+  fontBBox: 5,
+  charset: 15,
+  charStrings: 17,
+  private: 18,
+  defaultWidthX: 20,
+  nominalWidthX: 21,
+  subrs: 19,
+  charstringType: 1206,
+  fontMatrix: 1207,
+  ros: 1230
+};
+var STANDARD_STRINGS = 391;
+function readCff(bytes2) {
+  try {
+    const at = (offset2) => {
+      if (!Number.isInteger(offset2) || offset2 < 0 || offset2 >= bytes2.length)
+        throw new RangeError("Outside the font");
+      return bytes2[offset2];
+    };
+    const u162 = (offset2) => at(offset2) << 8 | at(offset2 + 1);
+    if (at(0) !== 1) return void 0;
+    const names2 = readIndex(bytes2, at(2), at, u162);
+    const tops = readIndex(bytes2, names2.end, at, u162);
+    const strings = readIndex(bytes2, tops.end, at, u162);
+    const globalSubrs = readIndex(bytes2, strings.end, at, u162);
+    if (names2.items.length !== 1 || tops.items.length !== 1) return void 0;
+    const top = readDict(bytes2, ...tops.items[0], at);
+    const charStringsAt = top.get(OP.charStrings)?.[0];
+    if (charStringsAt === void 0) return void 0;
+    if ((top.get(OP.charstringType)?.[0] ?? 2) !== 2) return void 0;
+    const charStrings = readIndex(bytes2, charStringsAt, at, u162);
+    const glyphCount = charStrings.items.length;
+    if (glyphCount === 0) return void 0;
+    const [scale = 1e-3, skewX = 0, skewY = 0, scaleY = 1e-3] = top.get(OP.fontMatrix) ?? [];
+    if (skewX !== 0 || skewY !== 0 || scale !== scaleY || scale <= 0)
+      return void 0;
+    const unitsPerEm = Math.round(1 / scale);
+    if (unitsPerEm < 16 || unitsPerEm > 16384) return void 0;
+    const [xMin = 0, yMin = 0, xMax = 0, yMax = 0] = top.get(OP.fontBBox) ?? [];
+    const cid = top.has(OP.ros);
+    const [nameStart, nameEnd] = names2.items[0];
+    const name = latin1(
+      bytes2.subarray(nameStart, Math.min(nameEnd, nameStart + 127))
+    );
+    if (cid)
+      return {
+        name,
+        cid,
+        glyphNames: [],
+        widths: [],
+        bbox: [xMin, yMin, xMax, yMax],
+        unitsPerEm
+      };
+    const custom = /* @__PURE__ */ new Map();
+    const stringOf = (sid) => {
+      if (sid < ISO_ADOBE_NAMES.length) return ISO_ADOBE_NAMES[sid];
+      const item = strings.items[sid - STANDARD_STRINGS];
+      if (!item) return void 0;
+      if (!custom.has(sid))
+        custom.set(
+          sid,
+          // A glyph name is 63 characters at most.
+          item[1] - item[0] <= 63 ? latin1(bytes2.subarray(...item)) : void 0
+        );
+      return custom.get(sid);
+    };
+    const glyphNames = charsetNames(
+      top.get(OP.charset)?.[0] ?? 0,
+      glyphCount,
+      stringOf,
+      at,
+      u162
+    );
+    const [privateSize, privateAt] = top.get(OP.private) ?? [0, 0];
+    const privateDict = privateSize ? readDict(bytes2, privateAt, privateAt + privateSize, at) : /* @__PURE__ */ new Map();
+    const localAt = privateDict.get(OP.subrs)?.[0];
+    const metrics = {
+      bytes: bytes2,
+      defaultWidth: privateDict.get(OP.defaultWidthX)?.[0] ?? 0,
+      nominalWidth: privateDict.get(OP.nominalWidthX)?.[0] ?? 0,
+      global: globalSubrs.items,
+      local: localAt === void 0 ? [] : readIndex(bytes2, privateAt + localAt, at, u162).items
+    };
+    const widths = charStrings.items.map(
+      ([start, end]) => charstringWidth(metrics, start, end)
+    );
+    return {
+      name,
+      cid,
+      glyphNames,
+      widths,
+      bbox: [xMin, yMin, xMax, yMax],
+      unitsPerEm
+    };
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
+  }
+}
+function cffWithSafeName(bytes2) {
+  try {
+    const at = (offset2) => {
+      if (offset2 < 0 || offset2 >= bytes2.length)
+        throw new RangeError("Outside the font");
+      return bytes2[offset2];
+    };
+    const u162 = (offset2) => at(offset2) << 8 | at(offset2 + 1);
+    const names2 = readIndex(bytes2, at(2), at, u162);
+    const [start, end] = names2.items[0] ?? [0, 0];
+    if (names2.items.length !== 1 || end - start > 127) return void 0;
+    const safe = bytes2.slice();
+    for (let offset2 = start; offset2 < end; offset2 += 1) {
+      const byte = safe[offset2];
+      if (offset2 === start && byte === 0) continue;
+      if (byte < 33 || byte > 126 || UNSAFE_NAME_BYTES.has(byte))
+        safe[offset2] = 95;
+    }
+    return safe;
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
+  }
+}
+var UNSAFE_NAME_BYTES = new Set(
+  [..."[](){}<>/%"].map((character) => character.charCodeAt(0))
+);
+function readIndex(bytes2, start, at, u162) {
+  const count = u162(start);
+  if (count === 0) return { items: [], end: start + 2 };
+  const offSize = at(start + 2);
+  if (offSize < 1 || offSize > 4) throw new RangeError("Bad offset size");
+  const offset2 = (index) => {
+    let value = 0;
+    for (let byte = 0; byte < offSize; byte += 1)
+      value = value * 256 + at(start + 3 + index * offSize + byte);
+    return value;
+  };
+  if (offset2(0) !== 1) throw new RangeError("Bad INDEX");
+  const base = start + 2 + (count + 1) * offSize;
+  const items = [];
+  for (let index = 0; index < count; index += 1) {
+    const from = base + offset2(index);
+    const to = base + offset2(index + 1);
+    if (to < from || to > bytes2.length) throw new RangeError("Bad INDEX");
+    items.push([from, to]);
+  }
+  return { items, end: base + offset2(count) };
+}
+function readDict(bytes2, start, end, at) {
+  if (end > bytes2.length) throw new RangeError("DICT past the font");
+  const entries = /* @__PURE__ */ new Map();
+  let operands = [];
+  let offset2 = start;
+  while (offset2 < end) {
+    const byte = at(offset2);
+    if (byte <= 21) {
+      const operator = byte === 12 ? 1200 + at(offset2 + 1) : byte;
+      offset2 += byte === 12 ? 2 : 1;
+      entries.set(operator, operands);
+      operands = [];
+    } else if (byte === 28) {
+      operands.push(int16(at(offset2 + 1) << 8 | at(offset2 + 2)));
+      offset2 += 3;
+    } else if (byte === 29) {
+      operands.push(
+        at(offset2 + 1) << 24 | at(offset2 + 2) << 16 | at(offset2 + 3) << 8 | at(offset2 + 4)
+      );
+      offset2 += 5;
+    } else if (byte === 30) {
+      let text = "";
+      offset2 += 1;
+      for (let done = false; !done; offset2 += 1) {
+        const pair = at(offset2);
+        for (const nibble of [pair >> 4, pair & 15]) {
+          if (nibble === 15) {
+            done = true;
+            break;
+          }
+          text += REAL_NIBBLES[nibble] ?? "";
+        }
+      }
+      operands.push(Number.parseFloat(text));
+    } else if (byte >= 32 && byte <= 246) {
+      operands.push(byte - 139);
+      offset2 += 1;
+    } else if (byte >= 247 && byte <= 250) {
+      operands.push((byte - 247) * 256 + at(offset2 + 1) + 108);
+      offset2 += 2;
+    } else if (byte >= 251 && byte <= 254) {
+      operands.push(-(byte - 251) * 256 - at(offset2 + 1) - 108);
+      offset2 += 2;
+    } else throw new RangeError("Bad DICT byte");
+  }
+  return entries;
+}
+var REAL_NIBBLES = [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  ".",
+  "E",
+  "E-",
+  "",
+  "-"
+];
+function charsetNames(offset2, glyphCount, stringOf, at, u162) {
+  const names2 = [".notdef"];
+  if (offset2 === 0) {
+    for (let glyph = 1; glyph < glyphCount; glyph += 1)
+      names2.push(stringOf(glyph));
+    return names2;
+  }
+  if (offset2 <= 2) return [...names2, ...Array(glyphCount - 1)];
+  const format = at(offset2);
+  let cursor = offset2 + 1;
+  if (format === 0) {
+    for (let glyph = 1; glyph < glyphCount; glyph += 1, cursor += 2)
+      names2.push(stringOf(u162(cursor)));
+  } else if (format === 1 || format === 2) {
+    while (names2.length < glyphCount) {
+      const first = u162(cursor);
+      const left = format === 1 ? at(cursor + 2) : u162(cursor + 2);
+      cursor += format === 1 ? 3 : 4;
+      for (let step = 0; step <= left && names2.length < glyphCount; step += 1)
+        names2.push(stringOf(first + step));
+    }
+  } else throw new RangeError("Bad charset format");
+  return names2;
+}
+function charstringWidth(context, start, end) {
+  const { bytes: bytes2, defaultWidth, nominalWidth } = context;
+  const stack = [];
+  const walk = (from, to, depth) => {
+    let offset2 = from;
+    while (offset2 < to) {
+      const byte = bytes2[offset2];
+      const size = byte === 28 ? 3 : byte === 255 ? 5 : byte >= 247 && byte <= 254 ? 2 : 1;
+      if (offset2 + size > to) return defaultWidth;
+      if (byte === 28 || byte >= 32) {
+        const next = (step) => bytes2[offset2 + step];
+        stack.push(
+          byte === 28 ? int16(next(1) << 8 | next(2)) : byte <= 246 ? byte - 139 : byte <= 250 ? (byte - 247) * 256 + next(1) + 108 : byte <= 254 ? -(byte - 251) * 256 - next(1) - 108 : (next(1) << 24 | next(2) << 16 | next(3) << 8 | next(4)) / 65536
+        );
+        if (stack.length > 48) return defaultWidth;
+        offset2 += size;
+        continue;
+      }
+      offset2 += 1;
+      if (byte === 10 || byte === 29) {
+        const subrs = byte === 10 ? context.local : context.global;
+        const index = stack.pop();
+        const subr = index === void 0 ? void 0 : subrs[index + subrBias(subrs.length)];
+        if (!subr || depth >= 10) return defaultWidth;
+        const width = walk(subr[0], subr[1], depth + 1);
+        if (width !== void 0) return width;
+        continue;
+      }
+      if (byte === 11) return depth > 0 ? void 0 : defaultWidth;
+      const takes = STACK_CLEARING[byte];
+      if (takes === void 0) return defaultWidth;
+      const count = stack.length;
+      const widthFirst = takes === "pairs" ? count % 2 === 1 : takes === "endchar" ? count === 1 || count === 5 : count > takes;
+      return widthFirst ? stack[0] + nominalWidth : defaultWidth;
+    }
+    return depth > 0 ? void 0 : defaultWidth;
+  };
+  return walk(start, end, 0) ?? defaultWidth;
+}
+function subrBias(count) {
+  return count < 1240 ? 107 : count < 33900 ? 1131 : 32768;
+}
+var STACK_CLEARING = {
+  1: "pairs",
+  // hstem
+  3: "pairs",
+  // vstem
+  18: "pairs",
+  // hstemhm
+  23: "pairs",
+  // vstemhm
+  19: "pairs",
+  // hintmask, after implied vstems
+  20: "pairs",
+  // cntrmask
+  21: 2,
+  // rmoveto
+  22: 1,
+  // hmoveto
+  4: 1,
+  // vmoveto
+  14: "endchar"
+  // endchar: none, or four for an accented character
+};
+function int16(value) {
+  return value >= 32768 ? value - 65536 : value;
+}
+function latin1(bytes2) {
+  return String.fromCharCode(...bytes2);
+}
+
+// src/edit/pdf/engine/opentype.ts
+var SFNT_TRUETYPE = 65536;
+var SFNT_CFF = 1330926671;
+function cffOpenType(program, font, unicode) {
+  const safe = cffWithSafeName(program);
+  if (unicode.size === 0 || !safe) return void 0;
+  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(65535, Math.round(width)))
+  );
+  const codes = [...unicode.keys()].sort((a, b) => a - b);
+  const tables = /* @__PURE__ */ 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(20480), u16(glyphCount))],
+    ["name", names(postScriptName(font.name))],
+    ["post", post(em)]
+  ]);
+  return assemble(tables, SFNT_CFF);
+}
+function fontBox(box, em) {
+  const clamp = (value) => Math.max(-32768, Math.min(32767, 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];
+}
+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 void 0;
+  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);
+  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);
+}
+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;
+}
+function sfntTables(program) {
+  if (program.length < 12) return void 0;
+  const view = new DataView(
+    program.buffer,
+    program.byteOffset,
+    program.byteLength
+  );
+  const count = view.getUint16(4);
+  if (count === 0 || 12 + count * 16 > program.length) return void 0;
+  const tables = /* @__PURE__ */ 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 offset2 = view.getUint32(record + 8);
+    const length = view.getUint32(record + 12);
+    if (tables.has(tag) || offset2 + length > program.length) return void 0;
+    tables.set(tag, program.subarray(offset2, offset2 + length));
+  }
+  return tables;
+}
+function postScriptName(name) {
+  return name.replace(/^[A-Z]{6}\+/, "").replace(/[^\x21-\x7e]|[[\](){}<>/%]/g, "").slice(0, 63) || "Embedded";
+}
+function post(em) {
+  return bytes(
+    u32(196608),
+    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(65536),
+    u32(65536),
+    u32(0),
+    // checkSumAdjustment, set once the font is assembled
+    u32(1594834165),
+    u16(11),
+    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(65536),
+    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),
+    [87, 68, 79, 67],
+    // "WDOC"
+    u16(64),
+    // regular
+    u16(Math.min(codes[0] ?? 32, 65535)),
+    u16(Math.min(codes.at(-1) ?? 65535, 65535)),
+    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)
+  );
+}
+function cmap(unicode, codes) {
+  const basic = codes.filter((code) => code <= 65535);
+  const format4 = cmapFormat4(unicode, basic);
+  const format12 = !format4 || codes.length > basic.length ? cmapFormat12(unicode, codes) : void 0;
+  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 }] : []
+  ];
+  const unique = [...new Set(subtables.map((subtable) => subtable.data))];
+  const headerSize = 4 + subtables.length * 8;
+  const offsets = /* @__PURE__ */ new Map();
+  let offset2 = headerSize;
+  for (const data of unique) {
+    offsets.set(data, offset2);
+    offset2 += 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
+  ]);
+}
+function cmapFormat4(unicode, codes) {
+  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: 65535, end: 65535, glyph: 0 });
+  const count = segments.length;
+  if (16 + count * 8 > 65535) return void 0;
+  const searchRange = 2 * 2 ** Math.floor(Math.log2(count));
+  const delta = (segment) => segment.start === 65535 ? 1 : segment.glyph - segment.start & 65535;
+  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 offset2 = 0;
+  const entries = records.map(([id], index) => {
+    const entry = [
+      ...u16(3),
+      ...u16(1),
+      ...u16(1033),
+      ...u16(id),
+      ...u16(strings[index].length),
+      ...u16(offset2)
+    ];
+    offset2 += strings[index].length;
+    return entry;
+  });
+  return bytes(
+    u16(0),
+    u16(records.length),
+    u16(6 + records.length * 12),
+    entries.flat(),
+    strings.flat()
+  );
+}
+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 offset2 = headerSize;
+  const placed = tags.map((tag) => {
+    const data = tables.get(tag);
+    const at = offset2;
+    offset2 += data.length + 3 & ~3;
+    return { tag, data, at };
+  });
+  const font = new Uint8Array(offset2);
+  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 head2 = placed.find((table) => table.tag === "head");
+  const adjustment = 2981146554 - checksum(font) >>> 0;
+  font.set(u32(adjustment), head2.at + 8);
+  return font;
+}
+function checksum(data) {
+  let sum = 0;
+  for (let offset2 = 0; offset2 < data.length; offset2 += 4)
+    sum = sum + ((data[offset2] ?? 0) << 24 | (data[offset2 + 1] ?? 0) << 16 | (data[offset2 + 2] ?? 0) << 8 | (data[offset2 + 3] ?? 0)) >>> 0;
+  return sum;
+}
+function u16(value) {
+  return [value >> 8 & 255, value & 255];
+}
+function i16(value) {
+  return u16(value < 0 ? value + 65536 : value);
+}
+function u32(value) {
+  return [
+    value >>> 24 & 255,
+    value >>> 16 & 255,
+    value >>> 8 & 255,
+    value & 255
+  ];
+}
+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 offset2 = 0;
+  for (const part of parts) {
+    out.set(part, offset2);
+    offset2 += part.length;
+  }
+  return out;
+}
+
+// src/edit/pdf/engine/text-font.ts
+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, bytes2) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes2)
+  );
+  if (!lib.FPDFFont_GetIsEmbedded(font))
+    return { key: `name:${baseName}`, family, missing: "not-embedded" };
+  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 data2 = completeSfnt(program, baseName);
+    return data2 ? { face: { data: data2, format: truetype ? "truetype" : "opentype" } } : { missing: "unreadable" };
+  }
+  if (tag.startsWith("%!") || program[0] === 128) return { missing: "type1" };
+  const cff = readCff(program);
+  if (!cff) return { missing: "unreadable" };
+  if (cff.cid) return { missing: "cid-keyed" };
+  const unicode = /* @__PURE__ */ new Map();
+  cff.glyphNames.forEach((name, glyph) => {
+    const code = glyphUnicode(name);
+    if (code !== void 0 && !unicode.has(code)) unicode.set(code, glyph);
+  });
+  const data = cffOpenType(program, cff, unicode);
+  return data ? { face: { data, format: "opentype" } } : { missing: "no-unicode" };
+}
+function fontProgram(pdfium, font) {
+  const { lib } = pdfium;
+  const size = pdfium.readNumbers(
+    1,
+    "i32",
+    ([out2]) => lib.FPDFFont_GetFontData(font, 0, 0, out2)
+  )?.[0];
+  if (!size) return void 0;
+  const buffer = pdfium.malloc(size);
+  const out = pdfium.malloc(4);
+  try {
+    return lib.FPDFFont_GetFontData(font, buffer, size, out) ? pdfium.readBytes(buffer, size) : void 0;
+  } finally {
+    pdfium.free(out);
+    pdfium.free(buffer);
+  }
+}
+function fnv1a(bytes2) {
+  let hash = 2166136261;
+  for (const byte of bytes2) hash = Math.imul(hash ^ byte, 16777619);
+  return hash >>> 0;
+}
+
 // src/edit/pdf/engine/text-layout.ts
 function layoutText(input) {
   const step = input.fontSize * input.lineHeight;
@@ -7407,7 +8326,7 @@ function drawTable(context, pageIndex, spec, insertAt) {
   );
   const geometry = context.geometry(pageIndex);
   const overflow = spec.at.y + layout.height > displayedSize(geometry).height + 1e-3;
-  const head = JSON.stringify(spec);
+  const head2 = JSON.stringify(spec);
   const memberMark = { kind: "table", id: spec.id };
   const member = JSON.stringify(memberMark);
   const at = (x, y) => pageToUser(geometry, x, y);
@@ -7446,7 +8365,7 @@ function drawTable(context, pageIndex, spec, insertAt) {
       const [r2, g2, b2] = parseColor(style.headerFill);
       lib.FPDFPageObj_SetFillColor(fill, r2, g2, b2, 255);
       lib.FPDFPath_SetDrawMode(fill, FILL_ALTERNATE, false);
-      place(fill, OBJECT_PATH, spec, head);
+      place(fill, OBJECT_PATH, spec, head2);
     }
     const frame = [
       at(spec.at.x, spec.at.y),
@@ -7474,7 +8393,7 @@ function drawTable(context, pageIndex, spec, insertAt) {
     lib.FPDFPageObj_SetStrokeColor(grid, r, g, b, 255);
     lib.FPDFPageObj_SetStrokeWidth(grid, style.borderWidth);
     lib.FPDFPath_SetDrawMode(grid, FILL_NONE, true);
-    place(grid, OBJECT_PATH, spec, head);
+    place(grid, OBJECT_PATH, spec, head2);
     layout.rows.forEach((row) => {
       row.cells.forEach((lines, columnIndex) => {
         const column = layout.columns[columnIndex];
@@ -8129,7 +9048,7 @@ function canKeepFont(context, target, text) {
     const font = lib.FPDFTextObj_GetFont(object);
     if (!lib.FPDFFont_GetIsEmbedded(font)) {
       const base = pdfium.readUtf8String(
-        (buffer, bytes) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes)
+        (buffer, bytes2) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes2)
       );
       return isStandardFamily(base.split(/[-,]/)[0] ?? "") && firstNonWinAnsi(text) === void 0;
     }
@@ -8179,11 +9098,11 @@ function replaceInPlace(context, target, text) {
     const textPage = lib.FPDFText_LoadPage(page);
     try {
       return pdfium.readWideString(
-        (buffer, bytes) => lib.FPDFTextObj_GetText(
+        (buffer, bytes2) => lib.FPDFTextObj_GetText(
           lib.FPDFPage_GetObject(page, index),
           textPage,
           buffer,
-          bytes
+          bytes2
         )
       );
     } finally {
@@ -8221,7 +9140,7 @@ function splitAround(context, target, before, middle, after) {
       1,
       "float",
       ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer)
-    )?.[0] ?? style.fontSize;
+    )?.[0] ?? style.fontSize / textScale(matrix);
     const [a, b, c, d, e, f] = matrix;
     const [r, g, bl] = parseColor(style.color);
     const parts = [
@@ -8266,7 +9185,7 @@ function splitAround(context, target, before, middle, after) {
     try {
       objects.forEach((object, at) => {
         const read2 = pdfium.readWideString(
-          (buffer, bytes) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes)
+          (buffer, bytes2) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes2)
         );
         if (read2.trimEnd() !== parts[at].text.trimEnd()) faithful = false;
       });
@@ -8328,7 +9247,7 @@ function replaceWithFallback(context, target, text) {
       1,
       "float",
       ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer)
-    )?.[0] ?? style.fontSize;
+    )?.[0] ?? style.fontSize / textScale(matrix);
     const object = lib.FPDFPageObj_CreateTextObj(
       context.document,
       font.handle,
@@ -8371,7 +9290,7 @@ function resize(context, target, fontSize) {
     let text;
     try {
       text = pdfium.readWideString(
-        (buffer, bytes) => lib.FPDFTextObj_GetText(old, textPage, buffer, bytes)
+        (buffer, bytes2) => lib.FPDFTextObj_GetText(old, textPage, buffer, bytes2)
       );
     } finally {
       lib.FPDFText_ClosePage(textPage);
@@ -8389,7 +9308,7 @@ function resize(context, target, fontSize) {
     const object = lib.FPDFPageObj_CreateTextObj(
       context.document,
       lib.FPDFTextObj_GetFont(old),
-      fontSize
+      fontSize / textScale(matrix)
     );
     setText(pdfium, object, text);
     lib.FPDFPageObj_SetFillColor(
@@ -8663,11 +9582,14 @@ var rotatePage = {
   validate(operation2, context, issue) {
     if (operation2.pageIndex >= context.pageCount)
       issue("/pageIndex", "unknown-target", `No page ${operation2.pageIndex}`);
+    if (operation2.rotation === void 0 === (operation2.by === void 0))
+      issue("", "one-of", "Give exactly one of `rotation` and `by`");
   },
   apply(operation2, context) {
     const { lib } = context.pdfium;
     context.withPage(operation2.pageIndex, (page) => {
-      lib.FPDFPage_SetRotation(page, operation2.rotation / 90);
+      const quarters = operation2.by !== void 0 ? (lib.FPDFPage_GetRotation(page) + operation2.by / 90) % 4 : operation2.rotation / 90;
+      lib.FPDFPage_SetRotation(page, quarters);
     });
     context.invalidatePage(operation2.pageIndex);
     return {
@@ -8888,8 +9810,8 @@ var PdfCompactionError = class extends ViewerError {
     });
   }
 };
-function compactPdf(bytes) {
-  const { objects, trailer, trailerReferences, headerEnd } = parseFile(bytes);
+function compactPdf(bytes2) {
+  const { objects, trailer, trailerReferences, headerEnd } = parseFile(bytes2);
   const byNumber = new Map(objects.map((object) => [object.number, object]));
   const reachable = /* @__PURE__ */ new Set();
   const queue = [...trailerReferences];
@@ -8902,12 +9824,12 @@ function compactPdf(bytes) {
     queue.push(...object.references);
   }
   const kept = objects.filter((object) => reachable.has(object.number));
-  const parts = [bytes.subarray(0, headerEnd)];
+  const parts = [bytes2.subarray(0, headerEnd)];
   const offsets = /* @__PURE__ */ new Map();
   let position = headerEnd;
   for (const object of kept) {
     offsets.set(object.number, position);
-    const slice = bytes.subarray(object.start, object.end);
+    const slice = bytes2.subarray(object.start, object.end);
     parts.push(slice, NEWLINE);
     position += slice.byteLength + 1;
   }
@@ -8933,10 +9855,10 @@ ${position}
 %%EOF
 `)
   );
-  return concat(parts);
+  return concat2(parts);
 }
-function parseFile(bytes) {
-  const lexer = new Lexer(bytes);
+function parseFile(bytes2) {
+  const lexer = new Lexer(bytes2);
   const objects = [];
   let trailer;
   let trailerReferences = [];
@@ -8956,7 +9878,7 @@ function parseFile(bytes) {
         throw new PdfCompactionError("an object header is malformed");
       const object = parseObject(
         lexer,
-        bytes,
+        bytes2,
         first.value,
         second.value,
         first.start
@@ -8971,7 +9893,7 @@ function parseFile(bytes) {
       const dictionaryStart = lexer.skipWhitespace();
       const references = [];
       const dictionaryEnd = skipValue(lexer, references);
-      trailer = latin1(bytes.subarray(dictionaryStart, dictionaryEnd));
+      trailer = latin12(bytes2.subarray(dictionaryStart, dictionaryEnd));
       trailerReferences = references;
       continue;
     }
@@ -8993,7 +9915,7 @@ function parseFile(bytes) {
     throw new PdfCompactionError("the file has no objects");
   return { objects, trailer, trailerReferences, headerEnd };
 }
-function parseObject(lexer, bytes, number, generation, start) {
+function parseObject(lexer, bytes2, number, generation, start) {
   const references = [];
   let integer;
   let lengthValue;
@@ -9014,7 +9936,7 @@ function parseObject(lexer, bytes, number, generation, start) {
     const dictionaryStart = lexer.position;
     const dictionaryEnd = skipValue(lexer, references);
     if (first.kind === "delimiter" && first.value === "<<") {
-      const length = findLength(bytes, dictionaryStart, dictionaryEnd);
+      const length = findLength(bytes2, dictionaryStart, dictionaryEnd);
       lengthValue = length?.value;
       lengthReference = length?.reference;
     }
@@ -9022,16 +9944,16 @@ function parseObject(lexer, bytes, number, generation, start) {
   let next = lexer.next();
   if (next.kind === "keyword" && next.value === "stream") {
     let dataStart = next.end;
-    if (bytes[dataStart] === CR) dataStart += 1;
-    if (bytes[dataStart] === LF) dataStart += 1;
+    if (bytes2[dataStart] === CR) dataStart += 1;
+    if (bytes2[dataStart] === LF) dataStart += 1;
     let dataEnd;
     if (lengthValue !== void 0) dataEnd = dataStart + lengthValue;
     else if (lengthReference !== void 0) {
       const known = lexer.integerObjects.get(lengthReference);
       if (known !== void 0) dataEnd = dataStart + known;
     }
-    if (dataEnd === void 0 || dataEnd > bytes.length || !followedByEndstream(bytes, dataEnd)) {
-      dataEnd = findEndstream(bytes, dataStart);
+    if (dataEnd === void 0 || dataEnd > bytes2.length || !followedByEndstream(bytes2, dataEnd)) {
+      dataEnd = findEndstream(bytes2, dataStart);
       if (dataEnd === void 0)
         throw new PdfCompactionError(`object ${number} has no endstream`);
     }
@@ -9086,8 +10008,8 @@ function skipValue(lexer, references) {
   } while (depth > 0);
   return end;
 }
-function findLength(bytes, start, end) {
-  const lexer = new Lexer(bytes.subarray(start, end));
+function findLength(bytes2, start, end) {
+  const lexer = new Lexer(bytes2.subarray(start, end));
   for (; ; ) {
     const token = lexer.next();
     if (token.kind === "end") return void 0;
@@ -9103,20 +10025,20 @@ function findLength(bytes, start, end) {
     return { value: value.value };
   }
 }
-function followedByEndstream(bytes, at) {
+function followedByEndstream(bytes2, at) {
   let index = at;
-  while (index < bytes.length && isWhitespace(bytes[index])) index += 1;
-  return matchesAscii(bytes, index, "endstream");
+  while (index < bytes2.length && isWhitespace(bytes2[index])) index += 1;
+  return matchesAscii(bytes2, index, "endstream");
 }
-function findEndstream(bytes, from) {
-  for (let index = from; index <= bytes.length - 9; index += 1) {
-    if (bytes[index] !== 101 || !matchesAscii(bytes, index, "endstream"))
+function findEndstream(bytes2, from) {
+  for (let index = from; index <= bytes2.length - 9; index += 1) {
+    if (bytes2[index] !== 101 || !matchesAscii(bytes2, index, "endstream"))
       continue;
     const after = index + 9;
-    if (after < bytes.length && !isWhitespace(bytes[after])) continue;
+    if (after < bytes2.length && !isWhitespace(bytes2[after])) continue;
     let end = index;
-    if (end > from && bytes[end - 1] === LF) end -= 1;
-    if (end > from && bytes[end - 1] === CR) end -= 1;
+    if (end > from && bytes2[end - 1] === LF) end -= 1;
+    if (end > from && bytes2[end - 1] === CR) end -= 1;
     return end;
   }
   return void 0;
@@ -9127,8 +10049,8 @@ var Lexer = class {
   #lastName = "";
   /** Objects whose value is a bare integer, as seen so far: indirect lengths. */
   integerObjects = /* @__PURE__ */ new Map();
-  constructor(bytes) {
-    this.#bytes = bytes;
+  constructor(bytes2) {
+    this.#bytes = bytes2;
   }
   get position() {
     return this.#position;
@@ -9147,35 +10069,35 @@ var Lexer = class {
   }
   /** Skips whitespace and comments; returns where the next token starts. */
   skipWhitespace() {
-    const bytes = this.#bytes;
+    const bytes2 = this.#bytes;
     for (; ; ) {
-      while (this.#position < bytes.length && isWhitespace(bytes[this.#position]))
+      while (this.#position < bytes2.length && isWhitespace(bytes2[this.#position]))
         this.#position += 1;
-      if (bytes[this.#position] !== 37) return this.#position;
-      while (this.#position < bytes.length && bytes[this.#position] !== LF && bytes[this.#position] !== CR)
+      if (bytes2[this.#position] !== 37) return this.#position;
+      while (this.#position < bytes2.length && bytes2[this.#position] !== LF && bytes2[this.#position] !== CR)
         this.#position += 1;
     }
   }
   next() {
-    const bytes = this.#bytes;
+    const bytes2 = this.#bytes;
     const start = this.skipWhitespace();
-    if (start >= bytes.length) return { kind: "end", start, end: start };
-    const byte = bytes[start];
+    if (start >= bytes2.length) return { kind: "end", start, end: start };
+    const byte = bytes2[start];
     if (byte === 40) {
       let depth = 0;
       let index2 = start;
-      for (; index2 < bytes.length; index2 += 1) {
-        const current = bytes[index2];
+      for (; index2 < bytes2.length; index2 += 1) {
+        const current = bytes2[index2];
         if (current === 92)
           index2 += 1;
         else if (current === 40) depth += 1;
         else if (current === 41 && --depth === 0) break;
       }
-      this.#position = Math.min(index2 + 1, bytes.length);
+      this.#position = Math.min(index2 + 1, bytes2.length);
       return { kind: "string", start, end: this.#position };
     }
     if (byte === 60) {
-      if (bytes[start + 1] === 60) {
+      if (bytes2[start + 1] === 60) {
         this.#position = start + 2;
         return {
           kind: "delimiter",
@@ -9185,11 +10107,11 @@ var Lexer = class {
         };
       }
       let index2 = start + 1;
-      while (index2 < bytes.length && bytes[index2] !== 62) index2 += 1;
-      this.#position = Math.min(index2 + 1, bytes.length);
+      while (index2 < bytes2.length && bytes2[index2] !== 62) index2 += 1;
+      this.#position = Math.min(index2 + 1, bytes2.length);
       return { kind: "string", start, end: this.#position };
     }
-    if (byte === 62 && bytes[start + 1] === 62) {
+    if (byte === 62 && bytes2[start + 1] === 62) {
       this.#position = start + 2;
       return {
         kind: "delimiter",
@@ -9209,16 +10131,16 @@ var Lexer = class {
     }
     if (byte === 47) {
       let index2 = start + 1;
-      while (index2 < bytes.length && isRegular(bytes[index2])) index2 += 1;
+      while (index2 < bytes2.length && isRegular(bytes2[index2])) index2 += 1;
       this.#position = index2;
-      this.#lastName = latin1(bytes.subarray(start + 1, index2));
+      this.#lastName = latin12(bytes2.subarray(start + 1, index2));
       return { kind: "name", start, end: index2 };
     }
     let index = start;
-    while (index < bytes.length && isRegular(bytes[index])) index += 1;
+    while (index < bytes2.length && isRegular(bytes2[index])) index += 1;
     if (index === start) index += 1;
     this.#position = index;
-    const text = latin1(bytes.subarray(start, index));
+    const text = latin12(bytes2.subarray(start, index));
     const value = Number(text);
     if (/^[+-]?(\d+\.?\d*|\.\d+)$/.test(text) && Number.isFinite(value))
       return { kind: "number", value, start, end: index };
@@ -9235,22 +10157,22 @@ function isWhitespace(byte) {
 function isRegular(byte) {
   return !isWhitespace(byte) && byte !== 40 && byte !== 41 && byte !== 60 && byte !== 62 && byte !== 91 && byte !== 93 && byte !== 123 && byte !== 125 && byte !== 47 && byte !== 37;
 }
-function matchesAscii(bytes, at, text) {
-  if (at + text.length > bytes.length) return false;
+function matchesAscii(bytes2, at, text) {
+  if (at + text.length > bytes2.length) return false;
   for (let index = 0; index < text.length; index += 1)
-    if (bytes[at + index] !== text.charCodeAt(index)) return false;
+    if (bytes2[at + index] !== text.charCodeAt(index)) return false;
   return true;
 }
-function latin1(bytes) {
+function latin12(bytes2) {
   let text = "";
-  for (let offset2 = 0; offset2 < bytes.length; offset2 += 32768)
-    text += String.fromCharCode(...bytes.subarray(offset2, offset2 + 32768));
+  for (let offset2 = 0; offset2 < bytes2.length; offset2 += 32768)
+    text += String.fromCharCode(...bytes2.subarray(offset2, offset2 + 32768));
   return text;
 }
 function ascii(text) {
   return Uint8Array.from(text, (character) => character.charCodeAt(0) & 255);
 }
-function concat(parts) {
+function concat2(parts) {
   const out = new Uint8Array(
     parts.reduce((total, part) => total + part.byteLength, 0)
   );
@@ -9276,10 +10198,10 @@ var AssetStore = class {
   has(id) {
     return this.#bytes.has(id);
   }
-  set(id, bytes) {
+  set(id, bytes2) {
     if (this.#bytes.has(id)) return;
-    this.#bytes.set(id, bytes);
-    this.#total += bytes.byteLength;
+    this.#bytes.set(id, bytes2);
+    this.#total += bytes2.byteLength;
   }
   /** Bytes held, for limits. */
   get byteLength() {
@@ -9289,8 +10211,8 @@ var AssetStore = class {
 function resolveBinary(data, assets) {
   if (data instanceof Uint8Array) return data;
   if (isAssetReference(data)) {
-    const bytes = assets.get(data);
-    if (!bytes)
+    const bytes2 = assets.get(data);
+    if (!bytes2)
       throw new ViewerError("invalid-operation", `Unknown asset ${data}`, {
         details: {
           issues: [
@@ -9303,7 +10225,7 @@ function resolveBinary(data, assets) {
           ]
         }
       });
-    return bytes;
+    return bytes2;
   }
   return Uint8Array.from(atob(data), (character) => character.charCodeAt(0));
 }
@@ -9318,17 +10240,17 @@ var ImageCache = class {
       const operation2 = raw;
       if (operation2.op !== "insertImage" || operation2.mimeType !== "image/png")
         continue;
-      const bytes = resolveBinary(operation2.data, assets);
-      if (!isPng(bytes)) continue;
-      const key = contentKey(bytes);
+      const bytes2 = resolveBinary(operation2.data, assets);
+      if (!isPng(bytes2)) continue;
+      const key = contentKey(bytes2);
       if (this.#decoded.has(key)) continue;
-      this.#decoded.set(key, await decode(bytes, "image/png"));
+      this.#decoded.set(key, await decode(bytes2, "image/png"));
       while (this.#decoded.size > 8)
         this.#decoded.delete(this.#decoded.keys().next().value);
     }
   }
-  get(bytes) {
-    return this.#decoded.get(contentKey(bytes));
+  get(bytes2) {
+    return this.#decoded.get(contentKey(bytes2));
   }
 };
 var insertImage = {
@@ -9338,19 +10260,19 @@ var insertImage = {
       return;
     }
     validateRect(operation2.rect, context.geometry(operation2.pageIndex), issue);
-    const bytes = resolveBinary(operation2.data, context.assets);
-    if (bytes.byteLength > context.limits.maxInputBytes)
+    const bytes2 = resolveBinary(operation2.data, context.assets);
+    if (bytes2.byteLength > context.limits.maxInputBytes)
       throw new ViewerError(
         "resource-limit",
         "Image data exceeds maxInputBytes",
         {
           details: {
-            bytes: bytes.byteLength,
+            bytes: bytes2.byteLength,
             limit: context.limits.maxInputBytes
           }
         }
       );
-    const size = operation2.mimeType === "image/png" ? pngSize(bytes) : jpegSize(bytes);
+    const size = operation2.mimeType === "image/png" ? pngSize(bytes2) : jpegSize(bytes2);
     if (!size) {
       issue(
         "/data",
@@ -9366,19 +10288,19 @@ var insertImage = {
         "Decoded image exceeds maxDecodedPixels",
         { details: { pixels, limit: context.limits.maxDecodedPixels } }
       );
-    if (operation2.mimeType === "image/png" && !context.images.get(bytes))
+    if (operation2.mimeType === "image/png" && !context.images.get(bytes2))
       issue("/data", "invalid-data", "The PNG could not be decoded");
   },
   apply(operation2, context) {
     const { pdfium } = context;
     const { lib } = pdfium;
-    const bytes = resolveBinary(operation2.data, context.assets);
+    const bytes2 = resolveBinary(operation2.data, context.assets);
     const id = context.newId(operation2.pageIndex);
     const geometry = context.geometry(operation2.pageIndex);
     const image = lib.FPDFPageObj_NewImageObj(context.document);
     if (operation2.mimeType === "image/jpeg") {
       const loaded = pdfium.withFileAccess(
-        bytes,
+        bytes2,
         (fileAccess) => lib.FPDFImageObj_LoadJpegFileInline(0, 0, image, fileAccess)
       );
       if (!loaded)
@@ -9386,7 +10308,7 @@ var insertImage = {
           details: { stage: "apply" }
         });
     } else {
-      const decoded = context.images.get(bytes);
+      const decoded = context.images.get(bytes2);
       setBitmap(context.pdfium, image, decoded);
     }
     const { rect } = operation2;
@@ -9460,24 +10382,24 @@ function setBitmap(pdfium, image, decoded) {
     pdfium.free(buffer);
   }
 }
-function isPng(bytes) {
-  return bytes.length > 24 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+function isPng(bytes2) {
+  return bytes2.length > 24 && bytes2[0] === 137 && bytes2[1] === 80 && bytes2[2] === 78 && bytes2[3] === 71;
 }
-function pngSize(bytes) {
-  if (!isPng(bytes)) return void 0;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+function pngSize(bytes2) {
+  if (!isPng(bytes2)) return void 0;
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
   const width = view.getUint32(16);
   const height = view.getUint32(20);
   return width > 0 && height > 0 ? { width, height } : void 0;
 }
-function jpegSize(bytes) {
-  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216)
+function jpegSize(bytes2) {
+  if (bytes2.length < 4 || bytes2[0] !== 255 || bytes2[1] !== 216)
     return void 0;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
   let offset2 = 2;
-  while (offset2 + 9 < bytes.length) {
-    if (bytes[offset2] !== 255) return void 0;
-    const marker = bytes[offset2 + 1];
+  while (offset2 + 9 < bytes2.length) {
+    if (bytes2[offset2] !== 255) return void 0;
+    const marker = bytes2[offset2 + 1];
     if (marker === 216 || marker >= 208 && marker <= 215 || marker === 1) {
       offset2 += 2;
       continue;
@@ -9493,10 +10415,10 @@ function jpegSize(bytes) {
   }
   return void 0;
 }
-function contentKey(bytes) {
+function contentKey(bytes2) {
   let hash = 2166136261;
-  for (const byte of bytes) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
-  return `${bytes.byteLength}:${hash.toString(16)}`;
+  for (const byte of bytes2) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+  return `${bytes2.byteLength}:${hash.toString(16)}`;
 }
 
 // src/limits.ts
@@ -9542,12 +10464,12 @@ function detectFeatures(pdfium, document2, original) {
   if (containsAscii(original, "pdfaid:part")) features.push("pdfa");
   return features;
 }
-function containsAscii(bytes, needle) {
+function containsAscii(bytes2, needle) {
   const first = needle.charCodeAt(0);
-  const limit = bytes.length - needle.length;
-  for (let at = bytes.indexOf(first); at >= 0 && at <= limit; at = bytes.indexOf(first, at + 1)) {
+  const limit = bytes2.length - needle.length;
+  for (let at = bytes2.indexOf(first); at >= 0 && at <= limit; at = bytes2.indexOf(first, at + 1)) {
     let index = 1;
-    while (index < needle.length && bytes[at + index] === needle.charCodeAt(index))
+    while (index < needle.length && bytes2[at + index] === needle.charCodeAt(index))
       index += 1;
     if (index === needle.length) return true;
   }
@@ -9612,6 +10534,8 @@ var PdfEditDocument = class {
   #measurer;
   #pages;
   #batches = 0;
+  /** Browser faces of the document's fonts, by font program; see `textFont`. */
+  #faces = /* @__PURE__ */ new Map();
   constructor(pdfium, original, fonts = new FontLibrary(async () => {
     throw new Error("No font source is configured");
   }), limits = defaultResourceLimits, assets = new AssetStore(), compact = compactPdf) {
@@ -9887,6 +10811,18 @@ var PdfEditDocument = class {
       return element ? layoutOf(this.#pdfium, scan, element) : void 0;
     });
   }
+  /** The browser face of the font a text or text box element is drawn in, see `TextFont`. */
+  textFont(elementId) {
+    const location = this.#locate(elementId);
+    const element = location && this.getElement(elementId);
+    if (!element || element.kind !== "text" && element.kind !== "textBox")
+      return void 0;
+    const { lib } = this.#pdfium;
+    return this.#withPage(location.pageIndex, (page) => {
+      const object = location.indexes.map((index) => lib.FPDFPage_GetObject(page, index)).find((entry) => lib.FPDFPageObj_GetType(entry) === OBJECT_TEXT);
+      return object === void 0 ? void 0 : { elementId, ...textFaceOf(this.#pdfium, object, this.#faces) };
+    });
+  }
   /** The layouts of every text element on a page, with the page's displayed size. */
   pageLayout(pageIndex) {
     if (pageIndex < 0 || pageIndex >= this.#pages.length) return void 0;
@@ -10043,8 +10979,11 @@ var PdfEditDocument = class {
       },
       // Ids name the state the batch leads to, the operation and the item,
       // so replaying the history reproduces them and an undone id is never
-      // handed out again.
-      newId: (pageIndex, suffix = "") => `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}${suffix}`,
+      // handed out again. A file saved by an earlier session carries the ids
+      // that session numbered from 1 as well, so one already on the page
+      // gets the first free `~n` instead (ACTION-886); the saved objects are
+      // part of the base, so a replay meets them and picks the same id.
+      newId: (pageIndex, suffix = "") => `${this.#unusedId(pageIndex, `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}`)}${suffix}`,
       withPage: (pageIndex, use) => this.#writePage(pageIndex, use),
       appendObjects: (pageIndex, records) => {
         const page = this.#pages[pageIndex];
@@ -10191,8 +11130,8 @@ var PdfEditDocument = class {
       const textPage = lib.FPDFText_LoadPage(page);
       try {
         for (const [id, indexes] of members) {
-          const head = heads.get(id);
-          if (!head || !markIsFresh(this.#pdfium, page, textPage, geometry, head, indexes))
+          const head2 = heads.get(id);
+          if (!head2 || !markIsFresh(this.#pdfium, page, textPage, geometry, head2, indexes))
             stale.add(id);
         }
       } finally {
@@ -10200,10 +11139,48 @@ var PdfEditDocument = class {
       }
     }
     record.objects = objects.map(
-      (object, index) => object.mark && stale.has(object.id) ? { id: `${record.key}:o${index}`, type: object.type } : object
+      (object, index) => object.mark && stale.has(object.id) ? {
+        id: `${record.key}:o${index}`,
+        type: object.type,
+        staleMarkId: object.id
+      } : object
     );
     return record.objects;
   }
+  /**
+   * `id`, or its first free `~n` when an object saved by an earlier session
+   * has it already. Only ids a session numbered (`<key>:n…`) can collide, so
+   * only those are gathered; the objects are read without the page's text.
+   */
+  #unusedId(pageIndex, id) {
+    const record = this.#pages[pageIndex];
+    const objects = record.objects ?? this.#loadObjects(pageIndex);
+    const numbered = `${record.key}:n`;
+    const taken = /* @__PURE__ */ new Set();
+    for (const object of objects) {
+      if (object.id.startsWith(numbered)) taken.add(object.id);
+      if (object.staleMarkId?.startsWith(numbered))
+        taken.add(object.staleMarkId);
+    }
+    if (!taken.has(id)) return id;
+    let suffix = 1;
+    while (taken.has(`${id}~${suffix}`)) suffix += 1;
+    return `${id}~${suffix}`;
+  }
+  /** A page's objects, loading the page alone when they are not known yet. */
+  #loadObjects(pageIndex) {
+    const { lib } = this.#pdfium;
+    const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+    if (!page)
+      throw new ViewerError("render-failed", "PDFium could not load the page", {
+        details: { pageIndex }
+      });
+    try {
+      return this.#objectsOf(pageIndex, page);
+    } finally {
+      lib.FPDF_ClosePage(page);
+    }
+  }
   /** Marks from other sessions keep their id only if it cannot collide with ours. */
   #ownMark(mark, pageKey) {
     return mark.id.startsWith(`${pageKey}:`) ? mark : { ...mark, id: `${pageKey}:${mark.id}` };
@@ -10272,12 +11249,12 @@ var PdfEditDocument = class {
     const { lib } = this.#pdfium;
     const count = lib.FPDFText_CountChars(textPage);
     if (count === 0) return;
-    const bytes = (count + 1) * 2;
-    const buffer = this.#pdfium.malloc(bytes);
+    const bytes2 = (count + 1) * 2;
+    const buffer = this.#pdfium.malloc(bytes2);
     let text;
     try {
       lib.FPDFText_GetText(textPage, 0, count, buffer);
-      text = this.#pdfium.readWideStringAt(buffer, bytes);
+      text = this.#pdfium.readWideStringAt(buffer, bytes2);
     } finally {
       this.#pdfium.free(buffer);
     }
@@ -10318,7 +11295,7 @@ var PdfEditDocument = class {
       }
       if (!bases.has(object)) {
         const own = this.#pdfium.readWideString(
-          (buffer, bytes) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes)
+          (buffer, bytes2) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes2)
         );
         const whole = elementTexts.get(elementId) ?? "";
         const from = cursors.get(elementId) ?? 0;
@@ -10450,11 +11427,11 @@ function createPdfEditHandler(host) {
       case "edit-materialize": {
         const { purpose, options } = payload ?? {};
         const mode = options?.mode;
-        const { bytes, warnings } = engine().materializeDocument(
+        const { bytes: bytes2, warnings } = engine().materializeDocument(
           purpose ?? "show",
           mode === "full" || mode === "incremental" ? mode : void 0
         );
-        return { data: bytes.buffer, warnings };
+        return { data: bytes2.buffer, warnings };
       }
       case "edit-restore": {
         const { batches, base } = payload;
@@ -10495,6 +11472,8 @@ 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
@@ -10546,9 +11525,9 @@ var Pdfium = class _Pdfium {
     if (pointer) this.#runtime.wasmExports.free(pointer);
   }
   /** Copies bytes into the WASM heap; the caller frees the pointer. */
-  writeBytes(bytes) {
-    const pointer = this.malloc(bytes.byteLength);
-    this.#runtime.HEAPU8.set(bytes, pointer);
+  writeBytes(bytes2) {
+    const pointer = this.malloc(bytes2.byteLength);
+    this.#runtime.HEAPU8.set(bytes2, pointer);
     return pointer;
   }
   readBytes(pointer, length) {
@@ -10556,26 +11535,26 @@ var Pdfium = class _Pdfium {
   }
   /** Writes a NUL-terminated UTF-16LE string; the caller frees the pointer. */
   writeWideString(text) {
-    const bytes = (text.length + 1) * 2;
-    const pointer = this.malloc(bytes);
-    this.#runtime.stringToUTF16(text, pointer, bytes);
+    const bytes2 = (text.length + 1) * 2;
+    const pointer = this.malloc(bytes2);
+    this.#runtime.stringToUTF16(text, pointer, bytes2);
     return pointer;
   }
   /** Reads a NUL-terminated UTF-16LE string of at most `bytes` bytes. */
-  readWideStringAt(pointer, bytes) {
-    return this.#runtime.UTF16ToString(pointer, bytes);
+  readWideStringAt(pointer, bytes2) {
+    return this.#runtime.UTF16ToString(pointer, bytes2);
   }
   /**
    * Reads a UTF-16LE string from an API that returns the byte size it needs
    * when called with an empty buffer.
    */
   readWideString(read2) {
-    const bytes = read2(0, 0);
-    if (bytes <= 2) return "";
-    const pointer = this.malloc(bytes);
+    const bytes2 = read2(0, 0);
+    if (bytes2 <= 2) return "";
+    const pointer = this.malloc(bytes2);
     try {
-      read2(pointer, bytes);
-      return this.#runtime.UTF16ToString(pointer, bytes);
+      read2(pointer, bytes2);
+      return this.#runtime.UTF16ToString(pointer, bytes2);
     } finally {
       this.free(pointer);
     }
@@ -10588,12 +11567,12 @@ var Pdfium = class _Pdfium {
     const outBytes = this.malloc(4);
     try {
       if (!read2(0, 0, outBytes)) return "";
-      const bytes = this.#runtime.getValue(outBytes, "i32");
-      if (bytes <= 2) return "";
-      const pointer = this.malloc(bytes);
+      const bytes2 = this.#runtime.getValue(outBytes, "i32");
+      if (bytes2 <= 2) return "";
+      const pointer = this.malloc(bytes2);
       try {
-        if (!read2(pointer, bytes, outBytes)) return "";
-        return this.#runtime.UTF16ToString(pointer, bytes);
+        if (!read2(pointer, bytes2, outBytes)) return "";
+        return this.#runtime.UTF16ToString(pointer, bytes2);
       } finally {
         this.free(pointer);
       }
@@ -10603,12 +11582,12 @@ var Pdfium = class _Pdfium {
   }
   /** Reads a NUL-terminated UTF-8 string from an API that returns the byte size it needs. */
   readUtf8String(read2) {
-    const bytes = read2(0, 0);
-    if (bytes <= 1) return "";
-    const pointer = this.malloc(bytes);
+    const bytes2 = read2(0, 0);
+    if (bytes2 <= 1) return "";
+    const pointer = this.malloc(bytes2);
     try {
-      read2(pointer, bytes);
-      const raw = this.readBytes(pointer, bytes);
+      read2(pointer, bytes2);
+      const raw = this.readBytes(pointer, bytes2);
       const end = raw.indexOf(0);
       return new TextDecoder().decode(end < 0 ? raw : raw.subarray(0, end));
     } finally {
@@ -10643,20 +11622,20 @@ var Pdfium = class _Pdfium {
    * a WASM table callback. Only for APIs that read the data before returning,
    * such as the inline JPEG loader.
    */
-  withFileAccess(bytes, use) {
+  withFileAccess(bytes2, use) {
     const runtime = this.#runtime;
     const callback = runtime.addFunction(
       (_parameter, position, buffer, size) => {
-        if (position < 0 || size < 0 || position + size > bytes.byteLength)
+        if (position < 0 || size < 0 || position + size > bytes2.byteLength)
           return 0;
-        runtime.HEAPU8.set(bytes.subarray(position, position + size), buffer);
+        runtime.HEAPU8.set(bytes2.subarray(position, position + size), buffer);
         return 1;
       },
       "iiiii"
     );
     const fileAccess = this.malloc(FILE_ACCESS_BYTES);
     try {
-      runtime.setValue(fileAccess, bytes.byteLength, "i32");
+      runtime.setValue(fileAccess, bytes2.byteLength, "i32");
       runtime.setValue(fileAccess + 4, callback, "i32");
       runtime.setValue(fileAccess + 8, 0, "i32");
       return use(fileAccess);
@@ -10666,9 +11645,9 @@ var Pdfium = class _Pdfium {
     }
   }
   /** Opens a document from bytes; PDFium reads them lazily, so they stay in the heap. */
-  openDocument(bytes) {
-    const data = this.writeBytes(bytes);
-    const handle = this.lib.FPDF_LoadMemDocument(data, bytes.byteLength, "");
+  openDocument(bytes2) {
+    const data = this.writeBytes(bytes2);
+    const handle = this.lib.FPDF_LoadMemDocument(data, bytes2.byteLength, "");
     if (!handle) {
       const error = this.lib.FPDF_GetLastError();
       this.free(data);
@@ -10733,9 +11712,9 @@ var PdfiumDocument = class {
     this.#pdfium.free(this.#data);
   }
 };
-function exactArrayBuffer(bytes) {
-  if (bytes instanceof ArrayBuffer) return bytes;
-  return bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
+function exactArrayBuffer(bytes2) {
+  if (bytes2 instanceof ArrayBuffer) return bytes2;
+  return bytes2.buffer instanceof ArrayBuffer && bytes2.byteOffset === 0 && bytes2.byteLength === bytes2.buffer.byteLength ? bytes2.buffer : bytes2.slice().buffer;
 }
 
 // src/worker-protocol.ts
@@ -10820,9 +11799,9 @@ attachWorkerEndpoint(
   createPdfEditHandler({
     loadPdfium: async (wasmUrl) => Pdfium.load(await fetchBytes(wasmUrl)),
     fetchBytes,
-    decodeImage: async (bytes, mimeType) => {
+    decodeImage: async (bytes2, mimeType) => {
       const bitmap = await createImageBitmap(
-        new Blob([new Uint8Array(bytes)], { type: mimeType })
+        new Blob([new Uint8Array(bytes2)], { type: mimeType })
       );
       try {
         const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);