codewave-openclaw-installer 1.0.2 → 2.1.0

package/skills/ppt-master/scripts/svg_to_pptx/drawingml_styles.py

@@ -0,0 +1,359 @@
+"""Fill, stroke, and shadow XML builders for DrawingML conversion."""
+
+from __future__ import annotations
+
+import math
+from xml.etree import ElementTree as ET
+
+from .drawingml_context import ConvertContext
+from .drawingml_utils import (
+    SVG_NS, ANGLE_UNIT, DASH_PRESETS,
+    px_to_emu, _f, _get_attr,
+    parse_hex_color, parse_stop_style, resolve_url_id,
+)
+
+
+def build_solid_fill(color: str, opacity: float | None = None) -> str:
+    """Build <a:solidFill> XML."""
+    alpha = ''
+    if opacity is not None and opacity < 1.0:
+        alpha = f'<a:alpha val="{int(opacity * 100000)}"/>'
+    return f'<a:solidFill><a:srgbClr val="{color}">{alpha}</a:srgbClr></a:solidFill>'
+
+
+def build_gradient_fill(
+    grad_elem: ET.Element,
+    opacity: float | None = None,
+) -> str:
+    """Build <a:gradFill> from SVG linearGradient or radialGradient element."""
+    tag = grad_elem.tag.replace(f'{{{SVG_NS}}}', '')
+
+    stops_xml = []
+    for child in grad_elem:
+        child_tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if child_tag != 'stop':
+            continue
+
+        offset_str = child.get('offset', '0').strip().rstrip('%')
+        try:
+            offset = float(offset_str)
+            if offset > 1.0:
+                offset = offset / 100.0
+        except ValueError:
+            offset = 0.0
+        pos = int(offset * 100000)
+
+        # Parse color from style attribute or direct attributes
+        style = child.get('style', '')
+        color, stop_opacity = parse_stop_style(style)
+        if not color:
+            color = parse_hex_color(child.get('stop-color', '#000000'))
+        if color is None:
+            color = '000000'
+
+        direct_stop_op = child.get('stop-opacity')
+        if direct_stop_op is not None:
+            try:
+                stop_opacity = float(direct_stop_op)
+            except ValueError:
+                pass
+
+        alpha_xml = ''
+        effective_opacity = stop_opacity
+        if opacity is not None:
+            effective_opacity *= opacity
+        if effective_opacity < 1.0:
+            alpha_xml = f'<a:alpha val="{int(effective_opacity * 100000)}"/>'
+
+        stops_xml.append(
+            f'<a:gs pos="{pos}"><a:srgbClr val="{color}">{alpha_xml}</a:srgbClr></a:gs>'
+        )
+
+    if not stops_xml:
+        return ''
+
+    gs_list = '\n'.join(stops_xml)
+
+    if tag == 'linearGradient':
+        def parse_grad_coord(val_str: str, default: float = 0.0) -> float:
+            val_str = val_str.strip()
+            if val_str.endswith('%'):
+                return float(val_str.rstrip('%')) / 100.0
+            v = float(val_str)
+            return v / 100.0 if v > 1.0 else v
+
+        x1 = parse_grad_coord(grad_elem.get('x1', '0'))
+        y1 = parse_grad_coord(grad_elem.get('y1', '0'))
+        x2 = parse_grad_coord(grad_elem.get('x2', '1'))
+        y2 = parse_grad_coord(grad_elem.get('y2', '1'))
+
+        angle_rad = math.atan2(y2 - y1, x2 - x1)
+        angle_deg = math.degrees(angle_rad)
+        dml_angle = int((angle_deg % 360) * ANGLE_UNIT)
+
+        return f'''<a:gradFill>
+<a:gsLst>{gs_list}</a:gsLst>
+<a:lin ang="{dml_angle}" scaled="1"/>
+</a:gradFill>'''
+
+    elif tag == 'radialGradient':
+        return f'''<a:gradFill>
+<a:gsLst>{gs_list}</a:gsLst>
+<a:path path="circle">
+<a:fillToRect l="50000" t="50000" r="50000" b="50000"/>
+</a:path>
+</a:gradFill>'''
+
+    return ''
+
+
+def build_fill_xml(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    opacity: float | None = None,
+) -> str:
+    """Build fill XML for a shape element, with inherited style support."""
+    fill = _get_attr(elem, 'fill', ctx)
+    if fill is None:
+        fill = '#000000'  # SVG default fill is black
+
+    if fill == 'none':
+        return '<a:noFill/>'
+
+    grad_id = resolve_url_id(fill)
+    if grad_id and grad_id in ctx.defs:
+        return build_gradient_fill(ctx.defs[grad_id], opacity)
+
+    color = parse_hex_color(fill)
+    if color:
+        return build_solid_fill(color, opacity)
+
+    return '<a:noFill/>'
+
+
+def build_stroke_xml(
+    elem: ET.Element,
+    ctx: ConvertContext,
+    opacity: float | None = None,
+) -> str:
+    """Build <a:ln> XML for stroke, with inherited style support."""
+    stroke = _get_attr(elem, 'stroke', ctx)
+    if not stroke or stroke == 'none':
+        return '<a:ln><a:noFill/></a:ln>'
+
+    width = _f(_get_attr(elem, 'stroke-width', ctx), 1.0)
+    width_emu = px_to_emu(width)
+
+    # Dash pattern
+    dash_xml = ''
+    dasharray = _get_attr(elem, 'stroke-dasharray', ctx)
+    if dasharray and dasharray != 'none':
+        preset = DASH_PRESETS.get(dasharray.strip())
+        if preset:
+            dash_xml = f'<a:prstDash val="{preset}"/>'
+        else:
+            dash_xml = '<a:prstDash val="dash"/>'
+
+    # Line cap
+    cap_map = {'round': 'rnd', 'square': 'sq', 'butt': 'flat'}
+    cap_attr = ''
+    linecap = _get_attr(elem, 'stroke-linecap', ctx)
+    if linecap and linecap in cap_map:
+        cap_attr = f' cap="{cap_map[linecap]}"'
+
+    # Line join
+    join_xml = ''
+    linejoin = _get_attr(elem, 'stroke-linejoin', ctx)
+    if linejoin == 'round':
+        join_xml = '<a:round/>'
+    elif linejoin == 'bevel':
+        join_xml = '<a:bevel/>'
+    elif linejoin == 'miter':
+        join_xml = '<a:miter lim="800000"/>'
+
+    # Gradient stroke
+    grad_id = resolve_url_id(stroke)
+    if grad_id and grad_id in ctx.defs:
+        grad_fill = build_gradient_fill(ctx.defs[grad_id], opacity)
+        return f'<a:ln w="{width_emu}"{cap_attr}>{grad_fill}{dash_xml}{join_xml}</a:ln>'
+
+    # Solid color stroke
+    color = parse_hex_color(stroke)
+    if not color:
+        return '<a:ln><a:noFill/></a:ln>'
+
+    alpha_xml = ''
+    if opacity is not None and opacity < 1.0:
+        alpha_xml = f'<a:alpha val="{int(opacity * 100000)}"/>'
+
+    return f'''<a:ln w="{width_emu}"{cap_attr}>
+<a:solidFill><a:srgbClr val="{color}">{alpha_xml}</a:srgbClr></a:solidFill>{dash_xml}{join_xml}
+</a:ln>'''
+
+
+def _parse_filter_params(
+    filter_elem: ET.Element,
+) -> dict[str, float | str]:
+    """Extract common parameters from an SVG filter element.
+
+    Returns:
+        Dict with keys: std_dev, dx, dy, opacity, color, has_offset.
+    """
+    std_dev = 4.0
+    dx = 0.0
+    dy = 0.0
+    opacity = 0.3
+    color = '000000'
+    has_offset = False
+
+    for child in filter_elem.iter():
+        tag = child.tag.replace(f'{{{SVG_NS}}}', '')
+        if tag == 'feGaussianBlur':
+            std_dev = _f(child.get('stdDeviation'), 4.0)
+        elif tag == 'feOffset':
+            dx = _f(child.get('dx'), 0.0)
+            dy = _f(child.get('dy'), 0.0)
+            if abs(dx) > 0.01 or abs(dy) > 0.01:
+                has_offset = True
+        elif tag == 'feFlood':
+            opacity = _f(child.get('flood-opacity'), 0.3)
+            raw_color = child.get('flood-color', '').strip().lstrip('#')
+            if len(raw_color) == 6 and all(c in '0123456789abcdefABCDEF' for c in raw_color):
+                color = raw_color.upper()
+        elif tag == 'feFuncA':
+            if child.get('type') == 'linear':
+                opacity = _f(child.get('slope'), 0.3)
+
+    return {
+        'std_dev': std_dev, 'dx': dx, 'dy': dy,
+        'opacity': opacity, 'color': color, 'has_offset': has_offset,
+    }
+
+
+def build_shadow_xml(filter_elem: ET.Element) -> str:
+    """Build <a:effectLst> with <a:outerShdw> from SVG filter element."""
+    if filter_elem is None:
+        return ''
+
+    p = _parse_filter_params(filter_elem)
+    std_dev = p['std_dev']
+    dx = p['dx']
+    dy = p['dy']
+    # For shadow, default dy to 4 if no offset was found
+    if not p['has_offset']:
+        dy = 4.0
+
+    blur_rad = px_to_emu(std_dev * 2)
+    dist = px_to_emu(math.sqrt(dx * dx + dy * dy))
+    dir_angle = int(((90 + math.degrees(math.atan2(dy, max(dx, 0.001)))) % 360) * ANGLE_UNIT)
+    alpha_val = int(p['opacity'] * 100000)
+
+    return f'''<a:effectLst>
+<a:outerShdw blurRad="{blur_rad}" dist="{dist}" dir="{dir_angle}" algn="tl" rotWithShape="0">
+<a:srgbClr val="{p['color']}"><a:alpha val="{alpha_val}"/></a:srgbClr>
+</a:outerShdw>
+</a:effectLst>'''
+
+
+def build_glow_xml(filter_elem: ET.Element) -> str:
+    """Build <a:effectLst> with <a:glow> from SVG filter element.
+
+    Used for filters that have feGaussianBlur without meaningful feOffset,
+    typically title glow or highlight effects.
+    """
+    if filter_elem is None:
+        return ''
+
+    p = _parse_filter_params(filter_elem)
+    rad = px_to_emu(p['std_dev'] * 2)
+    alpha_val = int(p['opacity'] * 100000)
+
+    return f'''<a:effectLst>
+<a:glow rad="{rad}">
+<a:srgbClr val="{p['color']}"><a:alpha val="{alpha_val}"/></a:srgbClr>
+</a:glow>
+</a:effectLst>'''
+
+
+def build_effect_xml(filter_elem: ET.Element) -> str:
+    """Build effect XML by classifying the SVG filter as shadow or glow.
+
+    Classification rules:
+    - feOffset with non-zero dx/dy → outer shadow
+    - No feOffset or zero offset → glow effect
+    """
+    if filter_elem is None:
+        return ''
+
+    p = _parse_filter_params(filter_elem)
+    if p['has_offset']:
+        return build_shadow_xml(filter_elem)
+    return build_glow_xml(filter_elem)
+
+
+def get_element_opacity(elem: ET.Element) -> float | None:
+    """Get opacity value from element. Returns None if 1.0 or not set."""
+    op = elem.get('opacity')
+    if op is None:
+        return None
+    try:
+        val = float(op)
+        return val if val < 1.0 else None
+    except ValueError:
+        return None
+
+
+def get_fill_opacity(
+    elem: ET.Element,
+    ctx: ConvertContext | None = None,
+) -> float | None:
+    """Get effective fill opacity combining 'opacity' and 'fill-opacity'.
+
+    Returns:
+        Combined opacity value, or None if fully opaque.
+    """
+    base = 1.0
+
+    op = _get_attr(elem, 'opacity', ctx) if ctx else elem.get('opacity')
+    if op:
+        try:
+            base = float(op)
+        except ValueError:
+            pass
+
+    fill_op = _get_attr(elem, 'fill-opacity', ctx) if ctx else elem.get('fill-opacity')
+    if fill_op:
+        try:
+            base *= float(fill_op)
+        except ValueError:
+            pass
+
+    return base if base < 1.0 else None
+
+
+def get_stroke_opacity(
+    elem: ET.Element,
+    ctx: ConvertContext | None = None,
+) -> float | None:
+    """Get effective stroke opacity combining 'opacity' and 'stroke-opacity'.
+
+    Returns:
+        Combined opacity value, or None if fully opaque.
+    """
+    base = 1.0
+
+    op = _get_attr(elem, 'opacity', ctx) if ctx else elem.get('opacity')
+    if op:
+        try:
+            base = float(op)
+        except ValueError:
+            pass
+
+    stroke_op = _get_attr(elem, 'stroke-opacity', ctx) if ctx else elem.get('stroke-opacity')
+    if stroke_op:
+        try:
+            base *= float(stroke_op)
+        except ValueError:
+            pass
+
+    return base if base < 1.0 else None

package/skills/ppt-master/scripts/svg_to_pptx/drawingml_utils.py

@@ -0,0 +1,310 @@
+"""Coordinate helpers, color parsing, and font utilities for DrawingML conversion."""
+
+from __future__ import annotations
+
+import re
+from xml.etree import ElementTree as ET
+
+from .drawingml_context import ConvertContext
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+SVG_NS = 'http://www.w3.org/2000/svg'
+XLINK_NS = 'http://www.w3.org/1999/xlink'
+
+EMU_PER_PX = 9525  # 1 SVG px = 9525 EMU (96 DPI)
+FONT_PX_TO_HUNDREDTHS_PT = 75  # 1px = 0.75pt -> 75 hundredths-of-a-point
+ANGLE_UNIT = 60000  # DrawingML angle: 60000ths of a degree
+
+# SVG attributes inheritable from parent <g>
+INHERITABLE_ATTRS = [
+    'fill', 'stroke', 'stroke-width', 'stroke-dasharray', 'stroke-linecap',
+    'stroke-linejoin', 'opacity', 'fill-opacity', 'stroke-opacity',
+    'font-family', 'font-size', 'font-weight', 'font-style',
+    'text-anchor', 'letter-spacing', 'text-decoration',
+]
+
+# Known East Asian fonts
+EA_FONTS = {
+    'PingFang SC', 'PingFang TC', 'PingFang HK',
+    'Microsoft YaHei', 'Microsoft JhengHei',
+    'SimSun', 'SimHei', 'FangSong', 'KaiTi', 'STKaiti',
+    'STHeiti', 'STSong', 'STFangsong', 'STXihei', 'STZhongsong',
+    'Hiragino Sans', 'Hiragino Sans GB', 'Hiragino Mincho ProN',
+    'Noto Sans SC', 'Noto Sans TC', 'Noto Serif SC', 'Noto Serif TC',
+    'Source Han Sans SC', 'Source Han Sans TC',
+    'Source Han Serif SC', 'Source Han Serif TC',
+    'WenQuanYi Micro Hei', 'WenQuanYi Zen Hei',
+    'YouYuan', 'LiSu', 'HuaWenKaiTi',
+    'Songti SC', 'Songti TC',
+}
+SYSTEM_FONTS = {'system-ui', '-apple-system', 'BlinkMacSystemFont'}
+
+# macOS/Linux-only fonts -> Windows equivalents
+FONT_FALLBACK_WIN = {
+    'PingFang SC': 'Microsoft YaHei',
+    'PingFang TC': 'Microsoft JhengHei',
+    'PingFang HK': 'Microsoft JhengHei',
+    'Hiragino Sans': 'Microsoft YaHei',
+    'Hiragino Sans GB': 'Microsoft YaHei',
+    'Hiragino Mincho ProN': 'SimSun',
+    'STHeiti': 'SimHei',
+    'STSong': 'SimSun',
+    'STKaiti': 'KaiTi',
+    'STFangsong': 'FangSong',
+    'STXihei': 'Microsoft YaHei',
+    'STZhongsong': 'SimSun',
+    'Songti SC': 'SimSun',
+    'Songti TC': 'SimSun',
+    'Noto Sans SC': 'Microsoft YaHei',
+    'Noto Sans TC': 'Microsoft JhengHei',
+    'Noto Serif SC': 'SimSun',
+    'Noto Serif TC': 'SimSun',
+    'Source Han Sans SC': 'Microsoft YaHei',
+    'Source Han Sans TC': 'Microsoft JhengHei',
+    'Source Han Serif SC': 'SimSun',
+    'Source Han Serif TC': 'SimSun',
+    'WenQuanYi Micro Hei': 'Microsoft YaHei',
+    'WenQuanYi Zen Hei': 'Microsoft YaHei',
+    # Latin fonts (macOS / Linux / Web -> Windows)
+    'SF Pro': 'Segoe UI',
+    'SF Pro Display': 'Segoe UI',
+    'SF Pro Text': 'Segoe UI',
+    'SF Mono': 'Consolas',
+    'Menlo': 'Consolas',
+    'Monaco': 'Consolas',
+    'Helvetica Neue': 'Arial',
+    'Helvetica': 'Arial',
+    'Roboto': 'Segoe UI',
+    'Ubuntu': 'Segoe UI',
+    'Liberation Sans': 'Arial',
+    'Liberation Serif': 'Times New Roman',
+    'Liberation Mono': 'Consolas',
+    'DejaVu Sans': 'Segoe UI',
+    'DejaVu Serif': 'Times New Roman',
+    'DejaVu Sans Mono': 'Consolas',
+}
+
+GENERIC_FONT_MAP = {
+    'monospace': 'Consolas',
+    'sans-serif': 'Segoe UI',
+    'serif': 'Times New Roman',
+}
+
+# When the latin font is serif and no EA font is specified,
+# prefer SimSun (serif CJK) over Microsoft YaHei (sans-serif CJK).
+_SERIF_LATIN = {
+    'Times New Roman', 'Georgia', 'Garamond', 'Palatino', 'Palatino Linotype',
+    'Book Antiqua', 'Cambria', 'SimSun', 'Liberation Serif', 'DejaVu Serif',
+}
+
+# SVG stroke-dasharray -> DrawingML prstDash
+DASH_PRESETS = {
+    '4,4': 'dash',  '4 4': 'dash',
+    '6,3': 'dash',  '6 3': 'dash',
+    '2,2': 'sysDot', '2 2': 'sysDot',
+    '8,4': 'lgDash', '8 4': 'lgDash',
+    '8,4,2,4': 'lgDashDot', '8 4 2 4': 'lgDashDot',
+}
+
+
+# ---------------------------------------------------------------------------
+# Coordinate helpers
+# ---------------------------------------------------------------------------
+
+def px_to_emu(px: float) -> int:
+    """Convert SVG pixels to EMU."""
+    return round(px * EMU_PER_PX)
+
+
+def _f(val: str | None, default: float = 0.0) -> float:
+    """Parse a float attribute value, returning default if missing."""
+    if val is None:
+        return default
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return default
+
+
+def _extract_inheritable_styles(elem: ET.Element) -> dict[str, str]:
+    """Extract all SVG-inheritable presentation attributes from an element."""
+    styles: dict[str, str] = {}
+    for attr in INHERITABLE_ATTRS:
+        val = elem.get(attr)
+        if val is not None:
+            styles[attr] = val
+    return styles
+
+
+def _get_attr(elem: ET.Element, attr: str, ctx: ConvertContext) -> str | None:
+    """Get effective attribute: element's own value first, then inherited."""
+    val = elem.get(attr)
+    if val is not None:
+        return val
+    return ctx.inherited_styles.get(attr)
+
+
+def ctx_x(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale + translate to an X coordinate."""
+    return val * ctx.scale_x + ctx.translate_x
+
+
+def ctx_y(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale + translate to a Y coordinate."""
+    return val * ctx.scale_y + ctx.translate_y
+
+
+def ctx_w(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale to a width value."""
+    return val * ctx.scale_x
+
+
+def ctx_h(val: float, ctx: ConvertContext) -> float:
+    """Apply context scale to a height value."""
+    return val * ctx.scale_y
+
+
+# ---------------------------------------------------------------------------
+# Color / style parsing
+# ---------------------------------------------------------------------------
+
+def parse_hex_color(color_str: str) -> str | None:
+    """Parse '#RRGGBB' or '#RGB' to 'RRGGBB'. Returns None on failure."""
+    if not color_str:
+        return None
+    color_str = color_str.strip()
+    if color_str.startswith('#'):
+        color_str = color_str[1:]
+    if len(color_str) == 3:
+        color_str = ''.join(c * 2 for c in color_str)
+    if len(color_str) == 6 and all(c in '0123456789abcdefABCDEF' for c in color_str):
+        return color_str.upper()
+    return None
+
+
+def parse_stop_style(style_str: str) -> tuple[str | None, float]:
+    """Parse a gradient stop's style attribute.
+
+    Args:
+        style_str: Style string like 'stop-color:#XXX;stop-opacity:N'.
+
+    Returns:
+        (color, opacity) tuple.
+    """
+    color = None
+    opacity = 1.0
+    if not style_str:
+        return color, opacity
+
+    for part in style_str.split(';'):
+        part = part.strip()
+        if part.startswith('stop-color:'):
+            color = parse_hex_color(part.split(':', 1)[1].strip())
+        elif part.startswith('stop-opacity:'):
+            try:
+                opacity = float(part.split(':', 1)[1].strip())
+            except ValueError:
+                pass
+
+    return color, opacity
+
+
+def resolve_url_id(url_str: str) -> str | None:
+    """Extract ID from 'url(#someId)' reference."""
+    if not url_str:
+        return None
+    m = re.match(r'url\(#([^)]+)\)', url_str.strip())
+    return m.group(1) if m else None
+
+
+def get_effective_filter_id(elem: ET.Element, ctx: ConvertContext) -> str | None:
+    """Get the effective filter ID for an element, including inherited context."""
+    filt = elem.get('filter')
+    if filt:
+        return resolve_url_id(filt)
+    return ctx.filter_id
+
+
+# ---------------------------------------------------------------------------
+# Font parsing
+# ---------------------------------------------------------------------------
+
+def parse_font_family(font_family_str: str) -> dict[str, str]:
+    """Parse CSS font-family into latin/ea typeface names.
+
+    Prioritizes Windows-available fonts since PPTX is primarily opened on
+    Windows. macOS/Linux-only fonts are mapped via FONT_FALLBACK_WIN.
+    """
+    if not font_family_str:
+        return {'latin': 'Segoe UI', 'ea': 'Microsoft YaHei'}
+
+    fonts = [f.strip().strip("'\"") for f in font_family_str.split(',')]
+    latin_font = None
+    ea_font = None
+
+    for font in fonts:
+        if font in SYSTEM_FONTS:
+            continue
+        if font in GENERIC_FONT_MAP:
+            resolved = GENERIC_FONT_MAP[font]
+            latin_font = latin_font or resolved
+            continue
+
+        win_font = FONT_FALLBACK_WIN.get(font, font)
+        if font in EA_FONTS:
+            ea_font = ea_font or win_font
+        else:
+            latin_font = latin_font or win_font
+
+    # PPT renders CJK text via latin typeface when ea doesn't match
+    if not latin_font and ea_font:
+        latin_font = ea_font
+
+    final_latin = latin_font or 'Segoe UI'
+
+    # EA must always be a CJK-capable font
+    if not ea_font:
+        ea_font = 'SimSun' if final_latin in _SERIF_LATIN else 'Microsoft YaHei'
+
+    return {'latin': final_latin, 'ea': ea_font}
+
+
+def is_cjk_char(ch: str) -> bool:
+    """Check if a character is CJK (Chinese/Japanese/Korean)."""
+    cp = ord(ch)
+    return (0x4E00 <= cp <= 0x9FFF or 0x3400 <= cp <= 0x4DBF or
+            0x2E80 <= cp <= 0x2EFF or 0x3000 <= cp <= 0x303F or
+            0xFF00 <= cp <= 0xFFEF or 0xF900 <= cp <= 0xFAFF or
+            0x20000 <= cp <= 0x2A6DF)
+
+
+def estimate_text_width(text: str, font_size: float, font_weight: str = '400') -> float:
+    """Estimate text width in SVG pixels."""
+    width = 0.0
+    for ch in text:
+        if is_cjk_char(ch):
+            width += font_size
+        elif ch == ' ':
+            width += font_size * 0.3
+        elif ch in 'mMwWOQ':
+            width += font_size * 0.75
+        elif ch in 'iIlj1!|':
+            width += font_size * 0.3
+        else:
+            width += font_size * 0.55
+
+    if font_weight in ('bold', '600', '700', '800', '900'):
+        width *= 1.05
+
+    return width
+
+
+def _xml_escape(text: str) -> str:
+    """Escape XML special characters."""
+    return (text.replace('&', '&amp;')
+                .replace('<', '&lt;')
+                .replace('>', '&gt;')
+                .replace('"', '&quot;'))