pyglet 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

pyglet/text/layout/base.py

@@ -33,6 +33,7 @@ from pyglet.gl import (
 )
 from pyglet.graphics import Group
 from pyglet.text import runlist
+from pyglet.font.base import GlyphPosition
 
 if TYPE_CHECKING:
     from pyglet.customtypes import AnchorX, AnchorY, ContentVAlign, HorizontalAlign
@@ -102,7 +103,7 @@ layout_fragment_source = """#version 330 core
 
     void main()
     {
-        final_colors = vec4(text_colors.rgb, texture(text, texture_coords).a * text_colors.a);
+        final_colors = texture(text, texture_coords) * text_colors;
         if (scissor == true) {
             if (vert_position.x < scissor_area[0]) discard;                     // left
             if (vert_position.y < scissor_area[1]) discard;                     // bottom
@@ -410,25 +411,26 @@ class _AbstractBox(ABC):
 class _GlyphBox(_AbstractBox):
     owner: Texture
     font: Font
-    glyphs: list[tuple[int, Glyph]]
+    glyphs: list[tuple[int, Glyph, GlyphPosition]]
     advance: int
     vertex_lists: list[_LayoutVertexList]
 
-    def __init__(self, owner: Texture, font: Font, glyphs: list[tuple[int, Glyph]], advance: int) -> None:
+    def __init__(self, owner: Texture, font: Font, glyphs: list[tuple[int, Glyph, GlyphPosition]], advance: int) -> None:
         """Create a run of glyphs sharing the same texture.
 
-        :Parameters:
-            `owner` : `pyglet.image.Texture`
+        Args:
+            owner:
                 Texture of all glyphs in this run.
-            `font` : `pyglet.font.base.Font`
+            font:
                 Font of all glyphs in this run.
-            `glyphs` : list of (int, `pyglet.font.base.Glyph`)
+            glyphs:
                 Pairs of ``(kern, glyph)``, where ``kern`` gives horizontal
                 displacement of the glyph in pixels (typically 0).
-            `advance` : int
+            advance:
                 Width of glyph run; must correspond to the sum of advances
                 and kerns in the glyph list.
-
+            offsets:
+                A list of all position transformations done to each glyph.
         """
         super().__init__(font.ascent, font.descent, advance, len(glyphs))
         assert owner
@@ -446,7 +448,7 @@ class _GlyphBox(_AbstractBox):
               rotation: float, visible: bool, anchor_x: float, anchor_y: float, context: _LayoutContext) -> None:
         # Creates the initial attributes and vertex lists of the glyphs.
         # line_x/line_y are calculated when lines shift. To prevent having to destroy and recalculate the layout
-        # everytime we move this layout, we bake those into the vertices. This way the translate can be moved directly.
+        # everytime it moves, they are merged into the vertices. This way the translation can be moved directly.
         assert self.glyphs
         assert not self.vertex_lists
         try:
@@ -463,17 +465,19 @@ class _GlyphBox(_AbstractBox):
         for start, end, baseline_ in context.baseline_iter.ranges(i, i + n_glyphs):
             baseline = layout._parse_distance(baseline_)  # noqa: SLF001
             assert len(self.glyphs[start - i:end - i]) == end - start
-            for kern, glyph in self.glyphs[start - i:end - i]:
+            for (kern, glyph, glyph_pos) in self.glyphs[start - i:end - i]:
                 x1 += kern
                 v0, v1, v2, v3 = glyph.vertices
-                v0 += x1
-                v2 += x1
-                v1 += line_y + baseline
-                v3 += line_y + baseline
+                v0 += x1 + glyph_pos.x_offset
+                v2 += x1 + glyph_pos.x_offset
+                v1 += line_y + baseline + glyph_pos.y_offset
+                v3 += line_y + baseline + glyph_pos.y_offset
                 vertices.extend(map(round, [v0, v1, 0, v2, v1, 0, v2, v3, 0, v0, v3, 0]))
                 t = glyph.tex_coords
                 tex_coords.extend(t)
-                x1 += glyph.advance
+                x1 += glyph.advance + glyph_pos.x_advance
+                v1 += glyph_pos.y_advance
+                v3 += glyph_pos.y_advance
 
         # Text color
         colors = []
@@ -519,8 +523,8 @@ class _GlyphBox(_AbstractBox):
         for start, end, decoration in context.decoration_iter.ranges(i, i + n_glyphs):
             bg, underline = decoration
             x2 = x1
-            for kern, glyph in self.glyphs[start - i:end - i]:
-                x2 += glyph.advance + kern
+            for (kern, glyph, glyph_pos) in self.glyphs[start - i:end - i]:
+                x2 += glyph.advance + kern + glyph_pos.x_advance
 
             if bg is not None:
                 if len(bg) != 4:
@@ -619,19 +623,19 @@ class _GlyphBox(_AbstractBox):
 
     def get_point_in_box(self, position: int) -> int:
         x = 0
-        for (kern, glyph) in self.glyphs:
+        for (kern, glyph, offset) in self.glyphs:
             if position == 0:
                 break
             position -= 1
-            x += glyph.advance + kern
+            x += glyph.advance + kern + offset.x_advance
         return x
 
     def get_position_in_box(self, x: float) -> int:
         position = 0
         last_glyph_x = 0
-        for kern, glyph in self.glyphs:
+        for (kern, glyph, offset) in self.glyphs:
             last_glyph_x += kern
-            if last_glyph_x + glyph.advance // 2 > x:
+            if last_glyph_x + glyph.advance + offset.x_advance // 2 > x:
                 return position
             position += 1
             last_glyph_x += glyph.advance
@@ -813,6 +817,9 @@ class TextDecorationGroup(Group):
         self.program.stop()
 
 
+# Just have one object for empty positions in layout. It won't be modified.
+_empty_pos = GlyphPosition(0, 0, 0, 0)
+
 class TextLayout:
     """Lay out and display documents.
 
@@ -978,11 +985,6 @@ class TextLayout:
         self.group_cache.clear()
         self._update()
 
-    @property
-    def dpi(self) -> float:
-        """Get DPI used by this layout."""
-        return self._dpi
-
     @property
     def document(self) -> AbstractDocument:
         """Document to display.
@@ -1370,17 +1372,12 @@ class TextLayout:
         self._update()
 
     @property
-    def dpi(self):
-        """Get DPI used by this layout.
-
-            Read-only.
-
-            :type: float
-        """
+    def dpi(self) -> float:
+        """Get DPI used by this layout."""
         return self._dpi
 
     @dpi.setter
-    def dpi(self, value):
+    def dpi(self, value: float) -> None:
         self._dpi = value
         self._update()
 
@@ -1438,9 +1435,10 @@ class TextLayout:
 
     def _get_lines(self) -> list[_Line]:
         len_text = len(self._document.text)
-        glyphs = self._get_glyphs()
-        owner_runs = self._get_owner_runs(glyphs)
-        lines = [line for line in self._flow_glyphs(glyphs, owner_runs, 0, len_text)]
+        glyphs, offsets = self._get_glyphs()
+        owner_runs = runlist.RunList(len_text, None)
+        self._get_owner_runs(owner_runs, glyphs, 0, len_text)
+        lines = list(self._flow_glyphs(glyphs, offsets, owner_runs, 0, len_text))
         self._content_width = 0
         self._line_count = len(lines)
         self._flow_lines(lines, 0, self._line_count)
@@ -1620,8 +1618,9 @@ class TextLayout:
         else:
             self._init_document()
 
-    def _get_glyphs(self) -> list[_InlineElementBox | Glyph]:
+    def _get_glyphs(self) -> tuple[list[_InlineElementBox | Glyph], list[tuple[int, int]]]:
         glyphs = []
+        offsets = []
         runs = runlist.ZipRunIterator((
             self._document.get_font_runs(dpi=self._dpi),
             self._document.get_element_runs()))
@@ -1629,28 +1628,33 @@ class TextLayout:
         for start, end, (font, element) in runs.ranges(0, len(text)):
             if element:
                 glyphs.append(_InlineElementBox(element))
+                offsets.append(_empty_pos)
             else:
-                glyphs.extend(font.get_glyphs(text[start:end]))
-        return glyphs
+                char_glyphs, char_offsets = font.get_glyphs(text[start:end])
+                glyphs.extend(char_glyphs)
+                offsets.extend(char_offsets)
+
+        return glyphs, offsets
 
-    def _get_owner_runs(self, glyphs: list[_InlineElementBox | Glyph]) -> runlist.RunList:
-        owner = glyphs[0].owner
-        run_start = 0
-        owner_runs = runlist.RunList(0, owner)
+    def _get_owner_runs(self, owner_runs: runlist.RunList, glyphs: list[_InlineElementBox | Glyph], start: int,
+                        end: int) -> None:
+        owner = glyphs[start].owner
+        run_start = start
 
-        for i, glyph in enumerate(glyphs):
+        # TODO avoid glyph slice on non-incremental
+        for i, glyph in enumerate(glyphs[start:end]):
             if owner != glyph.owner:
-                owner_runs.append_run(i-run_start, owner)
+                owner_runs.set_run(run_start, i + start, owner)
                 owner = glyph.owner
-                run_start = i
-        owner_runs.append_run(len(glyphs)-run_start, owner)
-        return owner_runs
+                run_start = i + start
+        owner_runs.set_run(run_start, end, owner)
 
-    def _flow_glyphs_wrap(self, glyphs: list[_InlineElementBox | Glyph], owner_runs: runlist.RunList, start: int,
+    def _flow_glyphs_wrap(self, glyphs: list[_InlineElementBox | Glyph],
+                          offsets: list[GlyphPosition],
+                          owner_runs: runlist.RunList, start: int,
                           end: int) -> Iterator[_Line]:
         # Word-wrap styled text into lines of fixed width.
         # Fits glyphs in range start to end into Lines which are then yielded.
-
         owner_iterator = owner_runs.get_run_iterator().ranges(start, end)
 
         font_iterator = self._document.get_font_runs(dpi=self._dpi)
@@ -1721,7 +1725,7 @@ class TextLayout:
             # Iterate over glyphs in this owner run.  `text` is the
             # corresponding character data for the glyph, and is used to find
             # whitespace and newlines.
-            for (text, glyph) in zip(self.document.text[start:end], glyphs[start:end]):
+            for (text, glyph, offset) in zip(self.document.text[start:end], glyphs[start:end], offsets[start:end]):
                 if nokern:
                     kern = 0
                     nokern = False
@@ -1747,15 +1751,15 @@ class TextLayout:
                             tab_stop = (((x + line.margin_left) // tab) + 1) * tab
                         kern = int(tab_stop - x - line.margin_left - glyph.advance)
 
-                    owner_accum.append((kern, glyph))
+                    owner_accum.append((kern, glyph, offset))
                     owner_accum_commit.extend(owner_accum)
-                    owner_accum_commit_width += owner_accum_width + glyph.advance + kern
-                    eol_ws += glyph.advance + kern
+                    owner_accum_commit_width += owner_accum_width + glyph.advance + kern + offset.x_advance
+                    eol_ws += glyph.advance + kern + offset.x_advance
 
                     owner_accum = []
                     owner_accum_width = 0
 
-                    x += glyph.advance + kern
+                    x += glyph.advance + kern + offset.x_advance
                     index += 1
 
                     # The index at which the next line will begin (the
@@ -1765,7 +1769,7 @@ class TextLayout:
                 else:
                     new_paragraph = text in "\n\u2029"
                     new_line = (text == "\u2028") or new_paragraph
-                    if (wrap and self._wrap_lines and x + kern + glyph.advance >= width) or new_line:
+                    if (wrap and self._wrap_lines and x + kern + glyph.advance + offset.x_advance >= width) or new_line:
                         # Either the pending runs have overflowed the allowed
                         # line width or a newline was encountered.  Either
                         # way, the current line must be flushed.
@@ -1827,11 +1831,11 @@ class TextLayout:
                             # Remove kern from first glyph of line
                             if run_accum and hasattr(run_accum, "glyphs") and run_accum.glyphs:
                                 k, g = run_accum[0].glyphs[0]
-                                run_accum[0].glyphs[0] = (0, g)
+                                run_accum[0].glyphs[0] = (0, g, _empty_pos)
                                 run_accum_width -= k
                             elif owner_accum:
-                                k, g = owner_accum[0]
-                                owner_accum[0] = (0, g)
+                                k, g, _ = owner_accum[0]
+                                owner_accum[0] = (0, g, _empty_pos)
                                 owner_accum_width -= k
                             else:
                                 nokern = True
@@ -1843,8 +1847,8 @@ class TextLayout:
                     if isinstance(glyph, _AbstractBox):
                         # Glyph is already in a box. XXX Ignore kern?
                         run_accum.append(glyph)
-                        run_accum_width += glyph.advance
-                        x += glyph.advance
+                        run_accum_width += glyph.advance + offset.x_advance
+                        x += glyph.advance + offset.x_advance
                     elif new_paragraph:
                         # New paragraph started, update wrap style
                         wrap = wrap_iterator[next_start]
@@ -1854,9 +1858,9 @@ class TextLayout:
                     elif not new_line:
                         # If the glyph was any non-whitespace, non-newline
                         # character, add it to the pending run.
-                        owner_accum.append((kern, glyph))
-                        owner_accum_width += glyph.advance + kern
-                        x += glyph.advance + kern
+                        owner_accum.append((kern, glyph, offset))
+                        owner_accum_width += glyph.advance + kern + offset.x_advance
+                        x += glyph.advance + kern + offset.x_advance
                     index += 1
                     eol_ws = 0
 
@@ -1882,7 +1886,9 @@ class TextLayout:
 
         yield line
 
-    def _flow_glyphs_single_line(self, glyphs: list[_InlineElementBox | Glyph], owner_runs: runlist.RunList,
+    def _flow_glyphs_single_line(self, glyphs: list[_InlineElementBox | Glyph],
+                                 offsets: list[GlyphPosition],
+                                 owner_runs: runlist.RunList,
                                  start: int, end: int) -> Iterator[_Line]:
         owner_iterator = owner_runs.get_run_iterator().ranges(start, end)
         font_iterator = self.document.get_font_runs(dpi=self._dpi)
@@ -1905,9 +1911,11 @@ class TextLayout:
             owner_glyphs = []
             for kern_start, kern_end, kern in kern_iterator.ranges(start, end):
                 gs = glyphs[kern_start:kern_end]
+                os = offsets[kern_start:kern_end]
                 width += sum([g.advance for g in gs])
                 width += kern * (kern_end - kern_start)
-                owner_glyphs.extend(zip([kern] * (kern_end - kern_start), gs))
+                width += sum([o.x_advance for o in os])
+                owner_glyphs.extend(zip([kern] * (kern_end - kern_start), gs, os))
             if owner is None:
                 # Assume glyphs are already boxes.
                 for kern, glyph in owner_glyphs:

pyglet/text/layout/incremental.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 import sys
 from typing import TYPE_CHECKING, Any, ClassVar
 
+import unicodedata
+
 from pyglet.event import EventDispatcher
-from pyglet.font.base import grapheme_break
+from pyglet.font.base import grapheme_break, GlyphPosition
 from pyglet.text import runlist
 from pyglet.text.layout.base import (
     TextLayout,
@@ -118,6 +120,9 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         #: :meta private:
         self.glyphs = []
 
+        #: :meta private:
+        self.offsets = []
+
         #: :meta private:
         # All lines in the document, including those hidden from view.
         self.lines = []
@@ -163,6 +168,7 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
     def on_insert_text(self, start: int, text: str) -> None:
         len_text = len(text)
         self.glyphs[start:start] = [None] * len_text
+        self.offsets[start:start] = [GlyphPosition(0, 0, 0, 0)] * len_text
 
         self._invalid_glyphs.insert(start, len_text)
 
@@ -186,6 +192,7 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
 
     def on_delete_text(self, start: int, end: int) -> None:
         self.glyphs[start:end] = []
+        self.offsets[start:end] = []
 
         # Same requirement as on_insert_text
         if self._multiline and self._content_valign != "top":
@@ -240,6 +247,7 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
             self.lines[0].descent = font.descent
             self.lines[0].paragraph_begin = self.lines[0].paragraph_end = True
             self._invalid_lines.invalidate(0, 1)
+            self.offsets.clear()
 
         self._update_glyphs()
         self._update_flow_glyphs()
@@ -265,16 +273,25 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         if invalid_end - invalid_start <= 0:
             return
 
+
         # Find grapheme breaks and extend glyph range to encompass.
         text = self.document.text
         while invalid_start > 0:
-            if grapheme_break(text[invalid_start - 1], text[invalid_start]):
+            left = text[invalid_start - 1]
+            right = text[invalid_start]
+            right_cc = unicodedata.category(right)
+            left_cc = unicodedata.category(left)
+            if grapheme_break(left, left_cc, right, right_cc):
                 break
             invalid_start -= 1
 
         len_text = len(text)
         while invalid_end < len_text:
-            if grapheme_break(text[invalid_end - 1], text[invalid_end]):
+            left = text[invalid_end - 1]
+            right = text[invalid_end]
+            right_cc = unicodedata.category(right)
+            left_cc = unicodedata.category(left)
+            if grapheme_break(left, left_cc, right, right_cc):
                 break
             invalid_end += 1
 
@@ -285,13 +302,15 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         for start, end, (font, element) in runs.ranges(invalid_start, invalid_end):
             if element:
                 self.glyphs[start] = _InlineElementBox(element)
+                self.offsets[start] = GlyphPosition(0, 0, 0, 0)
             else:
                 text = self.document.text[start:end]
-                self.glyphs[start:end] = font.get_glyphs(text)
+                glyphs, offsets = font.get_glyphs(text)
+                self.glyphs[start:end] = glyphs
+                self.offsets[start:end] = offsets
 
         # Update owner runs
-        owner_runs = self._get_owner_runs(self.glyphs[invalid_start:invalid_end])
-        self._owner_runs.set_runs(invalid_start, invalid_end, owner_runs)
+        self._get_owner_runs(self._owner_runs, self.glyphs, invalid_start, invalid_end)
 
         # Updated glyphs need flowing
         self._invalid_flow.invalidate(invalid_start, invalid_end)
@@ -334,7 +353,7 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         content_width_invalid = False
         next_start = invalid_start
 
-        for line in self._flow_glyphs(self.glyphs, self._owner_runs, invalid_start, len(self._document.text)):
+        for line in self._flow_glyphs(self.glyphs, self.offsets, self._owner_runs, invalid_start, len(self._document.text)):
             try:
                 old_line = self.lines[line_index]
                 old_line.delete(self)
@@ -444,6 +463,7 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         self._anchor_left = self._get_left_anchor()
         self._anchor_bottom = self._get_bottom_anchor()
         top_anchor = self._get_top_anchor()
+        group_ct = len(self.group_cache)
 
         for line in lines:
             line.delete(self)
@@ -462,6 +482,10 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         if update_view_translation:
             self._update_view_translation()
 
+        # Update groups with scissor areas if any groups were changed.
+        if group_ct != len(self.group_cache):
+            self._update_scissor_area()
+
     @property
     def x(self) -> float:
         return self._x
@@ -478,6 +502,8 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
     @y.setter
     def y(self, y: float) -> None:
         super()._set_y(y)
+        # Invalidate vertices, as the vertices will have changed.
+        self._invalid_vertex_lines.invalidate(0, len(self.document.text))
         self._update_scissor_area()
 
     @property
@@ -495,7 +521,11 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
 
     @position.setter
     def position(self, position: tuple[float, float, float]) -> None:
+        old_y = self._y
         super()._set_position(position)
+        # Invalidate the lines if the Y changed.
+        if self._y != old_y:
+            self._invalid_vertex_lines.invalidate(0, len(self.document.text))
         self._update_view_translation()
         self._update_scissor_area()
 
@@ -544,8 +574,8 @@ class IncrementalTextLayout(TextLayout, EventDispatcher):
         if height == self._height:
             return
         self._height = height
+        self._update_visible_lines()
         if self._update_enabled:
-            self._update_visible_lines()
             self._update_vertex_lists()
 
     @property

pyglet/text/layout/scrolling.py

@@ -123,7 +123,7 @@ class ScrollableTextLayout(TextLayout):
     _translate_x: int = 0
     _translate_y: int = 0
 
-    def __init__(self, document: AbstractDocument,
+    def __init__(self, document: AbstractDocument,  # noqa: D107
                  x: float = 0, y: float = 0, z: float = 0,
                  width: int = None, height: int = None,
                  anchor_x: AnchorX = 'left', anchor_y: AnchorY = 'bottom', rotation: float = 0, multiline: bool = False,

pyglet/text/runlist.py

@@ -5,6 +5,7 @@ from typing import Any, Callable, Generator, Iterable, Iterator
 
 
 class _Run:
+    __slots__ = ('count', 'value')
     def __init__(self, value: Any, count: int) -> None:
         self.value = value
         self.count = count
@@ -33,6 +34,7 @@ class RunList:
     ``set_run(2, 5, 'x')`` would change the sequence to ``aaxxxbccccc``.
     """
     runs: list[_Run]
+    __slots__ = ['runs']
 
     def __init__(self, size: int, initial: Any) -> None:
         """Create a run list of the given size and a default value.
@@ -64,7 +66,6 @@ class RunList:
         for run in self.runs:
             if i <= pos <= i + run.count:
                 run.count += length
-                break
             i += run.count
 
     def delete(self, start: int, end: int) -> None:
@@ -156,60 +157,6 @@ class RunList:
         # Delete collapsed runs
         self.runs = [r for r in self.runs if r.count > 0]
 
-    def append(self, length: int):
-        """Append characters into end of the run list.
-
-        The appended characters will take on the value immediately preceding
-        the end of run list.
-
-        Args:
-            length:
-                Number of characters to insert.
-
-        """
-        self.runs[-1].count += length
-
-    def append_run(self, count: int, value: Any) -> None:
-        """
-        Append a run to the end of the run list.
-
-        Args:
-            count:
-                Number of characters to append.
-            value:
-                Value to append.
-        """
-        if self.runs[-1].value == value:
-            self.runs[-1].count += count
-            return
-        self.runs.append(_Run(value, count))
-
-    def insert_run(self, pos: int, length: int, value: Any) -> None:
-        """
-        Insert a run into the run list.
-
-        Args:
-            pos:
-                Position to insert run.
-            length:
-                Number of characters to insert.
-            value:
-                Value to insert.
-        """
-        i = 0
-        for run_i, run in enumerate(self.runs):
-            if i <= pos <= i + run.count:
-                if run.value == value:
-                    run.count += length
-                else:
-                    self.runs.insert(run_i + 1, _Run(value, length))
-                    self.runs.insert(run_i + 2, _Run(run.value, run.count - (pos - i)))
-                    run.count = pos - i
-                    # Delete collapsed runs
-                    self.runs[run_i: run_i+2] = [r for r in self.runs[run_i: run_i+2] if r.count > 0]
-                break
-            i += run.count
-
     def __iter__(self) -> Generator[tuple[int, int, Any], Any, None]:
         i = 0
         for run in self.runs:
@@ -240,65 +187,6 @@ class RunList:
 
         raise IndexError
 
-    def set_runs(self, start: int, end: int, runs: RunList) -> None:
-        """Set a range of runs.
-
-        Args:
-            start:
-                Start index of range.
-            end:
-                End index of range, exclusive.
-            runs:
-                Runs to set.
-        """
-        if end - start <= 0:
-            return
-
-        # Find runs that need to be split
-        i = 0
-        start_i = None
-        start_trim = 0
-        end_i = None
-        end_trim = 0
-        for run_i, run in enumerate(self.runs):
-            count = run.count
-            if i < start < i + count:
-                start_i = run_i
-                start_trim = start - i
-            if i < end < i + count:
-                end_i = run_i
-                end_trim = end - i
-            i += count
-
-        # Split runs
-        if start_i is not None:
-            run = self.runs[start_i]
-            self.runs.insert(start_i, _Run(run.value, start_trim))
-            run.count -= start_trim
-            if end_i is not None:
-                if end_i == start_i:
-                    end_trim -= start_trim
-                end_i += 1
-            start_i += 1
-        if end_i is not None:
-            run = self.runs[end_i]
-            self.runs.insert(end_i, _Run(run.value, end_trim))
-            run.count -= end_trim
-            end_i += 1
-
-        self.runs[start_i: end_i] = runs.runs
-
-        # Merge adjacent runs
-        last_run = self.runs[0]
-        for run in self.runs[1:]:
-            if run.value == last_run.value:
-                run.count += last_run.count
-                last_run.count = 0
-            last_run = run
-
-        # Delete collapsed runs
-        self.runs = [r for r in self.runs if r.count > 0]
-
     def __repr__(self) -> str:
         return str(list(self))