fix ya.make

6 files changed, 0 insertions, 798 deletions

diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/__init__.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/__init__.py
deleted file mode 100644
index f0c92c96f9..0000000000
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/__init__.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""
-Many places in prompt_toolkit can take either plain text, or formatted text.
-For instance the :func:`~prompt_toolkit.shortcuts.prompt` function takes either
-plain text or formatted text for the prompt. The
-:class:`~prompt_toolkit.layout.FormattedTextControl` can also take either plain
-text or formatted text.
-
-In any case, there is an input that can either be just plain text (a string),
-an :class:`.HTML` object, an :class:`.ANSI` object or a sequence of
-`(style_string, text)` tuples. The :func:`.to_formatted_text` conversion
-function takes any of these and turns all of them into such a tuple sequence.
-"""
-from .ansi import ANSI
-from .base import (
-    AnyFormattedText,
-    FormattedText,
-    StyleAndTextTuples,
-    Template,
-    is_formatted_text,
-    merge_formatted_text,
-    to_formatted_text,
-)
-from .html import HTML
-from .pygments import PygmentsTokens
-from .utils import (
-    fragment_list_len,
-    fragment_list_to_text,
-    fragment_list_width,
-    split_lines,
-    to_plain_text,
-)
-
-__all__ = [
-    # Base.
-    "AnyFormattedText",
-    "to_formatted_text",
-    "is_formatted_text",
-    "Template",
-    "merge_formatted_text",
-    "FormattedText",
-    "StyleAndTextTuples",
-    # HTML.
-    "HTML",
-    # ANSI.
-    "ANSI",
-    # Pygments.
-    "PygmentsTokens",
-    # Utils.
-    "fragment_list_len",
-    "fragment_list_width",
-    "fragment_list_to_text",
-    "split_lines",
-    "to_plain_text",
-]
diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/ansi.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/ansi.py
deleted file mode 100644
index 2a30b09c21..0000000000
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/ansi.py
+++ /dev/null
@@ -1,297 +0,0 @@
-from string import Formatter
-from typing import Generator, List, Optional, Tuple, Union
-
-from prompt_toolkit.output.vt100 import BG_ANSI_COLORS, FG_ANSI_COLORS
-from prompt_toolkit.output.vt100 import _256_colors as _256_colors_table
-
-from .base import StyleAndTextTuples
-
-__all__ = [
-    "ANSI",
-    "ansi_escape",
-]
-
-
-class ANSI:
-    """
-    ANSI formatted text.
-    Take something ANSI escaped text, for use as a formatted string. E.g.
-
-    ::
-
-        ANSI('\\x1b[31mhello \\x1b[32mworld')
-
-    Characters between ``\\001`` and ``\\002`` are supposed to have a zero width
-    when printed, but these are literally sent to the terminal output. This can
-    be used for instance, for inserting Final Term prompt commands.  They will
-    be translated into a prompt_toolkit '[ZeroWidthEscape]' fragment.
-    """
-
-    def __init__(self, value: str) -> None:
-        self.value = value
-        self._formatted_text: StyleAndTextTuples = []
-
-        # Default style attributes.
-        self._color: Optional[str] = None
-        self._bgcolor: Optional[str] = None
-        self._bold = False
-        self._underline = False
-        self._strike = False
-        self._italic = False
-        self._blink = False
-        self._reverse = False
-        self._hidden = False
-
-        # Process received text.
-        parser = self._parse_corot()
-        parser.send(None)  # type: ignore
-        for c in value:
-            parser.send(c)
-
-    def _parse_corot(self) -> Generator[None, str, None]:
-        """
-        Coroutine that parses the ANSI escape sequences.
-        """
-        style = ""
-        formatted_text = self._formatted_text
-
-        while True:
-            # NOTE: CSI is a special token within a stream of characters that
-            #       introduces an ANSI control sequence used to set the
-            #       style attributes of the following characters.
-            csi = False
-
-            c = yield
-
-            # Everything between \001 and \002 should become a ZeroWidthEscape.
-            if c == "\001":
-                escaped_text = ""
-                while c != "\002":
-                    c = yield
-                    if c == "\002":
-                        formatted_text.append(("[ZeroWidthEscape]", escaped_text))
-                        c = yield
-                        break
-                    else:
-                        escaped_text += c
-
-            # Check for CSI
-            if c == "\x1b":
-                # Start of color escape sequence.
-                square_bracket = yield
-                if square_bracket == "[":
-                    csi = True
-                else:
-                    continue
-            elif c == "\x9b":
-                csi = True
-
-            if csi:
-                # Got a CSI sequence. Color codes are following.
-                current = ""
-                params = []
-
-                while True:
-                    char = yield
-
-                    # Construct number
-                    if char.isdigit():
-                        current += char
-
-                    # Eval number
-                    else:
-                        # Limit and save number value
-                        params.append(min(int(current or 0), 9999))
-
-                        # Get delimiter token if present
-                        if char == ";":
-                            current = ""
-
-                        # Check and evaluate color codes
-                        elif char == "m":
-                            # Set attributes and token.
-                            self._select_graphic_rendition(params)
-                            style = self._create_style_string()
-                            break
-
-                        # Check and evaluate cursor forward
-                        elif char == "C":
-                            for i in range(params[0]):
-                                # add <SPACE> using current style
-                                formatted_text.append((style, " "))
-                            break
-
-                        else:
-                            # Ignore unsupported sequence.
-                            break
-            else:
-                # Add current character.
-                # NOTE: At this point, we could merge the current character
-                #       into the previous tuple if the style did not change,
-                #       however, it's not worth the effort given that it will
-                #       be "Exploded" once again when it's rendered to the
-                #       output.
-                formatted_text.append((style, c))
-
-    def _select_graphic_rendition(self, attrs: List[int]) -> None:
-        """
-        Taken a list of graphics attributes and apply changes.
-        """
-        if not attrs:
-            attrs = [0]
-        else:
-            attrs = list(attrs[::-1])
-
-        while attrs:
-            attr = attrs.pop()
-
-            if attr in _fg_colors:
-                self._color = _fg_colors[attr]
-            elif attr in _bg_colors:
-                self._bgcolor = _bg_colors[attr]
-            elif attr == 1:
-                self._bold = True
-            # elif attr == 2:
-            #   self._faint = True
-            elif attr == 3:
-                self._italic = True
-            elif attr == 4:
-                self._underline = True
-            elif attr == 5:
-                self._blink = True  # Slow blink
-            elif attr == 6:
-                self._blink = True  # Fast blink
-            elif attr == 7:
-                self._reverse = True
-            elif attr == 8:
-                self._hidden = True
-            elif attr == 9:
-                self._strike = True
-            elif attr == 22:
-                self._bold = False  # Normal intensity
-            elif attr == 23:
-                self._italic = False
-            elif attr == 24:
-                self._underline = False
-            elif attr == 25:
-                self._blink = False
-            elif attr == 27:
-                self._reverse = False
-            elif attr == 28:
-                self._hidden = False
-            elif attr == 29:
-                self._strike = False
-            elif not attr:
-                # Reset all style attributes
-                self._color = None
-                self._bgcolor = None
-                self._bold = False
-                self._underline = False
-                self._strike = False
-                self._italic = False
-                self._blink = False
-                self._reverse = False
-                self._hidden = False
-
-            elif attr in (38, 48) and len(attrs) > 1:
-                n = attrs.pop()
-
-                # 256 colors.
-                if n == 5 and len(attrs) >= 1:
-                    if attr == 38:
-                        m = attrs.pop()
-                        self._color = _256_colors.get(m)
-                    elif attr == 48:
-                        m = attrs.pop()
-                        self._bgcolor = _256_colors.get(m)
-
-                # True colors.
-                if n == 2 and len(attrs) >= 3:
-                    try:
-                        color_str = "#{:02x}{:02x}{:02x}".format(
-                            attrs.pop(),
-                            attrs.pop(),
-                            attrs.pop(),
-                        )
-                    except IndexError:
-                        pass
-                    else:
-                        if attr == 38:
-                            self._color = color_str
-                        elif attr == 48:
-                            self._bgcolor = color_str
-
-    def _create_style_string(self) -> str:
-        """
-        Turn current style flags into a string for usage in a formatted text.
-        """
-        result = []
-        if self._color:
-            result.append(self._color)
-        if self._bgcolor:
-            result.append("bg:" + self._bgcolor)
-        if self._bold:
-            result.append("bold")
-        if self._underline:
-            result.append("underline")
-        if self._strike:
-            result.append("strike")
-        if self._italic:
-            result.append("italic")
-        if self._blink:
-            result.append("blink")
-        if self._reverse:
-            result.append("reverse")
-        if self._hidden:
-            result.append("hidden")
-
-        return " ".join(result)
-
-    def __repr__(self) -> str:
-        return f"ANSI({self.value!r})"
-
-    def __pt_formatted_text__(self) -> StyleAndTextTuples:
-        return self._formatted_text
-
-    def format(self, *args: str, **kwargs: str) -> "ANSI":
-        """
-        Like `str.format`, but make sure that the arguments are properly
-        escaped. (No ANSI escapes can be injected.)
-        """
-        return ANSI(FORMATTER.vformat(self.value, args, kwargs))
-
-    def __mod__(self, value: object) -> "ANSI":
-        """
-        ANSI('<b>%s</b>') % value
-        """
-        if not isinstance(value, tuple):
-            value = (value,)
-
-        value = tuple(ansi_escape(i) for i in value)
-        return ANSI(self.value % value)
-
-
-# Mapping of the ANSI color codes to their names.
-_fg_colors = {v: k for k, v in FG_ANSI_COLORS.items()}
-_bg_colors = {v: k for k, v in BG_ANSI_COLORS.items()}
-
-# Mapping of the escape codes for 256colors to their 'ffffff' value.
-_256_colors = {}
-
-for i, (r, g, b) in enumerate(_256_colors_table.colors):
-    _256_colors[i] = f"#{r:02x}{g:02x}{b:02x}"
-
-
-def ansi_escape(text: object) -> str:
-    """
-    Replace characters with a special meaning.
-    """
-    return str(text).replace("\x1b", "?").replace("\b", "?")
-
-
-class ANSIFormatter(Formatter):
-    def format_field(self, value: object, format_spec: str) -> str:
-        return ansi_escape(format(value, format_spec))
-
-
-FORMATTER = ANSIFormatter()
diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/base.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/base.py
deleted file mode 100644
index e88c5935a5..0000000000
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/base.py
+++ /dev/null
@@ -1,176 +0,0 @@
-from typing import TYPE_CHECKING, Any, Callable, Iterable, List, Tuple, Union, cast
-
-from prompt_toolkit.mouse_events import MouseEvent
-
-if TYPE_CHECKING:
-    from typing_extensions import Protocol
-
-__all__ = [
-    "OneStyleAndTextTuple",
-    "StyleAndTextTuples",
-    "MagicFormattedText",
-    "AnyFormattedText",
-    "to_formatted_text",
-    "is_formatted_text",
-    "Template",
-    "merge_formatted_text",
-    "FormattedText",
-]
-
-OneStyleAndTextTuple = Union[
-    Tuple[str, str], Tuple[str, str, Callable[[MouseEvent], None]]
-]
-
-# List of (style, text) tuples.
-StyleAndTextTuples = List[OneStyleAndTextTuple]
-
-
-if TYPE_CHECKING:
-    from typing_extensions import TypeGuard
-
-    class MagicFormattedText(Protocol):
-        """
-        Any object that implements ``__pt_formatted_text__`` represents formatted
-        text.
-        """
-
-        def __pt_formatted_text__(self) -> StyleAndTextTuples:
-            ...
-
-
-AnyFormattedText = Union[
-    str,
-    "MagicFormattedText",
-    StyleAndTextTuples,
-    # Callable[[], 'AnyFormattedText']  # Recursive definition not supported by mypy.
-    Callable[[], Any],
-    None,
-]
-
-
-def to_formatted_text(
-    value: AnyFormattedText, style: str = "", auto_convert: bool = False
-) -> "FormattedText":
-    """
-    Convert the given value (which can be formatted text) into a list of text
-    fragments. (Which is the canonical form of formatted text.) The outcome is
-    always a `FormattedText` instance, which is a list of (style, text) tuples.
-
-    It can take a plain text string, an `HTML` or `ANSI` object, anything that
-    implements `__pt_formatted_text__` or a callable that takes no arguments and
-    returns one of those.
-
-    :param style: An additional style string which is applied to all text
-        fragments.
-    :param auto_convert: If `True`, also accept other types, and convert them
-        to a string first.
-    """
-    result: Union[FormattedText, StyleAndTextTuples]
-
-    if value is None:
-        result = []
-    elif isinstance(value, str):
-        result = [("", value)]
-    elif isinstance(value, list):
-        result = value  # StyleAndTextTuples
-    elif hasattr(value, "__pt_formatted_text__"):
-        result = cast("MagicFormattedText", value).__pt_formatted_text__()
-    elif callable(value):
-        return to_formatted_text(value(), style=style)
-    elif auto_convert:
-        result = [("", f"{value}")]
-    else:
-        raise ValueError(
-            "No formatted text. Expecting a unicode object, "
-            "HTML, ANSI or a FormattedText instance. Got %r" % (value,)
-        )
-
-    # Apply extra style.
-    if style:
-        result = cast(
-            StyleAndTextTuples,
-            [(style + " " + item_style, *rest) for item_style, *rest in result],
-        )
-
-    # Make sure the result is wrapped in a `FormattedText`. Among other
-    # reasons, this is important for `print_formatted_text` to work correctly
-    # and distinguish between lists and formatted text.
-    if isinstance(result, FormattedText):
-        return result
-    else:
-        return FormattedText(result)
-
-
-def is_formatted_text(value: object) -> "TypeGuard[AnyFormattedText]":
-    """
-    Check whether the input is valid formatted text (for use in assert
-    statements).
-    In case of a callable, it doesn't check the return type.
-    """
-    if callable(value):
-        return True
-    if isinstance(value, (str, list)):
-        return True
-    if hasattr(value, "__pt_formatted_text__"):
-        return True
-    return False
-
-
-class FormattedText(StyleAndTextTuples):
-    """
-    A list of ``(style, text)`` tuples.
-
-    (In some situations, this can also be ``(style, text, mouse_handler)``
-    tuples.)
-    """
-
-    def __pt_formatted_text__(self) -> StyleAndTextTuples:
-        return self
-
-    def __repr__(self) -> str:
-        return "FormattedText(%s)" % super().__repr__()
-
-
-class Template:
-    """
-    Template for string interpolation with formatted text.
-
-    Example::
-
-        Template(' ... {} ... ').format(HTML(...))
-
-    :param text: Plain text.
-    """
-
-    def __init__(self, text: str) -> None:
-        assert "{0}" not in text
-        self.text = text
-
-    def format(self, *values: AnyFormattedText) -> AnyFormattedText:
-        def get_result() -> AnyFormattedText:
-            # Split the template in parts.
-            parts = self.text.split("{}")
-            assert len(parts) - 1 == len(values)
-
-            result = FormattedText()
-            for part, val in zip(parts, values):
-                result.append(("", part))
-                result.extend(to_formatted_text(val))
-            result.append(("", parts[-1]))
-            return result
-
-        return get_result
-
-
-def merge_formatted_text(items: Iterable[AnyFormattedText]) -> AnyFormattedText:
-    """
-    Merge (Concatenate) several pieces of formatted text together.
-    """
-
-    def _merge_formatted_text() -> AnyFormattedText:
-        result = FormattedText()
-        for i in items:
-            result.extend(to_formatted_text(i))
-        return result
-
-    return _merge_formatted_text
diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/html.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/html.py
deleted file mode 100644
index 0af2b18b57..0000000000
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/html.py
+++ /dev/null
@@ -1,143 +0,0 @@
-import xml.dom.minidom as minidom
-from string import Formatter
-from typing import Any, List, Tuple, Union
-
-from .base import FormattedText, StyleAndTextTuples
-
-__all__ = ["HTML"]
-
-
-class HTML:
-    """
-    HTML formatted text.
-    Take something HTML-like, for use as a formatted string.
-
-    ::
-
-        # Turn something into red.
-        HTML('<style fg="ansired" bg="#00ff44">...</style>')
-
-        # Italic, bold, underline and strike.
-        HTML('<i>...</i>')
-        HTML('<b>...</b>')
-        HTML('<u>...</u>')
-        HTML('<s>...</s>')
-
-    All HTML elements become available as a "class" in the style sheet.
-    E.g. ``<username>...</username>`` can be styled, by setting a style for
-    ``username``.
-    """
-
-    def __init__(self, value: str) -> None:
-        self.value = value
-        document = minidom.parseString(f"<html-root>{value}</html-root>")
-
-        result: StyleAndTextTuples = []
-        name_stack: List[str] = []
-        fg_stack: List[str] = []
-        bg_stack: List[str] = []
-
-        def get_current_style() -> str:
-            "Build style string for current node."
-            parts = []
-            if name_stack:
-                parts.append("class:" + ",".join(name_stack))
-
-            if fg_stack:
-                parts.append("fg:" + fg_stack[-1])
-            if bg_stack:
-                parts.append("bg:" + bg_stack[-1])
-            return " ".join(parts)
-
-        def process_node(node: Any) -> None:
-            "Process node recursively."
-            for child in node.childNodes:
-                if child.nodeType == child.TEXT_NODE:
-                    result.append((get_current_style(), child.data))
-                else:
-                    add_to_name_stack = child.nodeName not in (
-                        "#document",
-                        "html-root",
-                        "style",
-                    )
-                    fg = bg = ""
-
-                    for k, v in child.attributes.items():
-                        if k == "fg":
-                            fg = v
-                        if k == "bg":
-                            bg = v
-                        if k == "color":
-                            fg = v  # Alias for 'fg'.
-
-                    # Check for spaces in attributes. This would result in
-                    # invalid style strings otherwise.
-                    if " " in fg:
-                        raise ValueError('"fg" attribute contains a space.')
-                    if " " in bg:
-                        raise ValueError('"bg" attribute contains a space.')
-
-                    if add_to_name_stack:
-                        name_stack.append(child.nodeName)
-                    if fg:
-                        fg_stack.append(fg)
-                    if bg:
-                        bg_stack.append(bg)
-
-                    process_node(child)
-
-                    if add_to_name_stack:
-                        name_stack.pop()
-                    if fg:
-                        fg_stack.pop()
-                    if bg:
-                        bg_stack.pop()
-
-        process_node(document)
-
-        self.formatted_text = FormattedText(result)
-
-    def __repr__(self) -> str:
-        return f"HTML({self.value!r})"
-
-    def __pt_formatted_text__(self) -> StyleAndTextTuples:
-        return self.formatted_text
-
-    def format(self, *args: object, **kwargs: object) -> "HTML":
-        """
-        Like `str.format`, but make sure that the arguments are properly
-        escaped.
-        """
-        return HTML(FORMATTER.vformat(self.value, args, kwargs))
-
-    def __mod__(self, value: object) -> "HTML":
-        """
-        HTML('<b>%s</b>') % value
-        """
-        if not isinstance(value, tuple):
-            value = (value,)
-
-        value = tuple(html_escape(i) for i in value)
-        return HTML(self.value % value)
-
-
-class HTMLFormatter(Formatter):
-    def format_field(self, value: object, format_spec: str) -> str:
-        return html_escape(format(value, format_spec))
-
-
-def html_escape(text: object) -> str:
-    # The string interpolation functions also take integers and other types.
-    # Convert to string first.
-    if not isinstance(text, str):
-        text = f"{text}"
-
-    return (
-        text.replace("&", "&amp;")
-        .replace("<", "&lt;")
-        .replace(">", "&gt;")
-        .replace('"', "&quot;")
-    )
-
-
-FORMATTER = HTMLFormatter()
diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/pygments.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/pygments.py
deleted file mode 100644
index dd16f0efbe..0000000000
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/pygments.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from typing import TYPE_CHECKING, List, Tuple
-
-from prompt_toolkit.styles.pygments import pygments_token_to_classname
-
-from .base import StyleAndTextTuples
-
-if TYPE_CHECKING:
-    from pygments.token import Token
-
-__all__ = [
-    "PygmentsTokens",
-]
-
-
-class PygmentsTokens:
-    """
-    Turn a pygments token list into a list of prompt_toolkit text fragments
-    (``(style_str, text)`` tuples).
-    """
-
-    def __init__(self, token_list: List[Tuple["Token", str]]) -> None:
-        self.token_list = token_list
-
-    def __pt_formatted_text__(self) -> StyleAndTextTuples:
-        result: StyleAndTextTuples = []
-
-        for token, text in self.token_list:
-            result.append(("class:" + pygments_token_to_classname(token), text))
-
-        return result
diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/utils.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/utils.py
deleted file mode 100644
index cda4233e06..0000000000
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/formatted_text/utils.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""
-Utilities for manipulating formatted text.
-
-When ``to_formatted_text`` has been called, we get a list of ``(style, text)``
-tuples. This file contains functions for manipulating such a list.
-"""
-from typing import Iterable, cast
-
-from prompt_toolkit.utils import get_cwidth
-
-from .base import (
-    AnyFormattedText,
-    OneStyleAndTextTuple,
-    StyleAndTextTuples,
-    to_formatted_text,
-)
-
-__all__ = [
-    "to_plain_text",
-    "fragment_list_len",
-    "fragment_list_width",
-    "fragment_list_to_text",
-    "split_lines",
-]
-
-
-def to_plain_text(value: AnyFormattedText) -> str:
-    """
-    Turn any kind of formatted text back into plain text.
-    """
-    return fragment_list_to_text(to_formatted_text(value))
-
-
-def fragment_list_len(fragments: StyleAndTextTuples) -> int:
-    """
-    Return the amount of characters in this text fragment list.
-
-    :param fragments: List of ``(style_str, text)`` or
-        ``(style_str, text, mouse_handler)`` tuples.
-    """
-    ZeroWidthEscape = "[ZeroWidthEscape]"
-    return sum(len(item[1]) for item in fragments if ZeroWidthEscape not in item[0])
-
-
-def fragment_list_width(fragments: StyleAndTextTuples) -> int:
-    """
-    Return the character width of this text fragment list.
-    (Take double width characters into account.)
-
-    :param fragments: List of ``(style_str, text)`` or
-        ``(style_str, text, mouse_handler)`` tuples.
-    """
-    ZeroWidthEscape = "[ZeroWidthEscape]"
-    return sum(
-        get_cwidth(c)
-        for item in fragments
-        for c in item[1]
-        if ZeroWidthEscape not in item[0]
-    )
-
-
-def fragment_list_to_text(fragments: StyleAndTextTuples) -> str:
-    """
-    Concatenate all the text parts again.
-
-    :param fragments: List of ``(style_str, text)`` or
-        ``(style_str, text, mouse_handler)`` tuples.
-    """
-    ZeroWidthEscape = "[ZeroWidthEscape]"
-    return "".join(item[1] for item in fragments if ZeroWidthEscape not in item[0])
-
-
-def split_lines(fragments: StyleAndTextTuples) -> Iterable[StyleAndTextTuples]:
-    """
-    Take a single list of (style_str, text) tuples and yield one such list for each
-    line. Just like str.split, this will yield at least one item.
-
-    :param fragments: List of (style_str, text) or (style_str, text, mouse_handler)
-                      tuples.
-    """
-    line: StyleAndTextTuples = []
-
-    for style, string, *mouse_handler in fragments:
-        parts = string.split("\n")
-
-        for part in parts[:-1]:
-            if part:
-                line.append(cast(OneStyleAndTextTuple, (style, part, *mouse_handler)))
-            yield line
-            line = []
-
-        line.append(cast(OneStyleAndTextTuple, (style, parts[-1], *mouse_handler)))
-
-    # Always yield the last line, even when this is an empty line. This ensures
-    # that when `fragments` ends with a newline character, an additional empty
-    # line is yielded. (Otherwise, there's no way to differentiate between the
-    # cases where `fragments` does and doesn't end with a newline.)
-    yield line