wcwidth 0.8.4__tar.gz → 0.8.5__tar.gz

{wcwidth-0.8.4 → wcwidth-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: wcwidth
-Version: 0.8.4
+Version: 0.8.5
 Summary: Measures the displayed width of unicode strings in a terminal
 Project-URL: Homepage, https://github.com/jquast/wcwidth
 Author-email: Jeff Quast <contact@jeffquast.com>
@@ -61,9 +61,9 @@ Some examples of **incorrect results**:
     >>> 'コンニチハ'.rjust(11, 'X')
     'XXXXXXコンニチハ'
 
-    >>> # result consumes 5 total cells, 6 expected,
-    >>> 'café'.center(6, 'X')
-    'caféX'
+    >>> # combining acute accent: result consumes 5 total cells, 6 expected,
+    >>> 'cafe\u0301'.center(6, 'X')
+    'caféX'
 
 Solution
 --------

{wcwidth-0.8.4 → wcwidth-0.8.5}/docs/api_c.rst

@@ -20,9 +20,9 @@ Unicode character display width: wcwidth, wcswidth, wcstwidth.
    Return the display width of a single Unicode codepoint.
 
    Returns:
-   1 or 2  -- display cells occupied
-   0       -- zero-width codepoint (combining marks, ZWJ, etc.)
-   -1       -- non-printable control character
+   1 or 2: display cells occupied
+   0: zero-width codepoint (combining marks, ZWJ, etc.)
+   -1: non-printable control character
 
    :param ambiguous_width: width for East Asian Ambiguous (A) characters. 1 = narrow (default), 2 = wide (CJK context).
 
@@ -47,7 +47,7 @@ Unicode character display width: wcwidth, wcswidth, wcstwidth.
 
    Terminal-aware variant of wcswidth_u32().
 
-   :param term_program: canonical terminal name for override tables (e.g. "kitty", "xterm", "ghostty"). Use NULL for no terminal overrides.
+   :param term_program: terminal name for override tables (e.g. "kitty", "xterm", "ghostty"). Use NULL for no terminal overrides.
 
 .. c:function:: int wcstwidth_u8(const char *utf8, size_t n, int ambiguous_width, const char *term_program)
 
@@ -83,9 +83,9 @@ Main entry-points for string display width: wcwidth_width_u32 / wcwidth_width_u8
    wcwidth_width_u8(), and of the string transforms in clip.h and align.h.
    Distinct codes let callers distinguish the failure cause.
 
-   Every out-param is int rather than wcwidth_error_t: the underlying type of
-   an enum is implementation-defined, so int keeps the ABI stable across
-   compilers.  Compare against these constants directly.
+   Every out-param is int, whose size is fixed.  The underlying type of an enum
+   is implementation-defined, so int keeps the ABI stable across compilers.
+   Compare against these constants directly.
 
    .. c:enumerator:: WCWIDTH_ERROR_NONE
 
@@ -144,7 +144,7 @@ Main entry-points for string display width: wcwidth_width_u32 / wcwidth_width_u8
 
    Measure the visible width of text, including terminal control sequences such
    as colors, bold, tabstops, cursor movement, and OSC 66 Text Sizing.
-   wcwidth_width_u32() encodes its codepoints to UTF-8 and measures as wcwidth_width_u8().
+   wcwidth_width_u32() measures the codepoints directly.
 
    Returns the width in display cells, or -1 on error.
 
@@ -404,17 +404,17 @@ Clip text to a visible column range [v_start, v_end).
 
    Clip text to the visible column range [opts->v_start, opts->v_end).
 
-   Returns a malloc'd string on success, NULL on error.  When NULL is
-   returned, \*error (from width.h) is WCWIDTH_ERROR_UNSUPPORTED for a
-   terminal sequence this function does not support, another nonzero
-   wcwidth_error_t for a WCWIDTH_STRICT violation, and WCWIDTH_ERROR_NONE
-   for an allocation failure.  \*error is always written on return.
+   Returns a malloc'd string on success, NULL on error.  On success, \*out_len
+   receives the byte length of the result (excluding the NUL terminator, which
+   is always present), and the caller must free the returned pointer with a
+   single free() call.  When NULL is returned, \*error (from width.h) is
+   WCWIDTH_ERROR_UNSUPPORTED for a terminal sequence this function does not
+   support, another nonzero wcwidth_error_t for a WCWIDTH_STRICT violation, and
+   WCWIDTH_ERROR_NONE for an allocation failure.  \*error is always written on
+   return.
 
    Unsupported: horizontal cursor movement (BS, CR, CUF, CUB, HPA), OSC 8
    hyperlinks and OSC 66 text sizing.
-   On success, \*out_len receives the byte length of the result
-   (excluding NUL terminator, which is always present).
-   The caller must free the returned pointer with a single free() call.
 
    :param text: UTF-8 encoded input string, NOT NUL-terminated.
    :param text_len: length of text in bytes.
@@ -596,9 +596,8 @@ UTF-8 decoding and encoding.
    is undefined behavior.  Sets \*count\* and returns NULL on allocation
    failure.
 
-   The result is not const, so the `if (p != stack) free(p);` release is a
-   plain free() -- matching wcwidth_encode_u32() below.  Treat the contents as
-   read-only; the pointer is non-const only so ownership can be released.
+   The result type allows a plain free() release, matching wcwidth_encode_u32()
+   below.  Treat the contents as read-only.
 
 
 .. c:function:: uint32_t *wcwidth_decode_u32_heap(const char *utf8, size_t n, size_t *count)
@@ -663,8 +662,8 @@ Grapheme cluster segmentation for UTF-8 text.
 
 .. c:function:: wcwidth_grapheme_iter_t *wcwidth_grapheme_iter_new_u32(const uint32_t *codepoints, size_t n)
 
-   Iterate \*codepoints\*, which is borrowed, not copied, and must outlive the
-   iterator.  Returns NULL if allocation fails.
+   Iterate \*codepoints\*, which the iterator borrows; the caller must keep it
+   alive for the iterator's lifetime.  Returns NULL if allocation fails.
 
 
 .. c:function:: const uint32_t *wcwidth_grapheme_next_u32(wcwidth_grapheme_iter_t *iter, size_t *out_len)
@@ -936,8 +935,8 @@ table_types.h
 Table data model: the interval type, the terminal-override record layouts,
 and the binary search over them.
 
-Hand-written.  The tables themselves -- every WCWIDTH_* interval array, the
-terminal override and alias arrays, and their entry counts -- are declared
+Hand-written.  The tables themselves (every WCWIDTH_* interval array, the
+terminal override and alias arrays, and their entry counts) are declared
 in tables.h, which update-tables.py generates.
 
 .. c:struct:: wcwidth_interval_t

{wcwidth-0.8.4 → wcwidth-0.8.5}/docs/history.rst

@@ -1,6 +1,10 @@
 =======
 History
 =======
+
+0.8.5 *2026-09-23*
+  * **Bugfix** CJK hyphen break positions for `wrap()`_, `PR #262`_.
+
 0.8.4 *2026-09-17*
   * **Bugfix** `clip()`_ hangs with OSC 8 hyperlinks in some conditions, `PR #252`_.
   * **Bugfix** width of ITU T.416 colon-format SGR color parameters, `PR #243`_.
@@ -288,6 +292,7 @@ https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c::
 .. _`PR #252`: https://github.com/jquast/wcwidth/pull/252
 .. _`PR #253`: https://github.com/jquast/wcwidth/pull/253
 .. _`PR #259`: https://github.com/jquast/wcwidth/pull/259
+.. _`PR #262`: https://github.com/jquast/wcwidth/pull/262
 .. _`Issue #101`: https://github.com/jquast/wcwidth/issues/101
 .. _`Issue #155`: https://github.com/jquast/wcwidth/issues/155
 .. _`Issue #211`: https://github.com/jquast/wcwidth/issues/211

{wcwidth-0.8.4 → wcwidth-0.8.5}/docs/intro.rst

@@ -30,9 +30,9 @@ Some examples of **incorrect results**:
     >>> 'コンニチハ'.rjust(11, 'X')
     'XXXXXXコンニチハ'
 
-    >>> # result consumes 5 total cells, 6 expected,
-    >>> 'café'.center(6, 'X')
-    'caféX'
+    >>> # combining acute accent: result consumes 5 total cells, 6 expected,
+    >>> 'cafe\u0301'.center(6, 'X')
+    'caféX'
 
 Solution
 --------

{wcwidth-0.8.4 → wcwidth-0.8.5}/docs/libwcwidth.rst

@@ -6,8 +6,8 @@ A portable C11 library, mainly for CLI/TUI programs that carefully produce outpu
 
 This project is derived from the Python `wcwidth`_ project.
 
-The Python documentation_ closely matches this C library, except that the C API provides UTF-8 and
-codepoint array interfaces.
+The Python documentation_ closely matches this C library.  The C API adds UTF-8 and codepoint
+array interfaces.
 
 The lowest-level functions are derived from POSIX.1-2001 and POSIX.1-2008 `wcwidth(3)`_ and
 `wcswidth(3)`_, which this library implements as `wcwidth_u32()`_ and `wcswidth_u32()`_.  These
@@ -54,7 +54,7 @@ Example Programs
 
 Three small CLI utilities demonstrate use of this library.
 
-**textwrap** -- Unicode, CJK, emoji, and terminal sequence-aware text wrapping::
+**textwrap**: Unicode, CJK, emoji, and terminal sequence-aware text wrapping::
 
     $ textwrap 42 README.rst
     ==========
@@ -70,7 +70,7 @@ Three small CLI utilities demonstrate use of this library.
 Uses environment value, ``$COLUMNS``, if no width argument is given.  Use ``-v`` to append a red
 carriage-return marker.
 
-**width** -- report the display width of each line::
+**width**: report the display width of each line::
 
     $ width README.rst
     10
@@ -86,7 +86,7 @@ carriage-return marker.
     $ width -v <<< "café résumé"
     11:café résumé
 
-**align** -- demonstrate left, right, and center alignment::
+**align**: demonstrate left, right, and center alignment::
 
     $ echo "hello" | align 20
     hello                                hello         hello
@@ -101,8 +101,8 @@ corrections, and grapheme clustering are discussed in the Python documentation_.
 Memory ownership
 ~~~~~~~~~~~~~~~~
 
-The text transforms allocate their result and return ``NULL`` on failure, be certain to ``free()``
-on success:
+The text transforms allocate their result and return ``NULL`` on failure.  The caller must
+``free()`` a successful result:
 
 .. code-block:: c
 
@@ -117,8 +117,8 @@ on success:
     free(out);
 
 `wcwidth_encode_u32()`_ and `wcwidth_decode_u32()`_ instead return the caller's scratch buffer
-if the result fits, allocating only when it does not.  ``free()`` these with the condition that
-the result is at a new address:
+if the result fits, allocating only when it does not.  ``free()`` the result when it is at a new
+address:
 
 .. code-block:: c
 
@@ -141,16 +141,16 @@ Every string function takes an explicit length and reads exactly that many units
     count bytes.
 
 There is no NUL-terminated sentinel form; pass ``strlen(text)`` when the text is a C string.  The
-length is authoritative, so a NUL is an ordinary zero-width character rather than a terminator: it
-may appear anywhere, and survives into transform output, whose ``*out_len`` is the true length.
+length is authoritative: a NUL is an ordinary zero-width character that may appear anywhere, and
+it survives into transform output, whose ``*out_len`` is the true length.
 
 Alternate encodings
 ~~~~~~~~~~~~~~~~~~~
 
 Use ``_u8`` when your text is UTF-8 and ``_u32`` when you hold decoded codepoints; the two
-families mirror each other.  Auxiliary strings are UTF-8 in *both* families -- the ``fillchar``
-padding argument and the ``initial_indent``/``subsequent_indent``/``placeholder`` wrap options --
-since they are short constants, not the text being processed.
+families mirror each other.  Auxiliary strings are UTF-8 in *both* families (the ``fillchar``
+padding argument and the ``initial_indent``/``subsequent_indent``/``placeholder`` wrap options),
+because they are short constants.
 
 Other encodings (Latin-1, CP437, Shift-JIS, ...) are transcoded by the caller; the library carries
 no encoding tables.  Either transcode to UTF-8 once with iconv(3) or ICU and use the ``_u8`` forms
@@ -185,7 +185,7 @@ throughout, or use the ``_u32`` forms and re-encode the result.  `wcwidth_encode
     free(out);
 
 Re-encoding to a legacy charset is the caller's iconv(3) or ICU (``ucnv_*``) call; a byte cast
-works only when every codepoint fits the target, where iconv reports ``EILSEQ`` instead.
+works when every codepoint fits the target, and iconv reports ``EILSEQ`` when one does not.
 
 wcwidth_u32()
 ~~~~~~~~~~~~~
@@ -234,8 +234,8 @@ wcwidth_width_u32() and wcwidth_width_u8()
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Measure the visible width of text including terminal control sequences: colors, bold, tabstops,
-horizontal cursor movement, and OSC 66 Text Sizing.  `wcwidth_width_u32()`_ encodes
-its codepoints to UTF-8 and measures as `wcwidth_width_u8()`_:
+horizontal cursor movement, and OSC 66 Text Sizing.  `wcwidth_width_u32()`_ measures the
+codepoints directly:
 
 .. code-block:: c
 
@@ -313,7 +313,7 @@ graphemes with a fill string.  Returns a ``malloc``\ 'd NUL-terminated string th
     free(out);
 
 Leave ``opts.v_end`` at its ``SIZE_MAX`` default to clip from ``v_start`` through the final column
-of *text*, without measuring it first -- the counterpart of the ``-1`` default of Python's `clip()`_:
+of *text*, without measuring it first, matching the ``-1`` default of Python's `clip()`_:
 
 .. code-block:: c
 
@@ -326,9 +326,9 @@ of *text*, without measuring it first -- the counterpart of the ``-1`` default o
 Some sequences are unsupported, and `wcwidth_clip_u8()`_ returns ``NULL`` with ``*error`` set to
 ``WCWIDTH_ERROR_UNSUPPORTED``, these sequences are only supported in Python's `clip()`_:
 
-* **Horizontal cursor movement** -- BS, CR, and CSI ending in ``C`` (CUF), ``D`` (CUB) or ``G``
-  (HPA).  There is no counterpart to the ``overtyping`` option of Python's `clip()`_.
-* **OSC 8 hyperlinks** and **OSC 66 text sizing** are not supported.
+* **Horizontal cursor movement**: BS, CR, and CSI ending in ``C`` (CUF), ``D`` (CUB) or ``G``
+  (HPA).  Python's `clip()`_ additionally offers ``overtyping``.
+* **OSC 8 hyperlinks** and **OSC 66 text sizing**: Python's `clip()`_ covers these.
 
 .. code-block:: c
 
@@ -366,7 +366,7 @@ breaks.  Both emit a single ``malloc``\ 'd buffer of newline-separated lines:
     free(out);
 
 When the placeholder does not fit within the given width (``max_lines`` truncation),
-`wcwidth_wrap_u8()`_ returns ``-2`` rather than ``-1``, so callers can raise a tailored error.
+`wcwidth_wrap_u8()`_ returns ``-2``, so callers can raise a tailored error.
 `wcwidth_wrap_lines_u8()`_ additionally reports each line's start offset in the output buffer, which
 matters when a line contains ``'\n'`` from the placeholder itself:
 
@@ -408,8 +408,8 @@ Differences from the Python package
 `wcwidth_width_u32()`_ and `wcwidth_width_u8()`_ parse only the sequences that move the cursor
 within a line or change how much room text occupies: SGR, horizontal cursor movement (CUF, CUB,
 HPA), and OSC 66 text sizing.  Every other recognized sequence is zero-width.  Screen clears,
-scrolls and vertical movement are indeterminate -- their column effect depends on terminal state
-the text does not carry -- so ``WCWIDTH_STRICT`` reports them as an error and the other modes
+scrolls and vertical movement are indeterminate (their column effect depends on terminal state
+the text does not carry), so ``WCWIDTH_STRICT`` reports them as an error and the other modes
 count them as zero-width.
 
 ``wcswidth_*()`` and ``wcstwidth_*()`` take no ``wcwidth_control_mode_t`` and return -1 for any
@@ -419,8 +419,8 @@ and `wcwidth_center_u8()`_ match the Python functions exactly.
 The text transforms are simpler:
 
 * `wcwidth_clip_u8()`_ rejects the unsupported sequences described above; every other sequence but
-  SGR is zero-width, preserved where it appeared rather than clipped as a unit.  It otherwise
-  matches Python's `clip()`_, SGR included.
+  SGR is zero-width and preserved at its original position.  It otherwise matches Python's
+  `clip()`_, SGR included.
 * `wcwidth_wrap_u8()`_ treats an OSC 8 hyperlink as an ordinary zero-width OSC, so the link is not
   re-opened on each line; callers must re-emit the opener and terminator themselves.
 * `wcwidth_wrap_u8()`_ and `wcwidth_wrap_u8_text()`_ split words on the ASCII space alone, where
@@ -432,7 +432,7 @@ Supported Terminals
 -------------------
 
 The ``term_program`` argument selects per-terminal corrections from generated override tables.
-The following canonical names are recognized; common ``TERM``/``TERM_PROGRAM`` aliases such as
+The following terminal names are recognized; common ``TERM``/``TERM_PROGRAM`` aliases such as
 ``vscode`` and ``xterm-kitty`` resolve to them:
 
 .. BEGIN_LIST_TERM_PROGRAMS
@@ -445,7 +445,8 @@ The following canonical names are recognized; common ``TERM``/``TERM_PROGRAM`` a
 .. END_LIST_TERM_PROGRAMS
 
 For the most accurate corrections, query the terminal's software version via XTVERSION_
-(``CSI > q``) and pass the canonical name.  See the Python Corrections_ documentation for details.
+(``CSI > q``) and pass the name from the list above.  See the Python Corrections_ documentation
+for details.
 
 Unicode Version
 ---------------

{wcwidth-0.8.4 → wcwidth-0.8.5}/docs/specs.rst

@@ -136,8 +136,8 @@ described in the Virama section header).
 
 - A ``Virama`` contributes 0 width.
 - Most viramas have category ``Mn``, but six have category ``Mc``
-  (`Spacing Combining Mark`_): these are recognised as viramas first,
-  not as ``Mc``, so they begin a conjunct rather than capping the cluster.
+  (`Spacing Combining Mark`_): these are recognised as viramas, so they begin
+  a conjunct.
 - A ``Consonant`` immediately following a ``Virama`` adds its width to the
   current grapheme cluster.
 - The cluster total is capped at 2 cells since 0.8.0, `PR #224`_.

{wcwidth-0.8.4 → wcwidth-0.8.5}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "hatchling" ]
 
 [project]
 name = "wcwidth"
-version = "0.8.4"  # stamped into __init__.py and wcwidth_config.h by bin/update-tables.py
+version = "0.8.5"  # stamped into __init__.py and wcwidth_config.h by bin/update-tables.py
 description = "Measures the displayed width of unicode strings in a terminal"
 readme = "README.rst"
 keywords = [

{wcwidth-0.8.4 → wcwidth-0.8.5}/tests/test_textwrap.py

@@ -118,6 +118,16 @@ def test_wrap_long_words(text, w, break_long, expected):
     ('a---b', 2, True, True, ['a-', '--', 'b']),
     ('a-\x1b[31mb', 2, True, True, ['a-\x1b[31m\x1b[0m', '\x1b[31mb\x1b[0m']),
     ('a-\x1b[31mb', 2, True, False, ['a-\x1b[31m', 'b']),
+    ('古古-1abcdef', 3, True, True, ['古', '古-', '1ab', 'cde', 'f']),
+    ('古古-1abcdef', 4, True, True, ['古古', '-1ab', 'cdef']),
+    ('古古-1abcdef', 5, True, True, ['古古-', '1abcd', 'ef']),
+    ('e\u0301e\u0301-1abcdef', 4, True, True, ['e\u0301e\u0301-', '1abc', 'def']),
+    ('\U0001f469\U0001f469-1abc', 4, True, True, ['\U0001f469\U0001f469', '-1ab', 'c']),
+    ('\x1b[31m漢漢漢-é', 3, True, False, ['\x1b[31m漢', '漢', '漢-', 'é']),
+    ('\x1b[31m漢漢漢-é', 3, True, True,
+     ['\x1b[31m漢\x1b[0m', '\x1b[31m漢\x1b[0m', '\x1b[31m漢-\x1b[0m', '\x1b[31mé\x1b[0m']),
+    ('a-古古古', 6, True, False, ['a-', '古古古']),
+    ('a-古古古', 5, True, False, ['a-', '古古', '古']),
 ])
 def test_wrap_hyphen_long_words(text, w, break_hyphens, propagate, expected):
     assert wrap(text, w, break_on_hyphens=break_hyphens, propagate_sgr=propagate) == expected

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/__init__.py

@@ -47,22 +47,17 @@ from .table_ambiguous import AMBIGUOUS_EASTASIAN
 from .escape_sequences import iter_sequences, strip_sequences
 from .unicode_versions import list_versions
 
-# NOTE: this sort order is important for legacy import API compatibility before release 0.7.0
+# Import order matters for legacy API compatibility (releases before 0.7.0).
 #
-# On Python < 3.15 the legacy submodule is eagerly pre-imported for backward compatibility
-# (populates sys.modules['wcwidth.wcwidth']).  On 3.15+ __lazy_modules__ handles all submodules; the
-# legacy shim loads on-demand via file discovery when ``from wcwidth.wcwidth import ...`` is used.
+# The first release put every function in a single 'wcwidth.py' file, and while the top-level
+# 'from wcwidth import wcswidth' was always preferred, the deeper
+# 'from wcwidth.wcwidth import wcswidth' form was always possible too.  Both keep working.
+#
+# Below 3.15 the legacy submodule is pre-imported so sys.modules['wcwidth.wcwidth'] is populated
+# during package initialization; a later ``import wcwidth.wcwidth`` would otherwise trigger on-disk
+# file discovery and rebind that name from the function to the module object.  On 3.15+
+# __lazy_modules__ covers every submodule and the shim loads on demand.
 if __import__('sys').version_info < (3, 15):
-    # Pre-import the legacy submodule so that sys.modules['wcwidth.wcwidth'] is populated during
-    # package initialization.  Without this, a later downstream dependent ``import wcwidth.wcwidth``
-    # triggers on-disk file discovery which rebinds wcwidth.wcwidth from the function to the module
-    # object.
-    #
-    # this is just a lot of carefulness for the original release that contained all functions in a
-    # single 'wcwidth.py' file. Even though we always exposed our API at the top-level the preferred
-    # 'from wcwidth import wcswidth', it was always possible to import them more directly,
-    # 'from wcwidth.wcwidth import wcswidth'
-    # -- and we make a lot of effort to allow any such import statements to continue to function.
     from . import wcwidth as _wcwidth_module  # isort:skip
 from ._wcwidth import wcwidth, _wcmatch_version, _wcversion_value  # isort:skip  # pylint: disable=wrong-import-position
 
@@ -76,4 +71,4 @@ __all__ = ('wcwidth', 'wcswidth', 'wcstwidth', 'width', 'iter_sequences', 'iter_
            'Hyperlink', 'HyperlinkParams', 'TextSizing', 'TextSizingParams')
 
 # Version is stamped by code generation (bin/update-tables.py) from pyproject.toml.
-__version__ = '0.8.4'
+__version__ = '0.8.5'

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/_clip.py

@@ -507,9 +507,9 @@ def _clip_painter(
     col = 0
     idx = 0
     # captured_style is a frozen snapshot of current_style taken at the first
-    # visible character emitted within the clip window (start, end).  It stays
-    # None until that point.  current_style, by contrast, is continuously
-    # updated by SGR sequences throughout the scan.
+    # visible character emitted within the clip window (start, end); it stays
+    # None until that point.  current_style is continuously updated by SGR
+    # sequences throughout the scan.
     #
     # When propagate_sgr is False, current_style (and therefore captured_style)
     # remain None, and SGR sequences pass through as literal text.
@@ -757,8 +757,8 @@ def clip(
     r"""
     Clip text to display columns (start, end) while preserving all terminal sequences.
 
-    This function extracts a substring based on visible column positions rather than character
-    indices. Terminal escape sequences are preserved in output. If a wide character (width of 2) is
+    This function extracts a substring using visible column positions. Terminal escape sequences
+    are preserved in output. If a wide character (width of 2) is
     split at a boundary, it is replaced with ``fillchar``.
 
     TAB characters (``\t``) are expanded to spaces up to the next tab stop, controlled by the

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/_wcswidth.py

@@ -46,8 +46,8 @@ def _scan_zwj_cluster_end(text: str, start: int, end: int) -> int:
         idx += 1
         # GB11: \p{ExtPict} Extend* ZWJ × \p{ExtPict}
         # Extend modifiers (VS16, Fitzpatrick skin tones, etc.) attach to
-        # the ExtPict *before* the ZWJ, not after it.  After ZWJ the next
-        # codepoint is always an ExtPict directly, no Extend skip needed.
+        # the ExtPict *before* the ZWJ.  After ZWJ the next codepoint is
+        # always an ExtPict directly, no Extend skip needed.
         if idx < end and ord(text[idx]) in _EMOJI_ZWJ_SET:
             idx += 1
             # Skip trailing Extend (VS16, etc.) after ExtPict before next ZWJ
@@ -292,8 +292,8 @@ def wcstwidth(
         ucs = ord(char)
 
         #
-        # Much of the logic below matches the logic in width(), but is repeated for improved
-        # performance, they are given matching index reference numbers (starting at #5).
+        # Much of the logic below matches width(); it is repeated here for performance, with
+        # matching index reference numbers (starting at #5).
         #
         # 5. ZWJ (U+200D): consumed without contributing width.
         # Virama codepoints are treated as zero-width combining marks (Mn). When a

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/_width.py

@@ -150,9 +150,8 @@ def width(
         1
     """
     # pylint: disable=too-complex,too-many-branches,too-many-statements,too-many-locals,redefined-variable-type,too-many-nested-blocks
-    # This could be broken into sub-functions (#1, #3, and #6 especially), but for reduced overhead
-    # in consideration of this function a likely "hot path", they are inline, breaking many pylint
-    # complexity rules.
+    # This could be split into sub-functions (#1, #3 and #6 especially), but this function is a
+    # hot path, so the steps stay inline and the pylint complexity rules are disabled.
 
     # Fast path for ASCII printable (no tabs, escapes, or control chars)
     if text.isascii() and text.isprintable():
@@ -272,7 +271,7 @@ def width(
                     current_col -= n_backward
                     if current_col < 0:
                         current_col = 0
-                # 2d. OSC 66 Text Sizing — has positive display width
+                # 2d. OSC 66 Text Sizing: positive display width
                 elif (ts_meta := m.group('ts_meta')) is not None:
                     ts_text = m.group('ts_text') or ''
                     ts_term = m.group('ts_term')
@@ -281,7 +280,7 @@ def width(
                         TextSizingParams.from_params(ts_meta, control_codes=control_codes),
                         ts_text, ts_term)
                     current_col += text_size.display_width(ambiguous_width)
-                # 2e. SGR and other zero-width sequences -- no column advance
+                # 2e. SGR and other zero-width sequences: no column advance
                 idx = m.end()
             # Escape sequences break VS16 adjacency: reset last-measured state
             last_measured_idx = -2

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/align.py

@@ -22,8 +22,8 @@ def ljust(
     :param text: String to justify, may contain terminal sequences.
     :param dest_width: Total display width of result in terminal cells.
     :param fillchar: Single character for padding (default space). Must have
-        display width of 1 (not wide, not zero-width, not combining). Unicode
-        characters like ``'·'`` are acceptable. The width is not validated.
+        display width of 1. Unicode characters like ``'·'`` are acceptable.
+        The width is not validated.
     :param control_codes: How to handle control sequences when measuring.
         Passed to :func:`width` for measurement.
     :param ambiguous_width: Width to use for East Asian Ambiguous (A)
@@ -72,8 +72,8 @@ def rjust(
     :param text: String to justify, may contain terminal sequences.
     :param dest_width: Total display width of result in terminal cells.
     :param fillchar: Single character for padding (default space). Must have
-        display width of 1 (not wide, not zero-width, not combining). Unicode
-        characters like ``'·'`` are acceptable. The width is not validated.
+        display width of 1. Unicode characters like ``'·'`` are acceptable.
+        The width is not validated.
     :param control_codes: How to handle control sequences when measuring.
         Passed to :func:`width` for measurement.
     :param ambiguous_width: Width to use for East Asian Ambiguous (A)
@@ -122,8 +122,8 @@ def center(
     :param text: String to center, may contain terminal sequences.
     :param dest_width: Total display width of result in terminal cells.
     :param fillchar: Single character for padding (default space). Must have
-        display width of 1 (not wide, not zero-width, not combining). Unicode
-        characters like ``'·'`` are acceptable. The width is not validated.
+        display width of 1. Unicode characters like ``'·'`` are acceptable.
+        The width is not validated.
     :param control_codes: How to handle control sequences when measuring.
         Passed to :func:`width` for measurement.
     :param ambiguous_width: Width to use for East Asian Ambiguous (A)

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/escape_sequences.py

@@ -24,8 +24,8 @@ TEXT_SIZING_PATTERN = re.compile(
 ZERO_WIDTH_PATTERN = re.compile(
     # CSI sequences
     r'\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]|'
-    # OSC sequences, note that text sizing protocol (OSC 66) is special case in width() and clip(),
-    # and contrary to the variable name, it is positive width.
+    # OSC sequences; OSC 66 text sizing gets special handling in width() and clip() and has positive
+    # width, despite the ZERO_WIDTH_PATTERN name.
     r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|'
     # APC sequences
     r'\x1b_[^\x1b\x07]*(?:\x07|\x1b\\)|'

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/grapheme.py

@@ -66,7 +66,7 @@ class GCB(IntEnum):
 
 # All lru_cache sizes in this file use maxsize=1024, chosen by benchmarking UDHR data (500+
 # languages) and considering typical process-long sessions: western scripts need ~64 unique
-# codepoints, but CJK could reach ~2000 -- but likely not.
+# codepoints, and CJK can reach ~2000.
 @lru_cache(maxsize=1024)
 def _grapheme_cluster_break(ucs: int) -> GCB:
     # pylint: disable=too-many-branches,too-complex

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/hyperlink.py

@@ -79,7 +79,7 @@ class Hyperlink(typing.NamedTuple):
         close_end)`` or ``(-1, -1)`` if not found.
 
         Per the OSC 8 specification, terminal emulators treat hyperlinks as a
-        state attribute, not as nested HTML anchors.  A close sequence closes
+        state attribute.  A close sequence closes
         the current hyperlink regardless of how many open sequences preceded it.
         """
         m = HYPERLINK_CLOSE_RE.search(text, open_end)

{wcwidth-0.8.4 → wcwidth-0.8.5}/wcwidth/textwrap.py

@@ -119,8 +119,7 @@ class SequenceTextWrapper(textwrap.TextWrapper):
         # Build a mapping from stripped text positions to original text positions.
         #
         # Track where each character ENDS so that sequences between characters
-        # attach to the following text (not preceding text). This ensures sequences
-        # aren't lost when whitespace is dropped.
+        # attach to the following text, keeping them when whitespace is dropped.
         #
         # char_end[i] = position in original text right after the i-th stripped char
         char_end: list[int] = []
@@ -197,15 +196,15 @@ class SequenceTextWrapper(textwrap.TextWrapper):
         """
         Wrap chunks into lines using sequence-aware width.
 
-        Override TextWrapper._wrap_chunks to use _width instead of len. Follows stdlib's algorithm:
+        Override TextWrapper._wrap_chunks to measure with _width. Follows stdlib's algorithm:
         greedily fill lines, handle long words.  Also handle OSC hyperlink processing. When
         hyperlinks span multiple lines, each line gets complete open/close sequences with matching
         id parameters for hover underlining continuity per OSC 8 spec.
         """
         # pylint: disable=too-many-branches,too-many-statements,too-complex,too-many-locals
         # pylint: disable=too-many-nested-blocks
-        # the hyperlink code in particular really pushes the complexity rating of this method.
-        # preferring to keep it "all in one method" because of so much local state and manipulation.
+        # The hyperlink code pushes the complexity rating of this method.  It stays in one method
+        # because of the shared local state.
         if self.width <= 0:
             raise ValueError('invalid width %r (must be > 0)' % self.width)
         if not chunks:
@@ -250,7 +249,7 @@ class SequenceTextWrapper(textwrap.TextWrapper):
 
             # Drop leading whitespace (except at very start)
             # When dropping, transfer any sequences to the next chunk.
-            # Only drop if there's actual whitespace text, not if it's only sequences.
+            # Only drop when actual whitespace text is present.
             stripped = self._strip_sequences(chunks[-1])
             if self.drop_whitespace and lines and stripped and not stripped.strip():
                 sequences = self._extract_sequences(chunks[-1])
@@ -281,7 +280,7 @@ class SequenceTextWrapper(textwrap.TextWrapper):
 
             # Drop trailing whitespace
             # When dropping, transfer any sequences to the previous chunk.
-            # Only drop if there's actual whitespace text, not if it's only sequences.
+            # Only drop when actual whitespace text is present.
             stripped_last = self._strip_sequences(current_line[-1]) if current_line else ''
             if (self.drop_whitespace and current_line and
                     stripped_last and not stripped_last.strip()):
@@ -424,24 +423,23 @@ class SequenceTextWrapper(textwrap.TextWrapper):
         if self.break_long_words:
             break_at_hyphen = False
             hyphen_end = 0
+            # End of the prefix that fits within space_left by display width.
+            prefix_end = self._find_break_position(chunk, space_left)
 
-            # Handle break_on_hyphens: find last hyphen within space_left
+            # Handle break_on_hyphens: find last hyphen in the portion that fits.
             if self.break_on_hyphens:
-                # Strip sequences to find hyphen in logical text
-                stripped = self._strip_sequences(chunk)
-                if len(stripped) > space_left:
-                    # Find last hyphen in the portion that fits
-                    hyphen_pos = stripped.rfind('-', 0, space_left)
-                    if hyphen_pos > 0 and any(c != '-' for c in stripped[:hyphen_pos]):
-                        # Map back to original position including sequences
-                        hyphen_end = self._map_stripped_pos_to_original(chunk, hyphen_pos + 1)
-                        break_at_hyphen = True
+                stripped = self._strip_sequences(chunk[:prefix_end])
+                hyphen_pos = stripped.rfind('-')
+                if hyphen_pos > 0 and any(c != '-' for c in stripped[:hyphen_pos]):
+                    # Map back to original position including sequences
+                    hyphen_end = self._map_stripped_pos_to_original(chunk, hyphen_pos + 1)
+                    break_at_hyphen = True
 
             # Break at grapheme boundaries to avoid splitting multi-codepoint characters
             if break_at_hyphen:
                 actual_end = hyphen_end
             else:
-                actual_end = self._find_break_position(chunk, space_left)
+                actual_end = prefix_end
                 # Include first visible unit when break would take only leading sequences.
                 if not cur_line and (
                         actual_end == 0
@@ -551,8 +549,8 @@ def wrap(text: str, width: int = 70, *,
     r"""
     Wrap text to fit within given width, returning a list of wrapped lines.
 
-    Like :func:`textwrap.wrap`, but measures width in display cells rather than
-    characters, correctly handling wide characters, combining marks, and terminal
+    Like :func:`textwrap.wrap`, but measures width in display cells, correctly
+    handling wide characters, combining marks, and terminal
     escape sequences.
 
     :param text: Text to wrap, may contain terminal sequences.