52def annotate_debug_info(page: Page, new_doc: pp.PdfDocument = None, index: int = 0) -> pp.PdfDocument:
 53    """
 54    Copies each page into a new or existing PDF document and overlays the internal information on top of the content.
 55    - Renders the bounding boxes in RED and origins in BLACK of all characters.
 56    - Renders the bounding boxes of web links in BLUE GREEN.
 57    - Renders the bounding boxes of object links in YELLOW GREEN.
 58    - Renders all graphics paths in BLUE.
 59    - Renders the bounding boxes of computed graphics clusters in CYAN.
 60
 61    :param page: The page to be annotated.
 62    :param new_doc: The PDF document to copy the page to. If not provided, a new document is created.
 63    :param index: The index of the page in the new document.
 64    :return: The new document with the annotated page added.
 65    """
 66    _, height = page.width, page.height
 67
 68    if new_doc is None:
 69        new_doc = pp.raw.FPDF_CreateNewDocument()
 70    # copy page over to new doc
 71    assert pp.raw.FPDF_ImportPages(new_doc, page.pdf, str(page.number).encode("ascii"), index)
 72    new_page = pp.raw.FPDF_LoadPage(new_doc, index)
 73    rotation = page.rotation
 74
 75    for path in page.paths:
 76        p0 = path.points[0]
 77        if rotation:
 78            obj = pp.raw.FPDFPageObj_CreateNewPath(height - p0.y, p0.x)
 79        else:
 80            obj = pp.raw.FPDFPageObj_CreateNewPath(p0.x, p0.y)
 81        assert pp.raw.FPDFPageObj_SetStrokeColor(obj, 0, 0, 0xFF, 0xC0)
 82        assert pp.raw.FPDFPageObj_SetStrokeWidth(obj, 0.25)
 83        assert pp.raw.FPDFPageObj_SetLineJoin(obj, pp.raw.FPDF_LINEJOIN_ROUND)
 84        assert pp.raw.FPDFPageObj_SetLineCap(obj, pp.raw.FPDF_LINECAP_ROUND)
 85        assert pp.raw.FPDFPath_SetDrawMode(obj, 0, True)
 86        for point in path.points[1:]:
 87            if point.type == path.Type.MOVE:
 88                if rotation:
 89                    assert pp.raw.FPDFPath_MoveTo(obj, height - point.y, point.x)
 90                else:
 91                    assert pp.raw.FPDFPath_MoveTo(obj, point.x, point.y)
 92            else:
 93                if rotation:
 94                    assert pp.raw.FPDFPath_LineTo(obj, height - point.y, point.x)
 95                else:
 96                    assert pp.raw.FPDFPath_LineTo(obj, point.x, point.y)
 97        pp.raw.FPDFPage_InsertObject(new_page, obj)
 98
 99    for bbox, _ in page.graphic_clusters():
100        _rect(new_page, rotation, bbox, width=2, stroke=0x00FFFF)
101
102    for link in page.objlinks:
103        _rect(new_page, rotation, link.bbox, width=0.75, stroke=0x9ACD32)
104
105    for link in page.weblinks:
106        for bbox in link.bboxes:
107            _rect(new_page, rotation, bbox, width=0.75, stroke=0x00FF00)
108
109    for char in page.chars:
110        color = 0x0000FF
111        if char.bbox.width:
112            _rect(new_page, rotation, char.bbox, width=0.5, stroke=0xFF0000)
113            _vline(
114                new_page,
115                rotation,
116                char.bbox.midpoint.x,
117                char.bbox.midpoint.y - 1,
118                char.bbox.midpoint.y + 1,
119                width=0.25,
120                stroke=0xFF0000,
121            )
122            _hline(
123                new_page,
124                rotation,
125                char.bbox.midpoint.y,
126                char.bbox.midpoint.x - 1,
127                char.bbox.midpoint.x + 1,
128                width=0.25,
129                stroke=0xFF0000,
130            )
131            color = 0x000000
132        _vline(new_page, rotation, char.origin.x, char.origin.y - 1, char.origin.y + 1, width=0.25, stroke=color)
133        _hline(new_page, rotation, char.origin.y, char.origin.x - 1, char.origin.x + 1, width=0.25, stroke=color)
134
135    assert pp.raw.FPDFPage_GenerateContent(new_page)
136    pp.raw.FPDF_ClosePage(new_page)
137    return new_doc

 33class Document(pp.PdfDocument):
 34    """
 35    The PDF document is the root of the entire data structure and provides
 36    access to PDF metadata, the table of contents, as well as individual
 37    pages.
 38
 39    You should extend from this class for a specific vendor to provide the
 40    correct page class from `page()` function.
 41
 42    This class is a convenience wrapper with caching around the high-level APIs
 43    of pypdfium.
 44    """
 45
 46    def __init__(self, path: Path, autoclose: bool = False):
 47        """
 48        :param path: Path to the PDF to open.
 49        """
 50        path = Path(path)
 51        self.name: str = path.stem
 52        """Stem of the document file name"""
 53        super().__init__(path, autoclose=autoclose)
 54        self._path = path
 55        self._glyph_offsets: dict[str, int] = {}
 56        _LOGGER.debug(f"Loading: {path}")
 57
 58    @cached_property
 59    def metadata(self) -> dict[str, str]:
 60        """The PDF metadata dictionary."""
 61        return self.get_metadata_dict()
 62
 63    @property
 64    def destinations(self) -> Iterator[tuple[int, str]]:
 65        """Yields (page 0-index, named destination) of the whole document."""
 66        for ii in range(pp.raw.FPDF_CountNamedDests(self)):
 67            clength = ctypes.c_long()
 68            pp.raw.FPDF_GetNamedDest(self, ii, None, clength)
 69            cbuffer = ctypes.create_string_buffer(clength.value)
 70            dest = pp.raw.FPDF_GetNamedDest(self, ii, cbuffer, clength)
 71            name = cbuffer.raw[: clength.value].decode("utf-16-le").rstrip("\x00")
 72            page = pp.raw.FPDFDest_GetDestPageIndex(self, dest)
 73            yield (page, name)
 74
 75    @cached_property
 76    def toc(self) -> list[_OutlineItem]:
 77        """
 78        The table of content as a sorted list of outline items ensuring item has
 79        a page index by reusing the last one.
 80        """
 81        tocs = set()
 82        # Sometimes the TOC contains duplicates so we must use a set
 83        last_page_index = 0
 84        for toc in self.get_toc():
 85            dest = toc.get_dest()
 86            last_page_index = (dest and dest.get_index()) or last_page_index
 87            tocs.add(_OutlineItem(toc.level, toc.get_title(), last_page_index))
 88        return list(sorted(list(tocs), key=lambda o: (o.page_index, o.level, o.title)))
 89
 90    @cached_property
 91    def identifier_permanent(self) -> str:
 92        """The permanent file identifier."""
 93        return self.get_identifier(pp.raw.FILEIDTYPE_PERMANENT)
 94
 95    @cached_property
 96    def identifier_changing(self) -> str:
 97        """The changing file identifier."""
 98        return self.get_identifier(pp.raw.FILEIDTYPE_CHANGING)
 99
100    @cached_property
101    def page_count(self) -> int:
102        """The number of pages in the document."""
103        return pp.raw.FPDF_GetPageCount(self)
104
105    @cache
106    def page(self, index: int) -> Page:
107        """
108        :param index: 0-indexed page number.
109        :return: the page object for the index.
110        """
111        assert index < self.page_count
112        return Page(self, index)
113
114    def pages(self, numbers: Iterable[int] = None) -> Iterator[Page]:
115        """
116        :param numbers: an iterable range of page numbers (0-indexed!).
117                        If `None`, then the whole page range is used.
118        :return: yields each page in the range.
119        """
120        if numbers is None:
121            numbers = range(self.page_count)
122        for ii in numbers:
123            if 0 <= ii < self.page_count:
124                yield self.page(ii)
125
126    def __repr__(self) -> str:
127        return f"Doc({self.name})"

 25class Page(pp.PdfPage):
 26    """
 27    This class provides low-level access to graphics and characters of the page
 28    and allows searching for characters in an area instead of just text.
 29    """
 30
 31    def __init__(self, document: "modm_data.pdf.Document", index: int):  # noqa: F821
 32        """
 33        :param document: a PDF document.
 34        :param index: 0-index page number.
 35        """
 36        self.index = index
 37        """0-index page number."""
 38        self.number = index + 1
 39        """1-index page number."""
 40
 41        super().__init__(pp.raw.FPDF_LoadPage(document, index), document, document.formenv)
 42        document._add_kid(self)
 43        self._links = None
 44        self._weblinks = None
 45        self._linked = False
 46
 47        _LOGGER.debug(f"Loading: {index}")
 48
 49        self._text = self.get_textpage()
 50        self._linkpage = pp.raw.FPDFLink_LoadWebLinks(self._text)
 51        self._structtree = pp.raw.FPDF_StructTree_GetForPage(self)
 52        # close them in reverse order
 53        weakref.finalize(self, pp.raw.FPDF_StructTree_Close, self._structtree)
 54        weakref.finalize(self, pp.raw.FPDFLink_CloseWebLinks, self._linkpage)
 55
 56    @cached_property
 57    def label(self) -> str:
 58        """The page label."""
 59        return self.pdf.get_page_label(self.index)
 60
 61    @cached_property
 62    def width(self) -> float:
 63        """The page width."""
 64        return self.get_width()
 65
 66    @cached_property
 67    def height(self) -> float:
 68        """The page height."""
 69        return self.get_height()
 70
 71    @cached_property
 72    def rotation(self) -> int:
 73        """The page rotation in degrees."""
 74        return self.get_rotation()
 75
 76    @cached_property
 77    def bbox(self) -> Rectangle:
 78        """The page bounding box."""
 79        return Rectangle(*self.get_bbox())
 80
 81    @cached_property
 82    def char_count(self) -> int:
 83        """The total count of characters."""
 84        return self._text.count_chars()
 85
 86    @cached_property
 87    def _chars(self) -> list[Character | None]:
 88        return [None] * self.char_count
 89
 90    @cached_property
 91    def _glyph_unicodes(self) -> dict[tuple[str, int], int]:
 92        return decode_glyphs(self)
 93
 94    def char(self, index: int) -> Character:
 95        """:return: The character at the 0-index."""
 96        # A list per page is smaller than a global `functools.cache`, which
 97        # also keeps every page alive after the document is closed.
 98        if (char := self._chars[index]) is None:
 99            char = self._chars[index] = Character(self, index)
100        return char
101
102    @property
103    def chars(self) -> Iterator[Character]:
104        """Yields all characters."""
105        for ii in range(self.char_count):
106            yield self.char(ii)
107
108    @cached_property
109    def objlinks(self) -> list[ObjLink]:
110        """All object links."""
111        links = []
112        pos = ctypes.c_int(0)
113        link = pp.raw.FPDF_LINK()
114        while pp.raw.FPDFLink_Enumerate(self, pos, link):
115            links.append(ObjLink(self, link))
116        return links
117
118    @cached_property
119    def weblinks(self) -> list[WebLink]:
120        """All web links."""
121        links = []
122        for ii in range(pp.raw.FPDFLink_CountWebLinks(self._linkpage)):
123            links.append(WebLink(self, ii))
124        return links
125
126    def chars_in_area(self, area: Rectangle) -> list[Character]:
127        """
128        :param area: area to search for character in.
129        :return: All characters found in the area.
130        """
131        found = []
132        # We perform binary searches of the lower and upper y-positions first
133        # lines are ordered by y-position
134        ypositions = list(self._charlines.keys())
135        y_bottom = bisect_left(ypositions, area.bottom)
136        y_top = bisect_right(ypositions, area.top, lo=y_bottom)
137
138        # Then for every line we do another binary search for left and right
139        for ypos in ypositions[y_bottom:y_top]:
140            chars = self._charlines[ypos]
141            x_left = bisect_left(chars, area.left, key=lambda c: c.bbox.midpoint.x)
142            x_right = bisect_right(chars, area.right, lo=x_left, key=lambda c: c.bbox.midpoint.x)
143            # Finally we add all these characters
144            found.extend(chars[x_left:x_right])
145        return found
146
147    def text_in_area(self, area: Rectangle) -> str:
148        """
149        :param area: area to search for text in.
150        :return: Only the text found in the area.
151        """
152        return self._text.get_text_bounded(area.left, area.bottom, area.right, area.top)
153
154    @property
155    def structures(self) -> Iterator[Structure]:
156        """The PDF/UA tags."""
157        count = pp.raw.FPDF_StructTree_CountChildren(self._structtree)
158        for ii in range(count):
159            child = pp.raw.FPDF_StructTree_GetChildAtIndex(self._structtree, ii)
160            yield Structure(self, child)
161
162    def find(self, string: str, case_sensitive: bool = True) -> Iterator[Character]:
163        """
164        Searches for a match string as whole, consecutive words and yields the
165        characters.
166
167        :param string: The search string.
168        :param case_sensitive: Ignore case if false.
169        :return: yields the characters found.
170        """
171        searcher = self._text.search(string, match_case=case_sensitive, match_whole_word=True, consecutive=True)
172        while idx := searcher.get_next():
173            chars = [self.char(ii) for ii in range(idx[0], idx[0] + idx[1])]
174            yield chars
175
176    @cached_property
177    def paths(self) -> list[Path]:
178        """All paths."""
179        return [Path(o) for o in self.get_objects([pp.raw.FPDF_PAGEOBJ_PATH])]
180
181    @cached_property
182    def images(self) -> list[Image]:
183        """All images."""
184        return [Image(o) for o in self.get_objects([pp.raw.FPDF_PAGEOBJ_IMAGE])]
185
186    def graphic_clusters(
187        self, predicate: Callable[[Path | Image], bool] = None, absolute_tolerance: float = None
188    ) -> list[tuple[Rectangle, list[Path]]]:
189        if absolute_tolerance is None:
190            absolute_tolerance = min(self.width, self.height) * 0.01
191
192        # First collect all vertical regions
193        filtered_paths = []
194        for path in self.paths:
195            if predicate is None or predicate(path):
196                filtered_paths.append(path)
197        for image in self.images:
198            if predicate is None or predicate(image):
199                filtered_paths.append(image)
200
201        regions = []
202        for path in sorted(filtered_paths, key=lambda path: path.bbox.y):
203            for reg in regions:
204                if reg.overlaps(path.bbox.bottom, path.bbox.top, absolute_tolerance):
205                    # They overlap, so merge them
206                    reg.v0 = min(reg.v0, path.bbox.bottom)
207                    reg.v1 = max(reg.v1, path.bbox.top)
208                    reg.objs.append(path)
209                    break
210            else:
211                regions.append(Region(path.bbox.bottom, path.bbox.top, path))
212
213        # Now collect horizontal region inside each vertical region
214        for yreg in regions:
215            for path in sorted(filtered_paths, key=lambda path: path.bbox.x):
216                # check if horizontal line is contained in vregion
217                if yreg.contains(path.bbox.y, absolute_tolerance):
218                    for xreg in yreg.subregions:
219                        if xreg.overlaps(path.bbox.left, path.bbox.right, absolute_tolerance):
220                            # They overlap so merge them
221                            xreg.v0 = min(xreg.v0, path.bbox.left)
222                            xreg.v1 = max(xreg.v1, path.bbox.right)
223                            xreg.objs.append(path)
224                            break
225                    else:
226                        yreg.subregions.append(Region(path.bbox.left, path.bbox.right, path))
227
228        clusters = []
229        for yreg in regions:
230            for xreg in yreg.subregions:
231                if len(yreg.subregions) > 1:
232                    # Strip down the height again for subregions
233                    y0, y1 = 1e9, 0
234                    for path in xreg.objs:
235                        y0 = min(y0, path.bbox.bottom)
236                        y1 = max(y1, path.bbox.top)
237                else:
238                    y0, y1 = yreg.v0, yreg.v1
239                bbox = Rectangle(xreg.v0, y0, xreg.v1, y1)
240                clusters.append((bbox, xreg.objs))
241
242        return sorted(clusters, key=lambda c: (-c[0].y, c[0].x))
243
244    def _link_characters(self):
245        if self._linked:
246            return
247        # The in-document links only gives us rectangles and we must find the
248        # linked chars ourselves
249        for link in self.objlinks:
250            for char in self.chars_in_area(link.bbox):
251                char.objlink = link
252        # The weblinks give you an explicit char range, very convenient
253        for link in self.weblinks:
254            for ii in range(*link.range):
255                self.char(ii).weblink = link
256        self._linked = True
257
258    @cached_property
259    def _charlines(self):
260        charlines = defaultdict(list)
261        for char in self.chars:
262            charlines[round(char.bbox.midpoint.y, 1)].append(char)
263
264        orderedchars = OrderedDict.fromkeys(sorted(charlines))
265        for ypos, chars in charlines.items():
266            orderedchars[ypos] = sorted(chars, key=lambda c: c.bbox.midpoint.x)
267
268        return orderedchars

 37class Character:
 38    """
 39    Each character on the PDF page is represented by a character object,
 40    describing exactly where and how to render the associated glyph.
 41
 42    While there are font flags, PDF files typically use entirely different fonts
 43    to render normal, bold, and italic characters.
 44
 45    The character's loose bounding box may not always be available, since it
 46    must be explicitly provided by the font. The tight bounding box is only
 47    available as long as the glyph is renderable, so a space character may have
 48    a loose, but not a tight bounding box, or none at all.
 49    """
 50
 51    class RenderMode(Enum):
 52        """Tells the PDF viewer how to render this character glyph."""
 53
 54        UNKNOWN = -1
 55        FILL = 0
 56        STROKE = 1
 57        FILL_STROKE = 2
 58        INVISIBLE = 3
 59        FILL_CLIP = 4
 60        STROKE_CLIP = 5
 61        FILL_STROKE_CLIP = 6
 62        CLIP = 7
 63
 64    # A dictionary per character is the largest part of the memory usage
 65    __slots__ = (
 66        "_bbox",
 67        "_fill_",
 68        "_font",
 69        "_index",
 70        "_origin_",
 71        "_page",
 72        "_render_mode_",
 73        "_rotation",
 74        "_size_",
 75        "_stroke_",
 76        "_tbbox_",
 77        "_text",
 78        "_weight_",
 79        "objlink",
 80        "unicode",
 81        "weblink",
 82    )
 83
 84    def __init__(self, page: "modm_data.pdf.page.Page", index: int):  # noqa: F821
 85        """
 86        :param page: The page containing the character.
 87        :param index: The index of the character.
 88        """
 89        self._page = page
 90        self._text = page._text
 91        self._index = index
 92        self._font = None
 93        self._rotation = int(math.degrees(pp.raw.FPDFText_GetCharAngle(self._text, self._index)))
 94
 95        self.unicode: int = pp.raw.FPDFText_GetUnicode(self._text, self._index)
 96        """The unicode value of the character."""
 97        if pp.raw.FPDFText_HasUnicodeMapError(self._text, self._index):
 98            self.unicode = self._page._glyph_unicodes.get((self.font, self.unicode), self.unicode)
 99        if 0xD800 <= self.unicode < 0xDC00:
100            # Characters outside the BMP are split into two UTF-16 code units,
101            # so we combine them into the first and ignore the second one.
102            low = pp.raw.FPDFText_GetUnicode(self._text, self._index + 1)
103            if 0xDC00 <= low < 0xE000:
104                self.unicode = 0x10000 + ((self.unicode - 0xD800) << 10) + low - 0xDC00
105        elif 0xDC00 <= self.unicode < 0xE000:
106            self.unicode = 0
107        self.objlink: "modm_data.pdf.link.ObjLink" = None  # noqa: F821
108        """The object link of this character or `None`"""
109        self.weblink: "modm_data.pdf.link.WebLink" = None  # noqa: F821
110        """The web link of this character or `None`"""
111
112        bbox = Rectangle(*self._em_box())
113        if self._page.rotation:
114            bbox = Rectangle(bbox.p0.y, self._page.height - bbox.p1.x, bbox.p1.y, self._page.height - bbox.p0.x)
115        self._bbox = bbox
116
117    def _em_box(self) -> tuple[float, float, float, float]:
118        # The layout heuristics need the font size and the advance width of a
119        # character, not the extent of its glyph. We therefore compute our own
120        # box, which is exactly one font size tall, one advance width wide and
121        # placed by the text matrix, so that it also works for rotated text.
122        # The loose box of pdfium is not suitable, since its definition changed
123        # between versions and its height depends on the font metrics.
124        tight = self._text.get_charbox(self._index)
125        obj = pp.raw.FPDFText_GetTextObject(self._text, self._index)
126        size = pp.raw.FPDFText_GetFontSize(self._text, self._index)
127        if not obj or not size or pp.raw.FPDFText_IsGenerated(self._text, self._index):
128            return tight
129        font = pp.raw.FPDFTextObj_GetFont(obj)
130        ascent, descent, width = ctypes.c_float(), ctypes.c_float(), ctypes.c_float()
131        pp.raw.FPDFFont_GetAscent(font, size, ascent)
132        pp.raw.FPDFFont_GetDescent(font, size, descent)
133        if ascent.value == descent.value:
134            return tight
135
136        m = pp.raw.FS_MATRIX()
137        ox, oy = ctypes.c_double(), ctypes.c_double()
138        assert pp.raw.FPDFText_GetMatrix(self._text, self._index, m)
139        assert pp.raw.FPDFText_GetCharOrigin(self._text, self._index, ox, oy)
140        ox, oy = ox.value, oy.value
141
142        # Split the font size above and below the baseline like the font does
143        scale = size / (ascent.value - descent.value)
144        y0, y1 = descent.value * scale, ascent.value * scale
145        x1 = 0
146        if pp.raw.FPDFFont_GetGlyphWidth(font, self.unicode, size, width):
147            x1 = width.value
148        if not x1 and (norm := m.a * m.a + m.b * m.b):
149            # The width lookup fails for characters without a reverse unicode
150            # mapping, so we use the extent of the glyph along the baseline.
151            x1 = max(((x - ox) * m.a + (y - oy) * m.b) / norm for x in tight[::2] for y in tight[1::2])
152
153        xs = [ox + m.a * x + m.c * y for x in (0, x1) for y in (y0, y1)]
154        ys = [oy + m.b * x + m.d * y for x in (0, x1) for y in (y0, y1)]
155        return min(xs), min(ys), max(xs), max(ys)
156
157    def generated_space(self) -> "Character":
158        """
159        :return: A zero-sized space character located at the origin of this
160                 character, like the ones pdfium generates for visual gaps.
161        """
162        space = copy.copy(self)
163        space.unicode = 0x20
164        space._bbox = space.tbbox = Rectangle(self.origin.x, self.origin.y, self.origin.x, self.origin.y)
165        space.origin = self.origin
166        return space
167
168    def _font_flags(self) -> tuple[str, int]:
169        if self._font is None:
170            font = ctypes.create_string_buffer(255)
171            flags = ctypes.c_int()
172            pp.raw.FPDFText_GetFontInfo(self._text, self._index, font, 255, flags)
173            # Share one tuple per font instead of one per character
174            font = (font.value.decode("utf-8", errors="replace"), flags.value)
175            self._font = _FONTS.setdefault(font, font)
176        return self._font
177
178    @property
179    def char(self) -> str:
180        """The printable string of the unicode value."""
181        char = chr(self.unicode)
182        return char if char.isprintable() else ""
183
184    @_slot_cache
185    def origin(self) -> Point:
186        """The origin of the character."""
187        x, y = ctypes.c_double(), ctypes.c_double()
188        assert pp.raw.FPDFText_GetCharOrigin(self._text, self._index, x, y)
189        if self._page.rotation:
190            return Point(y.value, self._page.height - x.value)
191        return Point(x.value, y.value)
192
193    @property
194    def width(self) -> float:
195        """The width of the character's bounding box."""
196        if self.rotation:
197            return self.bbox.height
198        return self.bbox.width
199
200    @property
201    def height(self) -> float:
202        """The height of the character's bounding box."""
203        if self.rotation:
204            return self.bbox.width
205        return self.bbox.height
206
207    @_slot_cache
208    def tbbox(self) -> Rectangle:
209        """The tight bounding box of the character."""
210        tbbox = Rectangle(*self._text.get_charbox(self._index))
211        if self._page.rotation:
212            tbbox = Rectangle(tbbox.p0.y, self._page.height - tbbox.p1.x, tbbox.p1.y, self._page.height - tbbox.p0.x)
213        return tbbox
214
215    @property
216    def bbox(self) -> Rectangle:
217        """
218        The loose bounding box of the character.
219        .. note::
220            If the loose bounding box is not available, the tight bounding box
221            is used instead.
222        """
223        if not self._bbox.width or not self._bbox.height:
224            return self.tbbox
225        return self._bbox
226
227    @property
228    def twidth(self) -> float:
229        """The width of the character's tight bounding box."""
230        return self.tbbox.width
231
232    @property
233    def theight(self) -> float:
234        """The height of the character's tight bounding box."""
235        return self.tbbox.height
236
237    @_slot_cache
238    def render_mode(self) -> RenderMode:
239        """The render mode of the character."""
240        return Character.RenderMode(
241            pp.raw.FPDFTextObj_GetTextRenderMode(pp.raw.FPDFText_GetTextObject(self._text, self._index))
242        )
243
244    @property
245    def rotation(self) -> int:
246        """The rotation of the character in degrees modulo 360."""
247        # Special case for vertical text in rotated pages
248        if self._page.rotation == 90 and self._rotation == 0 and self.unicode not in {0x20, 0xA, 0xD}:
249            return 90
250        if self._page.rotation and self._rotation:
251            return (self._page.rotation + self._rotation) % 360
252        return self._rotation
253
254    @_slot_cache
255    def size(self) -> float:
256        """The font size of the character."""
257        return pp.raw.FPDFText_GetFontSize(self._text, self._index)
258
259    @_slot_cache
260    def weight(self) -> int:
261        """The font weight of the character."""
262        return pp.raw.FPDFText_GetFontWeight(self._text, self._index)
263
264    @_slot_cache
265    def fill(self) -> int:
266        """The fill color of the character."""
267        r, g, b, a = ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint()
268        pp.raw.FPDFText_GetFillColor(self._text, self._index, r, g, b, a)
269        return r.value << 24 | g.value << 16 | b.value << 8 | a.value
270
271    @_slot_cache
272    def stroke(self) -> int:
273        """The stroke color of the character."""
274        r, g, b, a = ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint()
275        pp.raw.FPDFText_GetStrokeColor(self._text, self._index, r, g, b, a)
276        return r.value << 24 | g.value << 16 | b.value << 8 | a.value
277
278    @property
279    def font(self) -> str:
280        """The font name of the character."""
281        return self._font_flags()[0]
282
283    @property
284    def flags(self) -> int:
285        """The font flags of the character."""
286        return self._font_flags()[1]
287
288    @property
289    def has_space_glyph(self) -> bool:
290        """
291        Whether the font of the character has a space with a width. pdfium
292        cannot generate spaces at the visual gaps of text in fonts without.
293        """
294        obj = pp.raw.FPDFText_GetTextObject(self._text, self._index)
295        if not obj:
296            return True
297        width = ctypes.c_float()
298        font = pp.raw.FPDFTextObj_GetFont(obj)
299        return not pp.raw.FPDFFont_GetGlyphWidth(font, 0x20, 1, width) or width.value > 0
300
301    def descr(self) -> str:
302        """Human-readable description of the character for debugging."""
303        char = chr(self.unicode)
304        if not char.isprintable():
305            char = hex(self.unicode)
306        return (
307            f"Chr({char}, {self.size}, {self.weight}, {self.rotation}, "
308            f"{self.render_mode}, {self.font}, {hex(self.flags)}, "
309            f"{self.fill}, {self.stroke}, {repr(self.bbox)})"
310        )
311
312    def __str__(self) -> str:
313        return self.char
314
315    def __repr__(self) -> str:
316        char = chr(self.unicode)
317        escape = {0xA: "\\n", 0xD: "\\r", 0x9: "\\t", 0x20: "␣"}
318        char = escape.get(self.unicode, char if char.isprintable() else hex(self.unicode))
319        return char