svg-ultralight 0.64.0__py3-none-any.whl → 0.73.1__py3-none-any.whl

svg_ultralight/__init__.py

@@ -7,17 +7,18 @@
 from svg_ultralight.bounding_boxes.bound_helpers import (
     bbox_dict,
     cut_bbox,
+    get_bounding_box_from_root,
     new_bbox_rect,
     new_bbox_union,
     new_bound_union,
-    new_element_union,
     pad_bbox,
     parse_bound_element,
 )
 from svg_ultralight.bounding_boxes.padded_text_initializers import (
+    join_tspans,
     pad_text,
     pad_text_ft,
-    pad_text_mix,
+    pad_text_inkscape,
     wrap_text_ft,
 )
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
@@ -25,10 +26,11 @@ from svg_ultralight.bounding_boxes.type_bound_collection import BoundCollection
 from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
 from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
 from svg_ultralight.bounding_boxes.type_padded_list import PaddedList
-from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
+from svg_ultralight.bounding_boxes.type_padded_text import PaddedText, new_padded_union
 from svg_ultralight.constructors.new_element import (
     deepcopy_element,
     new_element,
+    new_element_union,
     new_sub_element,
     update_element,
 )
@@ -48,7 +50,6 @@ from svg_ultralight.query import (
     get_bounding_box,
     get_bounding_boxes,
 )
-from svg_ultralight.read_svg import get_bounding_box_from_root, parse
 from svg_ultralight.root_elements import new_svg_root_around_bounds
 from svg_ultralight.string_conversion import (
     format_attr_dict,
@@ -81,6 +82,7 @@ __all__ = [
     "get_bounding_box",
     "get_bounding_box_from_root",
     "get_bounding_boxes",
+    "join_tspans",
     "mat_apply",
     "mat_dot",
     "mat_invert",
@@ -90,6 +92,7 @@ __all__ = [
     "new_element",
     "new_element_union",
     "new_metadata",
+    "new_padded_union",
     "new_qname",
     "new_sub_element",
     "new_svg_root",
@@ -97,8 +100,7 @@ __all__ = [
     "pad_bbox",
     "pad_text",
     "pad_text_ft",
-    "pad_text_mix",
-    "parse",
+    "pad_text_inkscape",
     "parse_bound_element",
     "transform_element",
     "update_element",

svg_ultralight/bounding_boxes/bound_helpers.py

@@ -9,57 +9,28 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from lxml import etree
-from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
 from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox, HasBoundingBox
-from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
 from svg_ultralight.constructors import new_element
+from svg_ultralight.constructors.new_element import new_element_union
 from svg_ultralight.layout import PadArg, expand_pad_arg
+from svg_ultralight.unit_conversion import MeasurementArg, to_user_units
 
 if TYPE_CHECKING:
     import os
 
+    from lxml.etree import (
+        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
+    )
+
     from svg_ultralight.attrib_hints import ElemAttrib
     from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 
 _Matrix = tuple[float, float, float, float, float, float]
 
 
-def new_element_union(
-    *elems: EtreeElement | SupportsBounds, **attributes: ElemAttrib
-) -> EtreeElement:
-    """Get the union of any elements found in the given arguments.
-
-    :param elems: BoundElements, PaddedTexts, or EtreeElements.
-        Other arguments will be ignored.
-    :return: a new group element containing all elements.
-
-    This does not support consolidating attributes. E.g., if all elements have the
-    same fill color, this will not be recognized and consilidated into a single
-    attribute for the group. Too many attributes change their behavior when applied
-    to a group.
-    """
-    elements_found: list[EtreeElement] = []
-    for elem in elems:
-        if isinstance(elem, (BoundElement, PaddedText)):
-            elements_found.append(elem.elem)
-        elif isinstance(elem, EtreeElement):
-            elements_found.append(elem)
-
-    if not elements_found:
-        msg = (
-            "Cannot find any elements to union. "
-            + "At least one argument must be a "
-            + "BoundElement, PaddedText, or EtreeElement."
-        )
-        raise ValueError(msg)
-    group = new_element("g", **attributes)
-    group.extend(elements_found)
-    return group
-
-
 def new_bbox_union(*blems: SupportsBounds | EtreeElement) -> BoundingBox:
     """Get the union of the bounding boxes of the given elements.
 
@@ -98,10 +69,10 @@ def new_bound_union(*blems: SupportsBounds | EtreeElement) -> BoundElement:
 def cut_bbox(
     bbox: SupportsBounds,
     *,
-    x: float | None = None,
-    y: float | None = None,
-    x2: float | None = None,
-    y2: float | None = None,
+    x: MeasurementArg | None = None,
+    y: MeasurementArg | None = None,
+    x2: MeasurementArg | None = None,
+    y2: MeasurementArg | None = None,
 ) -> BoundingBox:
     """Return a new bounding box with updated limits.
 
@@ -112,10 +83,10 @@ def cut_bbox(
     :param y2: the new y2-coordinate.
     :return: a new bounding box with the updated limits.
     """
-    x = bbox.x if x is None else x
-    y = bbox.y if y is None else y
-    x2 = bbox.x2 if x2 is None else x2
-    y2 = bbox.y2 if y2 is None else y2
+    x = bbox.x if x is None else to_user_units(x)
+    y = bbox.y if y is None else to_user_units(y)
+    x2 = bbox.x2 if x2 is None else to_user_units(x2)
+    y2 = bbox.y2 if y2 is None else to_user_units(y2)
     x, x2 = sorted((x, x2))
     y, y2 = sorted((y, y2))
     width = x2 - x
@@ -151,7 +122,7 @@ def bbox_dict(bbox: SupportsBounds) -> dict[str, float]:
     return {"x": bbox.x, "y": bbox.y, "width": bbox.width, "height": bbox.height}
 
 
-def new_bbox_rect(bbox: BoundingBox, **kwargs: float | str) -> EtreeElement:
+def new_bbox_rect(bbox: BoundingBox, **kwargs: ElemAttrib) -> EtreeElement:
     """Return a new rect element with the same dimensions as the bounding box.
 
     :param bbox: the bounding box or bound element from which to extract dimensions.
@@ -160,7 +131,19 @@ def new_bbox_rect(bbox: BoundingBox, **kwargs: float | str) -> EtreeElement:
     return new_element("rect", **bbox_dict(bbox), **kwargs)
 
 
-def _get_view_box(elem: EtreeElement) -> tuple[float, float, float, float]:
+def new_bound_rect(bbox: BoundingBox, **kwargs: ElemAttrib) -> BoundElement:
+    """Return a new rect element with the same dimensions as the bounding box.
+
+    :param bbox: the bounding box or bound element from which to extract dimensions.
+    :param kwargs: additional attributes for the rect element.
+    """
+    elem = new_bbox_rect(bbox, **kwargs)
+    return BoundElement(elem, bbox)
+
+
+def get_bounding_box_from_root(
+    elem: EtreeElement,
+) -> tuple[float, float, MeasurementArg, MeasurementArg]:
     """Return the view box of an element as a tuple of floats.
 
     :param elem: the element from which to extract the view box.
@@ -170,11 +153,15 @@ def _get_view_box(elem: EtreeElement) -> tuple[float, float, float, float]:
     files have a viewBox attribute.
     """
     view_box = elem.get("viewBox")
-    if view_box is None:
-        msg = "Element does not have a viewBox attribute."
+    if view_box:
+        x, y, width, height = map(float, view_box.split())
+        return x, y, width, height
+    width = elem.get("width")
+    height = elem.get("height")
+    if width is None or height is None:
+        msg = "Cannot infer viewBox from element."
         raise ValueError(msg)
-    x, y, width, height = map(float, view_box.split())
-    return x, y, width, height
+    return 0, 0, to_user_units(width), to_user_units(height)
 
 
 def parse_bound_element(svg_file: str | os.PathLike[str]) -> BoundElement:
@@ -196,5 +183,5 @@ def parse_bound_element(svg_file: str | os.PathLike[str]) -> BoundElement:
     elem.extend(list(root))
     if len(elem) == 1:
         elem = elem[0]
-    bbox = BoundingBox(*_get_view_box(root))
+    bbox = BoundingBox(*get_bounding_box_from_root(root))
     return BoundElement(elem, bbox)

svg_ultralight/bounding_boxes/padded_text_initializers.py

@@ -2,19 +2,15 @@
 
 Three variants:
 
-- `pad_text`: uses Inkscape to measure text bounds
+- `pad_text_inkscape`: uses Inkscape to measure text bounds
 
 - `pad_text_ft`: uses fontTools to measure text bounds (faster, and you get line_gap)
 
-- `pad_text_mix`: uses Inkscape and fontTools to give true ascent, descent, and
-  line_gap while correcting some of the layout differences between fontTools and
-  Inkscape.
-
-There is a default font size for pad_text if an element is passed. There is also a
-default for the other pad_text_ functions, but it taken from the font file and is
-usually 1024, so it won't be easy to miss. The default for standard pad_text is to
-prevent surprises if Inksape defaults to font-size 12pt while your browser defaults
-to 16px.
+There is a default font size for pad_text_inkscape if an element is passed. There is
+also a default for the other pad_text_ functions, but it taken from the font file and
+is usually 1024, so it won't be easy to miss. The default for standard
+pad_text_inkscape is to prevent surprises if Inksape defaults to font-size 12pt while
+your browser defaults to 16px.
 
 :author: Shay Hill
 :created: 2025-06-09
@@ -22,16 +18,21 @@ to 16px.
 
 from __future__ import annotations
 
-from copy import deepcopy
+import copy
+import itertools as it
 from typing import TYPE_CHECKING, overload
 
 from svg_ultralight.attrib_hints import ElemAttrib
-from svg_ultralight.bounding_boxes.bound_helpers import pad_bbox
-from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
-from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
-from svg_ultralight.constructors import new_element, update_element
+from svg_ultralight.bounding_boxes.type_padded_text import (
+    FontMetrics,
+    PaddedText,
+    new_padded_union,
+)
+from svg_ultralight.constructors import update_element
 from svg_ultralight.font_tools.font_info import (
+    DATA_TEXT_ESCAPE_CHARS,
     FTFontInfo,
+    FTTextInfo,
     get_padded_text_info,
     get_svg_font_attributes,
 )
@@ -49,12 +50,23 @@ if TYPE_CHECKING:
 
 DEFAULT_Y_BOUNDS_REFERENCE = "{[|gjpqyf"
 
-# A default font size for pad_text if font-size is not specified in the reference
-# element.
-DEFAULT_FONT_SIZE_FOR_PAD_TEXT = 12.0  # Default font size for pad_text if not specified
+# A default font size for pad_text_inkscape if font-size is not specified in the
+# reference element.
+DEFAULT_FONT_SIZE_FOR_PAD_TEXT = 12.0  # Default font size for pad_text_inkscape
 
 
-def pad_text(
+def _desanitize_svg_data_text(text: str) -> str:
+    """Desanitize a string from an SVG data-text attribute.
+
+    :param text: The input string to desanitize.
+    :return: The desanitized string with XML characters unescaped.
+    """
+    for char, escape_seq in DATA_TEXT_ESCAPE_CHARS.items():
+        text = text.replace(escape_seq, char)
+    return text
+
+
+def pad_text_inkscape(
     inkscape: str | os.PathLike[str],
     text_elem: EtreeElement,
     y_bounds_reference: str | None = None,
@@ -77,7 +89,8 @@ def pad_text(
         This is going to conflict with any font-family, font-style, or other
         font-related attributes *except* font-size. You likely want to use
         `font_tools.new_padded_text` if you're going to pass a font path, but you can
-        use it here to compare results between `pad_text` and `new_padded_text`.
+        use it here to compare results between `pad_text_inkscape` and
+        `new_padded_text`.
     :return: a PaddedText instance
     """
     if y_bounds_reference is None:
@@ -86,8 +99,8 @@ def pad_text(
         _ = update_element(text_elem, **get_svg_font_attributes(font))
     if "font-size" not in text_elem.attrib:
         text_elem.attrib["font-size"] = format_number(DEFAULT_FONT_SIZE_FOR_PAD_TEXT)
-    rmargin_ref = deepcopy(text_elem)
-    capline_ref = deepcopy(text_elem)
+    rmargin_ref = copy.deepcopy(text_elem)
+    capline_ref = copy.deepcopy(text_elem)
     _ = rmargin_ref.attrib.pop("id", None)
     _ = capline_ref.attrib.pop("id", None)
     rmargin_ref.attrib["text-anchor"] = "end"
@@ -107,113 +120,115 @@ def pad_text(
         rpad,
         bpad,
         lpad,
-        font_size=float(text_elem.attrib["font-size"]),
     )
 
 
-@overload
-def pad_chars_ft(
+def _remove_svg_font_attributes(attributes: dict[str, ElemAttrib]) -> dict[str, str]:
+    """Remove svg font attributes from the attributes dict.
+
+    These are either not required when explicitly passing a font file, not relevant,
+    or not supported by fontTools.
+    """
+    attributes_ = format_attr_dict(**attributes)
+    keys_to_remove = [
+        "font-size",
+        "font-family",
+        "font-style",
+        "font-weight",
+        "font-stretch",
+    ]
+    return {k: v for k, v in attributes_.items() if k not in keys_to_remove}
+
+
+def join_tspans(
     font: str | os.PathLike[str],
+    tspans: list[PaddedText],
+    attrib: OptionalElemAttribMapping = None,
+) -> PaddedText:
+    """Join multiple PaddedText elements into a single BoundElement.
+
+    :param font: the one font file used for kerning.
+    :param tspans: list of tspan elements to join (each an output from pad_chars_ft).
+
+    This is limited and will not handle arbitrary text elements (only `g` elements
+    with a "data-text" attribute equal to the character(s) in the tspan). Will also
+    not handle scaled PaddedText instances. This is for joining tspans originally
+    after they are created and all using similar fonts.
+    """
+    font_info = FTFontInfo(font)
+    for left, right in it.pairwise(tspans):
+        l_joint = _desanitize_svg_data_text(left.elem.attrib["data-text"])[-1]
+        r_joint = _desanitize_svg_data_text(right.elem.attrib["data-text"])[0]
+        l_name = font_info.get_glyph_name(l_joint)
+        r_name = font_info.get_glyph_name(r_joint)
+        kern = font_info.kern_table.get((l_name, r_name), 0)
+        right.x = left.x2 + kern
+    return new_padded_union(*tspans, **attrib or {})
+
+
+@overload
+def pad_text(
+    font: str | os.PathLike[str] | FTFontInfo,
     text: str,
     font_size: float | None = None,
-    ascent: float | None = None,
-    descent: float | None = None,
-    *,
-    y_bounds_reference: str | None = None,
-    attrib: OptionalElemAttribMapping = None,
     **attributes: ElemAttrib,
-) -> BoundElement: ...
+) -> PaddedText: ...
 
 
 @overload
-def pad_chars_ft(
-    font: str | os.PathLike[str],
+def pad_text(
+    font: str | os.PathLike[str] | FTFontInfo,
     text: list[str],
     font_size: float | None = None,
-    ascent: float | None = None,
-    descent: float | None = None,
-    *,
-    y_bounds_reference: str | None = None,
-    attrib: OptionalElemAttribMapping = None,
     **attributes: ElemAttrib,
-) -> list[BoundElement]: ...
+) -> list[PaddedText]: ...
 
 
-def pad_chars_ft(
-    font: str | os.PathLike[str],
+def pad_text(
+    font: str | os.PathLike[str] | FTFontInfo,
     text: str | list[str],
     font_size: float | None = None,
-    ascent: float | None = None,
-    descent: float | None = None,
-    *,
-    y_bounds_reference: str | None = None,
-    attrib: OptionalElemAttribMapping = None,
     **attributes: ElemAttrib,
-) -> BoundElement | list[BoundElement]:
-    """Create a bound group of paths for each character in the text.
+) -> PaddedText | list[PaddedText]:
+    """Create a new PaddedText instance using fontTools.
 
-    Create a bound group of path elements, one for each character in the text. This
-    will provide less utility in most respects than `pad_text_ft`, but will be useful
-    for animations and other effects where individual characters need to be
-    addressed.
+    :param font: path to a font file.
+    :param text: the text of the text element or a list of text strings.
+    :param font_size: the font size to use. Skip for default font size. This can
+        always be set later, but the argument is useful if you're working with fonts
+        that have different native font sizes (usually 1000, 1024, or 2048).
     """
-    attributes.update(attrib or {})
-    attributes_ = format_attr_dict(**attributes)
-    attributes_.update(get_svg_font_attributes(font))
+    attributes_ = _remove_svg_font_attributes(attributes)
+    font = font if isinstance(font, FTFontInfo) else FTFontInfo(font)
+    metrics = FontMetrics(
+        font.units_per_em,
+        font.ascent,
+        font.descent,
+        font.line_gap,
+        font.cap_height,
+        font.x_height,
+    )
 
-    _ = attributes_.pop("font-size", None)
-    _ = attributes_.pop("font-family", None)
-    _ = attributes_.pop("font-style", None)
-    _ = attributes_.pop("font-weight", None)
-    _ = attributes_.pop("font-stretch", None)
+    plems: list[PaddedText] = []
+    for t in [text] if isinstance(text, str) else text:
+        text_info = FTTextInfo(font, t)
+        elem = text_info.new_element(**attributes_)
+        plem = PaddedText(
+            elem, text_info.bbox, *text_info.padding, metrics=copy.copy(metrics)
+        )
+        if font_size:
+            plem.font_size = font_size
+        plems.append(plem)
+    font.maybe_close()
 
-    input_one_text_item = False
     if isinstance(text, str):
-        input_one_text_item = True
-        text = [text]
-    elems: list[BoundElement] = []
-
-    font_info = FTFontInfo(font)
-    try:
-        for text_item in text:
-            text_info = get_padded_text_info(
-                font_info,
-                text_item,
-                font_size,
-                ascent,
-                descent,
-                y_bounds_reference=y_bounds_reference,
-            )
-            elem = text_info.new_chars_group_element(**attributes_)
-            bbox = pad_bbox(text_info.bbox, text_info.padding)
-            elems.append(BoundElement(elem, bbox))
-    finally:
-        font_info.font.close()
-    if input_one_text_item:
-        return elems[0]
-    return elems
-
-
-def _remove_svg_font_attributes(attributes: dict[str, ElemAttrib]) -> dict[str, str]:
-    """Remove svg font attributes from the attributes dict.
-
-    These are either not required when explicitly passing a font file, not relevant,
-    or not supported by fontTools.
-    """
-    attributes_ = format_attr_dict(**attributes)
-    keys_to_remove = [
-        "font-size",
-        "font-family",
-        "font-style",
-        "font-weight",
-        "font-stretch",
-    ]
-    return {k: v for k, v in attributes_.items() if k not in keys_to_remove}
+        return plems[0]
+    return plems
 
 
 @overload
 def pad_text_ft(
-    font: str | os.PathLike[str],
+    font: str | os.PathLike[str] | FTFontInfo,
     text: str,
     font_size: float | None = None,
     ascent: float | None = None,
@@ -227,7 +242,7 @@ def pad_text_ft(
 
 @overload
 def pad_text_ft(
-    font: str | os.PathLike[str],
+    font: str | os.PathLike[str] | FTFontInfo,
     text: list[str],
     font_size: float | None = None,
     ascent: float | None = None,
@@ -240,7 +255,7 @@ def pad_text_ft(
 
 
 def pad_text_ft(
-    font: str | os.PathLike[str],
+    font: str | os.PathLike[str] | FTFontInfo,
     text: str | list[str],
     font_size: float | None = None,
     ascent: float | None = None,
@@ -262,8 +277,9 @@ def pad_text_ft(
     :param y_bounds_reference: optional character or string to use as a reference
         for the ascent and descent. If provided, the ascent and descent will be the y
         extents of the capline reference. This argument is provided to mimic the
-        behavior of the query module's `pad_text` function. `pad_text` does no
-        inspect font files and relies on Inkscape to measure reference characters.
+        behavior of the query module's `pad_text_inkscape` function.
+        `pad_text_inkscape` does not inspect font files and relies on Inkscape to
+        measure reference characters.
     :param attrib: optionally pass additional attributes as a mapping instead of as
         anonymous kwargs. This is useful for pleasing the linter when unpacking a
         dictionary into a function call.
@@ -282,23 +298,33 @@ def pad_text_ft(
         text = [text]
 
     font_info = FTFontInfo(font)
+    metrics = FontMetrics(
+        font_info.units_per_em,
+        font_info.ascent,
+        font_info.descent,
+        font_info.line_gap,
+        font_info.cap_height,
+        font_info.x_height,
+    )
+
+    elems: list[PaddedText] = []
+    for text_item in text:
+        ti = get_padded_text_info(
+            font_info,
+            text_item,
+            None,  # font_size
+            ascent,
+            descent,
+            y_bounds_reference=y_bounds_reference,
+        )
+        elem = ti.new_element(**attributes_)
+        plem = PaddedText(elem, ti.bbox, *ti.padding, metrics=copy.copy(metrics))
+        if font_size:
+            plem.font_size = font_size
+        elems.append(plem)
+
+    font_info.maybe_close()
 
-    try:
-        elems: list[PaddedText] = []
-        for text_item in text:
-            ti = get_padded_text_info(
-                font_info,
-                text_item,
-                font_size,
-                ascent,
-                descent,
-                y_bounds_reference=y_bounds_reference,
-            )
-            elem = ti.new_element(**attributes_)
-            plem = PaddedText(elem, ti.bbox, *ti.padding, ti.line_gap, ti.font_size)
-            elems.append(plem)
-    finally:
-        font_info.font.close()
     if input_one_text_item:
         return elems[0]
     return elems
@@ -380,63 +406,3 @@ def wrap_text_ft(
     if input_one_text_item:
         return all_wrapped[0]
     return all_wrapped
-
-
-def pad_text_mix(
-    inkscape: str | os.PathLike[str],
-    font: str | os.PathLike[str],
-    text: str,
-    font_size: float | None = None,
-    ascent: float | None = None,
-    descent: float | None = None,
-    *,
-    y_bounds_reference: str | None = None,
-    attrib: OptionalElemAttribMapping = None,
-    **attributes: ElemAttrib,
-) -> PaddedText:
-    """Use Inkscape text bounds and fill missing with fontTools.
-
-    :param font: path to a font file.
-    :param text: the text of the text element.
-    :param font_size: the font size to use.
-    :param ascent: the ascent of the font. If not provided, it will be calculated
-        from the font file.
-    :param descent: the descent of the font. If not provided, it will be calculated
-        from the font file.
-    :param y_bounds_reference: optional character or string to use as a reference
-        for the ascent and descent. If provided, the ascent and descent will be the y
-        extents of the capline reference. This argument is provided to mimic the
-        behavior of the query module's `pad_text` function. `pad_text` does no
-        inspect font files and relies on Inkscape to measure reference characters.
-    :param attrib: optionally pass additional attributes as a mapping instead of as
-        anonymous kwargs. This is useful for pleasing the linter when unpacking a
-        dictionary into a function call.
-    :param attributes: additional attributes to set on the text element. There is a
-        chance these will cause the font element to exceed the BoundingBox of the
-        PaddedText instance.
-    :return: a PaddedText instance with a line_gap defined.
-    """
-    attributes.update(attrib or {})
-    elem = new_element("text", text=text, **attributes)
-    padded_inkscape = pad_text(inkscape, elem, y_bounds_reference, font=font)
-    padded_fonttools = pad_text_ft(
-        font,
-        text,
-        font_size,
-        ascent,
-        descent,
-        y_bounds_reference=y_bounds_reference,
-        attrib=attributes,
-    )
-    bbox = padded_inkscape.tbox
-    rpad = padded_inkscape.rpad
-    lpad = padded_inkscape.lpad
-    if y_bounds_reference is None:
-        tpad = padded_fonttools.tpad
-        bpad = padded_fonttools.bpad
-    else:
-        tpad = padded_inkscape.tpad
-        bpad = padded_inkscape.bpad
-    return PaddedText(
-        elem, bbox, tpad, rpad, bpad, lpad, padded_fonttools.line_gap, font_size
-    )