web-doc 0.11.0 → 0.12.0

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

@@ -3415,8 +3415,8 @@ var init_index_browser = __esm({
             var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
             overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
             var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
-            var replacement = growMemory(newSize);
-            if (replacement) {
+            var replacement2 = growMemory(newSize);
+            if (replacement2) {
               return true;
             }
           }
@@ -5799,6 +5799,15 @@ var pdfOperationSchemas = Object.freeze({
       },
       ["target", "style"]
     ),
+    replaceParagraphText: operation(
+      "replaceParagraphText",
+      {
+        target: { $ref: "#/$defs/target" },
+        text: { type: "string", maxLength: 2e4 },
+        range: { $ref: "#/$defs/textRange" }
+      },
+      ["target", "text"]
+    ),
     resizeElement: operation(
       "resizeElement",
       {
@@ -5990,6 +5999,37 @@ var textBoxMarkSchema = {
   },
   $defs: definitions
 };
+var paragraphMarkSchema = {
+  type: "object",
+  required: ["kind", "id", "rect", "text", "lines", "style", "baselineOffset"],
+  additionalProperties: false,
+  properties: {
+    kind: { const: "paragraph" },
+    id: { $ref: "#/$defs/target" },
+    rect: { $ref: "#/$defs/rect" },
+    text: { type: "string", maxLength: 2e4 },
+    baselineOffset: { type: "number", minimum: 0, maximum: 2 },
+    lines: {
+      type: "array",
+      maxItems: 2e4,
+      items: { type: "string", maxLength: 2e4 }
+    },
+    style: {
+      type: "object",
+      required: [
+        "fontFamily",
+        "fontSize",
+        "bold",
+        "italic",
+        "color",
+        "lineHeight"
+      ],
+      additionalProperties: false,
+      properties: definitions.textBoxStyle.properties
+    }
+  },
+  $defs: definitions
+};
 
 // src/edit/schema.ts
 var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
@@ -6336,6 +6376,20 @@ var MARK_NAME = "WebDoc";
 var MARK_PARAM = "webdoc";
 var FLAG_ITALIC = 1 << 6;
 var FLAG_FORCE_BOLD = 1 << 18;
+function paragraphSpecOf(mark) {
+  return validateSchema(mark, paragraphMarkSchema, 0).length === 0 ? mark : void 0;
+}
+function paragraphBounds(spec, geometry) {
+  if (geometry.rotation === 0) return spec.rect;
+  const upright = { ...geometry, rotation: 0 };
+  const top = pageToUser(upright, spec.rect.x, spec.rect.y);
+  const bottom = pageToUser(
+    upright,
+    spec.rect.x + spec.rect.width,
+    spec.rect.y + spec.rect.height
+  );
+  return roundRect(userRectToPage(geometry, top.x, bottom.y, bottom.x, top.y));
+}
 function scanPage(pdfium, page, textPage, pageIndex, geometry, records) {
   const { lib } = pdfium;
   const byObject = /* @__PURE__ */ new Map();
@@ -6368,7 +6422,7 @@ function scanPage(pdfium, page, textPage, pageIndex, geometry, records) {
     elements: elements.map((element) => {
       const members = groups.get(element.id);
       const record = members && records.find((entry) => entry.id === element.id);
-      return members && record?.mark ? compositeElement(record.mark, members, pageIndex) : element;
+      return members && record?.mark ? compositeElement(record.mark, members, pageIndex, geometry) : element;
     }),
     byObject
   };
@@ -6403,6 +6457,8 @@ function isValidMark(params) {
   switch (params.kind) {
     case "textBox":
       return validateSchema(params, textBoxMarkSchema, 0).length === 0;
+    case "paragraph":
+      return validateSchema(params, paragraphMarkSchema, 0).length === 0;
     case "table":
       return validateSchema(params, tableMarkSchema, 0).length === 0 || validateSchema(params, tableMemberMarkSchema, 0).length === 0;
     default:
@@ -6419,11 +6475,50 @@ function markIsFresh(pdfium, page, textPage, geometry, mark, indexes) {
     objects.filter((object) => lib.FPDFPageObj_GetType(object) === OBJECT_TEXT).map((object) => textOf(pdfium, object, textPage)).join(" ")
   );
   const tolerance = 2;
-  if (mark.kind === "textBox") {
+  if (mark.kind === "paragraph") {
+    const spec = paragraphSpecOf(mark);
+    if (!spec || objects.some((object) => {
+      if (lib.FPDFPageObj_GetType(object) !== OBJECT_TEXT) {
+        if (spec.text.trim().length !== 0 || lib.FPDFPageObj_GetType(object) !== OBJECT_PATH)
+          return true;
+        const mode = pdfium.readNumbers(
+          2,
+          "i32",
+          ([fill, stroke]) => lib.FPDFPath_GetDrawMode(object, fill, stroke)
+        );
+        const color = pdfium.readNumbers(
+          4,
+          "i32",
+          ([r, g, b, a]) => lib.FPDFPageObj_GetFillColor(object, r, g, b, a)
+        );
+        return mode?.[0] !== 1 || mode[1] !== 0 || color?.[3] !== 0;
+      }
+      const current = textStyle(pdfium, object);
+      return current.fontSize !== round(spec.style.fontSize) || current.color !== spec.style.color || current.bold !== spec.style.bold || current.italic !== spec.style.italic;
+    }))
+      return false;
+    const frame = paragraphBounds(spec, geometry);
+    if (union.y + union.height > frame.y + frame.height + tolerance)
+      return false;
+    const nativeLines = objects.filter((object) => lib.FPDFPageObj_GetType(object) === OBJECT_TEXT).map((object) => textOf(pdfium, object, textPage).trimEnd());
+    if (nativeLines.length !== spec.lines.length || nativeLines.some((line, index) => line !== spec.lines[index]))
+      return false;
+    let cursor = 0;
+    for (const line of nativeLines) {
+      while (!spec.text.startsWith(line, cursor) && cursor < spec.text.length && /\s/u.test(spec.text[cursor]))
+        cursor += 1;
+      if (!spec.text.startsWith(line, cursor)) return false;
+      cursor += line.length;
+    }
+    if (spec.text.slice(cursor).trim()) return false;
+    if (geometry.rotation !== 0)
+      return union.x >= frame.x - tolerance && union.y >= frame.y - tolerance && union.x + union.width <= frame.x + frame.width + tolerance;
+  }
+  if (mark.kind === "textBox" || mark.kind === "paragraph") {
     const rect = mark.rect;
     const text = mark.text;
     const style2 = mark.style;
-    return drawn === normalizeText(text) && union.x >= rect.x - tolerance && union.x + union.width <= rect.x + rect.width + tolerance && // The first line's ink starts inside the box's first line band; the
+    return (mark.kind === "paragraph" || drawn === normalizeText(text)) && union.x >= rect.x - tolerance && union.x + union.width <= rect.x + rect.width + tolerance && // The first line's ink starts inside the box's first line band; the
     // bottom is not checked because overflowing text runs past the box.
     union.y >= rect.y - tolerance && union.y <= rect.y + style2.fontSize * style2.lineHeight + tolerance;
   }
@@ -6479,7 +6574,7 @@ function plainElement(pdfium, object, textPage, record, pageIndex, geometry) {
       return { ...base, kind: "other", operations: TRANSFORM_OPERATIONS };
   }
 }
-function compositeElement(mark, members, pageIndex) {
+function compositeElement(mark, members, pageIndex, geometry) {
   const bounds = roundRect(unionRects(members.map((member) => member.bounds)));
   const text = members.filter((member) => member.kind === "text" && member.text).map((member) => member.text).join("\n");
   if (mark.kind === "table") {
@@ -6502,6 +6597,23 @@ function compositeElement(mark, members, pageIndex) {
       operations: TABLE_OPERATIONS
     };
   }
+  const paragraph = paragraphSpecOf(mark);
+  if (paragraph)
+    return {
+      id: mark.id,
+      kind: "paragraph",
+      pageIndex,
+      bounds: paragraphBounds(paragraph, geometry),
+      text: paragraph.text,
+      textStyle: paragraph.style,
+      ...geometry.rotation ? { rotation: geometry.rotation * 90 } : {},
+      operations: geometry.rotation ? ["deleteElement"] : [
+        "replaceText",
+        "replaceParagraphText",
+        "setTextStyle",
+        "deleteElement"
+      ]
+    };
   const style = members.find((member) => member.textStyle)?.textStyle;
   return {
     id: mark.id,
@@ -6639,7 +6751,7 @@ function objectRotation(pdfium, object, geometry) {
 
 // src/edit/pdf/engine/layout.ts
 var HIT_TOLERANCE = 2;
-var TEXT_KINDS = /* @__PURE__ */ new Set(["text", "textBox", "table"]);
+var TEXT_KINDS = /* @__PURE__ */ new Set(["text", "textBox", "table", "paragraph"]);
 function layoutOf(pdfium, scan, element) {
   if (!TEXT_KINDS.has(element.kind)) return void 0;
   const glyphs = glyphsOf(
@@ -6775,10 +6887,10 @@ function linesOf(pdfium, scan, glyphs) {
       text: members.map((glyph) => glyph.char).join(""),
       bounds: roundRect(unionRects(members.map((glyph) => glyph.box))),
       baseline: members[0].origin,
-      glyphs: members.map(({ position, box, advance }) => ({
+      glyphs: members.map(({ position, box, advance: advance2 }) => ({
         offset: position.offset,
         box,
-        advance
+        advance: advance2
       })),
       fontFamily: style.fontFamily,
       fontSize: style.fontSize,
@@ -6811,893 +6923,989 @@ function roundPoint(point) {
   return { x: round(point.x), y: round(point.y) };
 }
 
-// src/edit/pdf/engine/fonts.ts
-var STANDARD_FAMILIES = {
-  helvetica: [
-    "Helvetica",
-    "Helvetica-Bold",
-    "Helvetica-Oblique",
-    "Helvetica-BoldOblique"
-  ],
-  times: ["Times-Roman", "Times-Bold", "Times-Italic", "Times-BoldItalic"],
-  courier: [
-    "Courier",
-    "Courier-Bold",
-    "Courier-Oblique",
-    "Courier-BoldOblique"
-  ]
-};
-var WIN_ANSI_EXTRAS = new Set(
-  "\u20AC\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\u017D\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\u017E\u0178".split("").map((c) => c.codePointAt(0))
+// 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)]] : []
+  )
 );
-var FONT_TRUETYPE = 1;
-var FALLBACK_FAMILY = "Noto Sans";
-function isStandardFamily(family) {
-  return family.toLowerCase() in STANDARD_FAMILIES;
-}
-function standardFontName(family, bold, italic) {
-  const variants = STANDARD_FAMILIES[family.toLowerCase()];
-  if (!variants) return void 0;
-  return variants[(bold ? 1 : 0) + (italic ? 2 : 0)];
-}
-function firstNonWinAnsi(text) {
-  for (const character of text) {
-    const code = character.codePointAt(0);
-    if (code === 10) continue;
-    if (code >= 32 && code <= 126 || code >= 160 && code <= 255 || WIN_ANSI_EXTRAS.has(code))
-      continue;
-    return character;
-  }
-  return void 0;
+
+// 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 FontLibrary = class {
-  #registered = [];
-  #fetch;
-  #bytes = /* @__PURE__ */ new Map();
-  #coverage = /* @__PURE__ */ new Map();
-  /** Loaded PDFium font handles, keyed by document and font bytes. */
-  #handles = /* @__PURE__ */ new Map();
-  #fallbackUrl;
-  #fallback;
-  constructor(fetchBytes2) {
-    this.#fetch = fetchBytes2;
-  }
-  setFallbackUrl(url) {
-    this.#fallbackUrl = url;
-  }
-  register(fonts) {
-    this.#registered.length = 0;
-    this.#registered.push(...fonts);
-  }
-  /** Whether `family` names a registered font. */
-  hasFamily(family) {
-    return this.#registered.some((font) => sameFamily(font.family, family));
-  }
-  /**
-   * Fetches whatever the given texts and families may need, so that
-   * validation and drawing can run synchronously afterwards.
-   */
-  async prepare(requests) {
-    const families = new Set(
-      requests.map((request) => request.family.toLowerCase())
-    );
-    const fonts = this.#registered.filter(
-      (font) => families.has(font.family.toLowerCase())
-    );
-    for (const font of fonts) await this.#bytesOf(font);
-    const needsFallback = requests.some(
-      (request) => (
-        // Text the standard fonts cannot encode, or a family only the
-        // fallback can stand in for (an embedded font that lost a glyph).
-        (firstNonWinAnsi(request.text) !== void 0 || !isStandardFamily(request.family) && !this.hasFamily(request.family)) && !this.#coveringRegistered({ ...request, bold: false, italic: false })
-      )
+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 (needsFallback && !this.#fallback && this.#fallbackUrl)
-      this.#fallback = await this.#fetch(this.#fallbackUrl);
-  }
-  /** Checks a request against what is loaded; `undefined` means it will resolve. */
-  problem(request) {
-    const standard = isStandardFamily(request.family);
-    if (!standard && !this.hasFamily(request.family))
+    if (cid)
       return {
-        path: "/style/fontFamily",
-        code: "unknown-font",
-        message: `Unknown font family ${request.family}; Helvetica, Times, Courier and registered fonts are available`
+        name,
+        cid,
+        glyphNames: [],
+        widths: [],
+        bbox: [xMin, yMin, xMax, yMax],
+        unitsPerEm
       };
-    if (standard && firstNonWinAnsi(request.text) === void 0)
-      return void 0;
-    if (this.#coveringRegistered(request)) return void 0;
-    if (this.#fallback && this.#covers(this.#fallback, request.text))
-      return void 0;
-    const bad = this.#fallback ? this.#firstMissing(this.#fallback, request.text) : firstNonWinAnsi(request.text);
-    return {
-      path: "/text",
-      code: "font-unavailable",
-      message: bad ? `No available font can draw "${bad}" (U+${bad.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")})` : "No available font can draw the text"
+    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);
     };
-  }
-  /** The font to draw `request` with in `document`; `prepare` must have run. */
-  resolve(pdfium, document2, request) {
-    const { lib } = pdfium;
-    if (isStandardFamily(request.family) && firstNonWinAnsi(request.text) === void 0) {
-      const name = standardFontName(
-        request.family,
-        request.bold,
-        request.italic
-      );
-      return {
-        handle: lib.FPDFText_LoadStandardFont(document2, name),
-        family: name
-      };
-    }
-    const registered = this.#coveringRegistered(request);
-    if (registered) {
-      const exact = isBold(registered.font) === request.bold && isItalic(registered.font) === request.italic;
-      return {
-        handle: this.#load(pdfium, document2, registered.bytes),
-        family: registered.font.family,
-        ...exact ? {} : {
-          substitution: `${registered.font.family} has no matching bold or italic face`
-        }
-      };
-    }
-    if (!this.#fallback || !this.#covers(this.#fallback, request.text))
-      throw new Error(`No font covers "${request.text}"`);
-    return {
-      handle: this.#load(pdfium, document2, this.#fallback),
-      family: FALLBACK_FAMILY,
-      substitution: `${request.family} cannot draw this text; ${FALLBACK_FAMILY} is used`
+    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
     };
-  }
-  /** Closes the fonts loaded into a document that is going away. */
-  release(pdfium, document2) {
-    const handles = this.#handles.get(document2);
-    if (!handles) return;
-    for (const handle of handles.values()) pdfium.lib.FPDFFont_Close(handle);
-    this.#handles.delete(document2);
-  }
-  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(
-      (entry) => entry.bytes !== void 0 && this.#covers(entry.bytes, request.text)
+    const widths = charStrings.items.map(
+      ([start, end]) => charstringWidth(metrics, start, end)
     );
-    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(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(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 character;
-    }
-    return void 0;
+    return {
+      name,
+      cid,
+      glyphNames,
+      widths,
+      bbox: [xMin, yMin, xMax, yMax],
+      unitsPerEm
+    };
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
   }
-  #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(bytes2);
-    if (handle === void 0) {
-      const pointer = pdfium.writeBytes(bytes2);
-      try {
-        handle = pdfium.lib.FPDFText_LoadFont(
-          document2,
-          pointer,
-          bytes2.byteLength,
-          FONT_TRUETYPE,
-          true
-        );
-      } finally {
-        pdfium.free(pointer);
-      }
-      if (!handle) throw new Error("PDFium could not load the font");
-      handles.set(bytes2, handle);
+}
+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 handle;
-  }
-  #loadedBytes(font) {
-    return typeof font.source === "string" ? this.#bytes.get(font.source) : this.#bytes.get(sourceKey(font)) ?? new Uint8Array(font.source);
+    return safe;
+  } catch (error) {
+    if (error instanceof RangeError) return void 0;
+    throw error;
   }
-  async #bytesOf(font) {
-    const key = sourceKey(font);
-    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 bytes2;
-  }
-};
-function sourceKey(font) {
-  return typeof font.source === "string" ? font.source : `${font.family}:${font.weight}:${font.style}:${font.source.byteLength}`;
-}
-function sameFamily(a, b) {
-  return a.toLowerCase() === b.toLowerCase();
-}
-function isBold(font) {
-  return font.weight >= 600;
-}
-function isItalic(font) {
-  return font.style !== "normal";
 }
-function glyphOutlines(view, tables) {
-  const head2 = tables.get("head");
-  const maxp = tables.get("maxp");
-  const loca = tables.get("loca");
-  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;
-    const at = loca.offset + glyph * (longOffsets ? 4 : 2);
-    const start = longOffsets ? view.getUint32(at) : view.getUint16(at) * 2;
-    const end = longOffsets ? view.getUint32(at + 4) : view.getUint16(at + 2) * 2;
-    return end > start;
+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 parseCmap(bytes2) {
-  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
-  const ranges = [];
-  const glyphs = /* @__PURE__ */ new Map();
-  let outlines;
-  try {
-    const tables = view.getUint16(4);
-    let cmapOffset = -1;
-    const offsets = /* @__PURE__ */ new Map();
-    for (let index = 0; index < tables; index += 1) {
-      const record = 12 + index * 16;
-      const tag = String.fromCharCode(
-        bytes2[record],
-        bytes2[record + 1],
-        bytes2[record + 2],
-        bytes2[record + 3]
+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)
       );
-      offsets.set(tag, {
-        offset: view.getUint32(record + 8),
-        length: view.getUint32(record + 12)
-      });
-      if (tag === "cmap") cmapOffset = view.getUint32(record + 8);
-    }
-    outlines = glyphOutlines(view, offsets);
-    if (cmapOffset < 0)
-      return {
-        has: () => false,
-        drawable: () => false,
-        glyph: () => void 0
-      };
-    const subtables = view.getUint16(cmapOffset + 2);
-    let best;
-    for (let index = 0; index < subtables; index += 1) {
-      const record = cmapOffset + 4 + index * 8;
-      const platform = view.getUint16(record);
-      const encoding = view.getUint16(record + 2);
-      const offset2 = cmapOffset + view.getUint32(record + 4);
-      const format = view.getUint16(offset2);
-      const unicode = platform === 0 || platform === 3 && (encoding === 1 || encoding === 10);
-      if (!unicode || format !== 4 && format !== 12) continue;
-      if (!best || format > best.format) best = { offset: offset2, format };
-    }
-    if (!best)
-      return {
-        has: () => false,
-        drawable: () => false,
-        glyph: () => void 0
-      };
-    if (best.format === 12) {
-      const groups = view.getUint32(best.offset + 12);
-      for (let index = 0; index < groups; index += 1) {
-        const group = best.offset + 16 + index * 12;
-        const start = view.getUint32(group);
-        const end = view.getUint32(group + 4);
-        const startGlyph = view.getUint32(group + 8);
-        ranges.push([start, end]);
-        for (let code = start; code <= end && code - start < 65536; code += 1)
-          glyphs.set(code, startGlyph + (code - start));
-      }
-    } else {
-      const segments = view.getUint16(best.offset + 6) / 2;
-      const ends = best.offset + 14;
-      const starts = ends + segments * 2 + 2;
-      const deltas = starts + segments * 2;
-      const rangeOffsets = deltas + segments * 2;
-      for (let index = 0; index < segments; index += 1) {
-        const end = view.getUint16(ends + index * 2);
-        const start = view.getUint16(starts + index * 2);
-        if (start === 65535) continue;
-        ranges.push([start, end]);
-        const delta = view.getInt16(deltas + index * 2);
-        const rangeOffset = view.getUint16(rangeOffsets + index * 2);
-        for (let code = start; code <= end; code += 1) {
-          let glyph;
-          if (rangeOffset === 0) glyph = code + delta & 65535;
-          else {
-            const at = rangeOffsets + index * 2 + rangeOffset + (code - start) * 2;
-            const raw = view.getUint16(at);
-            glyph = raw === 0 ? 0 : raw + delta & 65535;
+      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;
           }
-          glyphs.set(code, glyph);
+          text += REAL_NIBBLES[nibble] ?? "";
         }
       }
-    }
-  } catch {
-    return { has: () => false, drawable: () => false, glyph: () => void 0 };
+      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");
   }
-  ranges.sort((a, b) => a[0] - b[0]);
-  return {
-    glyph(codePoint) {
-      return glyphs.get(codePoint);
-    },
-    drawable(codePoint) {
-      const glyph = glyphs.get(codePoint);
-      if (glyph === void 0 || glyph === 0) return false;
-      return outlines ? outlines(glyph) : true;
-    },
-    has(codePoint) {
-      let low = 0;
-      let high = ranges.length - 1;
-      while (low <= high) {
-        const middle = low + high >> 1;
-        const [start, end] = ranges[middle];
-        if (codePoint < start) high = middle - 1;
-        else if (codePoint > end) low = middle + 1;
-        else return true;
-      }
-      return false;
-    }
-  };
+  return entries;
 }
-var TextMeasurer = class {
-  #pdfium;
-  #document;
-  #advances = /* @__PURE__ */ new Map();
-  #metrics = /* @__PURE__ */ new Map();
-  constructor(pdfium, document2) {
-    this.#pdfium = pdfium;
-    this.#document = document2;
-  }
-  /** Width of `text` in points at `fontSize`, without kerning. */
-  advance(font, fontSize, text) {
-    let total = 0;
-    for (const character of text) total += this.#advanceOf(font, character);
-    return total * fontSize / 1e3;
+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;
   }
-  /** Ascent above and descent below the baseline, in points, both positive. */
-  metrics(font, fontSize) {
-    let unit = this.#metrics.get(font);
-    if (!unit) {
-      const { lib } = this.#pdfium;
-      const ascent = this.#pdfium.readNumbers(
-        1,
-        "float",
-        ([pointer]) => lib.FPDFFont_GetAscent(font, 1e3, pointer)
-      )?.[0] ?? 750;
-      const descent = this.#pdfium.readNumbers(
-        1,
-        "float",
-        ([pointer]) => lib.FPDFFont_GetDescent(font, 1e3, pointer)
-      )?.[0] ?? -250;
-      unit = { ascent, descent: Math.abs(descent) };
-      this.#metrics.set(font, unit);
-    }
-    return {
-      ascent: unit.ascent * fontSize / 1e3,
-      descent: unit.descent * fontSize / 1e3
-    };
-  }
-  #advanceOf(font, character) {
-    let cache = this.#advances.get(font);
-    if (!cache) {
-      cache = /* @__PURE__ */ new Map();
-      this.#advances.set(font, cache);
-    }
-    let advance = cache.get(character);
-    if (advance === void 0) {
-      advance = this.#inkWidth(font, `H${character}H`) - this.#inkWidth(font, "HH");
-      cache.set(character, advance);
+  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));
     }
-    return advance;
-  }
-  #inkWidth(font, text) {
-    const { lib } = this.#pdfium;
-    const object = lib.FPDFPageObj_CreateTextObj(this.#document, font, 1e3);
-    try {
-      const wide = this.#pdfium.writeWideString(text);
-      try {
-        lib.FPDFText_SetText(object, wide);
-      } finally {
-        this.#pdfium.free(wide);
+  } 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;
       }
-      const bounds = this.#pdfium.readNumbers(
-        4,
-        "float",
-        ([l, b, r, t]) => lib.FPDFPageObj_GetBounds(object, l, b, r, t)
-      );
-      return bounds ? bounds[2] - bounds[0] : 0;
-    } finally {
-      lib.FPDFPageObj_Destroy(object);
+      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/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/fonts.ts
+var STANDARD_FAMILIES = {
+  helvetica: [
+    "Helvetica",
+    "Helvetica-Bold",
+    "Helvetica-Oblique",
+    "Helvetica-BoldOblique"
+  ],
+  times: ["Times-Roman", "Times-Bold", "Times-Italic", "Times-BoldItalic"],
+  courier: [
+    "Courier",
+    "Courier-Bold",
+    "Courier-Oblique",
+    "Courier-BoldOblique"
+  ]
+};
+var WIN_ANSI_EXTRAS = new Set(
+  "\u20AC\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\u017D\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\u017E\u0178".split("").map((c) => c.codePointAt(0))
 );
-
-// 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 FONT_TRUETYPE = 1;
+var FALLBACK_FAMILY = "Noto Sans";
+function isStandardFamily(family) {
+  return family.toLowerCase() in STANDARD_FAMILIES;
 }
-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))
+function standardFontName(family, bold, italic) {
+  const variants = STANDARD_FAMILIES[family.toLowerCase()];
+  if (!variants) return void 0;
+  return variants[(bold ? 1 : 0) + (italic ? 2 : 0)];
+}
+function firstNonWinAnsi(text) {
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    if (code === 10) continue;
+    if (code >= 32 && code <= 126 || code >= 160 && code <= 255 || WIN_ANSI_EXTRAS.has(code))
+      continue;
+    return character;
+  }
+  return void 0;
+}
+var FontLibrary = class {
+  #registered = [];
+  #fetch;
+  #bytes = /* @__PURE__ */ new Map();
+  #coverage = /* @__PURE__ */ new Map();
+  /** Loaded PDFium font handles, keyed by document and font bytes. */
+  #handles = /* @__PURE__ */ new Map();
+  #fallbackUrl;
+  #fallback;
+  constructor(fetchBytes2) {
+    this.#fetch = fetchBytes2;
+  }
+  setFallbackUrl(url) {
+    this.#fallbackUrl = url;
+  }
+  register(fonts) {
+    this.#registered.length = 0;
+    this.#registered.push(...fonts);
+  }
+  /** Whether `family` names a registered font. */
+  hasFamily(family) {
+    return this.#registered.some((font) => sameFamily(font.family, family));
+  }
+  /**
+   * Fetches whatever the given texts and families may need, so that
+   * validation and drawing can run synchronously afterwards.
+   */
+  async prepare(requests) {
+    const families = new Set(
+      requests.map((request) => request.family.toLowerCase())
     );
-    if (cid)
+    const fonts = this.#registered.filter(
+      (font) => families.has(font.family.toLowerCase())
+    );
+    for (const font of fonts) await this.#bytesOf(font);
+    const needsFallback = requests.some(
+      (request) => (
+        // Text the standard fonts cannot encode, or a family only the
+        // fallback can stand in for (an embedded font that lost a glyph).
+        (firstNonWinAnsi(request.text) !== void 0 || !isStandardFamily(request.family) && !this.hasFamily(request.family)) && !this.#coveringRegistered({ ...request, bold: false, italic: false })
+      )
+    );
+    if (needsFallback && !this.#fallback && this.#fallbackUrl)
+      this.#fallback = await this.#fetch(this.#fallbackUrl);
+  }
+  /** Checks a request against what is loaded; `undefined` means it will resolve. */
+  problem(request) {
+    const standard = isStandardFamily(request.family);
+    if (!standard && !this.hasFamily(request.family))
       return {
-        name,
-        cid,
-        glyphNames: [],
-        widths: [],
-        bbox: [xMin, yMin, xMax, yMax],
-        unitsPerEm
+        path: "/style/fontFamily",
+        code: "unknown-font",
+        message: `Unknown font family ${request.family}; Helvetica, Times, Courier and registered fonts are available`
       };
-    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);
+    if (standard && firstNonWinAnsi(request.text) === void 0)
+      return void 0;
+    if (this.#coveringRegistered(request)) return void 0;
+    if (this.#fallback && this.#covers(this.#fallback, request.text))
+      return void 0;
+    const bad = this.#fallback ? this.#firstMissing(this.#fallback, request.text) : firstNonWinAnsi(request.text);
+    return {
+      path: "/text",
+      code: "font-unavailable",
+      message: bad ? `No available font can draw "${bad}" (U+${bad.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")})` : "No available font can draw the text"
     };
-    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
+  }
+  /** The font to draw `request` with in `document`; `prepare` must have run. */
+  resolve(pdfium, document2, request) {
+    const { lib } = pdfium;
+    if (isStandardFamily(request.family) && firstNonWinAnsi(request.text) === void 0) {
+      const name = standardFontName(
+        request.family,
+        request.bold,
+        request.italic
+      );
+      return {
+        handle: lib.FPDFText_LoadStandardFont(document2, name),
+        family: name
+      };
+    }
+    const registered = this.#coveringRegistered(request);
+    if (registered) {
+      const exact = isBold(registered.font) === request.bold && isItalic(registered.font) === request.italic;
+      return {
+        handle: this.#load(pdfium, document2, registered.bytes),
+        family: registered.font.family,
+        ...exact ? {} : {
+          substitution: `${registered.font.family} has no matching bold or italic face`
+        }
+      };
+    }
+    if (!this.#fallback || !this.#covers(this.#fallback, request.text))
+      throw new Error(`No font covers "${request.text}"`);
+    return {
+      handle: this.#load(pdfium, document2, this.#fallback),
+      family: FALLBACK_FAMILY,
+      substitution: `${request.family} cannot draw this text; ${FALLBACK_FAMILY} is used`
     };
-    const widths = charStrings.items.map(
-      ([start, end]) => charstringWidth(metrics, start, end)
+  }
+  /** Closes the fonts loaded into a document that is going away. */
+  release(pdfium, document2) {
+    const handles = this.#handles.get(document2);
+    if (!handles) return;
+    for (const handle of handles.values()) pdfium.lib.FPDFFont_Close(handle);
+    this.#handles.delete(document2);
+  }
+  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(
+      (entry) => entry.bytes !== void 0 && this.#covers(entry.bytes, request.text)
     );
+    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(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(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 character;
+    }
+    return void 0;
+  }
+  #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(bytes2);
+    if (handle === void 0) {
+      const pointer = pdfium.writeBytes(bytes2);
+      try {
+        handle = pdfium.lib.FPDFText_LoadFont(
+          document2,
+          pointer,
+          bytes2.byteLength,
+          FONT_TRUETYPE,
+          true
+        );
+      } finally {
+        pdfium.free(pointer);
+      }
+      if (!handle) throw new Error("PDFium could not load the font");
+      handles.set(bytes2, handle);
+    }
+    return handle;
+  }
+  #loadedBytes(font) {
+    return typeof font.source === "string" ? this.#bytes.get(font.source) : this.#bytes.get(sourceKey(font)) ?? new Uint8Array(font.source);
+  }
+  async #bytesOf(font) {
+    const key = sourceKey(font);
+    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 bytes2;
+  }
+};
+function sourceKey(font) {
+  return typeof font.source === "string" ? font.source : `${font.family}:${font.weight}:${font.style}:${font.source.byteLength}`;
+}
+function sameFamily(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function isBold(font) {
+  return font.weight >= 600;
+}
+function isItalic(font) {
+  return font.style !== "normal";
+}
+function glyphOutlines(view, tables) {
+  const head2 = tables.get("head");
+  const maxp = tables.get("maxp");
+  const loca = tables.get("loca");
+  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;
+    const at = loca.offset + glyph * (longOffsets ? 4 : 2);
+    const start = longOffsets ? view.getUint32(at) : view.getUint16(at) * 2;
+    const end = longOffsets ? view.getUint32(at + 4) : view.getUint16(at + 2) * 2;
+    return end > start;
+  };
+}
+function parseCmap(bytes2) {
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+  const ranges = [];
+  const glyphs = /* @__PURE__ */ new Map();
+  let outlines;
+  try {
+    const tables = view.getUint16(4);
+    let cmapOffset = -1;
+    const offsets = /* @__PURE__ */ new Map();
+    for (let index = 0; index < tables; index += 1) {
+      const record = 12 + index * 16;
+      const tag = String.fromCharCode(
+        bytes2[record],
+        bytes2[record + 1],
+        bytes2[record + 2],
+        bytes2[record + 3]
+      );
+      offsets.set(tag, {
+        offset: view.getUint32(record + 8),
+        length: view.getUint32(record + 12)
+      });
+      if (tag === "cmap") cmapOffset = view.getUint32(record + 8);
+    }
+    outlines = glyphOutlines(view, offsets);
+    if (cmapOffset < 0)
+      return {
+        has: () => false,
+        drawable: () => false,
+        glyph: () => void 0
+      };
+    const subtables = view.getUint16(cmapOffset + 2);
+    let best;
+    for (let index = 0; index < subtables; index += 1) {
+      const record = cmapOffset + 4 + index * 8;
+      const platform = view.getUint16(record);
+      const encoding = view.getUint16(record + 2);
+      const offset2 = cmapOffset + view.getUint32(record + 4);
+      const format = view.getUint16(offset2);
+      const unicode = platform === 0 || platform === 3 && (encoding === 1 || encoding === 10);
+      if (!unicode || format !== 4 && format !== 12) continue;
+      if (!best || format > best.format) best = { offset: offset2, format };
+    }
+    if (!best)
+      return {
+        has: () => false,
+        drawable: () => false,
+        glyph: () => void 0
+      };
+    if (best.format === 12) {
+      const groups = view.getUint32(best.offset + 12);
+      for (let index = 0; index < groups; index += 1) {
+        const group = best.offset + 16 + index * 12;
+        const start = view.getUint32(group);
+        const end = view.getUint32(group + 4);
+        const startGlyph = view.getUint32(group + 8);
+        ranges.push([start, end]);
+        for (let code = start; code <= end && code - start < 65536; code += 1)
+          glyphs.set(code, startGlyph + (code - start));
+      }
+    } else {
+      const segments = view.getUint16(best.offset + 6) / 2;
+      const ends = best.offset + 14;
+      const starts = ends + segments * 2 + 2;
+      const deltas = starts + segments * 2;
+      const rangeOffsets = deltas + segments * 2;
+      for (let index = 0; index < segments; index += 1) {
+        const end = view.getUint16(ends + index * 2);
+        const start = view.getUint16(starts + index * 2);
+        if (start === 65535) continue;
+        ranges.push([start, end]);
+        const delta = view.getInt16(deltas + index * 2);
+        const rangeOffset = view.getUint16(rangeOffsets + index * 2);
+        for (let code = start; code <= end; code += 1) {
+          let glyph;
+          if (rangeOffset === 0) glyph = code + delta & 65535;
+          else {
+            const at = rangeOffsets + index * 2 + rangeOffset + (code - start) * 2;
+            const raw = view.getUint16(at);
+            glyph = raw === 0 ? 0 : raw + delta & 65535;
+          }
+          glyphs.set(code, glyph);
+        }
+      }
+    }
+  } catch {
+    return { has: () => false, drawable: () => false, glyph: () => void 0 };
+  }
+  ranges.sort((a, b) => a[0] - b[0]);
+  return {
+    glyph(codePoint) {
+      return glyphs.get(codePoint);
+    },
+    drawable(codePoint) {
+      const glyph = glyphs.get(codePoint);
+      if (glyph === void 0 || glyph === 0) return false;
+      return outlines ? outlines(glyph) : true;
+    },
+    has(codePoint) {
+      let low = 0;
+      let high = ranges.length - 1;
+      while (low <= high) {
+        const middle = low + high >> 1;
+        const [start, end] = ranges[middle];
+        if (codePoint < start) high = middle - 1;
+        else if (codePoint > end) low = middle + 1;
+        else return true;
+      }
+      return false;
+    }
+  };
+}
+var TextMeasurer = class {
+  #pdfium;
+  #document;
+  #advances = /* @__PURE__ */ new Map();
+  #metrics = /* @__PURE__ */ new Map();
+  constructor(pdfium, document2) {
+    this.#pdfium = pdfium;
+    this.#document = document2;
+  }
+  /** Width of `text` in points at `fontSize`, without kerning. */
+  advance(font, fontSize, text) {
+    let total = 0;
+    for (const character of text) total += this.#advanceOf(font, character);
+    return total * fontSize / 1e3;
+  }
+  /** Ascent above and descent below the baseline, in points, both positive. */
+  metrics(font, fontSize) {
+    let unit = this.#metrics.get(font);
+    if (!unit) {
+      const { lib } = this.#pdfium;
+      const ascent = this.#pdfium.readNumbers(
+        1,
+        "float",
+        ([pointer]) => lib.FPDFFont_GetAscent(font, 1e3, pointer)
+      )?.[0] ?? 750;
+      const descent = this.#pdfium.readNumbers(
+        1,
+        "float",
+        ([pointer]) => lib.FPDFFont_GetDescent(font, 1e3, pointer)
+      )?.[0] ?? -250;
+      unit = { ascent, descent: Math.abs(descent) };
+      this.#metrics.set(font, unit);
+    }
     return {
-      name,
-      cid,
-      glyphNames,
-      widths,
-      bbox: [xMin, yMin, xMax, yMax],
-      unitsPerEm
+      ascent: unit.ascent * fontSize / 1e3,
+      descent: unit.descent * fontSize / 1e3
     };
-  } 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;
+  #advanceOf(font, character) {
+    let cache = this.#advances.get(font);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      this.#advances.set(font, cache);
     }
-    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]);
+    let advance2 = cache.get(character);
+    if (advance2 === void 0) {
+      advance2 = this.#inkWidth(font, `H${character}H`) - this.#inkWidth(font, "HH");
+      cache.set(character, advance2);
+    }
+    return advance2;
   }
-  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] ?? "";
-        }
+  #inkWidth(font, text) {
+    const { lib } = this.#pdfium;
+    const object = lib.FPDFPageObj_CreateTextObj(this.#document, font, 1e3);
+    try {
+      const wide = this.#pdfium.writeWideString(text);
+      try {
+        lib.FPDFText_SetText(object, wide);
+      } finally {
+        this.#pdfium.free(wide);
       }
-      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");
+      const bounds = this.#pdfium.readNumbers(
+        4,
+        "float",
+        ([l, b, r, t]) => lib.FPDFPageObj_GetBounds(object, l, b, r, t)
+      );
+      return bounds ? bounds[2] - bounds[0] : 0;
+    } finally {
+      lib.FPDFPageObj_Destroy(object);
+    }
   }
-  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;
+};
+function fontCanDraw(pdfium, font, text) {
+  const { lib } = pdfium;
+  if (!lib.FPDFFont_GetIsEmbedded(font)) {
+    const base = pdfium.readUtf8String(
+      (buffer, bytes2) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes2)
+    );
+    return isStandardFamily(base.split(/[-,]/)[0] ?? "") && firstNonWinAnsi(text) === void 0;
   }
-  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;
+  const coverage = fontCoverage(pdfium, font);
+  if (!coverage) return false;
+  return [...text].every((character) => {
+    const code = character.codePointAt(0);
+    if (code === 32) return (coverage.glyph(code) ?? 0) !== 0;
+    return code === 10 || coverage.drawable(code);
+  });
 }
-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;
+function fontCanRewrite(pdfium, font, text) {
+  const characters = [...text].filter((character) => character !== "\n");
+  if (!characters.every(
+    (character) => advance(pdfium, font, character.codePointAt(0)) > 0
+  ))
+    return false;
+  if (fontCanDraw(pdfium, font, text)) return true;
+  if (!pdfium.lib.FPDFFont_GetIsEmbedded(font)) return false;
+  const data = fontBytes(pdfium, font);
+  const coverage = data && cffCoverage(data);
+  if (!coverage) return false;
+  return characters.every(
+    (character) => coverage.has(character.codePointAt(0))
+  );
+}
+function advance(pdfium, font, code) {
+  if (code > 65535) return 0;
+  return pdfium.readNumbers(
+    1,
+    "float",
+    ([width]) => pdfium.lib.FPDFFont_GetGlyphWidth(font, code, 1e3, width)
+  )?.[0] ?? 0;
+}
+function cffCoverage(data) {
+  const cff = readCff(data);
+  if (!cff || cff.cid) return void 0;
+  const glyphs = /* @__PURE__ */ new Map();
+  cff.glyphNames.forEach((name, glyph) => {
+    const code = glyphUnicode(name);
+    if (glyph !== 0 && code !== void 0 && !glyphs.has(code))
+      glyphs.set(code, glyph);
+  });
+  return {
+    has: (code) => glyphs.has(code),
+    glyph: (code) => glyphs.get(code),
+    drawable: (code) => glyphs.has(code)
+  };
+}
+function fontCoverage(pdfium, font) {
+  const data = fontBytes(pdfium, font);
+  if (!data) return void 0;
+  const tag = String.fromCharCode(...data.slice(0, 4));
+  const truetype = data[0] === 0 && data[1] === 1 && data[2] === 0 && data[3] === 0 || tag === "true";
+  return truetype ? parseCmap(data) : void 0;
+}
+function fontBytes(pdfium, font) {
+  const { lib } = pdfium;
+  const size = pdfium.readNumbers(
+    1,
+    "i32",
+    ([out]) => lib.FPDFFont_GetFontData(font, 0, 0, out)
+  )?.[0];
+  if (!size) return void 0;
+  const buffer = pdfium.malloc(size);
+  try {
+    const out = pdfium.malloc(4);
+    try {
+      if (!lib.FPDFFont_GetFontData(font, buffer, size, out)) return void 0;
+    } finally {
+      pdfium.free(out);
     }
-    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;
+    return pdfium.readBytes(buffer, size);
+  } finally {
+    pdfium.free(buffer);
+  }
 }
-function latin1(bytes2) {
-  return String.fromCharCode(...bytes2);
+function validateScript(text, issue) {
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    if (code >= 1424 && code <= 2303 || code >= 64285 && code <= 65023 || code >= 65136 && code <= 65279) {
+      issue(
+        "/text",
+        "unsupported-script",
+        `Right-to-left text such as "${character}" cannot be edited yet`
+      );
+      return false;
+    }
+  }
+  return true;
 }
 
 // src/edit/pdf/engine/opentype.ts
@@ -8088,7 +8296,7 @@ function textFaceOf(pdfium, object, cache) {
   );
   if (!lib.FPDFFont_GetIsEmbedded(font))
     return { key: `name:${baseName}`, family, missing: "not-embedded" };
-  const program = fontProgram(pdfium, font);
+  const program = fontBytes(pdfium, font);
   if (!program)
     return { key: `embedded:${baseName}`, family, missing: "unreadable" };
   const key = `${baseName}#${fnv1a(program).toString(16)}`;
@@ -8118,23 +8326,6 @@ function faceOf(program, baseName) {
   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);
@@ -8474,7 +8665,7 @@ function resolveTableStyle(style) {
     headerFill: style.headerFill ?? null
   };
 }
-function layoutTable(spec, ascent, advance) {
+function layoutTable(spec, ascent, advance2) {
   const { cellPadding, fontSize } = spec.style;
   const columns = [];
   let x = spec.at.x;
@@ -8494,7 +8685,7 @@ function layoutTable(spec, ascent, advance) {
         lineHeight: LINE_HEIGHT,
         align: "left",
         ascent,
-        advance
+        advance: advance2
       })
     );
     const height = Math.max(...layouts.map((layout) => layout.height)) + 2 * cellPadding;
@@ -8698,9 +8889,9 @@ function removeObjects(context, location) {
       const object = lib.FPDFPage_GetObject(page, index);
       lib.FPDFPage_RemoveObject(page, object);
       lib.FPDFPageObj_Destroy(object);
+      context.spliceObjects(location.pageIndex, index, 1, []);
     }
   });
-  context.spliceObjects(location.pageIndex, first, location.indexes.length, []);
   return first;
 }
 function textBoxTarget(target, context, issue = () => {
@@ -8761,6 +8952,7 @@ function fontRequestsOf(operations, markOf, elementOf) {
           text: operation2.text
         });
         break;
+      case "replaceParagraphText":
       case "replaceText": {
         const box = spec(operation2.target);
         if (box) {
@@ -8768,14 +8960,20 @@ function fontRequestsOf(operations, markOf, elementOf) {
           break;
         }
         const element = elementOf(operation2.target);
-        if (element?.kind === "text")
+        if (element?.kind === "text" || element?.kind === "paragraph")
           requests.push({
             family: element.textStyle?.fontFamily ?? "Helvetica",
-            text: operation2.text
+            text: element.kind === "paragraph" && operation2.range ? (element.text ?? "").slice(0, operation2.range.start.offset) + operation2.text + (element.text ?? "").slice(operation2.range.end.offset) : operation2.text
           });
         break;
       }
       case "setTextStyle": {
+        const paragraph = elementOf(operation2.target);
+        if (paragraph?.kind === "paragraph" && operation2.style.fontSize !== void 0 && operation2.style.fontSize !== paragraph.textStyle?.fontSize)
+          requests.push({
+            family: paragraph.textStyle?.fontFamily ?? "Helvetica",
+            text: paragraph.text ?? ""
+          });
         const box = spec(operation2.target);
         if (box)
           requests.push({
@@ -8813,83 +9011,826 @@ ${operation2.text}`
           });
         break;
       }
-      default:
-        break;
+      default:
+        break;
+    }
+  }
+  return requests;
+}
+function fontRequest(style, text) {
+  return {
+    family: style.fontFamily,
+    bold: style.bold,
+    italic: style.italic,
+    text
+  };
+}
+function validateFont(request, context, issue) {
+  const problem = context.fonts.problem(request);
+  if (problem) issue(problem.path, problem.code, problem.message);
+}
+function placeUpright(pdfium, object, geometry, pageX, pageY) {
+  const [a, b, c, d] = ROTATIONS[geometry.rotation % 4];
+  const origin = pageToUser(geometry, pageX, pageY);
+  pdfium.lib.FPDFPageObj_Transform(object, a, b, c, d, origin.x, origin.y);
+}
+var ROTATIONS = [
+  [1, 0, 0, 1],
+  [0, 1, -1, 0],
+  [-1, 0, 0, -1],
+  [0, -1, 1, 0]
+];
+function setText(pdfium, object, text) {
+  const wide = pdfium.writeWideString(text);
+  try {
+    pdfium.lib.FPDFText_SetText(object, wide);
+  } finally {
+    pdfium.free(wide);
+  }
+}
+function parseColor(color) {
+  return [1, 3, 5].map(
+    (offset2) => Number.parseInt(color.slice(offset2, offset2 + 2), 16)
+  );
+}
+function resolveStyle(style) {
+  return {
+    fontFamily: style.fontFamily ?? "Helvetica",
+    fontSize: style.fontSize ?? 12,
+    bold: style.bold ?? false,
+    italic: style.italic ?? false,
+    color: style.color ?? "#000000",
+    align: style.align ?? "left",
+    lineHeight: style.lineHeight ?? 1.2
+  };
+}
+function definedFields(style) {
+  return Object.fromEntries(
+    Object.entries(style).filter(([, value]) => value !== void 0)
+  );
+}
+function validateRect(rect, geometry, issue, path = "/rect") {
+  const size = displayedSize(geometry);
+  const tolerance = 0.01;
+  if (rect.x < -tolerance || rect.y < -tolerance || rect.x + rect.width > size.width + tolerance || rect.y + rect.height > size.height + tolerance)
+    issue(
+      path,
+      "range",
+      `The rectangle must lie within the ${size.width}\xD7${size.height} pt page`
+    );
+}
+
+// src/edit/pdf/engine/operations.ts
+function issueCollector(operationIndex, issues) {
+  return (path, code, message) => issues.push({ operationIndex, path, code, message });
+}
+
+// src/edit/pdf/engine/paragraph.ts
+function paragraphElement(paragraph) {
+  return {
+    id: paragraph.id,
+    kind: "paragraph",
+    pageIndex: paragraph.pageIndex,
+    text: paragraph.text,
+    bounds: paragraph.bounds,
+    textStyle: paragraph.textStyle,
+    operations: [
+      "replaceParagraphText",
+      "replaceText",
+      "setTextStyle",
+      "deleteElement"
+    ]
+  };
+}
+var MIN_CONTINUATION_FILL = 0.9;
+var MAX_CONNECTED_EDGE_GAP = 0.65;
+var MAX_LEFT_ALIGNMENT_DELTA = 1;
+var ADJACENT_BASELINE_EM = 0.25;
+var ADJACENT_TEXT_GAP_EM = 3;
+var LIST_ITEM_START = /^(?:[•◦▪‣·*–—-]|\(?\d{1,3}[.)]|\(?[a-z][.)])\s/iu;
+var NUMERIC_VALUE = /^[\d\s.,:/%()+−–—-]+$/u;
+var GLYPH_POSITION_PRECISION = 1e-3;
+var MAX_PAIR_ADJUSTMENT_EM = 0.1;
+var MATRIX_RELATIVE_PRECISION = 1e-6;
+function discoverParagraphs(pdfium, page, pageIndex, geometry, records, elements, textPage, measurer) {
+  const result3 = /* @__PURE__ */ new Map();
+  if (geometry.rotation !== 0) return result3;
+  const indexesById = /* @__PURE__ */ new Map();
+  records.forEach((record, index) => {
+    const indexes = indexesById.get(record.id) ?? [];
+    indexes.push(index);
+    indexesById.set(record.id, indexes);
+  });
+  const elementsById = /* @__PURE__ */ new Map();
+  for (const element of elements)
+    if (!elementsById.has(element.id)) elementsById.set(element.id, element);
+  for (const element of elements) {
+    const indexes = indexesById.get(element.id) ?? [];
+    const spec = paragraphSpecOf(records[indexes[0] ?? -1]?.mark);
+    if (!spec) continue;
+    const paragraph = {
+      id: element.id,
+      pageIndex,
+      text: spec.text,
+      bounds: spec.rect,
+      textStyle: spec.style,
+      memberIds: [element.id],
+      members: [{ elementId: element.id, start: 0, end: spec.text.length }]
+    };
+    result3.set(element.id, { paragraph, spec, indexes });
+  }
+  const rows = [];
+  const uprightTexts = /* @__PURE__ */ new Map();
+  const fontKeys = /* @__PURE__ */ new Map();
+  const programs = [];
+  const fontKey = (font) => {
+    const cached = fontKeys.get(font);
+    if (cached) return cached;
+    let key;
+    if (!pdfium.lib.FPDFFont_GetIsEmbedded(font))
+      key = `standard:${pdfium.readUtf8String((buffer, bytes2) => pdfium.lib.FPDFFont_GetBaseFontName(font, buffer, bytes2))}`;
+    else {
+      const bytes2 = fontBytes(pdfium, font);
+      let at = bytes2 ? programs.findIndex(
+        (program) => program.length === bytes2.length && program.every((byte, index) => byte === bytes2[index])
+      ) : -1;
+      if (at < 0 && bytes2) {
+        at = programs.length;
+        programs.push(bytes2);
+      }
+      key = bytes2 ? `embedded:${at}` : `unreadable:${font}`;
+    }
+    fontKeys.set(font, key);
+    return key;
+  };
+  const { lib } = pdfium;
+  const rightEdges = /* @__PURE__ */ new Map();
+  const glyphsByObject = /* @__PURE__ */ new Map();
+  for (let at = 0; at < lib.FPDFText_CountChars(textPage); at += 1) {
+    const unicode = lib.FPDFText_GetUnicode(textPage, at);
+    if (!Number.isInteger(unicode) || unicode < 32 || unicode > 1114111 || unicode >= 55296 && unicode <= 57343)
+      continue;
+    const object = lib.FPDFText_GetTextObject(textPage, at);
+    if (!object) continue;
+    const text = String.fromCodePoint(unicode);
+    const origin = pdfium.readNumbers(
+      2,
+      "double",
+      ([x, y]) => lib.FPDFText_GetCharOrigin(textPage, at, x, y)
+    );
+    if (origin) {
+      const point = userToPage(geometry, origin[0], origin[1]);
+      const glyphs = glyphsByObject.get(object) ?? [];
+      glyphs.push({ text, ...point });
+      glyphsByObject.set(object, glyphs);
+    }
+    if (/\s/u.test(text)) continue;
+    const box = pdfium.readNumbers(
+      4,
+      "float",
+      ([out]) => lib.FPDFText_GetLooseCharBox(textPage, at, out)
+    );
+    if (box)
+      rightEdges.set(
+        object,
+        Math.max(
+          rightEdges.get(object) ?? -Infinity,
+          userToPage(geometry, box[2], box[1]).x
+        )
+      );
+  }
+  records.forEach((record, index) => {
+    if (record.mark || record.staleMarkId || record.type !== OBJECT_TEXT || record.id.includes("/"))
+      return;
+    const element = elementsById.get(record.id);
+    if (!element?.text?.trim()) return;
+    const object = lib.FPDFPage_GetObject(page, index);
+    const matrix = pdfium.readNumbers(
+      6,
+      "float",
+      ([out]) => lib.FPDFPageObj_GetMatrix(object, out)
+    );
+    if (!matrix || matrix[0] <= 0 || matrix[3] <= 0 || Math.abs(matrix[1]) > 1e-3 || Math.abs(matrix[2]) > 1e-3)
+      return;
+    const origin = userToPage(geometry, matrix[4], matrix[5]);
+    uprightTexts.set(element.id, { element, baseline: origin.y });
+    if (!element.textStyle || element.text !== element.text.trimStart() || element.rotation || element.text.includes("") || /[\r\n\t]/u.test(element.text) || LIST_ITEM_START.test(element.text) || NUMERIC_VALUE.test(element.text) || Math.abs(matrix[0] - matrix[3]) > Math.max(matrix[0], matrix[3]) * MATRIX_RELATIVE_PRECISION)
+      return;
+    const rgba = pdfium.readNumbers(
+      4,
+      "i32",
+      ([r, g, b, a]) => lib.FPDFPageObj_GetFillColor(object, r, g, b, a)
+    );
+    if (rgba?.[3] !== 255 || lib.FPDFTextObj_GetTextRenderMode(object) !== 0)
+      return;
+    const font = lib.FPDFTextObj_GetFont(object);
+    const rawSize = pdfium.readNumbers(
+      1,
+      "float",
+      ([out]) => lib.FPDFTextObj_GetFontSize(object, out)
+    )?.[0];
+    if (!rawSize) return;
+    const effective = {
+      ...element,
+      textStyle: {
+        ...element.textStyle,
+        fontSize: round(rawSize * matrix[0])
+      }
+    };
+    if (effective.textStyle.fontSize < 1 || effective.textStyle.fontSize > 500)
+      return;
+    if (fontCanDraw(pdfium, font, element.text) && !hasSupportedAdvances(
+      glyphsByObject.get(object) ?? [],
+      element.text,
+      font,
+      rawSize * matrix[0],
+      measurer
+    ))
+      return;
+    const width = (rightEdges.get(object) ?? element.bounds.x + element.bounds.width) - origin.x;
+    if (!(width > 0) || element.bounds.width > width + 2) return;
+    rows.push({
+      element: effective,
+      index,
+      font: fontKey(font),
+      fontHandle: font,
+      x: origin.x,
+      baseline: origin.y,
+      width,
+      firstWordAdvance: observedFirstWordAdvance(
+        glyphsByObject.get(object) ?? [],
+        element.text
+      )
+    });
+  });
+  rows.sort((a, b) => a.baseline - b.baseline || a.x - b.x);
+  const blockedRows = rowsWithAdjacentText(rows, [...uprightTexts.values()]);
+  const used = /* @__PURE__ */ new Set();
+  for (const first of rows) {
+    if (used.has(first.element.id) || blockedRows.has(first.element.id))
+      continue;
+    const aligned = rows.filter(
+      (row) => !used.has(row.element.id) && row.baseline >= first.baseline && compatible(first, row)
+    );
+    const gaps = aligned.slice(1).map((row, index) => row.baseline - aligned[index].baseline).filter(
+      (gap) => gap >= first.element.textStyle.fontSize * 0.8 && gap <= first.element.textStyle.fontSize * 2.1
+    );
+    if (gaps.length === 0) continue;
+    const leading = Math.min(...gaps);
+    const group = [];
+    for (const row of aligned) {
+      const previous = group.at(-1);
+      if (previous && (Math.abs(row.baseline - previous.baseline - leading) > Math.max(1, leading * 0.15) || /[-\u00ad\u0002]$/u.test(previous.element.text.trim())))
+        break;
+      group.push(row);
+    }
+    if (group.length < 2 || group.some((row) => blockedRows.has(row.element.id)))
+      continue;
+    const bounds = unionRects(group.map((row) => row.element.bounds));
+    const rect = roundRect({
+      x: first.x,
+      y: bounds.y,
+      width: Math.max(...group.map((row) => row.width)),
+      height: bounds.height
+    });
+    const ids = new Set(group.map((row) => row.element.id));
+    const firstIndex = Math.min(...group.map((row) => row.index));
+    if (group.slice(0, -1).some(
+      (row, index) => !continuesAtWrap(
+        row,
+        group[index + 1],
+        rect.width,
+        pdfium,
+        measurer
+      )
+    ) || elements.some((element) => {
+      if (ids.has(element.id) || !element.text?.trim()) return false;
+      const b = element.bounds;
+      const upright = uprightTexts.get(element.id);
+      const sharesRow = upright && group.some((row) => isAdjacentText(row, upright));
+      if (sharesRow) return true;
+      const sharesColumn = b.x < rect.x + rect.width && b.x + b.width > rect.x;
+      const edgeGap = Math.max(
+        b.y - (rect.y + rect.height),
+        rect.y - (b.y + b.height)
+      );
+      return sharesColumn && edgeGap <= leading * MAX_CONNECTED_EDGE_GAP;
+    }))
+      continue;
+    if (elements.some(
+      (element) => !ids.has(element.id) && intersects(rect, element.bounds) && !backgroundBehind(element, rect, records, firstIndex)
+    ))
+      continue;
+    const id = `${first.element.id}:paragraph`;
+    if (elementsById.has(id)) continue;
+    let text = "";
+    const members = group.map((row) => {
+      if (text) text += " ";
+      const start = text.length;
+      text += row.element.text.trim();
+      return { elementId: row.element.id, start, end: text.length };
+    });
+    if (text.length > 2e4) continue;
+    const style = {
+      ...first.element.textStyle,
+      lineHeight: leading / first.element.textStyle.fontSize
+    };
+    const paragraph = {
+      id,
+      pageIndex,
+      text,
+      bounds: rect,
+      textStyle: style,
+      memberIds: [...ids],
+      members
+    };
+    const target = {
+      paragraph,
+      spec: {
+        kind: "paragraph",
+        id,
+        text,
+        lines: group.map((row) => row.element.text.trim()),
+        rect,
+        style,
+        baselineOffset: (first.baseline - rect.y) / style.fontSize
+      },
+      indexes: group.map((row) => row.index).sort((a, b) => a - b)
+    };
+    result3.set(id, target);
+    for (const member of members) {
+      result3.set(member.elementId, target);
+      used.add(member.elementId);
+    }
+  }
+  return result3;
+}
+function compatible(a, b) {
+  return Math.abs(a.x - b.x) <= MAX_LEFT_ALIGNMENT_DELTA && sameTypography(a, b);
+}
+function sameTypography(a, b) {
+  const x = a.element.textStyle;
+  const y = b.element.textStyle;
+  return a.font === b.font && x.fontSize === y.fontSize && x.color === y.color && x.bold === y.bold && x.italic === y.italic;
+}
+function rowsWithAdjacentText(rows, texts) {
+  texts.sort((a, b) => a.baseline - b.baseline);
+  const blocked = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const tolerance = row.element.textStyle.fontSize * ADJACENT_BASELINE_EM;
+    let low = 0;
+    let high = texts.length;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      if (texts[mid].baseline < row.baseline - tolerance) low = mid + 1;
+      else high = mid;
+    }
+    for (let at = low; at < texts.length; at += 1) {
+      const other = texts[at];
+      if (other.baseline > row.baseline + tolerance) break;
+      if (isAdjacentText(row, other)) {
+        blocked.add(row.element.id);
+        break;
+      }
+    }
+  }
+  return blocked;
+}
+function isAdjacentText(row, other) {
+  if (row.element.id === other.element.id) return false;
+  const size = row.element.textStyle.fontSize;
+  if (Math.abs(row.baseline - other.baseline) > size * ADJACENT_BASELINE_EM)
+    return false;
+  const a = row.element.bounds;
+  const b = other.element.bounds;
+  const gap = Math.max(b.x - (a.x + a.width), a.x - (b.x + b.width));
+  return gap <= size * ADJACENT_TEXT_GAP_EM;
+}
+function continuesAtWrap(row, next, width, pdfium, measurer) {
+  if (row.width >= width * MIN_CONTINUATION_FILL) return true;
+  if (next.firstWordAdvance !== void 0)
+    return row.width + next.firstWordAdvance > width + GLYPH_POSITION_PRECISION;
+  const nextWord = next.element.text.trim().split(/\s/u)[0];
+  if (!nextWord || !fontCanDraw(pdfium, row.fontHandle, ` ${nextWord}`))
+    return false;
+  const needed = measurer.advance(
+    row.fontHandle,
+    row.element.textStyle.fontSize,
+    ` ${nextWord}`
+  );
+  return Number.isFinite(needed) && row.width + needed > width + GLYPH_POSITION_PRECISION;
+}
+function observedFirstWordAdvance(glyphs, text) {
+  const prefix = /^\S+\s+/u.exec(text)?.[0];
+  if (!prefix) return void 0;
+  const count = [...prefix].length;
+  const first = glyphs[0];
+  const nextWord = glyphs[count];
+  if (!first || !nextWord || glyphs.slice(0, count).map((glyph) => glyph.text).join("") !== prefix)
+    return void 0;
+  const advance2 = nextWord.x - first.x;
+  return Number.isFinite(advance2) && advance2 > 0 ? advance2 : void 0;
+}
+function hasSupportedAdvances(glyphs, text, font, fontSize, measurer) {
+  const characters = [...text.trimEnd()];
+  const first = glyphs[0];
+  if (!first || glyphs.length < characters.length) return false;
+  const pairLimit = fontSize * MAX_PAIR_ADJUSTMENT_EM;
+  let previousAdvance = 0;
+  let cumulativeAdjustment = 0;
+  let adjustedPairs = 0;
+  let defaultPairs = 0;
+  for (const [index, character] of characters.entries()) {
+    const glyph = glyphs[index];
+    if (!glyph || glyph.text !== character || !Number.isFinite(glyph.x) || !Number.isFinite(glyph.y) || Math.abs(glyph.y - first.y) > GLYPH_POSITION_PRECISION)
+      return false;
+    const previous = glyphs[index - 1];
+    if (previous) {
+      const adjustment = glyph.x - previous.x - previousAdvance;
+      const changed2 = Math.abs(adjustment) > GLYPH_POSITION_PRECISION;
+      if (/\s/u.test(previous.text + character)) {
+        if (changed2) return false;
+      } else if (changed2) {
+        if (Math.abs(adjustment) > pairLimit) return false;
+        adjustedPairs += 1;
+      } else {
+        defaultPairs += 1;
+      }
+      cumulativeAdjustment += adjustment;
+      if (Math.abs(cumulativeAdjustment) > pairLimit) return false;
+    }
+    previousAdvance = measurer.advance(font, fontSize, character);
+    if (!Number.isFinite(previousAdvance) || previousAdvance <= 0) return false;
+  }
+  return adjustedPairs === 0 || defaultPairs > adjustedPairs;
+}
+function intersects(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+function backgroundBehind(element, rect, records, first) {
+  const b = element.bounds;
+  return element.kind !== "text" && element.text === void 0 && records.findIndex((record) => record.id === element.id) < first && b.x <= rect.x && b.y <= rect.y && b.x + b.width >= rect.x + rect.width && b.y + b.height >= rect.y + rect.height;
+}
+
+// src/edit/pdf/engine/paragraph-edit.ts
+var replaceParagraphText = {
+  validate(operation2, context, issue) {
+    const target = targetOf(operation2.target, context, issue);
+    if (!target) return;
+    const text = replacement(operation2, target.spec.text, issue);
+    if (text === void 0 || !validateScript(text, issue)) return;
+    if (text.length > 2e4) {
+      issue(
+        "/text",
+        "max-length",
+        "The complete paragraph cannot exceed 20000 characters"
+      );
+      return;
+    }
+    prepare(context, target, { ...target.spec, text }, issue);
+  },
+  apply(operation2, context) {
+    const target = requireTarget(operation2.target, context);
+    const text = replacement(operation2, target.spec.text);
+    if (text === void 0)
+      throw new ViewerError("invalid-operation", "Invalid paragraph range");
+    return rebuild(context, target, { ...target.spec, text });
+  }
+};
+var paragraphSetTextStyle = {
+  validate(operation2, context, issue) {
+    const target = targetOf(operation2.target, context, issue);
+    if (!target) return;
+    for (const field of [
+      "fontFamily",
+      "bold",
+      "italic",
+      "align",
+      "lineHeight"
+    ])
+      if (operation2.style[field] !== void 0)
+        issue(
+          `/style/${field}`,
+          "unsupported-style",
+          `Only color and fontSize can change on imported paragraphs; ${field} cannot`
+        );
+    const spec = styled(target.spec, operation2);
+    if (spec.style.fontSize !== target.spec.style.fontSize)
+      prepare(context, target, spec, issue);
+  },
+  apply(operation2, context) {
+    const target = requireTarget(operation2.target, context);
+    const spec = styled(target.spec, operation2);
+    if (spec.style.fontSize === target.spec.style.fontSize)
+      return colorInPlace(context, target, spec);
+    return rebuild(context, target, spec);
+  }
+};
+function colorInPlace(context, target, spec) {
+  const { pdfium } = context;
+  const { lib } = pdfium;
+  const color = parseColor(spec.style.color);
+  const persisted = target.paragraph.memberIds.includes(spec.id);
+  context.withPage(target.paragraph.pageIndex, (page) => {
+    for (const index of target.indexes) {
+      const object = lib.FPDFPage_GetObject(page, index);
+      if (lib.FPDFPageObj_GetType(object) === OBJECT_TEXT)
+        lib.FPDFPageObj_SetFillColor(object, ...color, 255);
+      if (!persisted) continue;
+      for (let at = 0; at < lib.FPDFPageObj_CountMarks(object); at += 1) {
+        const mark = lib.FPDFPageObj_GetMark(object, at);
+        const name = pdfium.readWideStringOut(
+          (buffer, bytes2, out) => lib.FPDFPageObjMark_GetName(mark, buffer, bytes2, out)
+        );
+        if (name === MARK_NAME)
+          lib.FPDFPageObjMark_SetStringParam(
+            context.document,
+            object,
+            mark,
+            MARK_PARAM,
+            JSON.stringify(spec)
+          );
+      }
+      context.spliceObjects(target.paragraph.pageIndex, index, 1, [
+        { id: spec.id, type: lib.FPDFPageObj_GetType(object), mark: spec }
+      ]);
     }
-  }
-  return requests;
-}
-function fontRequest(style, text) {
+  });
   return {
-    family: style.fontFamily,
-    bold: style.bold,
-    italic: style.italic,
-    text
+    createdIds: [],
+    changedPages: [target.paragraph.pageIndex],
+    warnings: []
   };
 }
-function validateFont(request, context, issue) {
-  const problem = context.fonts.problem(request);
-  if (problem) issue(problem.path, problem.code, problem.message);
-}
-function placeUpright(pdfium, object, geometry, pageX, pageY) {
-  const [a, b, c, d] = ROTATIONS[geometry.rotation % 4];
-  const origin = pageToUser(geometry, pageX, pageY);
-  pdfium.lib.FPDFPageObj_Transform(object, a, b, c, d, origin.x, origin.y);
+function styled(spec, operation2) {
+  return {
+    ...spec,
+    style: {
+      ...spec.style,
+      ...operation2.style.fontSize === void 0 ? {} : { fontSize: round(operation2.style.fontSize) },
+      ...operation2.style.color === void 0 ? {} : { color: operation2.style.color }
+    }
+  };
 }
-var ROTATIONS = [
-  [1, 0, 0, 1],
-  [0, 1, -1, 0],
-  [-1, 0, 0, -1],
-  [0, -1, 1, 0]
-];
-function setText(pdfium, object, text) {
-  const wide = pdfium.writeWideString(text);
-  try {
-    pdfium.lib.FPDFText_SetText(object, wide);
-  } finally {
-    pdfium.free(wide);
+function targetOf(id, context, issue) {
+  const target = context.paragraph(id);
+  if (!target || target.paragraph.id !== id) {
+    issue(
+      "/target",
+      "unsupported-target",
+      "The target must be a resolved native paragraph id"
+    );
+    return void 0;
   }
+  return target;
 }
-function parseColor(color) {
-  return [1, 3, 5].map(
-    (offset2) => Number.parseInt(color.slice(offset2, offset2 + 2), 16)
+function requireTarget(id, context) {
+  const target = targetOf(id, context, () => {
+  });
+  if (!target)
+    throw new ViewerError(
+      "invalid-operation",
+      "The paragraph no longer exists"
+    );
+  return target;
+}
+function replacement(operation2, previous, issue = () => {
+}) {
+  const range = operation2.range;
+  if (!range) return operation2.text;
+  const valid = [range.start, range.end].every(
+    (position) => position.elementId === operation2.target && Number.isInteger(position.offset) && position.offset >= 0 && position.offset <= previous.length
   );
+  if (!valid || range.start.offset > range.end.offset) {
+    issue(
+      "/range",
+      "invalid-range",
+      "The range must lie inside the paragraph's logical text"
+    );
+    return void 0;
+  }
+  return previous.slice(0, range.start.offset) + operation2.text + previous.slice(range.end.offset);
 }
-function resolveStyle(style) {
+function fontFor(context, target, spec, page) {
+  const { lib } = context.pdfium;
+  const original = target.indexes.map((index) => lib.FPDFPage_GetObject(page, index)).find((object) => lib.FPDFPageObj_GetType(object) === OBJECT_TEXT);
+  const native = original === void 0 ? void 0 : lib.FPDFTextObj_GetFont(original);
+  if (native !== void 0 && fontCanDraw(context.pdfium, native, spec.text))
+    return {
+      handle: native,
+      family: spec.style.fontFamily,
+      substituted: false
+    };
+  const family = isStandardFamily(spec.style.fontFamily) || context.fonts.hasFamily(spec.style.fontFamily) ? spec.style.fontFamily : "Helvetica";
+  const request = {
+    family,
+    bold: spec.style.bold,
+    italic: spec.style.italic,
+    text: spec.text
+  };
+  const problem = context.fonts.problem(request);
+  if (problem) return { problem };
+  const font = context.fonts.resolve(context.pdfium, context.document, request);
   return {
-    fontFamily: style.fontFamily ?? "Helvetica",
-    fontSize: style.fontSize ?? 12,
-    bold: style.bold ?? false,
-    italic: style.italic ?? false,
-    color: style.color ?? "#000000",
-    align: style.align ?? "left",
-    lineHeight: style.lineHeight ?? 1.2
+    handle: font.handle,
+    family: font.family,
+    substituted: original !== void 0 || !isStandardFamily(spec.style.fontFamily),
+    ...font.substitution ? { substitution: font.substitution } : {}
   };
 }
-function definedFields(style) {
-  return Object.fromEntries(
-    Object.entries(style).filter(([, value]) => value !== void 0)
-  );
+function prepare(context, target, spec, issue) {
+  return context.readPage(target.paragraph.pageIndex, (page) => {
+    const font = fontFor(context, target, spec, page);
+    if ("problem" in font) {
+      issue(font.problem.path, font.problem.code, font.problem.message);
+      return void 0;
+    }
+    const metrics = context.measurer.metrics(font.handle, spec.style.fontSize);
+    const layout = layoutText({
+      text: spec.text,
+      width: spec.rect.width,
+      height: Number.POSITIVE_INFINITY,
+      fontSize: spec.style.fontSize,
+      lineHeight: spec.style.lineHeight,
+      align: "left",
+      ascent: spec.baselineOffset * spec.style.fontSize,
+      advance: (text) => context.measurer.advance(font.handle, spec.style.fontSize, text)
+    });
+    const last = layout.lines.at(-1);
+    const height = spec.text.trim() && last ? last.baseline + metrics.descent : spec.rect.height;
+    const rect = { ...spec.rect, height: Math.max(height, 1e-3) };
+    const size = context.pageSize(target.paragraph.pageIndex);
+    const members = new Set(target.paragraph.memberIds);
+    const collision = context.pageElements(target.paragraph.pageIndex).some((element) => {
+      if (members.has(element.id) || !intersects(rect, element.bounds))
+        return false;
+      const old = target.spec.rect;
+      const b = element.bounds;
+      const location = context.locate(element.id);
+      const behind = location && location.indexes.every((index) => index < target.indexes[0]);
+      return !(element.text === void 0 && behind && b.x <= old.x && b.y <= old.y && b.x + b.width >= rect.x + rect.width && b.y + b.height >= rect.y + rect.height);
+    });
+    if (collision || rect.x < 0 || rect.y < 0 || rect.x + rect.width > size.width + 0.01 || rect.y + rect.height > size.height + 0.01) {
+      issue(
+        "/text",
+        "paragraph-overflow",
+        "The paragraph would overlap neighboring content or leave the page"
+      );
+      return void 0;
+    }
+    const warnings = font.substituted ? [
+      {
+        code: "font-substitution",
+        message: "substitution" in font && font.substitution ? font.substitution : `${spec.style.fontFamily} cannot draw the new paragraph; ${font.family} is used`,
+        details: { elementId: spec.id }
+      }
+    ] : [];
+    return {
+      spec: {
+        ...spec,
+        rect,
+        lines: layout.lines.map((line) => line.text).filter(Boolean),
+        style: {
+          ...spec.style,
+          fontFamily: font.substituted ? font.family : spec.style.fontFamily
+        }
+      },
+      layout,
+      warnings
+    };
+  });
 }
-function validateRect(rect, geometry, issue, path = "/rect") {
-  const size = displayedSize(geometry);
-  const tolerance = 0.01;
-  if (rect.x < -tolerance || rect.y < -tolerance || rect.x + rect.width > size.width + tolerance || rect.y + rect.height > size.height + tolerance)
-    issue(
-      path,
-      "range",
-      `The rectangle must lie within the ${size.width}\xD7${size.height} pt page`
+function rebuild(context, target, spec) {
+  const issues = [];
+  const prepared = prepare(
+    context,
+    target,
+    spec,
+    (path, code, message) => issues.push({ path, code, message })
+  );
+  if (!prepared)
+    throw new ViewerError(
+      "invalid-operation",
+      "The paragraph cannot be changed",
+      { details: { issues } }
     );
-}
-
-// src/edit/pdf/engine/operations.ts
-function issueCollector(operationIndex, issues) {
-  return (path, code, message) => issues.push({ operationIndex, path, code, message });
+  const { pdfium } = context;
+  const { lib } = pdfium;
+  const pageIndex = target.paragraph.pageIndex;
+  const geometry = context.geometry(pageIndex);
+  const first = target.indexes[0];
+  context.withPage(pageIndex, (page) => {
+    const font = fontFor(context, target, spec, page);
+    if ("problem" in font)
+      throw new ViewerError("invalid-operation", font.problem.message);
+    const objects = [];
+    const [r, g, b] = parseColor(spec.style.color);
+    if (!spec.text.trim()) {
+      const rect = prepared.spec.rect;
+      const origin = pageToUser(geometry, rect.x, rect.y + rect.height);
+      const object = lib.FPDFPageObj_CreateNewRect(
+        origin.x,
+        origin.y,
+        rect.width,
+        rect.height
+      );
+      lib.FPDFPageObj_SetFillColor(object, 0, 0, 0, 0);
+      lib.FPDFPath_SetDrawMode(object, 1, false);
+      objects.push({ object, type: OBJECT_PATH });
+    } else
+      for (const line of prepared.layout.lines) {
+        if (!line.text) continue;
+        const object = lib.FPDFPageObj_CreateTextObj(
+          context.document,
+          font.handle,
+          spec.style.fontSize
+        );
+        if (!object) {
+          for (const made of objects) lib.FPDFPageObj_Destroy(made.object);
+          throw new ViewerError(
+            "edit-failed",
+            "PDFium could not create paragraph text"
+          );
+        }
+        setText(pdfium, object, line.text);
+        lib.FPDFPageObj_SetFillColor(object, r, g, b, 255);
+        placeUpright(
+          pdfium,
+          object,
+          geometry,
+          spec.rect.x + line.x,
+          spec.rect.y + line.baseline
+        );
+        objects.push({ object, type: OBJECT_TEXT });
+      }
+    const params = JSON.stringify(prepared.spec);
+    for (const { object } of objects) {
+      const mark = lib.FPDFPageObj_AddMark(object, MARK_NAME);
+      lib.FPDFPageObjMark_SetStringParam(
+        context.document,
+        object,
+        mark,
+        MARK_PARAM,
+        params
+      );
+    }
+    for (const index of [...target.indexes].reverse()) {
+      const object = lib.FPDFPage_GetObject(page, index);
+      lib.FPDFPage_RemoveObject(page, object);
+      lib.FPDFPageObj_Destroy(object);
+      context.spliceObjects(pageIndex, index, 1, []);
+    }
+    objects.forEach(
+      ({ object }, at) => lib.FPDFPage_InsertObjectAtIndex(page, object, first + at)
+    );
+    const textPage = lib.FPDFText_LoadPage(page);
+    try {
+      const drawn = objects.filter(({ type }) => type === OBJECT_TEXT).map(
+        ({ object }) => pdfium.readWideString(
+          (buffer, bytes2) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes2)
+        ).trimEnd()
+      );
+      if (drawn.length !== prepared.spec.lines.length || drawn.some((line, index) => line !== prepared.spec.lines[index]))
+        throw new ViewerError(
+          "edit-failed",
+          "The native font could not encode the paragraph faithfully"
+        );
+    } finally {
+      lib.FPDFText_ClosePage(textPage);
+    }
+    context.spliceObjects(
+      pageIndex,
+      first,
+      0,
+      objects.map(({ type }) => ({ id: spec.id, type, mark: prepared.spec }))
+    );
+  });
+  const promoted = !target.paragraph.memberIds.includes(spec.id);
+  return {
+    createdIds: [],
+    removedIds: promoted ? target.paragraph.memberIds : [],
+    ...promoted ? {
+      textAnchorMigrations: target.paragraph.members.map((member) => ({
+        sourceElementId: member.elementId,
+        targetElementId: spec.id,
+        sourceLength: member.end - member.start,
+        targetOffset: member.start
+      }))
+    } : {},
+    changedPages: [pageIndex],
+    warnings: prepared.warnings
+  };
 }
 
 // src/edit/pdf/engine/existing-text.ts
 var replaceText = {
   validate(operation2, context, issue) {
+    if (context.paragraph(operation2.target)?.paragraph.id === operation2.target)
+      return replaceParagraphText.validate(
+        { ...operation2, op: "replaceParagraphText" },
+        context,
+        issue
+      );
     const box = textBoxTarget(operation2.target, context);
     if (box) {
       const spliced = splice(box.spec.text, operation2, issue);
@@ -8918,6 +9859,11 @@ var replaceText = {
     if (problem) issue(problem.path, problem.code, problem.message);
   },
   apply(operation2, context) {
+    if (context.paragraph(operation2.target)?.paragraph.id === operation2.target)
+      return replaceParagraphText.apply(
+        { ...operation2, op: "replaceParagraphText" },
+        context
+      );
     const box = textBoxTarget(operation2.target, context);
     if (box)
       return textBoxReplaceText.apply(
@@ -8968,6 +9914,8 @@ function spanOf(operation2, previous) {
 }
 var setTextStyle = {
   validate(operation2, context, issue) {
+    if (context.paragraph(operation2.target)?.paragraph.id === operation2.target)
+      return paragraphSetTextStyle.validate(operation2, context, issue);
     if (textBoxTarget(operation2.target, context))
       return textBoxSetTextStyle.validate(operation2, context, issue);
     if (!textTarget(operation2.target, context, issue)) return;
@@ -8986,6 +9934,8 @@ var setTextStyle = {
         );
   },
   apply(operation2, context) {
+    if (context.paragraph(operation2.target)?.paragraph.id === operation2.target)
+      return paragraphSetTextStyle.apply(operation2, context);
     if (textBoxTarget(operation2.target, context))
       return textBoxSetTextStyle.apply(operation2, context);
     const target = textTarget(operation2.target, context);
@@ -9026,66 +9976,19 @@ function textTarget(target, context, issue = () => {
   }
   return { location, element };
 }
-function validateScript(text, issue) {
-  for (const character of text) {
-    const code = character.codePointAt(0);
-    if (code >= 1424 && code <= 2303 || code >= 64285 && code <= 65023 || code >= 65136 && code <= 65279) {
-      issue(
-        "/text",
-        "unsupported-script",
-        `Right-to-left text such as "${character}" cannot be edited yet`
-      );
-      return false;
-    }
-  }
-  return true;
-}
 function canKeepFont(context, target, text) {
-  const { pdfium } = context;
-  const { lib } = pdfium;
-  return context.withPage(target.location.pageIndex, (page) => {
-    const object = lib.FPDFPage_GetObject(page, target.location.indexes[0]);
-    const font = lib.FPDFTextObj_GetFont(object);
-    if (!lib.FPDFFont_GetIsEmbedded(font)) {
-      const base = pdfium.readUtf8String(
-        (buffer, bytes2) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes2)
-      );
-      return isStandardFamily(base.split(/[-,]/)[0] ?? "") && firstNonWinAnsi(text) === void 0;
-    }
-    const coverage = fontCoverage(pdfium, font);
-    if (!coverage) return false;
-    for (const character of text) {
-      const code = character.codePointAt(0);
-      if (code !== 10 && code !== 32 && !coverage.drawable(code))
-        return false;
-    }
-    return true;
+  return context.readPage(target.location.pageIndex, (page) => {
+    const object = context.pdfium.lib.FPDFPage_GetObject(
+      page,
+      target.location.indexes[0]
+    );
+    return fontCanRewrite(
+      context.pdfium,
+      context.pdfium.lib.FPDFTextObj_GetFont(object),
+      text
+    );
   });
 }
-function fontCoverage(pdfium, font) {
-  const { lib } = pdfium;
-  const size = pdfium.readNumbers(
-    1,
-    "i32",
-    ([out]) => lib.FPDFFont_GetFontData(font, 0, 0, out)
-  )?.[0];
-  if (!size) return void 0;
-  const buffer = pdfium.malloc(size);
-  try {
-    const out = pdfium.malloc(4);
-    try {
-      if (!lib.FPDFFont_GetFontData(font, buffer, size, out)) return void 0;
-    } finally {
-      pdfium.free(out);
-    }
-    const data = pdfium.readBytes(buffer, size);
-    const tag = String.fromCharCode(data[0], data[1], data[2], data[3]);
-    const truetype = data[0] === 0 && data[1] === 1 && data[2] === 0 && data[3] === 0 || tag === "true";
-    return truetype ? parseCmap(data) : void 0;
-  } finally {
-    pdfium.free(buffer);
-  }
-}
 function replaceInPlace(context, target, text) {
   const { pdfium } = context;
   const { lib } = pdfium;
@@ -9351,6 +10254,14 @@ var moveElement = {
   validate(operation2, context, issue) {
     const target = anyTarget(operation2.target, context, issue);
     if (!target) return;
+    if (target.element.kind === "paragraph") {
+      issue(
+        "/target",
+        "unsupported-target",
+        "Imported paragraphs cannot be moved"
+      );
+      return;
+    }
     if (operation2.to === void 0 === (operation2.by === void 0)) {
       issue("", "one-of", "Give exactly one of `to` and `by`");
       return;
@@ -9402,8 +10313,12 @@ var resizeElement = {
   validate(operation2, context, issue) {
     const target = anyTarget(operation2.target, context, issue);
     if (!target) return;
-    if (target.element.kind === "table") {
-      issue("/target", "unsupported-target", "Tables cannot be resized");
+    if (target.element.kind === "table" || target.element.kind === "paragraph") {
+      issue(
+        "/target",
+        "unsupported-target",
+        "Tables and imported paragraphs cannot be resized"
+      );
       return;
     }
     validateRect(
@@ -9457,10 +10372,16 @@ var deleteElement = {
   },
   apply(operation2, context) {
     const { location } = anyTarget(operation2.target, context);
+    const paragraph = context.paragraph(operation2.target)?.paragraph;
     removeObjects(context, location);
     return {
       ...changed(location, { overflow: false }),
-      removedIds: [operation2.target]
+      removedIds: [
+        .../* @__PURE__ */ new Set([
+          operation2.target,
+          ...paragraph?.id === operation2.target ? paragraph.memberIds : []
+        ])
+      ]
     };
   }
 };
@@ -10500,6 +11421,7 @@ function referenceOf(operation2) {
   return typeof target === "string" ? parseReference(target) : void 0;
 }
 var handlers = {
+  replaceParagraphText,
   insertTextBox,
   replaceText,
   setTextStyle,
@@ -10622,6 +11544,7 @@ var PdfEditDocument = class {
     const createdIds = [];
     const createdByOperation = [];
     const removedIds = [];
+    const textAnchorMigrations = [];
     const changedPages = /* @__PURE__ */ new Set();
     const warnings = [];
     if (this.#batches === 0 && (this.#signatures > 0 || this.#features.length))
@@ -10646,6 +11569,8 @@ var PdfEditDocument = class {
       createdIds.push(...result3.createdIds);
       createdByOperation[operationIndex] = [...result3.createdIds];
       removedIds.push(...result3.removedIds ?? []);
+      for (const migration of result3.textAnchorMigrations ?? [])
+        textAnchorMigrations.push({ ...migration, operationIndex });
       for (const pageIndex of result3.changedPages) changedPages.add(pageIndex);
       warnings.push(...result3.warnings);
     });
@@ -10653,6 +11578,7 @@ var PdfEditDocument = class {
     return {
       createdIds,
       removedIds,
+      ...textAnchorMigrations.length ? { textAnchorMigrations } : {},
       changedPages: [...changedPages].sort((a, b) => a - b),
       pageCount: this.pageCount,
       warnings
@@ -10772,7 +11698,12 @@ var PdfEditDocument = class {
   getElement(id) {
     const pageIndex = this.#pageIndexOf(id);
     if (pageIndex === void 0) return void 0;
-    return this.#elementsOf(pageIndex).find((element) => element.id === id);
+    const element = this.#elementsOf(pageIndex).find(
+      (element2) => element2.id === id
+    );
+    if (element) return element;
+    const target = this.#pages[pageIndex]?.paragraphs?.get(id);
+    return target?.paragraph.id === id ? paragraphElement(target.paragraph) : void 0;
   }
   /** Elements under a point, top-most (drawn last) first. */
   elementsAt(pageIndex, point) {
@@ -10802,20 +11733,40 @@ var PdfEditDocument = class {
       });
     return targets;
   }
-  /** Lines, glyph boxes and styles of a text, text box or table element. */
+  /** Resolves the canonical imported paragraph, when its rows can be grouped safely. */
+  textParagraph(elementId) {
+    return this.#paragraphOf(elementId)?.paragraph;
+  }
+  #paragraphOf(id) {
+    const pageIndex = this.#pageIndexOf(id);
+    if (pageIndex === void 0) return void 0;
+    this.#elementsOf(pageIndex);
+    return this.#pages[pageIndex]?.paragraphs?.get(id);
+  }
+  /** Lines, glyph boxes and styles of a text, text box, paragraph or table element. */
   textLayout(elementId) {
     const pageIndex = this.#pageIndexOf(elementId);
     if (pageIndex === void 0) return void 0;
-    return this.#scanText(pageIndex, (scan) => {
+    const paragraph = this.#paragraphOf(elementId);
+    return this.#scanText(pageIndex, (raw) => {
+      const scan = paragraph?.paragraph.id === elementId ? this.#paragraphScan(raw, paragraph) : raw;
       const element = scan.elements.find((entry) => entry.id === elementId);
-      return element ? layoutOf(this.#pdfium, scan, element) : void 0;
+      const layout = element ? layoutOf(this.#pdfium, scan, element) : void 0;
+      return layout && paragraph?.paragraph.id === elementId ? {
+        ...layout,
+        lines: [...layout.lines].sort((a, b) => a.range.start.offset - b.range.start.offset).map((line) => ({
+          ...line,
+          fontSize: paragraph.paragraph.textStyle.fontSize
+        }))
+      } : layout;
     });
   }
   /** 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")
+    if (!location) return void 0;
+    const kind = this.getElement(elementId)?.kind ?? (this.#paragraphOf(elementId)?.paragraph.id === elementId ? "paragraph" : void 0);
+    if (kind !== "text" && kind !== "textBox" && kind !== "paragraph")
       return void 0;
     const { lib } = this.#pdfium;
     return this.#withPage(location.pageIndex, (page) => {
@@ -10870,7 +11821,12 @@ var PdfEditDocument = class {
           "The rendered page exceeds maxDecodedPixels",
           { details: { actual: pixels, limit: this.#limits.maxDecodedPixels } }
         );
-      const wanted = new Set(elementIds);
+      const wanted = new Set(
+        elementIds.flatMap((id) => {
+          const paragraph = this.#paragraphOf(id)?.paragraph;
+          return paragraph?.id === id ? paragraph.memberIds : [id];
+        })
+      );
       const records = this.#objectsOf(pageIndex, page);
       const suppressed = [];
       records.forEach((record, index) => {
@@ -10952,9 +11908,14 @@ var PdfEditDocument = class {
     const pageIndex = this.#pageIndexOf(range.start.elementId);
     if (pageIndex === void 0 || pageIndex !== this.#pageIndexOf(range.end.elementId))
       return [];
+    const paragraph = range.start.elementId === range.end.elementId ? this.#paragraphOf(range.start.elementId) : void 0;
     return this.#scanText(
       pageIndex,
-      (scan) => rectsOf(this.#pdfium, scan, range)
+      (scan) => rectsOf(
+        this.#pdfium,
+        paragraph?.paragraph.id === range.start.elementId ? this.#paragraphScan(scan, paragraph) : scan,
+        range
+      )
     );
   }
   dispose() {
@@ -10985,10 +11946,14 @@ var PdfEditDocument = class {
       // 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),
+      readPage: (pageIndex, use) => this.#withPage(pageIndex, use),
+      paragraph: (id) => this.#paragraphOf(id),
+      pageElements: (pageIndex) => this.#elementsOf(pageIndex),
       appendObjects: (pageIndex, records) => {
         const page = this.#pages[pageIndex];
         page.objects = [...page.objects ?? [], ...records];
         delete page.elements;
+        delete page.paragraphs;
       },
       locate: (id) => this.#locate(id),
       element: (id) => this.getElement(id),
@@ -11019,6 +11984,7 @@ var PdfEditDocument = class {
         if (!page) return;
         delete page.geometry;
         delete page.elements;
+        delete page.paragraphs;
       },
       spliceObjects: (pageIndex, start, count, records) => {
         const page = this.#pages[pageIndex];
@@ -11026,12 +11992,16 @@ var PdfEditDocument = class {
         objects.splice(start, count, ...records);
         page.objects = objects;
         delete page.elements;
+        delete page.paragraphs;
       }
     };
   }
   /** Cached elements carry page indexes, which a structure change makes stale. */
   #forgetElements() {
-    for (const page of this.#pages) delete page.elements;
+    for (const page of this.#pages) {
+      delete page.elements;
+      delete page.paragraphs;
+    }
   }
   #locate(id) {
     const pageIndex = this.#pageIndexOf(id);
@@ -11045,7 +12015,14 @@ var PdfEditDocument = class {
       if (record2.id === id) indexes.push(index);
     });
     const record = records[indexes[0] ?? -1];
-    return record ? { pageIndex, indexes, record } : void 0;
+    if (record) return { pageIndex, indexes, record };
+    const paragraph = this.#paragraphOf(id);
+    const first = paragraph && records[paragraph.indexes[0] ?? -1];
+    return paragraph?.paragraph.id === id && first ? {
+      pageIndex,
+      indexes: paragraph.indexes,
+      record: { ...first, id, mark: paragraph.spec }
+    } : void 0;
   }
   /** Loads a page, lets `use` change it, regenerates its content stream. */
   #writePage(pageIndex, use) {
@@ -11067,6 +12044,7 @@ var PdfEditDocument = class {
           }
         );
       delete this.#pages[pageIndex].elements;
+      delete this.#pages[pageIndex].paragraphs;
       return result3;
     } finally {
       lib.FPDF_ClosePage(page);
@@ -11093,7 +12071,22 @@ var PdfEditDocument = class {
         geometry,
         this.#objectsOf(pageIndex, page)
       );
-      record.elements = Object.freeze(elements);
+      record.paragraphs = discoverParagraphs(
+        this.#pdfium,
+        page,
+        pageIndex,
+        geometry,
+        this.#objectsOf(pageIndex, page),
+        elements,
+        textPage,
+        this.#measurer
+      );
+      record.elements = Object.freeze(
+        elements.map((element) => {
+          const paragraph = record.paragraphs?.get(element.id)?.paragraph;
+          return paragraph && paragraph.id !== element.id ? { ...element, textEditingTarget: paragraph.id } : element;
+        })
+      );
       return record.elements;
     });
   }
@@ -11206,6 +12199,27 @@ var PdfEditDocument = class {
     };
     return record.geometry;
   }
+  #paragraphScan(scan, target) {
+    const paragraph = target.paragraph;
+    if (paragraph.memberIds.includes(paragraph.id)) return scan;
+    const members = new Map(
+      paragraph.members.map((member) => [member.elementId, member])
+    );
+    return {
+      ...scan,
+      elements: [
+        ...scan.elements.filter((element) => !members.has(element.id)),
+        paragraphElement(paragraph)
+      ],
+      offsets: scan.offsets.map((position) => {
+        const member = position && members.get(position.elementId);
+        return member && position ? {
+          elementId: paragraph.id,
+          offset: Math.min(member.end, member.start + position.offset)
+        } : position;
+      })
+    };
+  }
   /** Loads a page with its text page and the character-to-element mapping. */
   #scanText(pageIndex, use) {
     return this.#withPage(pageIndex, (page, textPage, geometry) => {
@@ -11460,6 +12474,8 @@ function createPdfEditHandler(host) {
       }
       case "edit-text-layout":
         return engine().textLayout(payload.id);
+      case "edit-text-paragraph":
+        return engine().textParagraph(payload.id);
       case "edit-position-at": {
         const { pageIndex, point } = payload;
         return engine().positionAt(pageIndex, point);