python-hwpx 5.3.0__py3-none-any.whl → 5.5.0__py3-none-any.whl

hwpx/_document/layout.py

@@ -425,17 +425,28 @@ def add_hyperlink(
     paragraph: HwpxOxmlParagraph | None = None,
     section: HwpxOxmlSection | None = None,
     section_index: int | None = None,
+    char_pr_id_ref: str | int | None = None,
 ) -> HwpxOxmlInlineObject:
     """Insert a hyperlink (fieldBegin + text + fieldEnd).
 
+    The display text follows the Hancom convention (blue ``#0000FF`` text
+    with a blue bottom underline — dominant styling across real-corpus
+    hyperlinks) unless ``char_pr_id_ref`` overrides it.
+
     Returns the ``<hp:ctrl>`` wrapper containing the ``<hp:fieldBegin>``.
     """
+    if char_pr_id_ref is None:
+        char_pr_id_ref = doc.ensure_run_style(
+            underline=True,
+            color="#0000FF",
+            underline_color="#0000FF",
+        )
     if paragraph is None:
         paragraph = doc.add_paragraph(
             "", section=section, section_index=section_index,
             include_run=False,
         )
-    return paragraph.add_hyperlink(url, display_text)
+    return paragraph.add_hyperlink(url, display_text, char_pr_id_ref=char_pr_id_ref)
 
 
 def _resolve_section(

hwpx/document.py

@@ -264,14 +264,21 @@ class HwpxDocument:
         border_width: str = "0.12 mm",
         fill_color: str | None = None,
         active_borders: Sequence[str] | None = None,
+        border_type: str = "SOLID",
     ) -> str:
-        """Return a borderFill id matching the requested border/fill attributes."""
+        """Return a borderFill id matching the requested border/fill attributes.
+
+        ``border_type`` selects the OWPML line style (``SOLID``, ``DASH``,
+        ``DOT``, ``DOUBLE_SLIM``, ``WAVE``, …); values outside the OWPML
+        vocabulary are rejected.
+        """
 
         return self._root.ensure_border_fill(
             border_color=border_color,
             border_width=border_width,
             fill_color=fill_color,
             active_borders=active_borders,
+            border_type=border_type,
         )
 
     @property
@@ -594,9 +601,22 @@ class HwpxDocument:
         size: int | float | None = None,
         highlight: str | None = None,
         strike: bool | None = None,
+        underline_shape: str | None = None,
+        underline_color: str | None = None,
+        strike_shape: str | None = None,
+        ratio: int | None = None,
+        letter_spacing: int | None = None,
+        shadow: str | None = None,
+        script: str | None = None,
         base_char_pr_id: str | int | None = None,
     ) -> str:
-        """Return a ``charPr`` identifier matching the requested flags."""
+        """Return a ``charPr`` identifier matching the requested flags.
+
+        5.4.0 additions (render-verified vocabulary; invalid values are
+        rejected): ``underline_shape``/``underline_color``, ``strike_shape``,
+        ``ratio`` (장평 %), ``letter_spacing`` (자간 %), ``shadow`` (drop
+        shadow colour), ``script`` (``"sup"``/``"sub"``).
+        """
 
         return self._root.ensure_run_style(
             bold=bold,
@@ -607,6 +627,13 @@ class HwpxDocument:
             size=size,
             highlight=highlight,
             strike=strike,
+            underline_shape=underline_shape,
+            underline_color=underline_color,
+            strike_shape=strike_shape,
+            ratio=ratio,
+            letter_spacing=letter_spacing,
+            shadow=shadow,
+            script=script,
             base_char_pr_id=base_char_pr_id,
         )
 
@@ -1373,9 +1400,13 @@ class HwpxDocument:
         paragraph: HwpxOxmlParagraph | None = None,
         section: HwpxOxmlSection | None = None,
         section_index: int | None = None,
+        char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlInlineObject:
         """Insert a hyperlink (fieldBegin + text + fieldEnd).
 
+        The display text follows the Hancom convention (blue underlined)
+        unless ``char_pr_id_ref`` overrides it.
+
         Returns the ``<hp:ctrl>`` wrapper containing the ``<hp:fieldBegin>``.
         """
 
@@ -1386,6 +1417,7 @@ class HwpxDocument:
             paragraph=paragraph,
             section=section,
             section_index=section_index,
+            char_pr_id_ref=char_pr_id_ref,
         )
 
     def add_form_field(

hwpx/oxml/_document_primitives.py

@@ -422,9 +422,10 @@ def _border_fill_child_attrs(
     active: bool,
     color: str,
     width: str,
+    border_type: str = "SOLID",
 ) -> dict[str, str]:
     return {
-        "type": "SOLID" if active else "NONE",
+        "type": border_type if active else "NONE",
         "width": width,
         "color": color,
     }
@@ -465,6 +466,7 @@ def _border_fill_matches(
     border_width: str,
     fill_color: str | None,
     active_borders: set[str],
+    border_type: str = "SOLID",
 ) -> bool:
     if _element_local_name(element) != "borderFill":
         return False
@@ -484,7 +486,7 @@ def _border_fill_matches(
         child = element.find(f"{_HH}{child_name}")
         if child is None:
             return False
-        expected_type = "SOLID" if side in active_borders else "NONE"
+        expected_type = border_type if side in active_borders else "NONE"
         if (child.get("type") or "").upper() != expected_type:
             return False
         if _normalize_length(child.get("width")) != _normalize_length(border_width):
@@ -509,6 +511,7 @@ def _create_border_fill_element(
     border_width: str,
     fill_color: str | None,
     active_borders: set[str],
+    border_type: str = "SOLID",
 ) -> ET.Element:
     element = ET.Element(f"{_HH}borderFill", {"id": border_id, **_BASIC_BORDER_FILL_ATTRIBUTES})
     ET.SubElement(element, f"{_HH}slash", {"type": "NONE", "Crooked": "0", "isCounter": "0"})
@@ -521,6 +524,7 @@ def _create_border_fill_element(
                 active=side in active_borders,
                 color=border_color,
                 width=border_width,
+                border_type=border_type,
             ),
         )
     ET.SubElement(
@@ -579,6 +583,17 @@ def _default_cell_margin_attributes() -> dict[str, str]:
     return {"left": "0", "right": "0", "top": "0", "bottom": "0"}
 
 
+def _default_cell_inner_margin_attributes() -> dict[str, str]:
+    """Hancom's new-table cell padding: 1.8 mm left/right, 0.5 mm top/bottom.
+
+    Measured from real Hancom-authored gold documents
+    (specs/056-authoring-fidelity-audit — the audit found our former 0
+    padding makes text hug the borders, visibly unlike a Hancom table).
+    """
+
+    return {"left": "510", "right": "510", "top": "141", "bottom": "141"}
+
+
 def _get_int_attr(element: ET.Element, name: str, default: int = 0) -> int:
     """Return *name* attribute of *element* as an integer."""
 

hwpx/oxml/document_parts.py

@@ -59,6 +59,13 @@ class _RunStyleSpec:
     height: str | None
     strike: bool | None
     font_ref: dict[str, str] | None
+    underline_shape: str | None = None
+    underline_color: str | None = None
+    strike_shape: str | None = None
+    ratio: int | None = None
+    letter_spacing: int | None = None
+    shadow_color: str | None = None
+    script: str | None = None
 
 
 def _run_style_element_flags(element: ET.Element) -> tuple[bool, bool, bool]:
@@ -78,6 +85,81 @@ def _run_style_element_strike(element: ET.Element) -> bool:
     return strike_element.get("shape", "").upper() != "NONE"
 
 
+def _validated_line_shape(
+    value: str | None, vocabulary: frozenset[str], label: str
+) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).upper()
+    if normalized not in vocabulary:
+        raise ValueError(f"unsupported {label} {value!r}")
+    return normalized
+
+
+def _run_style_underline_matches(element: ET.Element, spec: _RunStyleSpec) -> bool:
+    if spec.underline_shape is None and spec.underline_color is None:
+        return True
+    underline = element.find(f"{_HH}underline")
+    if underline is None:
+        return False
+    if spec.underline_shape is not None and (
+        underline.get("shape", "").upper() != spec.underline_shape
+    ):
+        return False
+    if spec.underline_color is not None and (
+        (underline.get("color") or "").upper() != spec.underline_color.upper()
+    ):
+        return False
+    return True
+
+
+def _run_style_lang_value_matches(
+    element: ET.Element, tag: str, value: int | None
+) -> bool:
+    if value is None:
+        return True
+    node = element.find(f"{_HH}{tag}")
+    return node is not None and node.get("hangul") == str(value)
+
+
+def _run_style_extensions_match(element: ET.Element, spec: _RunStyleSpec) -> bool:
+    if not _run_style_underline_matches(element, spec):
+        return False
+    if spec.strike_shape is not None:
+        strike_el = element.find(f"{_HH}strikeout")
+        if strike_el is None or strike_el.get("shape", "").upper() != spec.strike_shape:
+            return False
+    if not _run_style_lang_value_matches(element, "ratio", spec.ratio):
+        return False
+    if not _run_style_lang_value_matches(element, "spacing", spec.letter_spacing):
+        return False
+    if not _run_style_shadow_matches(element, spec.shadow_color):
+        return False
+    if not _run_style_script_matches(element, spec.script):
+        return False
+    return True
+
+
+def _run_style_shadow_matches(element: ET.Element, shadow_color: str | None) -> bool:
+    if shadow_color is None:
+        return True
+    shadow_el = element.find(f"{_HH}shadow")
+    if shadow_el is None or shadow_el.get("type", "").upper() == "NONE":
+        return False
+    return (shadow_el.get("color") or "").upper() == shadow_color.upper()
+
+
+def _run_style_script_matches(element: ET.Element, script: str | None) -> bool:
+    if script is None:
+        return True
+    if not _run_style_lang_value_matches(element, "relSz", 67):
+        return False
+    off_el = element.find(f"{_HH}offset")
+    # 실한컴 렌더 실측: offset 음수=위로(위첨자), 양수=아래로(아래첨자).
+    wanted_offset = "-30" if script == "sup" else "30"
+    return off_el is not None and off_el.get("hangul") == wanted_offset
+
+
 def _run_style_predicate(element: ET.Element, spec: _RunStyleSpec) -> bool:
     if _run_style_element_flags(element) != spec.flags:
         return False
@@ -92,6 +174,8 @@ def _run_style_predicate(element: ET.Element, spec: _RunStyleSpec) -> bool:
         return False
     if spec.strike is not None and _run_style_element_strike(element) != bool(spec.strike):
         return False
+    if not _run_style_extensions_match(element, spec):
+        return False
     if spec.font_ref is not None:
         font_ref = element.find(f"{_HH}fontRef")
         if font_ref is None:
@@ -127,9 +211,10 @@ def _run_style_apply_underline(
 ) -> None:
     underline_attrs = dict(base_underline_attrs)
     if want_underline:
-        underline_attrs.setdefault("type", "SOLID")
-        if underline_attrs.get("type", "").upper() == "NONE":
-            underline_attrs["type"] = "SOLID"
+        # 실한컴 gold 관례: hh:underline type은 위치 어휘(BOTTOM/CENTER/TOP).
+        underline_attrs.setdefault("type", "BOTTOM")
+        if underline_attrs.get("type", "").upper() in ("NONE", "SOLID"):
+            underline_attrs["type"] = "BOTTOM"
         underline_attrs.setdefault(
             "shape", base_underline_attrs.get("shape", "SOLID")
         )
@@ -159,6 +244,56 @@ def _run_style_apply_strikeout(
         _append_child(element, f"{_HH}strikeout", strike_attrs)
 
 
+def _run_style_set_lang_values(element: ET.Element, tag: str, value: int) -> None:
+    node = element.find(f"{_HH}{tag}")
+    if node is None:
+        node = _append_child(element, f"{_HH}{tag}")
+    for lang in ("hangul", "latin", "hanja", "japanese", "other", "symbol", "user"):
+        node.set(lang, str(value))
+
+
+def _run_style_apply_underline_extension(
+    element: ET.Element, spec: _RunStyleSpec
+) -> None:
+    if spec.underline_shape is None and spec.underline_color is None:
+        return
+    underline = element.find(f"{_HH}underline")
+    if underline is None:
+        return
+    if underline.get("type", "").upper() == "NONE":
+        underline.set("type", "BOTTOM")
+    if spec.underline_shape is not None:
+        underline.set("shape", spec.underline_shape)
+    if spec.underline_color is not None:
+        underline.set("color", spec.underline_color)
+
+
+def _run_style_apply_extensions(element: ET.Element, spec: _RunStyleSpec) -> None:
+    _run_style_apply_underline_extension(element, spec)
+    if spec.strike_shape is not None:
+        strike_el = element.find(f"{_HH}strikeout")
+        if strike_el is None:
+            strike_el = _append_child(element, f"{_HH}strikeout")
+        strike_el.set("shape", spec.strike_shape)
+        if not strike_el.get("color"):
+            strike_el.set("color", "#000000")
+    if spec.ratio is not None:
+        _run_style_set_lang_values(element, "ratio", spec.ratio)
+    if spec.letter_spacing is not None:
+        _run_style_set_lang_values(element, "spacing", spec.letter_spacing)
+    if spec.shadow_color is not None:
+        shadow_el = element.find(f"{_HH}shadow")
+        if shadow_el is None:
+            shadow_el = _append_child(element, f"{_HH}shadow")
+        shadow_el.set("type", "DROP")
+        shadow_el.set("color", spec.shadow_color)
+        shadow_el.set("offsetX", "12")
+        shadow_el.set("offsetY", "12")
+    if spec.script is not None:
+        _run_style_set_lang_values(element, "relSz", 67)
+        _run_style_set_lang_values(element, "offset", -30 if spec.script == "sup" else 30)
+
+
 def _run_style_modifier(element: ET.Element, spec: _RunStyleSpec) -> None:
     underline_nodes = list(element.findall(f"{_HH}underline"))
     base_underline_attrs = (
@@ -186,6 +321,8 @@ def _run_style_modifier(element: ET.Element, spec: _RunStyleSpec) -> None:
     _run_style_apply_underline(element, base_underline_attrs, spec.flags[2])
     _run_style_apply_strikeout(element, base_strike_attrs, spec.strike)
 
+    _run_style_apply_extensions(element, spec)
+
 
 class HwpxOxmlDocument:
     """Aggregates the XML parts that make up an HWPX document."""
@@ -357,6 +494,12 @@ class HwpxOxmlDocument:
             return None
         return cache.get(normalized)
 
+    _UNDERLINE_SHAPES = frozenset({
+        "SOLID", "DASH", "DOT", "DASH_DOT", "DASH_DOT_DOT", "LONG_DASH",
+        "CIRCLE", "DOUBLE_SLIM", "SLIM_THICK", "THICK_SLIM",
+        "SLIM_THICK_SLIM", "WAVE", "DOUBLEWAVE",
+    })
+
     def ensure_run_style(
         self,
         *,
@@ -368,13 +511,45 @@ class HwpxOxmlDocument:
         size: int | float | None = None,
         highlight: str | None = None,
         strike: bool | None = None,
+        underline_shape: str | None = None,
+        underline_color: str | None = None,
+        strike_shape: str | None = None,
+        ratio: int | None = None,
+        letter_spacing: int | None = None,
+        shadow: str | None = None,
+        script: str | None = None,
         base_char_pr_id: str | int | None = None,
     ) -> str:
-        """Return a char property identifier matching the requested flags."""
+        """Return a char property identifier matching the requested flags.
+
+        The 5.4.0 additions mirror what the fidelity audit render-verified on
+        real Hancom: ``underline_shape``/``underline_color`` (implies an
+        underline), ``strike_shape`` (implies a strikeout), ``ratio`` (장평 %),
+        ``letter_spacing`` (자간 %), ``shadow`` (drop-shadow colour), and
+        ``script`` (``"sup"``/``"sub"``). Values outside the OWPML vocabulary
+        are rejected — no silent approximation.
+        """
 
         if not self._headers:
             raise ValueError("document does not contain any headers")
 
+        normalized_underline_shape = _validated_line_shape(
+            underline_shape, self._UNDERLINE_SHAPES, "underline_shape"
+        )
+        if normalized_underline_shape is not None or underline_color is not None:
+            underline = True
+        normalized_strike_shape = _validated_line_shape(
+            strike_shape, self._UNDERLINE_SHAPES, "strike_shape"
+        )
+        if normalized_strike_shape is not None:
+            strike = True
+        if ratio is not None and not 10 <= int(ratio) <= 400:
+            raise ValueError("ratio must be a percentage between 10 and 400")
+        if letter_spacing is not None and not -50 <= int(letter_spacing) <= 100:
+            raise ValueError("letter_spacing must be between -50 and 100")
+        if script is not None and script not in ("sup", "sub"):
+            raise ValueError('script must be "sup" or "sub"')
+
         header = self._headers[0]
         spec = _RunStyleSpec(
             flags=(bool(bold), bool(italic), bool(underline)),
@@ -383,6 +558,13 @@ class HwpxOxmlDocument:
             height=_char_height_from_points(size),
             strike=strike,
             font_ref=header.font_ref_for_face(font) if font is not None else None,
+            underline_shape=normalized_underline_shape,
+            underline_color=_normalize_color(underline_color),
+            strike_shape=normalized_strike_shape,
+            ratio=int(ratio) if ratio is not None else None,
+            letter_spacing=int(letter_spacing) if letter_spacing is not None else None,
+            shadow_color=_normalize_color(shadow),
+            script=script,
         )
         element = header.ensure_char_property(
             predicate=lambda el: _run_style_predicate(el, spec),
@@ -425,6 +607,7 @@ class HwpxOxmlDocument:
         border_width: str = "0.12 mm",
         fill_color: str | None = None,
         active_borders: Iterable[str] | None = None,
+        border_type: str = "SOLID",
     ) -> str:
         if not self._headers:
             return "0"
@@ -433,6 +616,7 @@ class HwpxOxmlDocument:
             border_width=border_width,
             fill_color=fill_color,
             active_borders=active_borders,
+            border_type=border_type,
         )
 
     def ensure_shading_border_fill(

hwpx/oxml/header_part.py

@@ -898,6 +898,13 @@ class HwpxOxmlHeader:
         self.mark_dirty()
         return new_id
 
+    _BORDER_LINE_TYPES = frozenset({
+        "SOLID", "DASH", "DOT", "DASH_DOT", "DASH_DOT_DOT", "LONG_DASH",
+        "CIRCLE", "DOUBLE_SLIM", "SLIM_THICK", "THICK_SLIM", "SLIM_THICK_SLIM",
+        "WAVE", "DOUBLEWAVE", "THICK_3D", "THICK_3D_REVERSE_LIGHTING",
+        "SLIM_3D", "SLIM_3D_REVERSE_LIGHTING",
+    })
+
     def ensure_border_fill(
         self,
         *,
@@ -905,11 +912,18 @@ class HwpxOxmlHeader:
         border_width: str = "0.12 mm",
         fill_color: str | None = None,
         active_borders: Iterable[str] | None = None,
+        border_type: str = "SOLID",
     ) -> str:
         element = self._border_fills_element(create=True)
         if element is None:  # pragma: no cover - defensive branch
             raise RuntimeError("failed to create <borderFills> element")
 
+        normalized_border_type = str(border_type or "SOLID").upper()
+        if normalized_border_type not in self._BORDER_LINE_TYPES:
+            raise ValueError(
+                f"unsupported border_type {border_type!r}; expected one of "
+                + ", ".join(sorted(self._BORDER_LINE_TYPES))
+            )
         normalized_border_color = _normalize_color(border_color) or "#BFBFBF"
         normalized_border_width = str(border_width or "0.12 mm")
         normalized_active_borders = _normalize_border_side_names(active_borders)
@@ -922,6 +936,7 @@ class HwpxOxmlHeader:
                 border_width=normalized_border_width,
                 fill_color=normalized_fill_color,
                 active_borders=normalized_active_borders,
+                border_type=normalized_border_type,
             ):
                 border_id = border_fill.get("id")
                 if border_id:
@@ -934,6 +949,7 @@ class HwpxOxmlHeader:
             border_width=normalized_border_width,
             fill_color=normalized_fill_color,
             active_borders=normalized_active_borders,
+            border_type=normalized_border_type,
         )
         if isinstance(element, LET._Element):
             new_border_fill = LET.fromstring(ET.tostring(new_border_fill, encoding="utf-8"))

hwpx/oxml/memo.py

@@ -14,7 +14,6 @@ from ._document_primitives import (
     _default_sublist_attributes,
     _element_local_name,
     _memo_id,
-    _paragraph_id,
     _sanitize_text,
 )
 
@@ -213,14 +212,35 @@ class HwpxOxmlNote:
 
     @text.setter
     def text(self, value: str) -> None:
-        """Replace the note body text."""
+        """Replace the note body text.
+
+        The gold-shaped body (각주/미주 style paragraph with the leading
+        ``<hp:autoNum>`` control real Hancom requires to render the note) is
+        preserved: only text content is replaced.
+        """
         sublist = self.element.find(f"{_HP}subList")
         if sublist is None:
-            sublist = _append_child(self.element, f"{_HP}subList", _default_sublist_attributes())
-        for p in sublist.findall(f"{_HP}p"):
+            attrs = _default_sublist_attributes()
+            attrs["vertAlign"] = "TOP"
+            sublist = _append_child(self.element, f"{_HP}subList", attrs)
+        paragraphs = sublist.findall(f"{_HP}p")
+        template = paragraphs[0] if paragraphs else None
+        p_attrs = (
+            dict(template.attrib)
+            if template is not None
+            else {"id": "0", **_DEFAULT_PARAGRAPH_ATTRS}
+        )
+        first_run = template.find(f"{_HP}run") if template is not None else None
+        run_attrs = dict(first_run.attrib) if first_run is not None else {"charPrIDRef": "0"}
+        auto_num = (
+            first_run.find(f"{_HP}ctrl") if first_run is not None else None
+        )
+        for p in paragraphs:
             sublist.remove(p)
-        paragraph = _append_child(sublist, f"{_HP}p", {"id": _paragraph_id(), **_DEFAULT_PARAGRAPH_ATTRS})
-        run = _append_child(paragraph, f"{_HP}run", {"charPrIDRef": "0"})
+        paragraph = _append_child(sublist, f"{_HP}p", p_attrs)
+        run = _append_child(paragraph, f"{_HP}run", run_attrs)
+        if auto_num is not None:
+            run.append(auto_num)
         t = _append_child(run, f"{_HP}t", {})
         t.text = _sanitize_text(value)
         self.paragraph.section.mark_dirty()

hwpx/oxml/paragraph.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Sequence
+from typing import TYPE_CHECKING, Sequence, cast
 import warnings
 import xml.etree.ElementTree as ET
 
@@ -23,7 +23,6 @@ from ._document_primitives import (
     _default_sublist_attributes,
     _is_tab_control_element,
     _object_id,
-    _paragraph_id,
     _sanitize_text,
 )
 from .memo import HwpxOxmlNote
@@ -405,6 +404,59 @@ class HwpxOxmlParagraph:
                     tables.append(HwpxOxmlTable(child, self))
         return tables
 
+    def _context_table_width(self) -> int | None:
+        """Hancom-like default table width for this paragraph's context.
+
+        Inside a table cell the parent cell's usable width bounds the new
+        (nested) table — the fidelity audit reproduced silent content loss
+        when the fixed per-cell default exceeded it. At body level Hancom
+        fits a new table to the text width (page width minus margins).
+        Returns ``None`` when neither context is measurable.
+        """
+
+        # stdlib ET has no getparent; lxml-backed elements do. Guarded getattr
+        # keeps both backends working (19 suite failures without the guard).
+        get_parent = getattr(self.element, "getparent", None)
+        ancestor = cast(
+            "ET.Element | None", get_parent() if callable(get_parent) else None
+        )
+        while ancestor is not None:
+            if tag_local_name(ancestor.tag) == "tc":
+                cell_sz = ancestor.find(f"{_HP}cellSz")
+                margin = ancestor.find(f"{_HP}cellMargin")
+                if cell_sz is not None:
+                    try:
+                        width = int(cell_sz.get("width", "0"))
+                    except ValueError:
+                        return None
+                    pad = 0
+                    if margin is not None:
+                        try:
+                            pad = int(margin.get("left", "0")) + int(
+                                margin.get("right", "0")
+                            )
+                        except ValueError:
+                            pad = 0
+                    usable = width - pad
+                    return usable if usable > 0 else None
+                return None
+            next_parent = getattr(ancestor, "getparent", None)
+            ancestor = cast(
+                "ET.Element | None",
+                next_parent() if callable(next_parent) else None,
+            )
+
+        try:
+            properties = self.section.properties
+            page = properties.page_size
+            margins = properties.page_margins
+        except Exception:
+            return None
+        if page.width <= 0:
+            return None
+        usable = page.width - margins.left - margins.right - margins.gutter
+        return usable if usable > 0 else None
+
     def add_table(
         self,
         rows: int,
@@ -416,6 +468,8 @@ class HwpxOxmlParagraph:
         run_attributes: dict[str, str] | None = None,
         char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlTable:
+        if width is None:
+            width = self._context_table_width()
         if border_fill_id_ref is None:
             document = self.section.document
             if document is not None:
@@ -809,8 +863,10 @@ class HwpxOxmlParagraph:
         """
         field_id = _object_id()
 
-        # Run 1: fieldBegin
-        run1 = self._create_run_for_object(char_pr_id_ref=char_pr_id_ref)
+        # 실한컴 gold 관례: 링크 서식(charPr)은 표시 텍스트 런에만 싣고
+        # fieldBegin/fieldEnd 런은 주변 서식을 유지한다 — 뒤에 추가되는
+        # 문단이 링크 서식을 상속(파랑 전염)하지 않게 하는 조건이기도 하다.
+        run1 = self._create_run_for_object()
         ctrl1 = _append_child(run1, f"{_HP}ctrl", {})
         fb_attrs: dict[str, str] = {
             "id": field_id,
@@ -827,7 +883,7 @@ class HwpxOxmlParagraph:
         t.text = _sanitize_text(display_text)
 
         # Run 3: fieldEnd
-        run3 = self._create_run_for_object(char_pr_id_ref=char_pr_id_ref)
+        run3 = self._create_run_for_object()
         ctrl3 = _append_child(run3, f"{_HP}ctrl", {})
         _append_child(ctrl3, f"{_HP}fieldEnd", {"beginIDRef": field_id})
 
@@ -1126,6 +1182,61 @@ class HwpxOxmlParagraph:
     # Footnote / Endnote helpers
     # ------------------------------------------------------------------
 
+    _NOTE_STYLE_NAMES = {"footNote": ("각주", "Footnote"), "endNote": ("미주", "Endnote")}
+    _NOTE_STYLE_FALLBACK = {"footNote": ("15", "10", "3"), "endNote": ("16", "10", "3")}
+
+    def _note_style_refs(self, tag: str) -> tuple[str, str, str]:
+        """(styleIDRef, paraPrIDRef, charPrIDRef) for the note body paragraph.
+
+        Real Hancom puts note bodies on the 각주/미주 paragraph styles. Resolve
+        by style name from the header so documents with re-numbered styles stay
+        correct; fall back to the fixed template coordinates.
+        """
+
+        korean, english = self._NOTE_STYLE_NAMES[tag]
+        document = self.section.document
+        headers = cast(
+            "Sequence[object]",
+            getattr(document, "_headers", []) if document is not None else [],
+        )
+        for header in headers:
+            styles = getattr(header, "_styles_element", None)
+            container = cast(
+                "ET.Element | None", styles() if callable(styles) else None
+            )
+            if container is None:
+                continue
+            for style in container:
+                if style.get("name") == korean or style.get("engName") == english:
+                    return (
+                        style.get("id") or self._NOTE_STYLE_FALLBACK[tag][0],
+                        style.get("paraPrIDRef") or self._NOTE_STYLE_FALLBACK[tag][1],
+                        style.get("charPrIDRef") or self._NOTE_STYLE_FALLBACK[tag][2],
+                    )
+        return self._NOTE_STYLE_FALLBACK[tag]
+
+    def _note_suffix_char(self, tag: str) -> str:
+        """The note suffix character from secPr, defaulting to ")"."""
+
+        properties = self.section._section_properties_element()
+        if properties is not None:
+            pr = properties.find(f"{_HP}{tag}Pr")
+            if pr is not None:
+                fmt = pr.find(f"{_HP}autoNumFormat")
+                if fmt is not None and fmt.get("suffixChar"):
+                    return fmt.get("suffixChar", ")")
+        return ")"
+
+    def _next_note_number(self, tag: str) -> int:
+        """Document-continuous note number, counted per note type."""
+
+        document = self.section.document
+        sections = document.sections if document is not None else [self.section]
+        count = 0
+        for section in sections:
+            count += sum(1 for _ in section.element.iter(f"{_HP}{tag}"))
+        return count + 1
+
     def _add_note(
         self,
         tag: str,
@@ -1134,17 +1245,54 @@ class HwpxOxmlParagraph:
         run_attributes: dict[str, str] | None = None,
         char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlNote:
-        """Insert a ``<hp:footNote>`` or ``<hp:endNote>`` element."""
+        """Insert a ``<hp:footNote>`` or ``<hp:endNote>`` element.
+
+        Emits the real-Hancom shape (gold-reversed): the note element is
+        wrapped in ``<hp:ctrl>`` inside a body run, carries ``number`` and
+        ``suffixChar``, and its body paragraph uses the 각주/미주 style with a
+        leading ``<hp:autoNum>`` control — without these real Hancom does not
+        render the note at all.
+        """
 
-        run = self._create_run_for_object(run_attributes, char_pr_id_ref=char_pr_id_ref)
-        note_element = _append_child(run, f"{_HP}{tag}", {"instId": _object_id()})
-        sublist = _append_child(note_element, f"{_HP}subList", _default_sublist_attributes())
-        p_attrs = {"id": _paragraph_id(), **_DEFAULT_PARAGRAPH_ATTRS}
+        number = self._next_note_number(tag)
+        suffix = self._note_suffix_char(tag)
+        style_ref, para_pr_ref, note_char_ref = self._note_style_refs(tag)
+        if char_pr_id_ref is not None:
+            note_char_ref = str(char_pr_id_ref)
+
+        runs = self._run_elements()
+        if run_attributes is None and runs:
+            run = runs[-1]
+        else:
+            run = self._create_run_for_object(run_attributes, char_pr_id_ref=char_pr_id_ref)
+        ctrl = _append_child(run, f"{_HP}ctrl", {})
+        note_element = _append_child(
+            ctrl,
+            f"{_HP}{tag}",
+            {
+                "number": str(number),
+                "suffixChar": str(ord(suffix[0])) if suffix else "41",
+                "instId": _object_id(),
+            },
+        )
+        sublist_attrs = _default_sublist_attributes()
+        sublist_attrs["vertAlign"] = "TOP"
+        sublist = _append_child(note_element, f"{_HP}subList", sublist_attrs)
+        p_attrs = dict(_DEFAULT_PARAGRAPH_ATTRS)
+        p_attrs.update({"id": "0", "paraPrIDRef": para_pr_ref, "styleIDRef": style_ref})
         paragraph = _append_child(sublist, f"{_HP}p", p_attrs)
-        # 본문 run의 charPrIDRef도 인자를 따라가도록 적용 (host run과 동일 스타일).
-        # None이면 "0"(default).
-        body_cpr = "0" if char_pr_id_ref is None else str(char_pr_id_ref)
-        note_run = _append_child(paragraph, f"{_HP}run", {"charPrIDRef": body_cpr})
+        note_run = _append_child(paragraph, f"{_HP}run", {"charPrIDRef": note_char_ref})
+        num_ctrl = _append_child(note_run, f"{_HP}ctrl", {})
+        auto_num = _append_child(
+            num_ctrl,
+            f"{_HP}autoNum",
+            {"num": str(number), "numType": "FOOTNOTE" if tag == "footNote" else "ENDNOTE"},
+        )
+        _append_child(
+            auto_num,
+            f"{_HP}autoNumFormat",
+            {"type": "DIGIT", "userChar": "", "prefixChar": "", "suffixChar": suffix, "supscript": "0"},
+        )
         t = _append_child(note_run, f"{_HP}t", {})
         t.text = _sanitize_text(text)
         self.section.mark_dirty()

hwpx/oxml/section.py

@@ -25,6 +25,7 @@ from ._document_primitives import (
 from .memo import HwpxOxmlMemo, HwpxOxmlMemoGroup
 from .paragraph import HwpxOxmlParagraph
 from .section_format import HwpxOxmlSectionProperties
+from .namespaces import tag_local_name
 from .section_story import HwpxOxmlSectionHeaderFooter
 
 if TYPE_CHECKING:
@@ -176,6 +177,55 @@ class HwpxOxmlSection:
             paragraph = paras[paragraph]
         paragraph.remove()
 
+    def _inherited_paragraph_refs(
+        self,
+    ) -> tuple[str | None, str | None, str | None]:
+        """Style refs the next appended paragraph inherits from the last one.
+
+        A list paragraph (bullet/numbered paraPr) must not leak into the next
+        paragraph — in Hancom, Enter continues the list but programmatic
+        appends of ordinary text are body text. The fidelity audit reproduced
+        every following paragraph turning into a list item without this guard.
+        """
+
+        existing = self.paragraphs
+        if not existing:
+            return None, None, None
+        last = existing[-1]
+        prev_para_ref = last.para_pr_id_ref
+        prev_style_ref = last.style_id_ref
+        prev_char_ref = last.char_pr_id_ref
+        if prev_para_ref is not None and self._para_pr_is_list(prev_para_ref):
+            prev_para_ref = None
+            prev_style_ref = None
+        return prev_para_ref, prev_style_ref, prev_char_ref
+
+    def _para_pr_is_list(self, para_pr_id_ref: str | int) -> bool:
+        """True when the paraPr carries a bullet/numbered heading."""
+
+        document = self.document
+        if document is None:
+            return False
+        wanted = str(para_pr_id_ref)
+        for header in getattr(document, "_headers", []):
+            para_properties = getattr(header, "_para_properties_element", None)
+            if para_properties is None:
+                continue
+            container = para_properties()
+            if container is None:
+                continue
+            for para_pr in container:
+                if para_pr.get("id") != wanted:
+                    continue
+                for child in para_pr:
+                    if tag_local_name(child.tag) == "heading":
+                        return str(child.get("type", "")).upper() in {
+                            "BULLET",
+                            "NUMBER",
+                        }
+                return False
+        return False
+
     def add_paragraph(
         self,
         text: str = "",
@@ -202,16 +252,9 @@ class HwpxOxmlSection:
         """
 
         # Collect style refs from the last paragraph for inheritance.
-        prev_para_ref: str | None = None
-        prev_style_ref: str | None = None
-        prev_char_ref: str | None = None
-        if inherit_style:
-            existing = self.paragraphs
-            if existing:
-                last = existing[-1]
-                prev_para_ref = last.para_pr_id_ref
-                prev_style_ref = last.style_id_ref
-                prev_char_ref = last.char_pr_id_ref
+        prev_para_ref, prev_style_ref, prev_char_ref = (
+            self._inherited_paragraph_refs() if inherit_style else (None, None, None)
+        )
 
         attrs = {"id": _paragraph_id(), **_DEFAULT_PARAGRAPH_ATTRS}
         attrs.update(extra_attrs)

hwpx/oxml/table.py

@@ -12,6 +12,7 @@ import xml.etree.ElementTree as ET
 from ._document_primitives import (
     _DEFAULT_CELL_HEIGHT,
     _DEFAULT_CELL_WIDTH,
+    _default_cell_inner_margin_attributes,
     _DEFAULT_PARAGRAPH_ATTRS,
     _HP,
     _append_child,
@@ -459,7 +460,7 @@ class HwpxOxmlTable:
             },
         )
         ET.SubElement(table, f"{_HP}outMargin", _default_cell_margin_attributes())
-        ET.SubElement(table, f"{_HP}inMargin", _default_cell_margin_attributes())
+        ET.SubElement(table, f"{_HP}inMargin", _default_cell_inner_margin_attributes())
 
         column_widths = _distribute_size(max(table_width, 0), cols)
         row_heights = _distribute_size(max(table_height, 0), rows)
@@ -486,7 +487,7 @@ class HwpxOxmlTable:
                         "height": str(row_heights[row_index] if row_heights else 0),
                     },
                 )
-                ET.SubElement(cell, f"{_HP}cellMargin", _default_cell_margin_attributes())
+                ET.SubElement(cell, f"{_HP}cellMargin", _default_cell_inner_margin_attributes())
         return table
 
     def mark_dirty(self) -> None:
@@ -647,6 +648,18 @@ class HwpxOxmlTable:
         entry = self._grid_entry(row_index, col_index)
         return entry.cell
 
+    def set_cell_border_fill(
+        self, row_index: int, col_index: int, border_fill_id_ref: str | int
+    ) -> None:
+        """Point one cell at a header ``borderFill`` definition.
+
+        Pairs with :meth:`set_cell_shading`; obtain ids from
+        ``document.ensure_border_fill`` (line style/width/color/fill).
+        """
+        cell = self.cell(row_index, col_index)
+        cell.element.set("borderFillIDRef", str(border_fill_id_ref))
+        self.mark_dirty()
+
     def set_cell_shading(self, row_index: int, col_index: int, color: str) -> None:
         cell = self.cell(row_index, col_index)
         document = self.paragraph.section.document

hwpx/tools/markdown_export.py

@@ -228,7 +228,7 @@ def _md_push_text(state: _MdParagraphState, cpr, text) -> None:
         state.items.append((cpr, text))
 
 
-def _md_handle_ctrl_child(child, state: _MdParagraphState, base_cp, chars) -> None:
+def _md_handle_ctrl_child(child, state: _MdParagraphState, base_cp, chars, doc=None, notes_out=None) -> None:
     for gc in child:
         gctag = _local_name(gc)
         if gctag == "fieldBegin" and gc.get("type") == "HYPERLINK":
@@ -236,6 +236,9 @@ def _md_handle_ctrl_child(child, state: _MdParagraphState, base_cp, chars) -> No
             state.link_url = gc.get("name", "")
         elif gctag == "fieldEnd":
             _md_flush_link(state, base_cp, chars)
+        elif gctag in ("footNote", "endNote"):
+            # 실한컴 계약: 각주/미주는 run 안 <hp:ctrl>에 래핑되어 있다.
+            _md_handle_note_child(gc, gctag, state, base_cp, chars, doc, notes_out)
 
 
 def _md_handle_note_child(
@@ -271,8 +274,9 @@ def _p_element_to_md(p_el, doc, notes_out: list | None = None) -> str:
                 if child.text:
                     _md_push_text(state, cpr, child.text)
             elif tag == "ctrl":
-                _md_handle_ctrl_child(child, state, base_cp, chars)
+                _md_handle_ctrl_child(child, state, base_cp, chars, doc, notes_out)
             elif tag in ("footNote", "endNote"):
+                # 구식(5.4 이전 자사 방출) 호환: run 직속 각주도 계속 읽는다.
                 _md_handle_note_child(child, tag, state, base_cp, chars, doc, notes_out)
 
     _md_flush_items(state, base_cp, chars)

hwpx/tools/text_extractor.py

@@ -483,6 +483,20 @@ class TextExtractor:
         annotations: Optional[AnnotationOptions],
         preserve_breaks: bool,
     ) -> None:
+        # 실한컴 계약: 각주/미주는 <hp:ctrl> 래핑으로 나타난다 — annotations
+        # 유무와 무관하게 노트 분기로 위임한다(구식 run 직속도 별도 분기 유지).
+        for note_tag in ("footNote", "endNote"):
+            note = _first_child_by_local(element, note_tag)
+            if note is not None:
+                self._handle_note(
+                    note,
+                    fragments,
+                    note_tag,
+                    annotations=annotations,
+                    preserve_breaks=preserve_breaks,
+                )
+                return
+
         if annotations is None:
             return
 

{python_hwpx-5.3.0.dist-info → python_hwpx-5.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 5.3.0
+Version: 5.5.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 문서 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0

{python_hwpx-5.3.0.dist-info → python_hwpx-5.5.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 hwpx/__init__.py,sha256=WmlWHk6vfjr2HQa6Dzp6rmIXIUJXKWKDZJZ-LBpL3Nc,15936
 hwpx/body_patch.py,sha256=XfwrTMThS9vPLA62PDnEleCGuvYv61URxelbD_LHe8w,25730
-hwpx/document.py,sha256=ly12zmjR96_4itGwJw9xljDI3sowmrSsZZfHHn4Znio,65995
+hwpx/document.py,sha256=XV8T-ucd0F-Uup6XBUe_ZLliSNuImq7MgGhefIwMQD0,67298
 hwpx/errors.py,sha256=l3QK2Izwkpm25ar7QnNQvyg0yosoLfQt7kW5wn5MCG0,3033
 hwpx/experimental.py,sha256=BfD3fvXDgiEEm8G66TuUe_OPETitGwFU0VurUXUuV9Q,1693
 hwpx/mutation_report.py,sha256=6hurhDdgGiONeLIeWZJT8lwLtWJZ1VHp1l6G0zy0mQo,19409
@@ -12,7 +12,7 @@ hwpx/templates.py,sha256=28bYqeJVeDb1Cq8G9NZG9Mhnu4K2GamAKC4QhxvUZyA,1187
 hwpx/_document/__init__.py,sha256=REiNqMbuk_TS4NVC27FIo1rUt3Z8nhJrTBGOgNtxBRg,90
 hwpx/_document/_units.py,sha256=qyC8YtnvV2VlSGltJntDaIMF_sHy_XJZCwwe-g080TQ,386
 hwpx/_document/fields.py,sha256=6VB7FV69cWcHLONj_Bn_DUGH5k9IMn94SRhRCia6wvI,22935
-hwpx/_document/layout.py,sha256=TicBhdxXW2lQkLyG5bg6PHW-OP-X4oWdP6XAgAXw8mg,23089
+hwpx/_document/layout.py,sha256=_fNHVqI2zFUn6L1-JsdyO8Z4UShmIi9G29Y5YJtQtKw,23553
 hwpx/_document/media.py,sha256=kamsFJZ4K9aoKhjyztMHC64MVFR_ZQ50rDVgouZqxFA,11592
 hwpx/_document/memos.py,sha256=_tscEhNfPe9-iAkcEtJGjwHTN42_lx4stFoPrgJxk3o,7481
 hwpx/_document/persistence.py,sha256=NgWeFmm6jWV11194kdx32lwRQ6dyqiQYnc1ZBzJcIbE,16003
@@ -43,28 +43,28 @@ hwpx/opc/security.py,sha256=hsA73sZxUoGIgy2zue9EnV7ChHMfasnplmqzxFs3Mp4,4419
 hwpx/opc/xml_utils.py,sha256=L_fHY1-D5I_TfdRkDQV-bn55EnXc6AqEDWItfMpawVs,3840
 hwpx/oxml/__init__.py,sha256=pqHqOK2snS74U_mkmkFcgyCUCLiGmbS84TKFBrwxF5I,5507
 hwpx/oxml/_document_impl.py,sha256=41cxktJqXHER37fjA5HIFR8kw7dHMoISTxEv53PRBYo,5367
-hwpx/oxml/_document_primitives.py,sha256=IrruWTqHevJZpfnpZNmedeYErpyNIlRSYlkWyEUOA8k,18636
+hwpx/oxml/_document_primitives.py,sha256=4nMOkaDmNbpg_kKRG0_Nr0k5TqmDGRWR_f9jhCykdZY,19207
 hwpx/oxml/body.py,sha256=qd_t8bPdK4QaW_y7hEIOsqM_qiB1UAKQXzvGI4xriGA,32163
 hwpx/oxml/canonical_defaults.py,sha256=WHAK7u_W-PDv3P3N1-1-aWAoiUgBh4x-UybFL4NqW-w,3791
 hwpx/oxml/color.py,sha256=K2lbU_JdqRxFkQelGD6BbBkH1IspJSQyGlKHNz1Nmf4,2393
 hwpx/oxml/common.py,sha256=TJkafzg7x4T3J29tZchRZk57ZTsrM9PEiqGT3rX3w5o,1044
 hwpx/oxml/document.py,sha256=0Ml-t2fwa4f2xMfu5jbkOoh_KDKCCf3gNpaYICRV-KY,1172
-hwpx/oxml/document_parts.py,sha256=fbj_MA8imnKhz6XN2ufNAMPYNI5xi0dCNjEv0nGESwo,41692
+hwpx/oxml/document_parts.py,sha256=NSlCmXKfItIaTEYruu6zUh-XHZRRDI9XZ2U-5rD2UUU,49240
 hwpx/oxml/header.py,sha256=4LtTDPe7YW0o_4jPv3Rd-vyv5suRfebecxtTWbF65Uw,50011
-hwpx/oxml/header_part.py,sha256=BIwdzDlwJSxcVIErZ8jQuT2vQ4Tndr4Xa87beYbpSFU,50640
-hwpx/oxml/memo.py,sha256=QlmuELEzywnmywgjm94S3vzJB8wPpoFOmI8KVuzoNPw,9484
+hwpx/oxml/header_part.py,sha256=JBOw3Ljkt0PCYYKP7IlFpxA1ZRbrBHqDo8hjvE-yMsk,51409
+hwpx/oxml/memo.py,sha256=jTtZIrR7LwWn_vvFN6Fr9yX2eSJfMPh8WnNW1DhD2Rs,10283
 hwpx/oxml/namespaces.py,sha256=c7JfdOdJbzrhyHvjbxoeeeloRE3xPuoB7v3YI8SmKDk,6524
 hwpx/oxml/numbering.py,sha256=9a0ARGW1DkKsTF7mEEXM4FA5loQmzIBuqE4APA8UFIQ,669
 hwpx/oxml/objects.py,sha256=8ErDXWvkjLm3FTsx0Z_IovUXbiv2uc-j0B5Y2-OtihA,20864
-hwpx/oxml/paragraph.py,sha256=p9M22WLPt3_mjmQZGrpSS9agRDKAXwSvnKJGnCUgc48,47075
+hwpx/oxml/paragraph.py,sha256=btJlX6WScB9gjKRu2uAs1qAdEQYar2BuKdSwNfdRm9U,53408
 hwpx/oxml/parser.py,sha256=pIfyNdW3WdFkCcE8JFY7hn1fobRbMngzfhVZICvWeVs,2937
 hwpx/oxml/run.py,sha256=F939J1W6zQjr-JQ1Z8-nKh2s7NQ_0Okov4QJAEyw_5M,15503
 hwpx/oxml/schema.py,sha256=ElR3_IIhhPPZEqJtNKMNCHA-VFVLdhL454W_4spuvlc,1284
-hwpx/oxml/section.py,sha256=i3t1SKIMneA1qWAajDlmZ-yrWJF9VvqT-aoq3mRXtxE,11638
+hwpx/oxml/section.py,sha256=W91Si7-kaUvl2y_VLV5kpsXPGtT5fUwOyIRh6qQLGyM,13395
 hwpx/oxml/section_format.py,sha256=EKqod989mzcaPz-lDKM1Y7atdpFX9x_SdQ8zfCL3BpU,18320
 hwpx/oxml/section_story.py,sha256=zvUV7O4dtogWcM9-zudRAszCHRwfzTBMW2GGI1Q24kg,22410
 hwpx/oxml/simple_parts.py,sha256=dOVKWlUCQV8GePH0WRWPUmRylvH5O8bu0B6jj_4lejk,1864
-hwpx/oxml/table.py,sha256=DhvbAlD9ZX0t2dhsR-XfrGbL3Iw-Xtq8KBJDXWtyxLA,42198
+hwpx/oxml/table.py,sha256=sImxS7SMgfhgvaAVUg-zILeMqlrRY3BD2GmmLtTbREQ,42727
 hwpx/oxml/utils.py,sha256=2L9au3SD_MFkFt2DXx3udXBT5caYuYO623lhGhgldVo,2972
 hwpx/quality/__init__.py,sha256=zvOvfOYh0nlKH5ywpj9ZQHov0sdRIouicv9DamKmHLU,1478
 hwpx/quality/ledger.py,sha256=MvrUxd6LlJPD_dWoD5yH9ceFPNcjBR6tr6STqQqAdk0,3534
@@ -83,7 +83,7 @@ hwpx/tools/idempotence.py,sha256=kRZBWsPJFVprYRJkkxn3DHjrT6qX2nK7KvhmdgJ4JpA,501
 hwpx/tools/ir_equality.py,sha256=NIjq33-4q7iTo_asv7WUvh_-EfB1JZMTwbLfYIw2c5w,4765
 hwpx/tools/layout_preview.py,sha256=cHlBUEdMn_ac-hNFDUgF5r2PMM0cTw65l7sqq7Li8NM,22702
 hwpx/tools/mail_merge.py,sha256=8kGlSk2GQL7cFxZgg6P_bKisj1zVUWy8qh8AXIZLK_w,18611
-hwpx/tools/markdown_export.py,sha256=6g0G30Zk0psN9KeZWVMK_fnSzd6Ij9w7t-ZSOsHxW3c,20133
+hwpx/tools/markdown_export.py,sha256=_qhOqnYg2tFQa4-EuXyFdJvkc_-9x6ln9lx-MeqtNeY,20495
 hwpx/tools/object_finder.py,sha256=ovXlbuPiQFdGzNSU08SuEzNFoeYcIb7GfF6vB9MRwBE,13800
 hwpx/tools/package_reconcile.py,sha256=y1Hl7hbPh4YaV59LTdDLzQwgn4g1qEnFmSjmajnrEbA,2416
 hwpx/tools/package_validator.py,sha256=fYkJevV_soQuM8LEUQMkwYaTy2k2HV4VWBwfIXFt29Y,33306
@@ -98,16 +98,16 @@ hwpx/tools/table_cleanup.py,sha256=0_f6NnvNp3QD4owKd_bRX6FZbeUmoQC7a4_VGzF2SCE,1
 hwpx/tools/table_navigation.py,sha256=rtbrWFKpJhqC3LD0ZXImyHgjmDR2hjHCFy3_S-qNBwA,16479
 hwpx/tools/template_analyzer.py,sha256=iH7egGRYNb8UesDB1TJ4tvW41-mlmv5Ap3VacqJFSlE,21355
 hwpx/tools/text_extract_cli.py,sha256=BmsDAwNXpDPhEayb9ez2ORtGNzPd_Xxduy4_cLXhnUw,2188
-hwpx/tools/text_extractor.py,sha256=m9OSBd4FjZrzlMP8b4uS2Lnmjp-u-t7EBKFDF3P1bTM,25514
+hwpx/tools/text_extractor.py,sha256=6Wtk3av69z848ZJAEh-fV4TU2BkAwk3qKJpIyUkYT_4,26122
 hwpx/tools/toc_author.py,sha256=eS1Zm5OBoonuD_H92JxcN2o276d5XmcJDqpfscd4wSg,15445
 hwpx/tools/toc_fidelity.py,sha256=rvoKH8QJ65WNVrxS0d-i2AtODvBy-4O8NRudfQ244v4,19890
 hwpx/tools/validator.py,sha256=U856izL9NcJZOiKDYoCpwOSaFNQ2Un8Jn4pzL20A96Q,7100
 hwpx/tools/_schemas/header.xsd,sha256=mJXuFMuHGT1JnFFaluUpYUglwjMCNlfbFCRVM26eHXE,664
 hwpx/tools/_schemas/section.xsd,sha256=MgvavVHG05RDfUnVPxVU10H4FQOja5ON04_m9Uk_m7E,522
-python_hwpx-5.3.0.dist-info/licenses/LICENSE,sha256=_ubz4wv-BkkT3l3gu-QuH7JGeVjuRYGZoZK95eNsCHU,9688
-python_hwpx-5.3.0.dist-info/licenses/NOTICE,sha256=auRgKYGdrOgWrj4kZfAuXQnqgDnx5myI9TI17IztIzQ,3466
-python_hwpx-5.3.0.dist-info/METADATA,sha256=ve8a6QxqNSMJ6H-PbMfQOS6OpFREBe8Xfe1jEWER33U,13162
-python_hwpx-5.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_hwpx-5.3.0.dist-info/entry_points.txt,sha256=JUKRxbly9UaeHV7YzOea23y8IiqSTcrhUlooP3fS_Zc,405
-python_hwpx-5.3.0.dist-info/top_level.txt,sha256=R1iToqDh80Nf2oQhRjTN0rbN2X6kyDUizIocZjkhuxc,5
-python_hwpx-5.3.0.dist-info/RECORD,,
+python_hwpx-5.5.0.dist-info/licenses/LICENSE,sha256=_ubz4wv-BkkT3l3gu-QuH7JGeVjuRYGZoZK95eNsCHU,9688
+python_hwpx-5.5.0.dist-info/licenses/NOTICE,sha256=auRgKYGdrOgWrj4kZfAuXQnqgDnx5myI9TI17IztIzQ,3466
+python_hwpx-5.5.0.dist-info/METADATA,sha256=8nE4IAXunnxWpqeKPO01ZzKLHA1mXKqZUb034C9gB9k,13162
+python_hwpx-5.5.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_hwpx-5.5.0.dist-info/entry_points.txt,sha256=JUKRxbly9UaeHV7YzOea23y8IiqSTcrhUlooP3fS_Zc,405
+python_hwpx-5.5.0.dist-info/top_level.txt,sha256=R1iToqDh80Nf2oQhRjTN0rbN2X6kyDUizIocZjkhuxc,5
+python_hwpx-5.5.0.dist-info/RECORD,,