@miliastry/quasar 1.0.6 → 1.1.0

package/src/HTML/HTMLToGreenNode.ts

@@ -3,6 +3,38 @@ import { RedNode } from '../Syntax/RedNode';
 import type { NodeKind } from '../Types/core';
 import { isBlockKind } from '../BBCode/BBCodeToGreenNode';
 
+/**
+ * The colour exactly as the author wrote it in the `style` attribute.
+ *
+ * `el.style.color` goes through CSSOM, which re-spells the value: `#FFE6F0`
+ * comes back lowercased. Re-serialising a block then rewrote every hex in it,
+ * a change the author never made.
+ */
+function rawStyleValue(el: HTMLElement, prop: string): string {
+  const attr = el.getAttribute('style')
+  if (!attr) return ''
+  const match = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, 'i').exec(attr)
+  return match ? match[1].trim() : ''
+}
+
+function normalizeColorToHex(color: string): string {
+  if (!color) return color;
+  const trimmed = color.trim();
+  // Se respeta la caja que escribió el autor: pasarlo a minúsculas convertía
+  // `[color=#FF00AA]` en `[color=#ff00aa]` en cada ida y vuelta por el lienzo.
+  if (trimmed.startsWith('#')) return trimmed;
+
+  const rgbMatch = trimmed.match(/^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)(?:\s*,\s*([\d.]+))?\s*\)$/i);
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1], 10).toString(16).padStart(2, '0');
+    const g = parseInt(rgbMatch[2], 10).toString(16).padStart(2, '0');
+    const b = parseInt(rgbMatch[3], 10).toString(16).padStart(2, '0');
+    return `#${r}${g}${b}`.toLowerCase();
+  }
+
+  return trimmed;
+}
+
 function domToGreenTree(root: HTMLElement): GreenNode {
   let currentOffset = 0;
 
@@ -44,25 +76,74 @@ function domToGreenTree(root: HTMLElement): GreenNode {
       
       switch (tag) {
         case 'b':
-        case 'strong': kind = 'bold'; break;
+        case 'strong': {
+          // El renderer envuelve las entidades en `<strong><a>`; sin mirar la
+          // marca volvían desazucaradas como `[b][url=…]…[/url][/b]`.
+          const entity = el.getAttribute('data-entity');
+          if (entity === 'profile' || entity === 'guild' || entity === 'map') {
+            kind = entity;
+            const label = el.textContent || '';
+            if (label) {
+              children.push(greenLeaf('text', label));
+              currentOffset += label.length;
+            }
+            // `[profile=5458323]ElMick33[/profile]` lleva el id en el atributo y
+            // el nombre en el contenido; sin el primero volvía como `[profile]`.
+            const valor = el.getAttribute('data-entity-value') || '';
+            return greenNode(kind, valor ? `=${valor}` : '', children);
+          }
+          kind = 'bold';
+          break;
+        }
         case 'i':
         case 'em': kind = 'italic'; break;
         case 'u': kind = 'underline'; break;
         case 's':
         case 'strike':
         case 'del': kind = 'strikethrough'; break;
-        case 'a': 
-          kind = 'url'; 
-          text = `=${el.getAttribute('href') || ''}`;
+        case 'a': {
+          const rawHref = el.getAttribute('href') || '';
+          if (rawHref.startsWith('mailto:')) {
+            // `[email]` guarda la dirección en el hijo de texto y sólo el prefijo
+            // en el atributo; el exporter reconstruye el resto.
+            kind = 'email';
+            text = '=mailto:';
+          } else {
+            kind = 'url';
+            text = `=${rawHref}`;
+          }
           break;
-        case 'img': 
+        }
+        case 'img': {
+          // El parser de BBCode deja la URL en un hijo de texto y el modificador
+          // en el atributo. Copiando esa forma el exporter la vuelve a emitir;
+          // cuando la URL vivía sólo en `text` salía `[img][/img]`.
           kind = 'image';
-          text = el.getAttribute('src') || '';
+          const imgAttr = el.getAttribute('data-img-attr') || '';
+          text = imgAttr ? `=${imgAttr}` : '';
+          const imgSrc = el.getAttribute('src') || '';
+          if (imgSrc) {
+            children.push(greenLeaf('text', imgSrc));
+            currentOffset += imgSrc.length;
+          }
           break;
+        }
         case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
           kind = 'heading';
-          const level = parseInt(tag.charAt(1));
-          text = `=${level}`;
+          // Un `[heading]` pelado se pinta como h2 por convención del renderer;
+          // devolverlo como `[heading=2]` reescribía el source del autor.
+          text = el.hasAttribute('data-bare-level') ? '' : `=${parseInt(tag.charAt(1))}`;
+          break;
+        case 'font':
+          if (el.getAttribute('color')) {
+            kind = 'color';
+            text = `=${normalizeColorToHex(el.getAttribute('color') || '')}`;
+          } else if (el.getAttribute('size')) {
+            kind = 'font_size';
+            text = `=${el.getAttribute('size') || ''}`;
+          } else {
+            kind = 'group';
+          }
           break;
         case 'br':
           kind = 'spacing'; 
@@ -70,9 +151,21 @@ function domToGreenTree(root: HTMLElement): GreenNode {
           currentOffset += 1;
           break;
         case 'div':
+        case 'p': {
+          // Un aviso de medio vacío vuelve a ser su etiqueta, no la frase que
+          // el renderer puso en su sitio. El atributo lleva el nombre BBCode;
+          // aquí hace falta el `NodeKind`, que no siempre coincide.
+          const vacio = el.getAttribute('data-bb-empty');
+          if (vacio) {
+            const KIND_DE_TAG: Record<string, string> = { img: 'image', youtube: 'video', imagemap: 'imagemap' };
+            return greenNode(KIND_DE_TAG[vacio] ?? vacio, '', []);
+          }
           if (el.classList.contains('notice')) kind = 'notice';
+          else if (el.classList.contains('bb-empty-line') || el.classList.contains('bbcode-para')) {
+            const hasText = (el.textContent || '').replace(/\u200B/g, '').trim().length > 0;
+            kind = hasText ? 'paragraph' : 'empty_line';
+          }
           else if (el.classList.contains('bbcode-sp')) kind = 'spacing';
-          else if (el.classList.contains('bbcode-para')) kind = 'empty_line';
           else if (el.classList.contains('bbcode-imagemap') || el.classList.contains('imagemap-container')) {
             kind = 'imagemap';
             const img = el.querySelector('img');
@@ -101,41 +194,56 @@ function domToGreenTree(root: HTMLElement): GreenNode {
           else if (el.style.textAlign === 'left') kind = 'left';
           else kind = 'group';
           break;
+        }
         case 'span':
-          if (el.classList.contains('spoiler')) kind = 'spoiler';
+          if (el.classList.contains('bb-empty-line')) {
+            const hasText = (el.textContent || '').replace(/\u200B/g, '').trim().length > 0;
+            kind = hasText ? 'paragraph' : 'empty_line';
+          }
+          else if (el.classList.contains('spoiler')) kind = 'spoiler';
           else if (el.classList.contains('aesthetic')) kind = 'aesthetic';
-          else if (el.style.color) { kind = 'color'; text = `=${el.style.color}`; }
-          else if (el.style.fontSize) { kind = 'font_size'; text = `=${el.style.fontSize.replace('%', '')}`; }
-          // If it's just a text wrapper generated by HTMLRenderer, we should just unwrap it
-          else if (el.classList.contains('bb-text')) {
-             // We can use a transparent group or a specialized inline node, 
-             // but flattening it is best. We can use a temporary kind that gets flattened,
-             // or just use 'group' but wait, 'group' is block-like.
-             // Actually, if we just set it to 'text_wrapper', we can filter it out, but for now 
-             // let's just make it a 'group' but ideally we shouldn't create a node at all.
-             // Wait, the simplest fix is to not create a node for bb-text and just append its children!
-             kind = 'bb_text_wrapper'; 
+          else if (el.style.color) { kind = 'color'; text = `=${normalizeColorToHex(rawStyleValue(el, 'color') || el.style.color)}`; }
+          else if (el.style.fontSize) { kind = 'font_size'; text = `=${(rawStyleValue(el, 'font-size') || el.style.fontSize).replace('%', '')}`; }
+          else if (el.classList.contains('bb-text') || el.classList.contains('bb-paragraph')) {
+            kind = 'bb_text_wrapper'; 
           }
           else kind = 'group';
           break;
         case 'iframe':
           if (el.classList.contains('bb-youtube') || el.hasAttribute('data-youtube')) {
-            kind = 'youtube';
-            text = `=${el.getAttribute('data-youtube') || (el as HTMLIFrameElement).src.split('/embed/')[1]?.split('?')[0] || ''}`;
+            // El parser produce `video`, no `youtube`, y con el id en un hijo de
+            // texto. Emitir otra forma hacía que el exporter no encontrara el tag.
+            kind = 'video';
+            const videoId = el.getAttribute('data-youtube')
+              || (el as HTMLIFrameElement).src.split('/embed/')[1]?.split('?')[0]
+              || '';
+            if (videoId) {
+              children.push(greenLeaf('text', videoId));
+              currentOffset += videoId.length;
+            }
           } else {
             kind = 'group';
           }
           break;
-        case 'audio':
+        case 'audio': {
           kind = 'audio';
-          text = `=${el.getAttribute('src') || ''}`;
+          const audioSrc = el.getAttribute('src') || '';
+          if (audioSrc) {
+            children.push(greenLeaf('text', audioSrc));
+            currentOffset += audioSrc.length;
+          }
           break;
-        case 'details':
+        }
+        case 'details': {
           kind = el.classList.contains('box') ? 'box' : 'spoilerbox';
-          const summary = el.querySelector('summary');
-          if (summary) text = `=${summary.textContent || ''}`;
+          // `data-bare-title` dice que el texto del summary lo puso el renderer.
+          // Leerlo como título del autor devolvía `[box=Box]` desde un `[box]`.
+          if (!el.hasAttribute('data-bare-title')) {
+            const summary = el.querySelector('summary');
+            if (summary) text = `=${summary.textContent || ''}`;
+          }
           break;
-        case 'p':
+        }
         case 'section':
           kind = 'group';
           break;
@@ -154,6 +262,8 @@ function domToGreenTree(root: HTMLElement): GreenNode {
             const strong = firstElem.querySelector('strong');
             if (strong && strong.textContent && strong.textContent.endsWith(' wrote:')) {
               const author = strong.textContent.slice(0, -7);
+              // Clave `source`: es la que lee `BBCodeExporter.getTagAttributes`,
+              // que además vuelve a poner las comillas de `[quote="Nombre Largo"]`.
               text = `=${author}`;
               (firstElem as any).__quasar_extracted = true;
             }
@@ -162,7 +272,16 @@ function domToGreenTree(root: HTMLElement): GreenNode {
         case 'pre':
           kind = 'code';
           // Extract raw text as a child text node (DocumentEngine expects code content in children)
-          const codeText = el.textContent || '';
+          let codeText = el.textContent || '';
+          const padAttr = el.getAttribute('data-code-pad');
+          if (padAttr) {
+            try {
+              const [lead, trail] = (JSON.parse(padAttr) as string).split('\u0000');
+              codeText = `${lead}${codeText}${trail}`;
+            } catch {
+              // Atributo corrupto: mejor el contenido pelado que perder el bloque.
+            }
+          }
           children.push(greenLeaf('text', codeText));
           currentOffset += codeText.length;
           break;
@@ -213,21 +332,43 @@ function domToGreenTree(root: HTMLElement): GreenNode {
   const normalizedRoot: GreenNode[] = [];
   let currentParagraph: GreenNode[] = [];
 
+  /**
+   * Separa dos nodos de raíz con un solo salto.
+   *
+   * Nunca inventa una línea en blanco: una línea vacía del documento sólo
+   * existe si el autor la escribió, y el lienzo no puede añadir ninguna por su
+   * cuenta al traducir de vuelta.
+   */
+  const pushSeparator = () => {
+    if (normalizedRoot.length === 0) return;
+    const prev = normalizedRoot[normalizedRoot.length - 1];
+    if (prev.kind === 'empty_line' || prev.kind === 'spacing') return;
+    normalizedRoot.push(greenLeaf('spacing', '\n'));
+  };
+
   const flushParagraph = () => {
     if (currentParagraph.length > 0) {
+      pushSeparator();
       normalizedRoot.push(greenNode('paragraph', '', currentParagraph));
       currentParagraph = [];
     }
   };
 
   for (const child of rootChildren) {
-    // If it's a completely empty whitespace text node (0 newlines), ignore it
     if (child.kind === 'text' && child.text.trim() === '') {
+      // Un espacio suelto entre dos tags inline (`[s]a[/s] [spoiler]b[/spoiler]`)
+      // es contenido del autor y se conserva; el resto es sangría del HTML.
+      const isInlineGap = !child.text.includes('\n') && currentParagraph.length > 0;
+      if (!isInlineGap) continue;
+      currentParagraph.push(child);
       continue;
     }
 
-    if (isBlockKind(child.kind as NodeKind) || child.kind === 'empty_line') {
+    if (isBlockKind(child.kind as NodeKind) || child.kind === 'empty_line' || child.kind === 'paragraph') {
       flushParagraph();
+      if (child.kind !== 'empty_line' && child.kind !== 'spacing') {
+        pushSeparator();
+      }
       normalizedRoot.push(child);
     } else {
       currentParagraph.push(child);
@@ -253,20 +394,27 @@ export function greenToRedNode(green: GreenNode, parent?: RedNode | null): RedNo
   let metadata: Record<string, unknown> = {};
   if (green.kind === 'heading' && green.text.startsWith('=')) {
     metadata = { level: parseInt(green.text.slice(1)) || 1 };
-  } else if (green.kind === 'url' && green.text.startsWith('=')) {
+  } else if ((green.kind === 'url' || green.kind === 'email') && green.text.startsWith('=')) {
     metadata = { href: green.text.slice(1) };
   } else if (green.kind === 'color' && green.text.startsWith('=')) {
     metadata = { color: green.text.slice(1) };
   } else if (green.kind === 'font_size' && green.text.startsWith('=')) {
     metadata = { size: green.text.slice(1) };
   } else if (green.kind === 'quote' && green.text.startsWith('=')) {
-    metadata = { author: green.text.slice(1) };
+    metadata = { source: green.text.slice(1) };
   } else if ((green.kind === 'box' || green.kind === 'spoilerbox') && green.text.startsWith('=')) {
     metadata = { title: green.text.slice(1) };
   } else if (green.kind === 'image') {
-    metadata = { src: green.text };
-  } else if ((green.kind === 'youtube' || green.kind === 'audio') && green.text.startsWith('=')) {
-    metadata = green.kind === 'youtube' ? { videoId: green.text.slice(1) } : { src: green.text.slice(1) };
+    const src = green.children.map(c => (c as GreenNode).text || '').join('');
+    metadata = green.text.startsWith('=')
+      ? { src, imgAttr: green.text.slice(1) }
+      : { src };
+  } else if (green.kind === 'video' || green.kind === 'audio') {
+    const value = green.children.map(c => (c as GreenNode).text || '').join('');
+    metadata = green.kind === 'video' ? { videoId: value } : { src: value };
+  } else if (green.kind === 'profile' || green.kind === 'guild' || green.kind === 'map') {
+    const key = green.kind === 'profile' ? 'username' : green.kind === 'guild' ? 'tag' : 'id';
+    metadata = { [key]: green.text.startsWith('=') ? green.text.slice(1) : '' };
   } else if (green.kind === 'list') {
     metadata = { ordered: green.text === '=1' };
   }

package/src/Incremental/BracketIndex.ts

@@ -0,0 +1,249 @@
+/**
+ * DocumentEngine — BracketDepthIndex
+ *
+ * Answers the incremental parser's one question about the text OUTSIDE its
+ * window — "does every `[` before this offset find its `]` before it too?" —
+ * without reading the text before the offset.
+ *
+ * ─── Why the scan had to go ─────────────────────────────────────────────────
+ *
+ * `bracketsCloseBefore` walked the whole prefix on every keystroke: with the
+ * caret at the end of the 547 KB fixture that is 547.000 `charCodeAt` calls
+ * per key, measured at 2.2 ms — more than the parse, the splice and the red
+ * build of that same keystroke put together. Caching was declined once on the
+ * grounds that the reasoning is subtle: an edit can expose a `]` that a
+ * deleted `[` used to claim, so any cache keyed on "the prefix has not
+ * changed" is wrong the moment it is asked about a prefix that has.
+ *
+ * ─── Why this is not that cache ─────────────────────────────────────────────
+ *
+ * The scan computes a CLAMPED running depth — `d ← max(0, d + a)` where `a`
+ * is +1 for `[`, −1 for `]`, 0 otherwise — and a clamped running sum has an
+ * exact, composable summary. Over any stretch of text with prefix sums
+ * P₁…Pₙ, the depth after the stretch is a function of the depth before it:
+ *
+ *     d' = Pₙ + max(d, −min(0, P₁, …, Pₙ))
+ *
+ * so a stretch is fully described by two integers, its net sum and its lowest
+ * dip. The index keeps the source as a sequence of PIECES (a few KB each),
+ * each carrying that pair. An edit re-summarises only the piece(s) it touched,
+ * from the NEW text, and every other piece keeps a summary that is still
+ * exactly true of its (unchanged, merely displaced) characters. A query walks
+ * the piece summaries up to the offset and scans only the tail of the piece
+ * the offset falls in. Nothing here is a guess about what the edit exposed:
+ * the touched piece is re-read verbatim, and composition is arithmetic.
+ *
+ * Cost per keystroke: one summary of ≤ 8 KB plus one walk over ~140 piece
+ * summaries at 547 KB — a few microseconds, and independent of where the
+ * caret is. Verified against the plain scan by `BracketIndex.test.ts`: 2.000
+ * random edits over documents full of stray brackets, every offset agreeing.
+ *
+ * The index does not know which document it describes; the parser keys it on
+ * the green root it was last synchronised with and rebuilds it (one scan) when
+ * the root it is handed is not that one. See `IncrementalParser.reparse`.
+ */
+
+/** Pieces are re-cut to this size when an edit grows one past `MAX_PIECE`. */
+const TARGET_PIECE = 4096
+/** A piece may grow to this before it is split. */
+const MAX_PIECE = TARGET_PIECE * 2
+/** A piece that shrinks below this merges into a neighbour when that fits. */
+const MIN_PIECE = TARGET_PIECE / 4
+
+export class BracketDepthIndex {
+  /** Length of each piece, in characters. Pieces partition `[0, length)`. */
+  private lengths: number[] = []
+  /** Net bracket sum of each piece: `[` counts +1, `]` counts −1. */
+  private sums: number[] = []
+  /** Lowest prefix sum inside each piece, capped at 0 (see the header). */
+  private dips: number[] = []
+  private _length = 0
+
+  /**
+   * Characters read by the last `depthAt` — the tail of one piece, never the
+   * prefix. Exposed so a regression back to an O(prefix) scan is something a
+   * test can assert on, rather than something a profile has to notice.
+   */
+  lastScanned = 0
+
+  /** The length of the text this index currently describes. */
+  get length(): number {
+    return this._length
+  }
+
+  /** Number of pieces — for tests; it should stay ~`length / TARGET_PIECE`. */
+  get pieceCount(): number {
+    return this.lengths.length
+  }
+
+  /** Describe `source` from scratch. O(n) — one scan, the same the query used to be. */
+  rebuild(source: string): void {
+    this.lengths.length = 0
+    this.sums.length = 0
+    this.dips.length = 0
+    this._length = source.length
+    for (let at = 0; at < source.length; at += TARGET_PIECE) {
+      this.pushPiece(source, at, Math.min(source.length, at + TARGET_PIECE))
+    }
+  }
+
+  /**
+   * Bring the index from the text before an edit to `newSource`, the text
+   * after it. `start`/`endOld` bound the replaced region in OLD coordinates;
+   * `insertedLength` is the length of the text that replaced it.
+   *
+   * Only the pieces overlapping the replaced region are re-read. They are
+   * re-summarised as one piece over the same span in NEW coordinates, and
+   * that piece is split if it has grown past `MAX_PIECE` — so a long paste
+   * ends up as several normal pieces, not one giant one that every later
+   * query near it would have to scan.
+   */
+  applyChange(newSource: string, start: number, endOld: number, insertedLength: number): void {
+    const delta = insertedLength - (endOld - start)
+    const oldLength = this._length
+    if (endOld > oldLength || start > endOld || newSource.length !== oldLength + delta) {
+      // The caller's picture of the previous text and ours disagree. There is
+      // no way to reconcile them locally; describe the new text outright.
+      this.rebuild(newSource)
+      return
+    }
+
+    // The piece containing `start` — the LAST piece when the edit sits at the
+    // very end — and the piece whose closed span `[pieceStart, pieceEnd]`
+    // contains `endOld`, so an edit that ends exactly on a boundary does not
+    // reach into the piece after it.
+    const lengths = this.lengths
+    let i = 0
+    let pieceStart = 0
+    while (i < lengths.length - 1 && pieceStart + lengths[i] <= start) {
+      pieceStart += lengths[i]
+      i++
+    }
+    let j = i
+    let pieceEnd = pieceStart + (lengths.length === 0 ? 0 : lengths[i])
+    while (j < lengths.length - 1 && pieceEnd < endOld) {
+      j++
+      pieceEnd += lengths[j]
+    }
+
+    const newEnd = pieceEnd + delta
+    const removed = lengths.length === 0 ? 0 : j - i + 1
+    this.spliceSummaries(i, removed, newSource, pieceStart, newEnd)
+    this._length = newSource.length
+
+    // Keep the pieces around the edit from dwindling: a piece that lost most
+    // of its text merges into a neighbour so the piece count stays bounded by
+    // the text length, not by the number of edits it has seen.
+    this.mergeSmallAround(i)
+  }
+
+  /**
+   * The clamped bracket depth just before `end` — what the plain scan of
+   * `[0, end)` would return. `end === 0` is depth 0; `end > length` is
+   * clamped to the text.
+   */
+  depthAt(source: string, end: number): number {
+    if (end > this._length) end = this._length
+    const lengths = this.lengths
+    let depth = 0
+    let pos = 0
+    let i = 0
+    // Whole pieces before `end`: compose their summaries.
+    for (; i < lengths.length && pos + lengths[i] <= end; i++) {
+      const dip = this.dips[i]
+      depth = this.sums[i] + (depth > -dip ? depth : -dip)
+      pos += lengths[i]
+    }
+    // The tail of the piece `end` falls in: scan it.
+    this.lastScanned = end - pos
+    for (let k = pos; k < end; k++) {
+      const c = source.charCodeAt(k)
+      if (c === 91 /* [ */) depth++
+      else if (c === 93 /* ] */ && depth > 0) depth--
+    }
+    return depth
+  }
+
+  /** Summarise `[from, to)` of `source` and append it as a piece. */
+  private pushPiece(source: string, from: number, to: number): void {
+    let sum = 0
+    let dip = 0
+    for (let k = from; k < to; k++) {
+      const c = source.charCodeAt(k)
+      if (c === 91 /* [ */) sum++
+      else if (c === 93 /* ] */) {
+        sum--
+        if (sum < dip) dip = sum
+      }
+    }
+    this.lengths.push(to - from)
+    this.sums.push(sum)
+    this.dips.push(dip)
+  }
+
+  /**
+   * Replace `count` pieces at `index` with the summaries of `[from, to)` of
+   * `source`, cut into pieces of at most `MAX_PIECE`.
+   */
+  private spliceSummaries(index: number, count: number, source: string, from: number, to: number): void {
+    const savedLengths = this.lengths
+    const savedSums = this.sums
+    const savedDips = this.dips
+    this.lengths = []
+    this.sums = []
+    this.dips = []
+    const span = to - from
+    if (span > MAX_PIECE) {
+      const parts = Math.ceil(span / TARGET_PIECE)
+      const step = Math.ceil(span / parts)
+      for (let at = from; at < to; at += step) this.pushPiece(source, at, Math.min(to, at + step))
+    } else if (span > 0 || savedLengths.length === 0) {
+      // An empty document keeps one empty piece so `applyChange` always has
+      // a piece to anchor on; anywhere else an emptied piece simply goes.
+      this.pushPiece(source, from, to)
+    }
+    const fresh = this.lengths
+    const freshSums = this.sums
+    const freshDips = this.dips
+    savedLengths.splice(index, count, ...fresh)
+    savedSums.splice(index, count, ...freshSums)
+    savedDips.splice(index, count, ...freshDips)
+    this.lengths = savedLengths
+    this.sums = savedSums
+    this.dips = savedDips
+  }
+
+  /**
+   * Merge the piece at `index` (and the one after it) into a neighbour when
+   * it has shrunk below `MIN_PIECE` and the pair stays under `MAX_PIECE`.
+   *
+   * Merging two summaries is the composition from the header applied to the
+   * pair: the sum adds, and the dip of the second is measured from the end of
+   * the first. No text is read.
+   */
+  private mergeSmallAround(index: number): void {
+    for (let pass = 0; pass < 2; pass++) {
+      const i = Math.min(index, this.lengths.length - 1)
+      if (i < 0) return
+      if (this.lengths[i] >= MIN_PIECE || this.lengths.length < 2) return
+      // Prefer the previous neighbour (it keeps `index` valid for the next pass).
+      const left = i > 0 && this.lengths[i - 1] + this.lengths[i] <= MAX_PIECE
+      const right = i + 1 < this.lengths.length && this.lengths[i] + this.lengths[i + 1] <= MAX_PIECE
+      if (left) this.mergePair(i - 1)
+      else if (right) this.mergePair(i)
+      else return
+    }
+  }
+
+  /** Fold piece `i + 1` into piece `i`. */
+  private mergePair(i: number): void {
+    const sumA = this.sums[i]
+    const dipB = this.dips[i + 1] + sumA
+    this.dips[i] = Math.min(this.dips[i], dipB)
+    this.sums[i] = sumA + this.sums[i + 1]
+    this.lengths[i] += this.lengths[i + 1]
+    this.lengths.splice(i + 1, 1)
+    this.sums.splice(i + 1, 1)
+    this.dips.splice(i + 1, 1)
+  }
+}