@kabmo-labs/kabmo 0.8.0 → 0.9.0

package/src/shared/lib/code/editor/history.ts

@@ -1,101 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Undo history for the code editor.
- *
- * The editor cannot lean on the browser's own undo: it renders a transparent
- * `<textarea>` over a highlighted `<pre>`, so a native undo would desync the two
- * layers. Every entry therefore stores the whole buffer plus the caret, and this
- * module is the bookkeeping behind ⌘Z / ⇧⌘Z — push, merge a typing burst into
- * the word being typed, cap the stack, and step through it.
- */
-
-export interface HistoryRecord {
-  value: string;
-  selectionStart: number;
-  selectionEnd: number;
-  timestamp: number;
-}
-
-export interface History {
-  stack: HistoryRecord[];
-  offset: number;
-}
-
-const HISTORY_LIMIT = 100;
-/** Typing within this window of the previous edit merges into that entry. */
-export const HISTORY_TIME_GAP = 3000;
-/** The word the caret sits at the end of, which is what a burst keeps extending. */
-const WORD_TAIL = /[^a-z0-9]([a-z0-9]+)$/i;
-
-export function createHistory(): History {
-  return { stack: [], offset: -1 };
-}
-
-/** Append `record`, dropping the redo entries that follow the current position. */
-export function pushRecord(history: History, record: HistoryRecord): void {
-  if (history.stack.length && history.offset > -1) {
-    history.stack = history.stack.slice(0, history.offset + 1);
-  }
-  history.stack.push(record);
-  history.offset = history.stack.length - 1;
-}
-
-/** Push an edit and cap the stack, leaving `offset` on the same entry. */
-export function pushEdit(history: History, record: HistoryRecord): void {
-  pushRecord(history, record);
-  if (history.stack.length <= HISTORY_LIMIT) return;
-  const extras = history.stack.length - HISTORY_LIMIT;
-  history.stack = history.stack.slice(extras);
-  history.offset = Math.max(history.offset - extras, 0);
-}
-
-/** The tail word of the line `position` sits on. */
-function tailWord(value: string, position: number): string | undefined {
-  return value.substring(0, position).split('\n').pop()?.match(WORD_TAIL)?.[1];
-}
-
-/**
- * Whether a change keeps typing the word the previous entry ended with — the
- * test that folds a run of keystrokes into one undoable edit.
- */
-export function continuesTyping(
-  last: HistoryRecord | undefined,
-  next: string,
-  selectionStart: number,
-  timestamp: number,
-): boolean {
-  if (!last || timestamp - last.timestamp >= HISTORY_TIME_GAP) return false;
-  const previous = tailWord(last.value, last.selectionStart);
-  const current = tailWord(next, selectionStart);
-  return Boolean(previous && current?.startsWith(previous));
-}
-
-/** Fold a continuation into the current entry, which stays the current position. */
-export function mergeTyping(
-  history: History,
-  next: string,
-  selectionStart: number,
-  selectionEnd: number,
-  timestamp: number,
-): void {
-  // A merge is an edit like any other, so it drops the redo entries after it —
-  // otherwise typing straight after an undo would leave a stale redo target.
-  history.stack = history.stack.slice(0, history.offset + 1);
-  history.stack[history.offset] = { value: next, selectionStart, selectionEnd, timestamp };
-}
-
-/**
- * Step one entry back (undo) or forward (redo) and return the buffer to
- * restore, or null at either end of the stack.
- */
-export function stepHistory(history: History, direction: 'undo' | 'redo'): HistoryRecord | null {
-  const index = direction === 'undo' ? history.offset - 1 : history.offset + 1;
-  const record = history.stack[index];
-  if (!record) return null;
-  history.offset = direction === 'undo' ? Math.max(index, 0) : Math.min(index, history.stack.length - 1);
-  return record;
-}

package/src/shared/lib/code/editor/layers.test.ts

@@ -1,77 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The two-layer alignment contract.
- *
- * The transparent `<textarea>` sits exactly on top of the highlighted `<pre>`,
- * so any typographic property that differs between them puts the caret on a
- * different row than the glyphs. These assertions pin the two things that
- * matter: both layers inherit their typography (a second copy of the font stack
- * is what makes them drift), and the `<pre>` reserves the unrendered lines as
- * padding while the textarea keeps the plain inset.
- */
-
-import { describe, expect, test } from 'bun:test';
-
-import { layerStyle, layerStyles } from '@/shared/lib/code/editor/layers';
-
-describe('layerStyle', () => {
-  test('inherits every typographic property rather than restating it', () => {
-    const style = layerStyle();
-
-    for (const property of ['fontFamily', 'fontSize', 'lineHeight', 'letterSpacing', 'tabSize'] as const) {
-      expect(style[property]).toBe('inherit');
-    }
-  });
-
-  test('breaks words the same way the gutter measured them', () => {
-    // The measurement mirror copies these from the editor's computed style; a
-    // layer that broke differently would put the numbers on the wrong rows.
-    const style = layerStyle();
-
-    expect(style.whiteSpace).toBe('pre-wrap');
-    expect(style.overflowWrap).toBe('break-word');
-    expect(style.wordBreak).toBe('keep-all');
-  });
-
-  test('takes its box from the caller, not from the UA', () => {
-    const style = layerStyle();
-
-    expect(style.boxSizing).toBe('inherit');
-    expect(style.display).toBe('inherit');
-    expect(style.margin).toBe(0);
-    expect(style.border).toBe(0);
-  });
-});
-
-describe('layerStyles', () => {
-  test('both layers carry the caller’s padding', () => {
-    const { pre, textarea } = layerStyles(16, null);
-
-    expect(textarea.paddingTop).toBe(16);
-    expect(textarea.paddingLeft).toBe(16);
-    expect(pre.paddingTop).toBe(16);
-    expect(pre.paddingBottom).toBe(16);
-  });
-
-  test('the pre reserves the unrendered lines as padding', () => {
-    // Windowing is the whole trick: the textarea holds the document, the pre
-    // holds a slice of it, and the space of everything else is this padding.
-    const { pre, textarea } = layerStyles(8, { start: 100, end: 120, top: 900, bottom: 200, breakAtEnd: false });
-
-    expect(pre.paddingTop).toBe(908);
-    expect(pre.paddingBottom).toBe(208);
-    expect(textarea.paddingTop).toBe(8);
-    expect(textarea.paddingBottom).toBe(8);
-  });
-
-  test('a window without space leaves the plain inset', () => {
-    const { pre } = layerStyles(4, { start: 0, end: 10, top: 0, bottom: 0, breakAtEnd: true });
-
-    expect(pre.paddingTop).toBe(4);
-    expect(pre.paddingBottom).toBe(4);
-  });
-});

package/src/shared/lib/code/editor/layers.ts

@@ -1,67 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The inline styles that keep the editor's two layers in register.
- *
- * The transparent `<textarea>` (which owns the caret, the selection and every
- * keystroke) sits exactly on top of the `<pre>` (which paints the glyphs), so
- * both must lay text out identically: `layerStyles` is the shared half —
- * every typographic property inherits rather than being restated, because a
- * second copy of the font stack is what makes the two drift.
- *
- * The `<pre>` additionally carries the space of the lines the window is not
- * rendering, as padding, which is the whole trick behind the lazy surface: the
- * textarea still holds every line, so the caret lands where the reader expects
- * without the highlighter ever tokenizing the rest of the document.
- */
-
-import type { CSSProperties } from 'preact';
-import type { CodeWindow } from '@/shared/lib/code/lazy-window';
-
-/** The shared typography, inherited from the caller's own class. */
-export function layerStyle(): CSSProperties {
-  return {
-    margin: 0,
-    border: 0,
-    background: 'none',
-    boxSizing: 'inherit',
-    display: 'inherit',
-    fontFamily: 'inherit',
-    fontSize: 'inherit',
-    fontStyle: 'inherit',
-    fontVariantLigatures: 'inherit',
-    fontWeight: 'inherit',
-    letterSpacing: 'inherit',
-    lineHeight: 'inherit',
-    tabSize: 'inherit',
-    textIndent: 'inherit',
-    textRendering: 'inherit',
-    textTransform: 'inherit',
-    whiteSpace: 'pre-wrap',
-    wordBreak: 'keep-all',
-    overflowWrap: 'break-word',
-  };
-}
-
-/** The plain inset both layers take; `padding` is the editor's own padding. */
-function contentStyle(padding: number): CSSProperties {
-  return { paddingTop: padding, paddingRight: padding, paddingBottom: padding, paddingLeft: padding };
-}
-
-/** Both layers' styles for one render: the shared typography plus each one's box. */
-export function layerStyles(padding: number, virtual: CodeWindow | null | undefined) {
-  const content = contentStyle(padding);
-  return {
-    /** Textarea: the full document, so its padding is the plain inset. */
-    textarea: content,
-    /** `<pre>`: the window, with the unrendered lines reserved as padding. */
-    pre: {
-      ...content,
-      paddingTop: padding + (virtual?.top ?? 0),
-      paddingBottom: padding + (virtual?.bottom ?? 0),
-    },
-  };
-}

package/src/shared/lib/code/editor/line-edits.test.ts

@@ -1,131 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The line commands: move, duplicate, delete, insert, and the caret's line
- * edges.
- *
- * The cases that matter are the document's edges — the first and last line have
- * no neighbour to swap with, a last line with no trailing newline still needs its
- * own separator, and a line deleted rather than blanked. Each of those was a
- * visible bug in the naive concatenation.
- */
-
-import { describe, expect, test } from 'bun:test';
-
-import { deleteLines, duplicateLines, insertLine, lineEdges, moveLines } from '@/shared/lib/code/editor/line-edits';
-
-describe('moveLines', () => {
-  test('moves the block up and carries the selection with it', () => {
-    const result = moveLines('one\ntwo\nthree', { start: 4, end: 8 }, -1);
-
-    expect(result.value).toBe('two\none\nthree');
-    expect([result.selectionStart, result.selectionEnd]).toEqual([0, 4]);
-  });
-
-  test('moves the block down', () => {
-    const result = moveLines('one\ntwo\nthree', { start: 4, end: 8 }, 1);
-
-    expect(result.value).toBe('one\nthree\ntwo');
-    expect([result.selectionStart, result.selectionEnd]).toEqual([10, 14]);
-  });
-
-  test('a block already at the edge does not move', () => {
-    const first = moveLines('one\ntwo', { start: 0, end: 4 }, -1);
-    expect(first.value).toBe('one\ntwo');
-    expect(first.selectionStart).toBe(0);
-
-    const last = moveLines('one\ntwo', { start: 4, end: 7 }, 1);
-    expect(last.value).toBe('one\ntwo');
-  });
-
-  test('moving several lines keeps them together', () => {
-    const result = moveLines('a\nb\nc\nd', { start: 2, end: 6 }, 1);
-
-    expect(result.value).toBe('a\nd\nb\nc');
-  });
-});
-
-describe('duplicateLines', () => {
-  test('copies the line below and leaves the original selected', () => {
-    const result = duplicateLines('one\ntwo', { start: 0, end: 4 }, 1);
-
-    expect(result.value).toBe('one\none\ntwo');
-    expect([result.selectionStart, result.selectionEnd]).toEqual([0, 4]);
-  });
-
-  test('copies above and selects the copy', () => {
-    const result = duplicateLines('one\ntwo', { start: 4, end: 7 }, -1);
-
-    expect(result.value).toBe('one\ntwo\ntwo');
-    expect([result.selectionStart, result.selectionEnd]).toEqual([8, 11]);
-  });
-
-  test('a last line with no trailing newline still gets its own line', () => {
-    const result = duplicateLines('one\ntwo', { start: 4, end: 7 }, 1);
-
-    expect(result.value).toBe('one\ntwo\ntwo');
-  });
-});
-
-describe('deleteLines', () => {
-  test('removes the line rather than blanking it', () => {
-    const result = deleteLines('one\ntwo\nthree', { start: 4, end: 8 });
-
-    expect(result.value).toBe('one\nthree');
-    expect(result.selectionStart).toBe(4);
-  });
-
-  test('deleting the last line leaves the caret at the buffer end', () => {
-    const result = deleteLines('one\ntwo', { start: 4, end: 7 });
-
-    expect(result.value).toBe('one\n');
-    expect(result.selectionStart).toBe(4);
-  });
-
-  test('deleting a multi-line block removes all of it', () => {
-    const result = deleteLines('a\nb\nc\nd', { start: 2, end: 6 });
-
-    expect(result.value).toBe('a\nd');
-  });
-});
-
-describe('insertLine', () => {
-  test('opens a line below, keeping the indentation', () => {
-    const result = insertLine('  one\ntwo', 5, 'below');
-
-    expect(result.value).toBe('  one\n  \ntwo');
-    expect(result.selectionStart).toBe(8);
-  });
-
-  test('opens a line above, keeping the indentation', () => {
-    const result = insertLine('  one\ntwo', 5, 'above');
-
-    expect(result.value).toBe('  \n  one\ntwo');
-    expect(result.selectionStart).toBe(2);
-  });
-
-  test('on the buffer’s last line without a trailing newline the line is appended', () => {
-    const result = insertLine('  one', 5, 'below');
-
-    // No trailing newline: the new line simply follows, indented, and the caret
-    // lands after that indent. Writing a second newline (what this used to do)
-    // left a blank line under the caret.
-    expect(result.value).toBe('  one\n  ');
-    expect(result.selectionStart).toBe(8);
-  });
-});
-
-describe('lineEdges', () => {
-  test('reports the start of the line and the end of its content', () => {
-    // The trailing newline is not part of the line's content, so ⌘→ stops
-    // before it rather than on the next line.
-    expect(lineEdges('one\ntwo\n', 5)).toEqual({ start: 4, end: 7 });
-  });
-
-  test('the last line has no newline to exclude', () => {
-    expect(lineEdges('one\ntwo', 5)).toEqual({ start: 4, end: 7 });
-  });
-});

package/src/shared/lib/code/editor/line-edits.ts

@@ -1,159 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The editor's line commands: move, duplicate, delete, insert a line, and the
- * caret's line edges.
- *
- * Split from `editor-commands` (which owns the multi-selection and comment
- * concerns) because the two families have nothing in common beyond both being
- * pure string arithmetic — and because the repository caps a file at 350 lines.
- */
-
-import { lineIndexAt, lineRangeAt, lineRangesInSelection, lineStartOffset, type TextRange } from '@/shared/lib/code/editor/lines';
-
-/** The block of lines a selection touches, as ONE range. */
-function selectionBlock(text: string, selection: TextRange): TextRange {
-  const lines = lineRangesInSelection(text, selection);
-  return { start: lines[0].start, end: lines[lines.length - 1].end };
-}
-
-/**
- * Move the selected lines up (`-1`) or down (`1`).
- *
- * The two groups are swapped as a REGION rather than as two concatenations:
- * the neighbour may be the document's last line with no trailing newline, so
- * the separator between the swapped halves has to be re-emitted from the
- * region's own shape. Getting that wrong turns `one\ntwo\nthree` into
- * `one\nthreetwo` — which is what the naive `body + neighbour` swap produced.
- *
- * The selection travels with its lines, so a repeated ⌥↑ keeps moving the same
- * block. At the document's first/last line there is no neighbour and the buffer
- * is returned unchanged.
- */
-export function moveLines(
-  text: string,
-  selection: TextRange,
-  direction: -1 | 1,
-): { value: string; selectionStart: number; selectionEnd: number } {
-  const block = selectionBlock(text, selection);
-  const blockText = text.slice(block.start, block.end);
-  const neighbour = direction === -1 ? lineRangeAt(text, block.start - 1) : lineRangeAt(text, block.end);
-  if (direction === -1 && block.start === 0) {
-    return { value: text, selectionStart: selection.start, selectionEnd: selection.end };
-  }
-  if (direction === 1 && block.end >= text.length) {
-    return { value: text, selectionStart: selection.start, selectionEnd: selection.end };
-  }
-
-  const neighbourText = text.slice(neighbour.start, neighbour.end);
-  // Both groups are whole lines, so each carries at most one trailing newline.
-  const blockBody = blockText.replace(/\n$/, '');
-  const neighbourBody = neighbourText.replace(/\n$/, '');
-  const regionEndsWithNewline = text.slice(Math.min(block.start, neighbour.start), Math.max(block.end, neighbour.end)).endsWith('\n');
-
-  const ordered = direction === -1
-    ? `${blockBody}\n${neighbourBody}`
-    : `${neighbourBody}\n${blockBody}`;
-  const region = ordered + (regionEndsWithNewline ? '\n' : '');
-  const regionStart = Math.min(block.start, neighbour.start);
-  const regionEnd = Math.max(block.end, neighbour.end);
-
-  // The block's own first line moves by exactly the neighbour's length plus the
-  // separator that now precedes it.
-  const shift = neighbourBody.length + 1;
-  const delta = direction === -1 ? -shift : shift;
-  return {
-    value: text.slice(0, regionStart) + region + text.slice(regionEnd),
-    selectionStart: selection.start + delta,
-    selectionEnd: selection.end + delta,
-  };
-}
-
-/** Copy the selected lines below (`1`) or above (`-1`); the copy stays selected. */
-export function duplicateLines(
-  text: string,
-  selection: TextRange,
-  direction: -1 | 1,
-): { value: string; selectionStart: number; selectionEnd: number } {
-  const block = selectionBlock(text, selection);
-  const body = text.slice(block.start, block.end);
-  // A block that reaches the end of a document with no trailing newline needs
-  // one, or the copy would land on the same line it came from.
-  const separator = body.endsWith('\n') ? '' : '\n';
-
-  if (direction === 1) {
-    const inserted = separator + body;
-    return {
-      value: text.slice(0, block.end) + inserted + text.slice(block.end),
-      selectionStart: selection.start,
-      selectionEnd: selection.end,
-    };
-  }
-  const inserted = body + separator;
-  return {
-    value: text.slice(0, block.start) + inserted + text.slice(block.start),
-    selectionStart: selection.start + inserted.length,
-    selectionEnd: selection.end + inserted.length,
-  };
-}
-
-/**
- * Delete the selected lines, newline included — so the line is gone rather than
- * blanked. The caret lands at the start of the line that took its place, or at
- * the end of the buffer when the last line was deleted.
- */
-export function deleteLines(
-  text: string,
-  selection: TextRange,
-): { value: string; selectionStart: number; selectionEnd: number } {
-  const block = selectionBlock(text, selection);
-  const value = text.slice(0, block.start) + text.slice(block.end);
-  const caret = Math.min(block.start, value.length);
-  return { value, selectionStart: caret, selectionEnd: caret };
-}
-
-/**
- * Open a new line above or below the caret's line, keeping that line's
- * indentation. ⌘⏎ is "below" and ⌘⇧⏎ is "above", like VS Code.
- */
-export function insertLine(
-  text: string,
-  offset: number,
-  where: 'above' | 'below',
-): { value: string; selectionStart: number; selectionEnd: number } {
-  const line = lineRangeAt(text, offset);
-  const lineText = text.slice(line.start, line.end).replace(/\n$/, '');
-  const indent = lineText.match(/^\s*/)?.[0] ?? '';
-
-  if (where === 'above') {
-    const caret = line.start + indent.length;
-    return {
-      value: `${text.slice(0, line.start)}${indent}\n${text.slice(line.start)}`,
-      selectionStart: caret,
-      selectionEnd: caret,
-    };
-  }
-
-  // Below a line that already ends in a newline the new line is inserted
-  // BEFORE that successor; below the document's last line the newline has to be
-  // written first. Emitting both unconditionally left a blank line behind
-  // (measured: `a\nb` + ⌘⏎ became `a\nb\n\n`).
-  const lineEndsWithNewline = text[line.end - 1] === '\n';
-  const inserted = lineEndsWithNewline ? `${indent}\n` : `\n${indent}`;
-  const caret = line.end + inserted.length - (lineEndsWithNewline ? 1 : 0);
-  return {
-    value: text.slice(0, line.end) + inserted + text.slice(line.end),
-    selectionStart: caret,
-    selectionEnd: caret,
-  };
-}
-
-/** The offset at the start of the caret's line, and at the end of it (⌘← / ⌘→). */
-export function lineEdges(text: string, offset: number): { start: number; end: number } {
-  const line = lineRangeAt(text, offset);
-  const start = lineStartOffset(text, lineIndexAt(text, offset));
-  return { start, end: Math.max(start, line.end - (text[line.end - 1] === '\n' ? 1 : 0)) };
-}

package/src/shared/lib/code/editor/occurrences.test.ts

@@ -1,117 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * The multi-selection rules.
- *
- * ⌘D's two-stage behaviour is the one users notice immediately: the first press
- * selects the word, the second adds the next occurrence. Getting that wrong
- * leaves the word selected once and its neighbour selected twice, which reads
- * as a duplicated cursor.
- */
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  growToNextOccurrence,
-  offsetBelow,
-  replicateAtRanges,
-  selectAllOccurrences,
-} from '@/shared/lib/code/editor/occurrences';
-
-describe('growToNextOccurrence', () => {
-  const text = 'alpha beta alpha gamma alpha';
-
-  test('the first press on a bare caret selects the word and adds nothing', () => {
-    expect(growToNextOccurrence(text, { start: 2, end: 2 }, [])).toEqual({
-      primary: { start: 0, end: 5 },
-      extras: [],
-    });
-  });
-
-  test('the second press adds the next occurrence', () => {
-    const grown = growToNextOccurrence(text, { start: 0, end: 5 }, []);
-    expect(grown?.primary).toEqual({ start: 0, end: 5 });
-    expect(grown?.extras).toEqual([{ start: 11, end: 16 }]);
-  });
-
-  test('each further press adds the one after it, never a duplicate', () => {
-    const grown = growToNextOccurrence(text, { start: 0, end: 5 }, [{ start: 11, end: 16 }]);
-    expect(grown?.extras).toEqual([
-      { start: 11, end: 16 },
-      { start: 23, end: 28 },
-    ]);
-  });
-
-  test('reports nothing when every occurrence is already selected', () => {
-    const extras = [
-      { start: 11, end: 16 },
-      { start: 23, end: 28 },
-    ];
-    expect(growToNextOccurrence(text, { start: 0, end: 5 }, extras)).toBeNull();
-  });
-
-  test('reports nothing on whitespace with no word beside it', () => {
-    expect(growToNextOccurrence('   ', { start: 1, end: 1 }, [])).toBeNull();
-  });
-});
-
-describe('selectAllOccurrences', () => {
-  test('the first occurrence is the primary, the rest are extras', () => {
-    const all = selectAllOccurrences('alpha beta alpha', { start: 0, end: 5 });
-
-    expect(all?.primary).toEqual({ start: 0, end: 5 });
-    expect(all?.extras).toEqual([{ start: 11, end: 16 }]);
-  });
-
-  test('a bare caret takes the word under it', () => {
-    const all = selectAllOccurrences('alpha beta alpha', { start: 2, end: 2 });
-    expect(all?.primary).toEqual({ start: 0, end: 5 });
-  });
-
-  test('a one-off word yields the selection alone', () => {
-    const all = selectAllOccurrences('alpha beta', { start: 0, end: 5 });
-    expect(all?.primary).toEqual({ start: 0, end: 5 });
-    expect(all?.extras).toEqual([]);
-  });
-});
-
-describe('offsetBelow', () => {
-  test('keeps the column', () => {
-    expect(offsetBelow('one\ntwo\nthree', 1)).toBe(5);
-  });
-
-  test('clamps to the end of a shorter next line', () => {
-    // Column 6 does not exist on `ab`; the caret lands at its end rather than
-    // on a character the line never had.
-    expect(offsetBelow('longer line\nab\nnext', 6)).toBe(14);
-  });
-
-  test('reports nothing on the last line', () => {
-    expect(offsetBelow('one\ntwo', 5)).toBeNull();
-  });
-});
-
-describe('replicateAtRanges', () => {
-  test('reports nothing when there are no extra ranges', () => {
-    expect(replicateAtRanges('abc', 'abXc', { start: 2, end: 2 }, [])).toBeNull();
-  });
-
-  test('replays one insertion at every range and collapses them to carets', () => {
-    const applied = replicateAtRanges('alpha alpha', 'Xalpha alpha', { start: 0, end: 0 }, [{ start: 6, end: 6 }]);
-
-    expect(applied?.value).toBe('Xalpha Xalpha');
-    expect(applied?.caret).toBe(1);
-    expect(applied?.rest).toEqual([{ start: 8, end: 8 }]);
-  });
-
-  test('replays a replacement over the selected text', () => {
-    const applied = replicateAtRanges('alpha beta alpha', 'Z beta alpha', { start: 0, end: 5 }, [{ start: 11, end: 16 }]);
-
-    expect(applied?.value).toBe('Z beta Z');
-    // The caret sits after the inserted `Z`, which now ends the buffer.
-    expect(applied?.rest).toEqual([{ start: 8, end: 8 }]);
-  });
-});