python-hwpx 6.4.0__py3-none-any.whl → 6.6.0__py3-none-any.whl

hwpx/__init__.py

@@ -376,6 +376,7 @@ from .tools.package_validator import (
 )
 from .ingest import HwpxMarkdownConverter
 from .errors import HwpxError
+from .hwp5.errors import Hwp5ConversionWarning, Hwp5Error
 from .mutation_report import (
     MutationReport,
     PreservationDowngradeError,
@@ -415,6 +416,8 @@ __all__ = [
     "PackageValidationReport",
     "BytePreservingPatchResult",
     "HwpxError",
+    "Hwp5Error",
+    "Hwp5ConversionWarning",
     "MutationReport",
     "PreservationDowngradeError",
     "ParagraphTextPatch",

hwpx/_document/_legacy.py

@@ -1241,7 +1241,9 @@ class _LegacyFacade:
         """Remove an embedded image by its manifest item id.
 
         This removes the binary data from the ZIP, the manifest entry, and
-        the header binItem entry.
+        the header binItem entry. An item the document still points at is
+        refused with ``HwpxValueError`` (code ``media-item-in-use``);
+        ``doc.media.remove_image(item_id, force=True)`` removes it anyway.
 
         Returns:
             ``True`` if any component was removed.

hwpx/_document/fields.py

@@ -8,10 +8,11 @@ from typing import TYPE_CHECKING, Any, Iterator, Mapping, Sequence, cast
 
 from ..errors import HwpxStateError, HwpxValueError
 from ..objects.checkbox import CheckBox
-from ..objects.form_field import FieldLocation, FieldParameter, FormField
+from ..objects.form_field import CellField, FieldLocation, FieldParameter, FormField
 from ..objects.results import FieldFillResult
 from ..oxml import HwpxOxmlParagraph
 from ..oxml.namespaces import HP
+from ..oxml.section_story import control_twins
 
 if TYPE_CHECKING:
     from hwpx.document import HwpxDocument
@@ -291,11 +292,13 @@ def _iter_form_field_matches(doc: "HwpxDocument") -> list[dict[str, Any]]:
             paragraph.element: index
             for index, paragraph in enumerate(section.paragraphs)
         }
+        # a header/footer python-hwpx keeps twice counts once: its hp:secPr copy
+        twins = control_twins(section.element)
 
         def iter_content_paragraphs(element: Any) -> Iterator[Any]:
             for child in element:
                 local = _local_name(child)
-                if local == "memogroup":
+                if local == "memogroup" or child in twins:
                     continue
                 if local == "p":
                     yield child
@@ -403,6 +406,42 @@ def list_form_fields(doc: "HwpxDocument") -> tuple[FormField, ...]:
     return tuple(_form_field_from_match(doc, match) for match in _iter_form_field_matches(doc))
 
 
+def _named_cells(paragraphs: Any) -> Iterator[Any]:
+    for paragraph in paragraphs:
+        for table in paragraph.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    if cell.field_name:
+                        yield cell
+                    yield from _named_cells(cell.paragraphs)
+
+
+def list_cell_fields(doc: "HwpxDocument") -> tuple[CellField, ...]:
+    """Named table cells (Hancom's cell fields) in document order: body tables and the tables in their cells."""
+
+    return tuple(CellField(cell) for section in doc.sections for cell in _named_cells(section.paragraphs))
+
+
+def fill_cell_fields(doc: "HwpxDocument", value: str, *, name: str, index: int | None = None) -> tuple[CellField, ...]:
+    """Set the text of every cell field called *name*, or of the *index*-th of them only."""
+
+    wanted = (name or "").strip()
+    fields = [field for field in list_cell_fields(doc) if wanted and field.name == wanted]
+    if index is not None:
+        fields = fields[index : index + 1] if index >= 0 else []
+    if not fields:
+        where = f"{wanted!r}" if index is None else f"{wanted!r} at index {index}"
+        raise HwpxValueError(
+            f"no cell field named {where}",
+            code="field-cell-not-found",
+            context={"name": wanted, "index": index},
+            suggestion="List doc.fields.cells to see the cell field names.",
+        )
+    for field in fields:
+        field.text = value
+    return tuple(fields)
+
+
 _PROMPT_TEXT_COLOR = "#FF0000"
 
 
@@ -823,7 +862,10 @@ def _measure_form_field_fit(
 ) -> "FitResult":
     """Run the FormFit engine for a native field (plan §2 C)."""
 
+    from dataclasses import replace
+
     from hwpx.form_fit import DEFAULT_SAFETY, FitEngine, FitResult, SlotMetrics
+    from hwpx.form_fit.measure import text_style_from_refs
 
     runs = match["_runs"]
     begin_index = int(match["_begin_run_index"])
@@ -850,10 +892,16 @@ def _measure_form_field_fit(
             field_id=field_id,
         )
 
+    # The field sits inside its paragraph, so the paragraph's indent does not
+    # apply to the box.
+    text_style = text_style_from_refs(
+        doc._root, match["_paragraph"].para_pr_id_ref, [begin_ref]
+    )
     slot = SlotMetrics(
         available_width=float(box_width) * DEFAULT_SAFETY,
         font_pt=resolved_pt,
         max_lines=fit_policy.effective_max_lines,
+        text_style=replace(text_style, indent=0),
     )
     return FitEngine().fit(value, slot, fit_policy, field_id=field_id)
 

hwpx/_document/layout.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Mapping, Sequence
 
-from ..errors import HwpxStateError, HwpxValueError
+from ..errors import HwpxStateError, HwpxTypeError, HwpxValueError
 from ..objects.results import (
     ColumnLayout,
     ListFormatResult,
@@ -16,13 +16,14 @@ from ..objects.results import (
     Units,
 )
 from ..oxml._document_primitives import NEW_NUM_KINDS
-from ..oxml.namespaces import HH
+from ..oxml.namespaces import HH, HP
+from ..oxml.objects import HwpxOxmlInlineObject
+from ..oxml.section_format import _PAGE_LANDSCAPE, _PAGE_PORTRAIT, _page_orientation_value
 from ._units import _mm_to_hwp_units, _pt_to_hwp_units
 
 if TYPE_CHECKING:
     from hwpx.document import HwpxDocument
     from ..oxml import (
-        HwpxOxmlInlineObject,
         HwpxOxmlParagraph,
         HwpxOxmlSection,
         HwpxOxmlSectionHeaderFooter,
@@ -45,16 +46,9 @@ _PAPER_SIZES_MM: dict[str, tuple[float, float]] = {
 def _normalize_page_orientation(value: str | None) -> str | None:
     if value is None:
         return None
-    normalized = value.strip().upper()
-    aliases = {
-        "PORTRAIT": "PORTRAIT",
-        "NARROW": "PORTRAIT",
-        "NARROWLY": "PORTRAIT",
-        "LANDSCAPE": "WIDELY",
-        "WIDE": "WIDELY",
-        "WIDELY": "WIDELY",
-    }
-    orientation = aliases.get(normalized)
+    # PORTRAIT/NARROW -> WIDELY and LANDSCAPE/WIDE -> NARROWLY; the stored
+    # values themselves keep Hancom's meaning (WIDELY is portrait).
+    orientation = _page_orientation_value(value)
     if orientation is None:
         raise HwpxValueError(
             f"unsupported page orientation: {value}",
@@ -65,6 +59,81 @@ def _normalize_page_orientation(value: str | None) -> str | None:
     return orientation
 
 
+#: Keys of ``set_paragraph_format(border=...)``.
+_PARAGRAPH_BORDER_KEYS = frozenset(
+    {"sides", "color", "width", "type", "connect", "offset_mm", "ignore_margin"}
+)
+_PARAGRAPH_BORDER_SIDES = ("left", "right", "top", "bottom")
+
+
+def _paragraph_border_problem(
+    spec: Mapping[str, Any], sides: tuple[str, ...], offsets: tuple[Any, ...]
+) -> str | None:
+    unknown = sorted(set(spec) - _PARAGRAPH_BORDER_KEYS)
+    if unknown:
+        return f"unknown paragraph border keys: {unknown}"
+    if not sides or any(side not in _PARAGRAPH_BORDER_SIDES for side in sides):
+        return f"unsupported paragraph border sides: {list(sides)}"
+    if len(offsets) != 4 or any(
+        isinstance(value, bool) or not isinstance(value, (int, float)) or value < 0 for value in offsets
+    ):
+        return "offset_mm must be a non-negative number or four of them (left, right, top, bottom)"
+    return None
+
+
+def _paragraph_border_attrs(
+    header: Any,
+    border: Mapping[str, Any] | None,
+    *,
+    bottom_border: bool,
+    border_color: str,
+    border_width: str,
+) -> dict[str, str] | None:
+    """``hh:paraPr/hh:border`` attributes for ``border`` (or ``bottom_border``)."""
+
+    if border is None and not bottom_border:
+        return None
+    spec: Mapping[str, Any] = (
+        border if border is not None
+        else {"sides": ("bottom",), "color": border_color, "width": border_width}
+    )
+    raw_sides = spec.get("sides", _PARAGRAPH_BORDER_SIDES)
+    sides = tuple(str(side).strip().lower() for side in ((raw_sides,) if isinstance(raw_sides, str) else raw_sides))
+    raw_offsets = spec.get("offset_mm", 0)
+    offsets = tuple((raw_offsets,) * 4 if isinstance(raw_offsets, (int, float)) else raw_offsets)
+    problem = (
+        "pass either bottom_border or border, not both"
+        if border is not None and bottom_border
+        else _paragraph_border_problem(spec, sides, offsets)
+    )
+    if problem is not None:
+        raise HwpxValueError(
+            problem,
+            code="paragraph-border-invalid",
+            context={"border": {str(key): str(value) for key, value in spec.items()}},
+            suggestion=(
+                "border keys: sides, color, width, type, connect, offset_mm "
+                "(mm, one number or left/right/top/bottom), ignore_margin."
+            ),
+        )
+    border_fill_id = header.ensure_border_fill(
+        border_color=str(spec.get("color", "#000000")),
+        border_width=str(spec.get("width", "0.12 mm")),
+        active_borders=sides,
+        border_type=str(spec.get("type", "SOLID")),
+    )
+    left, right, top, bottom = (str(_mm_to_hwp_units(float(value))) for value in offsets)
+    return {
+        "borderFillIDRef": border_fill_id,
+        "offsetLeft": left,
+        "offsetRight": right,
+        "offsetTop": top,
+        "offsetBottom": bottom,
+        "connect": "1" if spec.get("connect") else "0",
+        "ignoreMargin": "1" if spec.get("ignore_margin") else "0",
+    }
+
+
 def _resolve_paragraph_targets(
     doc: "HwpxDocument",
     *,
@@ -104,11 +173,67 @@ def _resolve_paragraph_targets(
     return targets
 
 
+def _tree_root(element: Any) -> Any:
+    if hasattr(element, "getparent"):
+        while element.getparent() is not None:
+            element = element.getparent()
+    return element
+
+
+def _resolve_paragraph_objects(
+    doc: "HwpxDocument", paragraphs: Sequence[HwpxOxmlParagraph]
+) -> list[HwpxOxmlParagraph]:
+    """Check that every paragraph object belongs to *doc*, before anything changes.
+
+    Body, table cell (nested too), header and footer paragraphs all live in a
+    section's XML tree, so a paragraph belongs to the document when its element
+    is inside one of the document's section elements.
+    """
+
+    from ..oxml import HwpxOxmlParagraph
+
+    items = list(paragraphs)
+    if not items:
+        raise HwpxValueError(
+            "paragraphs 가 비어 있습니다.",
+            code="paragraph-indexes-empty",
+            suggestion="서식을 적용할 문단을 하나 이상 지정하세요.",
+        )
+    roots = [section.element for section in doc.sections]
+    resolved: list[HwpxOxmlParagraph] = []
+    for position, paragraph in enumerate(items):
+        if not isinstance(paragraph, HwpxOxmlParagraph):
+            raise HwpxTypeError(
+                f"paragraphs[{position}] 는 문단 객체가 아닙니다 — {type(paragraph).__name__}.",
+                code="paragraph-invalid-type",
+                context={"position": position, "type": type(paragraph).__name__},
+                suggestion="doc.paragraphs, cell.paragraphs, header.paragraphs 의 문단을 넘기세요.",
+            )
+        element = paragraph.element
+        root = _tree_root(element)
+        inside = (
+            any(root is section_root for section_root in roots)
+            if hasattr(element, "getparent")
+            else any(node is element for section_root in roots for node in section_root.iter())
+        )
+        if not inside:
+            raise HwpxValueError(
+                f"paragraphs[{position}] 는 이 문서에 속한 문단이 아닙니다.",
+                code="paragraph-not-in-document",
+                context={"position": position},
+                suggestion="이 문서에서 얻은 문단(본문·셀·머리말·꼬리말)을 넘기세요. 지운 문단이나 다른 문서의 문단은 받지 않습니다.",
+            )
+        if all(element is not seen.element for seen in resolved):
+            resolved.append(paragraph)
+    return resolved
+
+
 def set_paragraph_format(
     doc: "HwpxDocument",
     *,
     paragraph_index: int | None = None,
     paragraph_indexes: Sequence[int] | None = None,
+    paragraphs: Sequence[HwpxOxmlParagraph] | None = None,
     alignment: str | None = None,
     line_spacing_percent: int | float | None = None,
     indent_left_mm: float | None = None,
@@ -127,9 +252,16 @@ def set_paragraph_format(
     tab_stops: Sequence[Mapping[str, Any]] | None = None,
     auto_tab_left: bool | None = None,
     auto_tab_right: bool | None = None,
+    border: Mapping[str, Any] | None = None,
 ) -> ParagraphFormatResult:
     """Apply paragraph-level formatting using human units.
 
+    Targets are body paragraphs by index (``paragraph_index`` /
+    ``paragraph_indexes``; neither means every body paragraph) or paragraph
+    objects of this document (``paragraphs``): body, table cell (nested
+    tables too), header and footer paragraphs. The result lists body indexes
+    only; ``formatted`` counts every target.
+
     Millimetre inputs are converted to HWP units; paragraph spacing uses
     points; line spacing is stored as a percent value. ``keep_with_next`` /
     ``keep_lines`` / ``page_break_before`` set the paragraph's keep-together
@@ -145,6 +277,17 @@ def set_paragraph_format(
     position-ascending. Passing ``tab_stops``/``auto_tab_left``/
     ``auto_tab_right`` mints (or reuses — dedupe) a ``hh:tabPr`` and wires
     the paragraph's ``tabPrIDRef`` to it.
+
+    ``border`` is a mapping for a paragraph border: ``sides`` (default all
+    four of ``"left"``/``"right"``/``"top"``/``"bottom"``), ``color``
+    (``"#000000"``), ``width`` (``"0.12 mm"``), ``type`` (``"SOLID"``),
+    ``offset_mm`` (gap to the text in mm, one number or ``(left, right, top,
+    bottom)``, default 0), ``connect`` and ``ignore_margin`` (default
+    ``False``). With
+    ``connect=True`` Hancom draws consecutive paragraphs that share the
+    paragraph shape as one box, across columns and pages; give an empty
+    paragraph inside the box the same format so it does not split the box.
+    ``bottom_border=True`` is the older bottom-only form.
     """
 
     if not doc._root.headers:
@@ -207,6 +350,7 @@ def set_paragraph_format(
         and not margins
         and heading is None
         and not bottom_border
+        and border is None
         and not break_setting
         and not wants_tab_definition
         and column_break is None
@@ -217,6 +361,26 @@ def set_paragraph_format(
             suggestion="Pass alignment, line_spacing_percent, or another option to change.",
         )
 
+    # Resolve every target before the header gains tab or border definitions,
+    # so a bad target changes nothing.
+    targets: list[tuple[int | None, HwpxOxmlParagraph]]
+    if paragraphs is not None:
+        if paragraph_index is not None or paragraph_indexes is not None:
+            raise HwpxValueError(
+                "use either paragraphs or paragraph_index/paragraph_indexes, not both",
+                code="paragraph-argument-conflict",
+                suggestion="Pass only one.",
+            )
+        objects = _resolve_paragraph_objects(doc, paragraphs)
+        body = doc.paragraphs
+        body_index = {paragraph.element: index for index, paragraph in enumerate(body)}
+        targets = [(body_index.get(paragraph.element), paragraph) for paragraph in objects]
+    else:
+        targets = list(_resolve_paragraph_targets(doc,
+            paragraph_index=paragraph_index,
+            paragraph_indexes=paragraph_indexes,
+        ))
+
     tab_pr_id: str | None = None
     if wants_tab_definition:
         converted_stops: list[dict[str, object]] = []
@@ -239,22 +403,13 @@ def set_paragraph_format(
             auto_tab_right=bool(auto_tab_right),
         )
 
-    border: dict[str, str] | None = None
-    if bottom_border:
-        border_fill_id = header.ensure_border_fill(
-            border_color=border_color,
-            border_width=border_width,
-            active_borders=("bottom",),
-        )
-        border = {
-            "borderFillIDRef": border_fill_id,
-            "offsetLeft": "0",
-            "offsetRight": "0",
-            "offsetTop": "0",
-            "offsetBottom": "0",
-            "connect": "0",
-            "ignoreMargin": "0",
-        }
+    border_attrs = _paragraph_border_attrs(
+        header,
+        border,
+        bottom_border=bottom_border,
+        border_color=border_color,
+        border_width=border_width,
+    )
 
     # column_break bypasses paraPr entirely (it's hp:p's own attribute, not
     # a shared style) -- only mint a new paraPr when one of the *other*
@@ -265,17 +420,12 @@ def set_paragraph_format(
         or line_spacing_percent is not None
         or bool(margins)
         or heading is not None
-        or bottom_border
+        or border_attrs is not None
         or bool(break_setting)
         or wants_tab_definition
     )
 
-    targets = _resolve_paragraph_targets(doc,
-        paragraph_index=paragraph_index,
-        paragraph_indexes=paragraph_indexes,
-    )
-    formatted: list[int] = []
-    for index, paragraph in targets:
+    for paragraph in (paragraph for _, paragraph in targets):
         if wants_para_pr_change:
             para_pr_id = header.ensure_paragraph_format(
                 base_para_pr_id=paragraph.para_pr_id_ref,
@@ -283,18 +433,17 @@ def set_paragraph_format(
                 line_spacing_percent=line_spacing_percent,
                 margins=margins,
                 heading=heading,
-                border=border,
+                border=border_attrs,
                 break_setting=break_setting or None,
                 tab_pr_id_ref=tab_pr_id,
             )
             paragraph.para_pr_id_ref = para_pr_id
         if column_break is not None:
             paragraph.column_break = column_break
-        formatted.append(index)
 
     return ParagraphFormatResult(
-        formatted=len(formatted),
-        paragraphs=tuple(formatted),
+        formatted=len(targets),
+        paragraphs=tuple(index for index, _ in targets if index is not None),
         units=Units(indent="mm", paragraph_spacing="pt", line_spacing="%"),
     )
 
@@ -396,7 +545,12 @@ def set_page_setup(
     section: HwpxOxmlSection | None = None,
     section_index: int | None = None,
 ) -> PageSetup:
-    """Set page size, margins, orientation, and optional columns in human units."""
+    """Set page size, margins, orientation, and optional columns in human units.
+
+    The page is written as Hancom writes it: ``WIDELY`` for portrait and
+    ``NARROWLY`` for landscape, both with the paper's portrait size. The
+    returned ``page_size`` reports the page as drawn (landscape is wider).
+    """
 
     normalized_orientation = _normalize_page_orientation(orientation)
     target_width_mm = width_mm
@@ -415,10 +569,11 @@ def set_page_setup(
         target_height_mm = paper_height if target_height_mm is None else target_height_mm
 
     if target_width_mm is not None and target_height_mm is not None:
-        if normalized_orientation == "WIDELY" and target_width_mm < target_height_mm:
-            target_width_mm, target_height_mm = target_height_mm, target_width_mm
-        elif normalized_orientation == "PORTRAIT" and target_width_mm > target_height_mm:
-            target_width_mm, target_height_mm = target_height_mm, target_width_mm
+        short_side, long_side = sorted((target_width_mm, target_height_mm))
+        if normalized_orientation == _PAGE_LANDSCAPE:
+            target_width_mm, target_height_mm = long_side, short_side
+        elif normalized_orientation == _PAGE_PORTRAIT:
+            target_width_mm, target_height_mm = short_side, long_side
 
     width = _mm_to_hwp_units(float(target_width_mm)) if target_width_mm is not None else None
     height = _mm_to_hwp_units(float(target_height_mm)) if target_height_mm is not None else None
@@ -510,10 +665,12 @@ def set_columns(
     section: HwpxOxmlSection | None = None,
     section_index: int | None = None,
 ) -> HwpxOxmlInlineObject:
-    """Insert a column definition control.
+    """Set the columns of a section, or start new columns at a paragraph.
 
-    This adds a ``<hp:ctrl><hp:colPr>`` element to the specified paragraph.
-    Text that follows will be laid out in the specified number of columns.
+    Without ``paragraph`` this rewrites the section's own column layout (the
+    ``hp:colPr`` next to ``hp:secPr``) in place, so the whole section is laid
+    out in ``col_count`` columns. With ``paragraph`` it adds a column
+    definition control there, and the text from that paragraph on uses it.
 
     Args:
         col_count: Number of columns (1–255).
@@ -521,7 +678,28 @@ def set_columns(
         same_gap: Gap in HWPUNIT (7200 = 1 inch).
         separator_type: Optional column separator line type (e.g. ``SOLID``).
     """
+    if not 1 <= col_count <= 255:
+        raise HwpxValueError(
+            "col_count must be between 1 and 255",
+            code="page-columns-invalid",
+            context={"requested": col_count},
+            suggestion="Use columns=1 to remove columns.",
+        )
     if paragraph is None:
+        target_section = _resolve_section(doc, section=section, section_index=section_index)
+        ctrl = target_section.properties.set_columns(
+            col_count,
+            col_type=col_type,
+            layout=layout,
+            same_size=same_size,
+            same_gap=same_gap,
+            column_widths=column_widths,
+            separator_type=separator_type,
+            separator_width=separator_width,
+            separator_color=separator_color,
+        )
+        if ctrl is not None:
+            return HwpxOxmlInlineObject(ctrl, target_section.paragraphs[0])
         paragraph = doc.add_paragraph(
             "", section=section, section_index=section_index,
             include_run=False,
@@ -573,21 +751,12 @@ def add_hyperlink(
 
     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.
+    hyperlinks) on the character look of the paragraph it goes into, unless
+    ``char_pr_id_ref`` overrides it. ``paragraph.add_hyperlink`` picks that
+    style, so a link looks the same whichever way it was added.
 
     Returns the ``<hp:ctrl>`` wrapper containing the ``<hp:fieldBegin>``.
     """
-    if char_pr_id_ref is None:
-        # `doc._root.ensure_run_style` rather than `doc.ensure_run_style` —
-        # that facade name moved in 6.0 (design table row 52) and is a pure
-        # passthrough to `_root`, so this is byte-identical minus the
-        # DeprecationWarning it would otherwise fire on every hyperlink even
-        # when reached via the new `doc.refs.add_hyperlink` namespace path.
-        char_pr_id_ref = doc._root.ensure_run_style(
-            underline=True,
-            color="#0000FF",
-            underline_color="#0000FF",
-        )
     if paragraph is None:
         paragraph = doc.add_paragraph(
             "", section=section, section_index=section_index,
@@ -631,7 +800,7 @@ def set_page_size(
     target_section.properties.set_page_size(
         width=width,
         height=height,
-        orientation=orientation,
+        orientation=_normalize_page_orientation(orientation),
         gutter_type=gutter_type,
     )
 
@@ -868,10 +1037,14 @@ def hide_page_elements(
     fill: bool = False,
     page_num: bool = False,
 ) -> "HwpxOxmlInlineObject":
-    """Hide the named page elements from *paragraph*'s page onward.
+    """Hide the named page elements on *paragraph*'s page only.
 
     Inserts ``<hp:ctrl><hp:pageHiding .../></hp:ctrl>`` (``ParaList XML
     schema.xml:148-163`` — six independent booleans, all default unhidden).
+    Hancom applies it to that page alone (its "hide on the current page
+    only"); the next page shows the elements again. *page_num* hides
+    Hancom's page-number control, not the header/footer number that
+    ``set_page_number`` writes -- hide that one with *footer* (or *header*).
     """
 
     return paragraph.add_page_hiding(
@@ -920,3 +1093,57 @@ def remove_footer(
             return
         target_section = doc._root.sections[-1]
     target_section.properties.remove_footer(page_type=page_type)
+
+
+def flow_table_taller_than_page(doc: "HwpxDocument", table: Any) -> None:
+    """Let a new body *table* flow across pages when its rows alone outgrow a page.
+
+    Hancom never breaks a table laid out as a character (``treatAsChar``, the
+    ``add_table`` default) across pages: one taller than the page body is cut
+    off at the paper's edge. Such a table becomes a flowing one instead
+    (``Table.set_treat_as_char(False)``), which Hancom breaks between rows.
+    """
+
+    properties = table.paragraph.section.properties
+    size, margins = properties.page_size, properties.page_margins
+    body = size.drawn_height - margins.top - margins.bottom - margins.header - margins.footer
+    if body > 0 and _table_min_height(doc, table.element) > body:
+        table.set_treat_as_char(False)
+
+
+def _table_min_height(doc: "HwpxDocument", table: Any) -> int:
+    """A lower bound of the drawn height: every row is at least its tallest
+    single-row cell, and a cell at least one line of its text plus its top and
+    bottom margins."""
+
+    total = 0
+    for row in table.findall(f"{HP}tr"):
+        tallest = 0
+        for cell in row.findall(f"{HP}tc"):
+            span = cell.find(f"{HP}cellSpan")
+            if span is not None and span.get("rowSpan", "1") != "1":
+                continue
+            run = cell.find(f".//{HP}run")
+            line = _char_height(doc, run.get("charPrIDRef") if run is not None else None)
+            margin = cell.find(f"{HP}cellMargin")
+            padding = _int_attr(margin, "top") + _int_attr(margin, "bottom")
+            tallest = max(tallest, _int_attr(cell.find(f"{HP}cellSz"), "height"), line + padding)
+        total += tallest
+    return total
+
+
+def _char_height(doc: "HwpxDocument", char_pr_id_ref: str | None) -> int:
+    style = doc._root.char_property(char_pr_id_ref if char_pr_id_ref is not None else "0")
+    try:
+        return int(style.attributes.get("height", "1000")) if style is not None else 1000
+    except ValueError:
+        return 1000
+
+
+def _int_attr(element: Any, name: str) -> int:
+    if element is None:
+        return 0
+    try:
+        return int(element.get(name, "0"))
+    except ValueError:
+        return 0