pi-oxidized 0.1.1

package/crates/pi-tui/src/text/tests.rs

@@ -0,0 +1,359 @@
+//! Ports of TS width / wrap / truncate / slice / tab / RI regression tables.
+
+use proptest::prelude::*;
+use unicode_segmentation::UnicodeSegmentation;
+
+use super::{
+    CURSOR_MARKER, composite_line_at, extract_ansi_code, extract_segments, find_cursor_marker,
+    grapheme_width, is_partial_closing_fence_line, normalize_terminal_output, slice_by_column,
+    slice_with_width, strip_cursor_marker, strip_trailing_partial_closing_fence, truncate_to_width,
+    visible_width, wrap_text_with_ansi,
+};
+
+#[test]
+fn printable_ascii_width() {
+    assert_eq!(visible_width(""), 0);
+    assert_eq!(visible_width("hello"), 5);
+    assert_eq!(visible_width("a\tb"), 5);
+}
+
+#[test]
+fn tab_counts_as_three() {
+    assert_eq!(grapheme_width("\t"), 3);
+    assert_eq!(visible_width("\t"), 3);
+    assert_eq!(visible_width("\t\u{1b}[31m界\u{1b}[0m"), 5);
+}
+
+#[test]
+fn regional_indicator_singleton_and_pair() -> Result<(), String> {
+    assert_eq!(visible_width("🇨"), 2);
+    assert_eq!(visible_width("🇨🇳"), 2);
+    assert_eq!(visible_width("      - 🇨"), 10);
+    for cp in 0x1f1e6u32..=0x1f1ff {
+        let scalar = char::from_u32(cp).ok_or_else(|| format!("invalid scalar U+{cp:X}"))?;
+        let regional_indicator = scalar.to_string();
+        assert_eq!(visible_width(&regional_indicator), 2, "U+{cp:X}");
+    }
+    for flag in ["🇯🇵", "🇺🇸", "🇬🇧", "🇨🇳", "🇩🇪", "🇫🇷"] {
+        assert_eq!(visible_width(flag), 2, "{flag}");
+    }
+    Ok(())
+}
+
+#[test]
+fn streaming_emoji_intermediates() {
+    for sample in ["👍", "👍🏻", "✅", "⚡", "⚡️", "👨", "👨‍💻", "🏳️‍🌈"]
+    {
+        assert_eq!(visible_width(sample), 2, "{sample}");
+    }
+}
+
+#[test]
+fn thai_lao_am_widths_and_normalize() {
+    assert_eq!(visible_width("ำ"), 1);
+    assert_eq!(visible_width("ຳ"), 1);
+    assert_eq!(visible_width("กำ"), 2);
+    assert_eq!(visible_width("ກຳ"), 2);
+    assert_eq!(normalize_terminal_output("ำ"), "ํา");
+    assert_eq!(normalize_terminal_output("ຳ"), "ໍາ");
+    assert_eq!(
+        visible_width(&normalize_terminal_output("ำabc")),
+        visible_width("ำabc")
+    );
+}
+
+#[test]
+fn osc_and_apc_ignored_in_width() {
+    assert_eq!(visible_width("\u{1b}]133;A\u{7}hello\u{1b}]133;B\u{7}"), 5);
+    assert_eq!(
+        visible_width("\u{1b}]133;A\u{1b}\\hello\u{1b}]133;B\u{1b}\\"),
+        5
+    );
+    assert_eq!(visible_width(&format!("hi{CURSOR_MARKER}")), 2);
+}
+
+#[test]
+fn normalize_leaves_tabs_inside_escapes() {
+    let control_sequences = [
+        "\u{1b}]8;;https://example.test/a\tb\u{7}",
+        "\u{1b}]0;window\ttitle\u{1b}\\",
+        "\u{1b}_payload\tdata\u{1b}\\",
+    ];
+    for control in control_sequences {
+        assert_eq!(
+            normalize_terminal_output(&format!("{control}label\ttext")),
+            format!("{control}label   text")
+        );
+    }
+}
+
+#[test]
+fn wrap_basic_and_line_endings() {
+    assert_eq!(
+        wrap_text_with_ansi("first\nsecond\r\nthird\rfourth", 80),
+        vec!["first", "second", "third", "fourth"]
+    );
+    let red = "\u{1b}[31m";
+    let reset = "\u{1b}[0m";
+    assert_eq!(
+        wrap_text_with_ansi(&format!("{red}first\r\nsecond\rthird{reset}"), 80),
+        vec![
+            format!("{red}first"),
+            format!("{red}second"),
+            format!("{red}third{reset}"),
+        ]
+    );
+}
+
+#[test]
+fn wrap_cjk_and_color() {
+    let text = "This is an example 中文汉字测试段落内容中文汉字测试段落内容.";
+    let wrapped = wrap_text_with_ansi(text, 40);
+    assert_eq!(
+        wrapped,
+        vec![
+            "This is an example 中文汉字测试段落内容".to_owned(),
+            "中文汉字测试段落内容.".to_owned()
+        ]
+    );
+    for line in &wrapped {
+        assert!(visible_width(line) <= 40);
+    }
+
+    let red = "\u{1b}[31m";
+    let reset = "\u{1b}[0m";
+    let colored = format!("{red}{text}{reset}");
+    let wrapped = wrap_text_with_ansi(&colored, 40);
+    assert_eq!(wrapped.len(), 2);
+    assert_eq!(
+        wrapped[0],
+        format!("{red}This is an example 中文汉字测试段落内容")
+    );
+    assert_eq!(wrapped[1], format!("{red}中文汉字测试段落内容.{reset}"));
+}
+
+#[test]
+fn wrap_partial_flag_list_line() {
+    let wrapped = wrap_text_with_ansi("      - 🇨", 9);
+    assert_eq!(wrapped.len(), 2);
+    assert_eq!(visible_width(&wrapped[0]), 7);
+    assert_eq!(visible_width(&wrapped[1]), 2);
+}
+
+#[test]
+fn wrap_underline_and_background() {
+    let underline_on = "\u{1b}[4m";
+    let underline_off = "\u{1b}[24m";
+    let url = "https://example.com/very/long/path/that/will/wrap";
+    let text = format!("read this thread {underline_on}{url}{underline_off}");
+    let wrapped = wrap_text_with_ansi(&text, 40);
+    assert_eq!(wrapped[0], "read this thread");
+    assert!(wrapped[1].starts_with(underline_on));
+    assert!(wrapped[1].contains("https://"));
+
+    let bg_blue = "\u{1b}[44m";
+    let reset = "\u{1b}[0m";
+    let text = format!("{bg_blue}hello world this is blue background text{reset}");
+    let wrapped = wrap_text_with_ansi(&text, 15);
+    for line in &wrapped {
+        assert!(line.contains(bg_blue));
+    }
+    for line in wrapped.iter().take(wrapped.len().saturating_sub(1)) {
+        assert!(!line.ends_with("\u{1b}[0m"));
+    }
+}
+
+#[test]
+fn wrap_osc8_hyperlinks_st_and_bel() {
+    let url = "https://example.com";
+    let input = format!("\u{1b}]8;;{url}\u{1b}\\0123456789\u{1b}]8;;\u{1b}\\");
+    let lines = wrap_text_with_ansi(&input, 6);
+    assert!(lines.len() > 1);
+    for line in &lines {
+        let stripped = strip_escapes_for_check(line);
+        if !stripped.trim().is_empty() {
+            assert!(
+                line.contains(&format!("\u{1b}]8;;{url}\u{1b}\\")),
+                "missing OSC8 reopen: {line:?}"
+            );
+        }
+    }
+    for line in lines.iter().take(lines.len() - 1) {
+        if line.contains(&format!("\u{1b}]8;;{url}\u{1b}\\")) {
+            assert!(
+                line.ends_with("\u{1b}]8;;\u{1b}\\"),
+                "missing OSC8 close: {line:?}"
+            );
+        }
+    }
+
+    let oauth = format!("https://example.com/oauth/{}", "a".repeat(32));
+    let input = format!("\u{1b}]8;;{oauth}\u{7}{oauth}\u{1b}]8;;\u{7}");
+    let lines = wrap_text_with_ansi(&input, 20);
+    assert!(lines.len() > 1);
+    for line in &lines {
+        assert!(line.contains(&format!("\u{1b}]8;;{oauth}\u{7}")));
+        assert!(!line.contains(&format!("\u{1b}]8;;{oauth}\u{1b}\\")));
+    }
+    for line in lines.iter().take(lines.len() - 1) {
+        assert!(line.ends_with("\u{1b}]8;;\u{7}"));
+    }
+}
+
+fn strip_escapes_for_check(line: &str) -> String {
+    let mut out = String::new();
+    let mut i = 0;
+    while i < line.len() {
+        if let Some(ansi) = extract_ansi_code(line, i) {
+            i += ansi.len;
+        } else {
+            let Some(ch) = line[i..].chars().next() else {
+                break;
+            };
+            out.push(ch);
+            i += ch.len_utf8();
+        }
+    }
+    out
+}
+
+#[test]
+fn truncate_tables() {
+    let text = "🙂界".repeat(1000);
+    let truncated = truncate_to_width(&text, 40, "…", false);
+    assert!(visible_width(&truncated) <= 40);
+    assert!(truncated.ends_with("…\u{1b}[0m"));
+
+    let text = format!("\u{1b}[31m{}{}", "hello ".repeat(1000), "\u{1b}[0m");
+    let truncated = truncate_to_width(&text, 20, "…", false);
+    assert!(visible_width(&truncated) <= 20);
+    assert!(truncated.contains("\u{1b}[31m"));
+    assert!(truncated.ends_with("\u{1b}[0m…\u{1b}[0m"));
+
+    let text = format!("abc\u{1b}not-ansi {}", "🙂".repeat(100));
+    let truncated = truncate_to_width(&text, 20, "…", false);
+    assert!(visible_width(&truncated) <= 20);
+
+    assert_eq!(truncate_to_width("abcdef", 1, "🙂", false), "");
+    assert_eq!(
+        truncate_to_width("abcdef", 2, "🙂", false),
+        "\u{1b}[0m🙂\u{1b}[0m"
+    );
+    assert_eq!(truncate_to_width("a", 2, "🙂", false), "a");
+    assert_eq!(truncate_to_width("界", 2, "🙂", false), "界");
+
+    let truncated = truncate_to_width("🙂界🙂界🙂界", 8, "…", true);
+    assert_eq!(visible_width(&truncated), 8);
+
+    let truncated = truncate_to_width(&format!("\u{1b}[31m{}", "hello".repeat(100)), 10, "", false);
+    assert!(visible_width(&truncated) <= 10);
+    assert!(truncated.ends_with("\u{1b}[0m"));
+
+    let truncated = truncate_to_width("🙂\t界 \u{1b}_abc\u{7}", 7, "…", true);
+    assert_eq!(truncated, "🙂\t\u{1b}[0m…\u{1b}[0m ");
+}
+
+#[test]
+fn slice_and_segments_tabs() {
+    let text = "out 192M\t.pi/skill-tests/results-ha";
+    let slice = slice_with_width(text, 0, 10, true);
+    assert_eq!(slice.text, "out 192M");
+    assert_eq!(slice.width, 8);
+    assert_eq!(visible_width(&slice.text), slice.width);
+
+    let segments = extract_segments(text, 10, 13, 10, true);
+    assert_eq!(segments.before, "out 192M");
+    assert_eq!(segments.before_width, 8);
+    assert_eq!(visible_width(&segments.before), segments.before_width);
+
+    let tab_fits = extract_segments(text, 11, 13, 10, true);
+    assert_eq!(tab_fits.before, "out 192M\t");
+    assert_eq!(tab_fits.before_width, 11);
+    assert_eq!(visible_width(&tab_fits.before), tab_fits.before_width);
+
+    assert_eq!(slice_by_column("hello world", 6, 5, false), "world");
+}
+
+#[test]
+fn composite_line_basic() {
+    let base = "abcdefghij";
+    let overlay = "XY";
+    let out = composite_line_at(base, overlay, 3, 2, 10);
+    // before "abc" + pad0 + reset + "XY" + pad0 + reset + after + pad
+    assert!(out.contains("abc"));
+    assert!(out.contains("XY"));
+    assert!(visible_width(&out) <= 10);
+}
+
+#[test]
+fn cursor_marker_helpers() -> Result<(), String> {
+    let line = format!("hi{CURSOR_MARKER}there");
+    let (idx, col) =
+        find_cursor_marker(&line).ok_or_else(|| "cursor marker not found".to_owned())?;
+    assert_eq!(col, 2);
+    assert_eq!(idx, 2);
+    assert_eq!(strip_cursor_marker(&line), "hithere");
+    Ok(())
+}
+
+#[test]
+fn partial_fence_streaming() {
+    assert!(is_partial_closing_fence_line("``", "```"));
+    assert!(!is_partial_closing_fence_line("```", "```"));
+    let raw = "```ts\nconst x = 1;\n``";
+    let stripped = strip_trailing_partial_closing_fence(raw);
+    assert_eq!(stripped, "```ts\nconst x = 1;");
+}
+
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(64))]
+
+    #[test]
+    fn visible_width_never_panics(s in "\\PC{0,80}") {
+        let _ = visible_width(&s);
+    }
+
+    #[test]
+    fn wrap_lines_respect_width(s in "\\PC{0,60}", w in 1usize..40) {
+        for line in wrap_text_with_ansi(&s, w) {
+            let mut plain = String::new();
+            let mut i = 0;
+            while i < line.len() {
+                if let Some(ansi) = extract_ansi_code(&line, i) {
+                    i += ansi.len;
+                } else {
+                    let Some(ch) = line[i..].chars().next() else {
+                        break;
+                    };
+                    plain.push(ch);
+                    i += ch.len_utf8();
+                }
+            }
+            // A single unbreakable grapheme wider than `w` may still occupy a line
+            // (matches TS breakLongWord: it never splits a grapheme).
+            let max_g = plain
+                .graphemes(true)
+                .map(crate::text::grapheme_width)
+                .max()
+                .unwrap_or(0);
+            prop_assert!(visible_width(&plain) <= w.max(max_g));
+        }
+    }
+
+    #[test]
+    fn truncate_respects_width(s in "\\PC{0,80}", w in 1usize..40) {
+        let t = truncate_to_width(&s, w, "...", false);
+        prop_assert!(visible_width(&t) <= w);
+    }
+
+    #[test]
+    fn slice_width_consistent(
+        s in "[ -~\\t\\u{4e00}-\\u{4e10}]{0,40}",
+        start in 0usize..20,
+        len in 0usize..20
+    ) {
+        let slice = slice_with_width(&s, start, len, true);
+        prop_assert_eq!(visible_width(&slice.text), slice.width);
+        prop_assert!(slice.width <= len);
+    }
+}

package/crates/pi-tui/src/text/width.rs

@@ -0,0 +1,311 @@
+//! Grapheme / visible terminal column width.
+//!
+//! Semantics match the TypeScript `graphemeWidth` / `visibleWidth` helpers:
+//! tab = 3, regional-indicator (incl. singleton) = 2, RGI-style emoji = 2,
+//! combining / control / zero-width = 0, East-Asian wide = 2.
+
+use std::sync::{LazyLock, Mutex};
+
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
+
+use super::ansi::extract_ansi_code;
+
+/// ASCII punctuation set used by editor word navigation / break helpers.
+pub const PUNCTUATION: &str = "(){}[]<>.,;:'\"!?+-=*/\\|&%^$#@~`";
+
+const WIDTH_CACHE_SIZE: usize = 512;
+
+static WIDTH_CACHE: LazyLock<Mutex<lru_like::LruMap>> =
+    LazyLock::new(|| Mutex::new(lru_like::LruMap::new(WIDTH_CACHE_SIZE)));
+
+fn width_cache() -> &'static Mutex<lru_like::LruMap> {
+    &WIDTH_CACHE
+}
+
+/// Small insertion-order map used only as a bounded width cache.
+mod lru_like {
+    use std::collections::{HashMap, hash_map::Entry};
+
+    pub(super) struct LruMap {
+        map: HashMap<String, usize>,
+        order: Vec<String>,
+        cap: usize,
+    }
+
+    impl LruMap {
+        pub(super) fn new(cap: usize) -> Self {
+            Self {
+                map: HashMap::new(),
+                order: Vec::new(),
+                cap,
+            }
+        }
+
+        pub(super) fn get(&self, key: &str) -> Option<usize> {
+            self.map.get(key).copied()
+        }
+
+        pub(super) fn insert(&mut self, key: String, value: usize) {
+            if let Entry::Occupied(mut entry) = self.map.entry(key.clone()) {
+                entry.insert(value);
+                return;
+            }
+            if self.order.len() >= self.cap
+                && let Some(oldest) = self.order.first().cloned()
+            {
+                self.order.remove(0);
+                self.map.remove(&oldest);
+            }
+            self.map.insert(key.clone(), value);
+            self.order.push(key);
+        }
+    }
+}
+
+/// Return `true` when every character is printable ASCII (`0x20..=0x7E`).
+#[must_use]
+pub fn is_printable_ascii(s: &str) -> bool {
+    s.bytes().all(|b| (0x20..=0x7e).contains(&b))
+}
+
+/// East-Asian / terminal cell width of a single code point (non-CJK ambiguous = 1).
+#[must_use]
+pub fn east_asian_width(c: char) -> usize {
+    c.width().unwrap_or(0)
+}
+
+fn is_zero_width_char(c: char) -> bool {
+    c.width().is_none_or(|width| width == 0)
+}
+
+fn is_zero_width_segment(segment: &str) -> bool {
+    !segment.is_empty() && segment.chars().all(is_zero_width_char)
+}
+
+fn strip_leading_non_printing(segment: &str) -> &str {
+    let byte_index = segment
+        .char_indices()
+        .find_map(|(index, ch)| (!is_zero_width_char(ch)).then_some(index))
+        .unwrap_or(segment.len());
+    &segment[byte_index..]
+}
+
+/// Fast pre-filter mirroring the TS `couldBeEmoji` heuristic.
+#[must_use]
+pub fn could_be_emoji(segment: &str) -> bool {
+    let Some(cp) = segment.chars().next().map(|c| c as u32) else {
+        return false;
+    };
+    (0x1f_000..=0x1f_bff).contains(&cp)
+        || (0x2300..=0x23ff).contains(&cp)
+        || (0x2600..=0x27bf).contains(&cp)
+        || (0x2b50..=0x2b55).contains(&cp)
+        || segment.contains('\u{FE0F}')
+        || segment.chars().count() > 2
+}
+
+/// Approximate RGI emoji detection using `unicode-width` sequence rules.
+fn is_rgi_emojiish(segment: &str) -> bool {
+    if segment.width() == 2 && could_be_emoji(segment) {
+        return true;
+    }
+    // ZWJ / skin-tone / presentation sequences that some tables report as width 1
+    // still render as emoji cells in terminals pi targets.
+    segment.contains('\u{200D}')
+        || segment.contains('\u{FE0F}')
+        || segment
+            .chars()
+            .any(|c| (0x1f_3fb..=0x1f_3ff).contains(&(c as u32)))
+}
+
+/// Terminal width of a single grapheme cluster.
+#[must_use]
+pub fn grapheme_width(segment: &str) -> usize {
+    if segment == "\t" {
+        return 3;
+    }
+    if segment.is_empty() || is_zero_width_segment(segment) {
+        return 0;
+    }
+    if could_be_emoji(segment) && is_rgi_emojiish(segment) {
+        return 2;
+    }
+
+    let base = strip_leading_non_printing(segment);
+    let Some(cp) = base.chars().next() else {
+        return 0;
+    };
+    let cp_u = cp as u32;
+    if (0x1f_1e6..=0x1f_1ff).contains(&cp_u) {
+        return 2;
+    }
+
+    let mut width = east_asian_width(cp);
+    if segment.chars().count() > 1 {
+        for c in segment.chars().skip(1) {
+            let cu = c as u32;
+            if (0xff00..=0xffef).contains(&cu) {
+                width = width.saturating_add(east_asian_width(c));
+            } else if cu == 0x0e33 || cu == 0x0eb3 {
+                width = width.saturating_add(1);
+            }
+        }
+    }
+    width
+}
+
+/// Visible terminal columns of `str`, ignoring ANSI/OSC/APC and counting tabs as 3.
+#[must_use]
+pub fn visible_width(s: &str) -> usize {
+    if s.is_empty() {
+        return 0;
+    }
+    if is_printable_ascii(s) {
+        return s.len();
+    }
+    if let Ok(cache) = width_cache().lock()
+        && let Some(width) = cache.get(s)
+    {
+        return width;
+    }
+
+    let mut clean = s.to_owned();
+    if clean.contains('\t') {
+        clean = clean.replace('\t', "   ");
+    }
+    if clean.contains('\u{1b}') {
+        let mut stripped = String::with_capacity(clean.len());
+        let mut i = 0;
+        while i < clean.len() {
+            if let Some(ansi) = extract_ansi_code(&clean, i) {
+                i += ansi.len;
+                continue;
+            }
+            // Copy one UTF-8 char.
+            let ch = clean[i..].chars().next().map_or(1, char::len_utf8);
+            // SAFETY: i is a char boundary by construction.
+            stripped.push_str(&clean[i..i + ch]);
+            i += ch;
+        }
+        clean = stripped;
+    }
+
+    let mut width = 0usize;
+    for grapheme in clean.graphemes(true) {
+        width = width.saturating_add(grapheme_width(grapheme));
+    }
+
+    if let Ok(mut cache) = width_cache().lock() {
+        cache.insert(s.to_owned(), width);
+    }
+    width
+}
+
+/// Normalize text for terminal output without changing logical editor content.
+///
+/// Expands standalone tabs outside escapes to three spaces and splits Thai/Lao
+/// AM vowels so terminal cells match editor width accounting.
+#[must_use]
+pub fn normalize_terminal_output(s: &str) -> String {
+    let mut normalized = s.to_owned();
+    if normalized.contains('\u{0e33}') || normalized.contains('\u{0eb3}') {
+        let mut out = String::with_capacity(normalized.len() + 8);
+        for ch in normalized.chars() {
+            match ch {
+                '\u{0e33}' => out.push_str("\u{0e4d}\u{0e32}"),
+                '\u{0eb3}' => out.push_str("\u{0ecd}\u{0eb2}"),
+                other => out.push(other),
+            }
+        }
+        normalized = out;
+    }
+    if !normalized.contains('\t') {
+        return normalized;
+    }
+
+    let mut result = String::with_capacity(normalized.len());
+    let mut i = 0;
+    while i < normalized.len() {
+        if let Some(ansi) = extract_ansi_code(&normalized, i) {
+            result.push_str(ansi.code);
+            i += ansi.len;
+            continue;
+        }
+        let ch = normalized[i..].chars().next().map_or('\0', |c| c);
+        if ch == '\t' {
+            result.push_str("   ");
+            i += 1;
+        } else {
+            let len = ch.len_utf8();
+            result.push_str(&normalized[i..i + len]);
+            i += len;
+        }
+    }
+    result
+}
+
+/// `true` when the grapheme is a CJK break opportunity (Han/Hira/Kata/Hangul/Bopomofo).
+#[must_use]
+pub fn cjk_break_grapheme(segment: &str) -> bool {
+    let Some(c) = segment.chars().next() else {
+        return false;
+    };
+    matches!(
+        c,
+        // Bopomofo
+        '\u{3100}'..='\u{312F}'
+            | '\u{31A0}'..='\u{31BF}'
+            // Hiragana / Katakana
+            | '\u{3040}'..='\u{309F}'
+            | '\u{30A0}'..='\u{30FF}'
+            | '\u{31F0}'..='\u{31FF}'
+            | '\u{FF65}'..='\u{FF9F}'
+            // Hangul
+            | '\u{1100}'..='\u{11FF}'
+            | '\u{3130}'..='\u{318F}'
+            | '\u{A960}'..='\u{A97F}'
+            | '\u{AC00}'..='\u{D7AF}'
+            | '\u{D7B0}'..='\u{D7FF}'
+            // Han / CJK
+            | '\u{2E80}'..='\u{2EFF}'
+            | '\u{2F00}'..='\u{2FDF}'
+            | '\u{3400}'..='\u{4DBF}'
+            | '\u{4E00}'..='\u{9FFF}'
+            | '\u{F900}'..='\u{FAFF}'
+            | '\u{20000}'..='\u{2A6DF}'
+            | '\u{2A700}'..='\u{2B73F}'
+            | '\u{2B740}'..='\u{2B81F}'
+            | '\u{2B820}'..='\u{2CEAF}'
+            | '\u{2CEB0}'..='\u{2EBEF}'
+            | '\u{30000}'..='\u{3134F}'
+            | '\u{31350}'..='\u{323AF}'
+    )
+}
+
+/// Whitespace character (Unicode `White_Space`).
+#[must_use]
+pub fn is_whitespace_char(ch: &str) -> bool {
+    ch.chars().next().is_some_and(char::is_whitespace) && ch.chars().count() == 1
+}
+
+/// Punctuation character from the editor punctuation set.
+#[must_use]
+pub fn is_punctuation_char(ch: &str) -> bool {
+    ch.chars().count() == 1 && ch.chars().next().is_some_and(|c| PUNCTUATION.contains(c))
+}
+
+/// Apply a background painter to a line after padding it to `width`.
+///
+/// `bg_fn` receives the already-padded content and returns styled text.
+#[must_use]
+pub fn apply_background_to_line(
+    line: &str,
+    width: usize,
+    bg_fn: impl FnOnce(&str) -> String,
+) -> String {
+    let visible_len = visible_width(line);
+    let padding_needed = width.saturating_sub(visible_len);
+    let with_padding = format!("{line}{}", " ".repeat(padding_needed));
+    bg_fn(&with_padding)
+}