vim-motions.test.ts

import { describe, expect, test } from "bun:test"
import type { TextareaRenderable } from "@opentui/core"
import { createSignal } from "solid-js"
import { createVimHandler } from "../../../src/cli/cmd/tui/component/vim/vim-handler"
import { createVimState } from "../../../src/cli/cmd/tui/component/vim/vim-state"
import type { VimScroll } from "../../../src/cli/cmd/tui/component/vim/vim-scroll"
import { vimScroll } from "../../../src/cli/cmd/tui/component/vim/vim-scroll"
import type { VimJump } from "../../../src/cli/cmd/tui/component/vim/vim-motion-jump"
import {
  copyNextParagraph,
  copyPreviousParagraph,
  copyWordNext,
  copyWordPrev,
  deleteSelection,
} from "../../../src/cli/cmd/tui/component/vim/vim-motions"

function rowColToOffset(text: string, row: number, col: number) {
  let index = 0
  let current = 0
  while (current < row) {
    const next = text.indexOf("\n", index)
    if (next === -1) return text.length
    index = next + 1
    current++
  }
  return Math.min(index + col, text.length)
}

function offsetToRowCol(text: string, offset: number) {
  let row = 0
  let col = 0
  let index = 0
  while (index < offset && index < text.length) {
    if (text[index] === "\n") {
      row++
      col = 0
      index++
      continue
    }
    col++
    index++
  }
  return { row, col }
}

function createTextarea(text: string, opts?: { strict?: boolean }) {
  let sel: { start: number; end: number } | null = null
  let anchor: number | null = null
  const textarea = {
    plainText: text,
    cursorOffset: 0,
    get logicalCursor() {
      return offsetToRowCol(textarea.plainText, textarea.cursorOffset)
    },
    setText(value: string) {
      textarea.plainText = value
      textarea.cursorOffset = Math.min(textarea.cursorOffset, value.length)
    },
    insertText(value: string) {
      const head = textarea.plainText.slice(0, textarea.cursorOffset)
      const tail = textarea.plainText.slice(textarea.cursorOffset)
      textarea.plainText = head + value + tail
      textarea.cursorOffset += value.length
    },
    deleteRange(startRow: number, startCol: number, endRow: number, endCol: number) {
      const start = rowColToOffset(textarea.plainText, startRow, startCol)
      const end = rowColToOffset(textarea.plainText, endRow, endCol)
      textarea.plainText = textarea.plainText.slice(0, start) + textarea.plainText.slice(end)
      textarea.cursorOffset = start
    },
    updateSelectionForMovement(shift: boolean, before: boolean) {
      if (!shift) {
        anchor = null
        sel = null
        return
      }
      if (before) {
        anchor = textarea.cursorOffset
        return
      }
      if (anchor === null) return
      sel = { start: Math.min(anchor, textarea.cursorOffset), end: Math.max(anchor, textarea.cursorOffset) }
    },
    editorView: {
      setSelection(start: number, end: number) {
        sel = { start, end }
      },
      resetSelection() {
        sel = null
        anchor = null
      },
      resetLocalSelection() {},
      getSelection() {
        return sel
      },
      hasSelection() {
        return sel !== null
      },
      getSelectedText() {
        if (!sel) return ""
        return textarea.plainText.slice(sel.start, sel.end)
      },
      deleteSelectedText() {
        if (!sel) return
        textarea.plainText = textarea.plainText.slice(0, sel.start) + textarea.plainText.slice(sel.end)
        textarea.cursorOffset = sel.start
        sel = null
      },
    },
    editBuffer: {
      offsetToPosition(offset: number) {
        if (opts?.strict && offset > textarea.plainText.length) return null
        return offsetToRowCol(textarea.plainText, offset)
      },
    },
  }
  return textarea as unknown as TextareaRenderable
}

function createEvent(name: string, options?: { shift?: boolean; ctrl?: boolean; meta?: boolean; super?: boolean }) {
  let prevented = false
  return {
    event: {
      name,
      shift: options?.shift,
      ctrl: options?.ctrl,
      meta: options?.meta,
      super: options?.super,
      preventDefault() {
        prevented = true
      },
    },
    prevented: () => prevented,
  }
}

function createHandler(
  text: string,
  options?: {
    enabled?: boolean
    mode?: "normal" | "insert" | "replace" | "visual" | "visual-line" | "copy"
    strict?: boolean
    submit?: () => void
    autocomplete?: () => false | "@" | "/"
    flash?: (span: { start: number; end: number }) => void
    copy?: {
      text?: string
      texts?: string[]
      col?: number
      idx?: number
      rows?: Array<{ col: number }>
      isVisual?: boolean
    }
    register?: {
      get?: () => { text: string; linewise: boolean } | null
      set?: (register: { text: string; linewise: boolean } | null, notify?: boolean) => void
    }
    data?: unknown
  },
) {
  const textarea = createTextarea(text, { strict: options?.strict })
  const [enabled] = createSignal(options?.enabled ?? true)
  const [mode, setMode] = createSignal<"normal" | "insert" | "replace" | "visual" | "visual-line" | "copy">(
    options?.mode ?? "normal",
  )
  const [pending, setPending] = createSignal<"" | "c" | "d" | "g" | "z" | "f" | "F" | "t" | "T" | "y">("")
  const [lastFind, setLastFind] = createSignal<{ char: string; forward: boolean; till: boolean } | null>(null)
  const [register, setRegister] = createSignal<{ text: string; linewise: boolean } | null>(null)
  const [anchor, setAnchor] = createSignal<number | null>(null)
  const [replace, setReplace] = createSignal<number | null>(null)
  const [typed, setTyped] = createSignal(false)
  const [copyVisual, setCopyVisual] = createSignal<undefined | "char" | "line">(
    options?.copy?.isVisual ? "char" : undefined,
  )
  const [meta, setMeta] = createSignal(options?.data)
  const [undos, setUndos] = createSignal<Array<{ before: { text: string; cursor: number }; after: { text: string; cursor: number } }>>([])
  const [redos, setRedos] = createSignal<Array<{ text: string; cursor: number }>>([])
  const [editState, setEditState] = createSignal<{ text: string; cursor: number } | null>(null)
  const [copyCol, setCopyCol] = createSignal(options?.copy?.col ?? 0)
  const [copyIdx, setCopyIdx] = createSignal(options?.copy?.idx ?? 0)
  const copyRows = options?.copy?.rows
  const scrollCalls: VimScroll[] = []
  const jumpCalls: VimJump[] = []
  const copyMoves: Array<"up" | "down" | "left" | "right"> = []
  const copyJumps: Array<VimJump | "high" | "middle" | "low"> = []
  const copyVisualCalls: Array<"char" | "line"> = []
  const copyScrollCalls: Array<"center" | "top" | "bottom"> = []
  let copyYanks = 0
  let copyCopies = 0
  let copyExitVisuals = 0

  function clearPending() {
    setPending("")
  }

  function changeMode(next: "normal" | "insert" | "replace" | "visual" | "visual-line" | "copy") {
    clearPending()
    if (next !== "visual" && next !== "visual-line") setAnchor(null)
    if (next !== "replace") {
      setReplace(null)
      setTyped(false)
    }
    setMode(next)
  }

  const state: ReturnType<typeof createVimState> = {
    mode,
    setMode: changeMode,
    pending,
    setPending,
    clearPending,
    lastFind,
    setLastFind,
    register,
    setRegister,
    anchor,
    setAnchor,
    replace,
    setReplace,
    typed,
    setTyped,
    beginEdit(snapshot) {
      setEditState(snapshot)
    },
    commitEdit(snapshot) {
      const start = editState()
      setEditState(null)
      if (!start) return
      if (start.text === snapshot.text && start.cursor === snapshot.cursor) return
      setUndos((list) => [...list, { before: start, after: snapshot }])
      setRedos([])
    },
    cancelEdit() {
      setEditState(null)
    },
    push(before, after) {
      setEditState(null)
      if (before.text === after.text && before.cursor === after.cursor) return
      setUndos((list) => [...list, { before, after }])
      setRedos([])
    },
    undo(snapshot) {
      const item = undos()[undos().length - 1]
      if (!item) return
      setUndos((list) => list.slice(0, -1))
      setRedos((list) => [...list, snapshot])
      setEditState(null)
      return item.before
    },
    redo(snapshot) {
      const item = redos()[redos().length - 1]
      if (!item) return
      setRedos((list) => list.slice(0, -1))
      setUndos((list) => [...list, { before: snapshot, after: item }])
      setEditState(null)
      return item
    },
    resetHistory() {
      setUndos([])
      setRedos([])
      setEditState(null)
    },
    canUndo: () => undos().length > 0,
    canRedo: () => redos().length > 0,
    reset() {
      clearPending()
      setAnchor(null)
      setReplace(null)
      setTyped(false)
      setUndos([])
      setRedos([])
      setEditState(null)
      setMode("insert")
    },
    isInsert: () => mode() === "insert",
    isReplace: () => mode() === "replace",
    isVisual: () => mode() === "visual" || mode() === "visual-line",
    isVisualLine: () => mode() === "visual-line",
    isCopy: () => mode() === "copy",
  } as ReturnType<typeof createVimState>
  const handler = createVimHandler({
    enabled,
    state,
    textarea: () => textarea,
    register: options?.register?.get,
    setRegister: options?.register?.set,
    submit: options?.submit ?? (() => {}),
    scroll(action) {
      scrollCalls.push(action)
    },
    jump(action) {
      jumpCalls.push(action)
    },
    copy(action) {
      copyMoves.push(action)
    },
    copyVisual(mode) {
      copyVisualCalls.push(mode)
      setCopyVisual(mode)
    },
    copyExitVisual() {
      copyExitVisuals++
      setCopyVisual(undefined)
    },
    copyYank() {
      copyYanks++
      state.setRegister({ text: options?.copy?.text ?? "picked", linewise: false })
    },
    copyCopy() {
      copyCopies++
    },
    copyIsVisual() {
      return copyVisual() !== undefined
    },
    copyJump(action) {
      copyJumps.push(action)
    },
    copyWordNext(big) {
      if (!copyRows) return false
      const next = copyWordNext(copyRows, (idx) => options?.copy?.texts?.[idx] ?? "", copyIdx(), copyCol(), big)
      const moved = next.idx !== copyIdx() || next.col !== copyCol()
      setCopyIdx(next.idx)
      setCopyCol(next.col)
      return moved
    },
    copyWordPrev(big) {
      if (!copyRows) return false
      const prev = copyWordPrev(copyRows, (idx) => options?.copy?.texts?.[idx] ?? "", copyIdx(), copyCol(), big)
      const moved = prev.idx !== copyIdx() || prev.col !== copyCol()
      setCopyIdx(prev.idx)
      setCopyCol(prev.col)
      return moved
    },
    copyNextParagraph() {
      if (!copyRows) return false
      const next = copyNextParagraph(copyRows, (idx) => options?.copy?.texts?.[idx] ?? "", copyIdx())
      const col = copyRows[next.index]?.col ?? 0
      if (next.index === copyIdx() && !next.atEnd && col === copyCol()) return false
      setCopyIdx(next.index)
      setCopyCol(col)
      return true
    },
    copyPreviousParagraph() {
      if (!copyRows) return false
      const previous = copyPreviousParagraph(copyRows, (idx) => options?.copy?.texts?.[idx] ?? "", copyIdx())
      const col = copyRows[previous.index]?.col ?? 0
      if (previous.index === copyIdx() && col === copyCol()) return false
      setCopyIdx(previous.index)
      setCopyCol(col)
      return true
    },
    copyText() {
      return options?.copy?.texts?.[copyIdx()] ?? options?.copy?.text ?? "alpha beta gamma"
    },
    copyCol,
    setCopyCol(offset) {
      setCopyCol(offset)
    },
    setCopyStick() {},
    copyScroll(action: "center" | "top" | "bottom") {
      copyScrollCalls.push(action)
    },
    autocomplete: options?.autocomplete,
    snapshot() {
      return {
        text: textarea.plainText,
        cursor: textarea.cursorOffset,
        data: structuredClone(meta()),
      }
    },
    restore(next) {
      textarea.setText(next.text)
      textarea.cursorOffset = Math.max(0, Math.min(next.cursor, next.text.length))
      setMeta(next.data)
    },
    flash: options?.flash,
  })

  return {
    textarea,
    handler,
    state,
    scrollCalls,
    jumpCalls,
    copyMoves,
    copyJumps,
    copyVisual,
    copyVisualCalls,
    copyScrollCalls,
    copyYanks: () => copyYanks,
    copyCopies: () => copyCopies,
    copyExitVisuals: () => copyExitVisuals,
    copyCol,
    copyIdx,
    meta,
    setMeta,
  }
}

describe("vim motion handler", () => {
  test("moves with h j k l and clamps to line", () => {
    const ctx = createHandler("abc\nxy")

    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    expect(ctx.textarea.cursorOffset).toBe(2)

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(5)

    ctx.handler.handleKey(createEvent("h").event)
    expect(ctx.textarea.cursorOffset).toBe(4)

    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("h clamps at line start", () => {
    const ctx = createHandler("abc\ndef")
    ctx.textarea.cursorOffset = 4
    ctx.handler.handleKey(createEvent("h").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("l clamps at line end", () => {
    const ctx = createHandler("ab\ncd")
    ctx.textarea.cursorOffset = 1
    ctx.handler.handleKey(createEvent("l").event)
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("j on last line stays", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("k on first line stays", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("j/k move across leading empty first line", () => {
    const text = "\nline1\nline2\nline3\n"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 1, 0)

    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 0, 0))

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 0))
  })

  test("j/k move across trailing empty last line", () => {
    const text = "\nline1\nline2\nline3\n"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 3, 0)

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 4, 0))

    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 3, 0))
  })

  test("j and k preserve desired column across short lines", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 0))

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 5))

    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 0))

    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 0, 5))
  })

  test("arrow up and down preserve desired column across short lines", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 4)

    ctx.handler.handleKey(createEvent("down").event)
    ctx.handler.handleKey(createEvent("down").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 4))

    ctx.handler.handleKey(createEvent("up").event)
    ctx.handler.handleKey(createEvent("up").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 0, 4))
  })

  test("non-vertical motion resets desired column", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("h").event)
    ctx.handler.handleKey(createEvent("j").event)

    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 0))
  })

  test("shifted j join resets desired column", () => {
    const text = "abcdef\nx\nabc\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("j", { shift: true }).event)
    ctx.handler.handleKey(createEvent("j").event)

    expect(ctx.textarea.plainText).toBe("abcdef\nx abc\nabcdef")
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(ctx.textarea.plainText, 2, 1))
  })

  test("$ makes vertical movement stick to line end", () => {
    const text = "abc\ndefgh\nxy"
    const ctx = createHandler(text)

    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 0, 2))

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 4))

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 1))
  })

  test("supports word and big-word key shapes", () => {
    const ctx = createHandler("foo,bar baz")

    const w = createEvent("w")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(3)

    const upperW = createEvent("W")
    expect(ctx.handler.handleKey(upperW.event)).toBe(true)
    expect(upperW.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(8)

    ctx.textarea.cursorOffset = 0
    const shiftW = createEvent("w", { shift: true })
    expect(ctx.handler.handleKey(shiftW.event)).toBe(true)
    expect(shiftW.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(8)

    const upperE = createEvent("E")
    expect(ctx.handler.handleKey(upperE.event)).toBe(true)
    expect(upperE.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(10)

    const upperB = createEvent("B")
    expect(ctx.handler.handleKey(upperB.event)).toBe(true)
    expect(upperB.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("e stays on single-char word", () => {
    const ctx = createHandler("a")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("e from end of word moves to next word end", () => {
    const ctx = createHandler("a b")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("e from word end moves to next word end", () => {
    const ctx = createHandler("ab cd")
    ctx.textarea.cursorOffset = 1
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("e from whitespace moves to next word end", () => {
    const ctx = createHandler("ab  cd")
    ctx.textarea.cursorOffset = 2
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(5)
  })

  test("e treats punct cluster as its own word", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 2
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(5)
  })

  test("e from inside punct cluster lands on its last char", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 4
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(5)
  })

  test("e from end of punct cluster advances to next word end", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 5
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("e on standalone trailing punct stays put", () => {
    const ctx = createHandler("hello!")
    ctx.textarea.cursorOffset = 5
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.cursorOffset).toBe(5)
  })

  test("E treats punct as part of bigword", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("E").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("b moves to previous word start", () => {
    const ctx = createHandler("foo bar baz")
    ctx.textarea.cursorOffset = 8
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("b at start of text stays", () => {
    const ctx = createHandler("foo bar")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("b treats punctuation as its own word", () => {
    const ctx = createHandler("foo,bar")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("w lands on trailing punctuation", () => {
    const ctx = createHandler("changed?")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.cursorOffset).toBe(7)
  })

  test("w advances from punctuation to next word", () => {
    const ctx = createHandler("changed? next")
    ctx.textarea.cursorOffset = 7

    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.cursorOffset).toBe(9)
  })

  test("W treats punctuation as part of big word", () => {
    const ctx = createHandler("changed? next")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("W").event)
    expect(ctx.textarea.cursorOffset).toBe(9)
  })

  test("0 moves to line beginning", () => {
    const ctx = createHandler("  hello")
    ctx.textarea.cursorOffset = 4
    ctx.handler.handleKey(createEvent("0").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("0 on multiline moves to current line start", () => {
    const ctx = createHandler("abc\n  def")
    ctx.textarea.cursorOffset = 7
    ctx.handler.handleKey(createEvent("0").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("^ moves to first non-whitespace", () => {
    const ctx = createHandler("  hello")
    ctx.textarea.cursorOffset = 5
    ctx.handler.handleKey(createEvent("^").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("^ on line with no leading whitespace goes to column 0", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 3
    ctx.handler.handleKey(createEvent("^").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("_ moves to first non-whitespace like ^", () => {
    const ctx = createHandler("  hello")
    ctx.textarea.cursorOffset = 5
    ctx.handler.handleKey(createEvent("_").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("$ moves to last char of line", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("$ on multiline moves to last char of current line", () => {
    const ctx = createHandler("abc\ndef")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("$ on single char stays put", () => {
    const ctx = createHandler("a")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("^ on all-whitespace line goes to end", () => {
    const ctx = createHandler("   ")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("^").event)
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("$ on empty line in multiline", () => {
    const ctx = createHandler("abc\n\ndef")
    ctx.textarea.cursorOffset = 4
    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("} jumps to the next blank line", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("} lands on the first of consecutive blank lines", () => {
    const ctx = createHandler("a\n\n\n\nb")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("} from a blank line skips blanks then next paragraph", () => {
    const ctx = createHandler("a\n\n\nb\n\nc")
    ctx.textarea.cursorOffset = 2
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(6)
  })

  test("{ jumps to the previous blank line", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 14
    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("{ at start of buffer stays at 0", () => {
    const ctx = createHandler("abc\ndef")
    ctx.textarea.cursorOffset = 2
    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("} with no blank lines lands on last char", () => {
    const ctx = createHandler("only\nparagraph")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(13)
  })

  test("} does not treat whitespace-only line as blank", () => {
    const ctx = createHandler("a\n   \nb")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(6)
  })

  test("{ does not treat whitespace-only line as blank", () => {
    const ctx = createHandler("a\n\t \nb")
    ctx.textarea.cursorOffset = 5
    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("} with trailing newline lands on the trailing empty line", () => {
    const ctx = createHandler("abc\n\ndef\n")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("} with trailing newline lands on last char of last line", () => {
    const ctx = createHandler("abc\n")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("} with no blank line but trailing newline lands on last char of last line", () => {
    const ctx = createHandler("one\ntwo\n")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(6)
  })

  test("} with no blank lines anywhere goes to last char", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(12)
  })

  test("{ with no blank lines anywhere goes to start", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 10
    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("d} deletes through next paragraph boundary", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    const motion = createEvent("}")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("\nthree\nfour")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo\n", linewise: true })
  })

  test("d{ deletes backward through previous paragraph boundary", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 13

    ctx.handler.handleKey(createEvent("d").event)
    const motion = createEvent("{")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("one\ntwo\ne\nfour")
    expect(ctx.textarea.cursorOffset).toBe(8)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "\nthre", linewise: false })
  })

  test("c} deletes through next paragraph boundary and enters insert", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("c").event)
    const motion = createEvent("}")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    // c linewise preserves the line separator before the blank, unlike d
    expect(ctx.textarea.plainText).toBe("\n\nthree\nfour")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo\n", linewise: true })
  })

  test("c} on last char of last paragraph deletes the char and enters insert", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 12

    ctx.handler.handleKey(createEvent("c").event)
    const motion = createEvent("}")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("one\ntwo\nthre")
    expect(ctx.textarea.cursorOffset).toBe(12)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "e", linewise: false })
  })

  test("y} yanks through next paragraph boundary", () => {
    const flashes: Array<{ start: number; end: number }> = []
    const ctx = createHandler("one\ntwo\n\nthree\nfour", { flash: (span) => flashes.push(span) })
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    const motion = createEvent("}")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("one\ntwo\n\nthree\nfour")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo\n", linewise: true })
    expect(flashes).toEqual([{ start: 0, end: 8 }])
  })

  test("y} on last char of last paragraph yanks the char", () => {
    const flashes: Array<{ start: number; end: number }> = []
    const ctx = createHandler("one\ntwo\nthree", { flash: (span) => flashes.push(span) })
    ctx.textarea.cursorOffset = 12

    ctx.handler.handleKey(createEvent("y").event)
    const motion = createEvent("}")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("one\ntwo\nthree")
    expect(ctx.textarea.cursorOffset).toBe(12)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "e", linewise: false })
    expect(flashes).toEqual([{ start: 12, end: 13 }])
  })

  test("d} on last char of last paragraph deletes the char", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 12

    ctx.handler.handleKey(createEvent("d").event)
    const motion = createEvent("}")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("one\ntwo\nthre")
    expect(ctx.textarea.cursorOffset).toBe(12)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "e", linewise: false })
  })

  test("y{ yanks backward through previous paragraph boundary", () => {
    const flashes: Array<{ start: number; end: number }> = []
    const ctx = createHandler("one\ntwo\n\nthree\nfour", { flash: (span) => flashes.push(span) })
    ctx.textarea.cursorOffset = 13

    ctx.handler.handleKey(createEvent("y").event)
    const motion = createEvent("{")
    expect(ctx.handler.handleKey(motion.event)).toBe(true)
    expect(motion.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("one\ntwo\n\nthree\nfour")
    expect(ctx.textarea.cursorOffset).toBe(13)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "\nthre", linewise: false })
    expect(flashes).toEqual([{ start: 8, end: 13 }])
  })

  test("v then } extends selection to next blank line", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 9 })
  })

  test("v then { extends selection backward to previous blank line", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 14

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 8, end: 15 })
  })

  test("V then } extends linewise selection across paragraph", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.state.mode()).toBe("visual-line")
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("v then } then d deletes selection charwise through blank", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("}").event)
    ctx.handler.handleKey(createEvent("d").event)

    expect(ctx.textarea.plainText).toBe("three\nfour")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo\n\n", linewise: false })
  })

  test("v then } then y yanks selection charwise", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("}").event)
    ctx.handler.handleKey(createEvent("y").event)

    expect(ctx.textarea.plainText).toBe("one\ntwo\n\nthree\nfour")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo\n\n", linewise: false })
  })

  test("v then { then d deletes selection charwise backward", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 14

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("{").event)
    ctx.handler.handleKey(createEvent("d").event)

    expect(ctx.textarea.plainText).toBe("one\ntwo\nfour")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "\nthree\n", linewise: false })
  })

  test("V then } then d deletes full lines linewise", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("}").event)
    ctx.handler.handleKey(createEvent("d").event)

    expect(ctx.textarea.plainText).toBe("three\nfour")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()?.linewise).toBe(true)
  })

  test("V then } then y yanks full lines linewise", () => {
    const ctx = createHandler("one\ntwo\n\nthree\nfour")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("}").event)
    ctx.handler.handleKey(createEvent("y").event)

    expect(ctx.textarea.plainText).toBe("one\ntwo\n\nthree\nfour")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()?.linewise).toBe(true)
  })

  test("supports insert transitions for A I O", () => {
    const i0 = createHandler("abc")
    i0.textarea.cursorOffset = 1
    expect(i0.handler.handleKey(createEvent("i").event)).toBe(true)
    expect(i0.state.mode()).toBe("insert")
    expect(i0.textarea.cursorOffset).toBe(1)

    const i = createHandler("  abc")
    i.textarea.cursorOffset = 1
    expect(i.handler.handleKey(createEvent("I").event)).toBe(true)
    expect(i.state.mode()).toBe("insert")
    expect(i.textarea.cursorOffset).toBe(2)

    const a = createHandler("  abc")
    a.textarea.cursorOffset = 1
    expect(a.handler.handleKey(createEvent("A").event)).toBe(true)
    expect(a.state.mode()).toBe("insert")
    expect(a.textarea.cursorOffset).toBe(5)

    const o = createHandler("abc")
    o.textarea.cursorOffset = 1
    expect(o.handler.handleKey(createEvent("o", { shift: true }).event)).toBe(true)
    expect(o.state.mode()).toBe("insert")
    expect(o.textarea.plainText).toBe("\nabc")
  })

  test("a appends after cursor", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    expect(ctx.handler.handleKey(createEvent("a").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("a at end of line stays at end", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 2
    expect(ctx.handler.handleKey(createEvent("a").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("escape from insert clamps cursor off newline", () => {
    const ctx = createHandler("ab\ncd")
    ctx.textarea.cursorOffset = 0

    expect(ctx.handler.handleKey(createEvent("x").event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("b\ncd")
    expect(ctx.state.register()).toEqual({ text: "a", linewise: false })

    expect(ctx.handler.handleKey(createEvent("A").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.cursorOffset).toBe(1)

    expect(ctx.handler.handleKey(createEvent("escape").event)).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.textarea.cursorOffset).toBe(0)

    expect(ctx.handler.handleKey(createEvent("p").event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("ba\ncd")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("escape from insert leaves cursor inside line content alone", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    expect(ctx.handler.handleKey(createEvent("i").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")

    expect(ctx.handler.handleKey(createEvent("escape").event)).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("o opens line below and enters insert", () => {
    const ctx = createHandler("abc\ndef")
    ctx.textarea.cursorOffset = 1
    expect(ctx.handler.handleKey(createEvent("o").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("abc\n\ndef")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("o on last line opens line below", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    expect(ctx.handler.handleKey(createEvent("o").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("abc\n")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("O on first line inserts line above", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    expect(ctx.handler.handleKey(createEvent("O").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("\nabc")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("backspace is consumed in normal mode", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    const bs = createEvent("backspace")
    expect(ctx.handler.handleKey(bs.event)).toBe(true)
    expect(bs.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("abc")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("delete is consumed in normal mode", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    const del = createEvent("delete")
    expect(ctx.handler.handleKey(del.event)).toBe(true)
    expect(del.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("abc")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("printable keys are consumed in normal mode", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    const z = createEvent("z")
    expect(ctx.handler.handleKey(z.event)).toBe(true)
    expect(z.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("abc")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("printable keys with modifiers pass through", () => {
    const ctx = createHandler("abc")
    const v = createEvent("v", { ctrl: true })
    expect(ctx.handler.handleKey(v.event)).toBe(false)
    expect(v.prevented()).toBe(false)
  })

  test("x deletes under cursor and no-ops at end", () => {
    const a = createHandler("abc")
    a.textarea.cursorOffset = 1
    const x = createEvent("x")
    expect(a.handler.handleKey(x.event)).toBe(true)
    expect(x.prevented()).toBe(true)
    expect(a.textarea.plainText).toBe("ac")

    const b = createHandler("ab\ncd")
    b.textarea.cursorOffset = 2
    expect(b.handler.handleKey(createEvent("x").event)).toBe(true)
    expect(b.textarea.plainText).toBe("ab\ncd")
  })

  test("uses custom register setter", () => {
    let reg = null as { text: string; linewise: boolean } | null
    const ctx = createHandler("abc", {
      register: {
        set(next) {
          reg = next
        },
      },
    })

    ctx.textarea.cursorOffset = 1
    expect(ctx.handler.handleKey(createEvent("x").event)).toBe(true)
    expect(reg).toEqual({ text: "b", linewise: false })
    expect(ctx.state.register()).toBe(null)
  })

  test("~ toggles case and moves right like vim", () => {
    const ctx = createHandler("a.")

    const a = createEvent("~")
    expect(ctx.handler.handleKey(a.event)).toBe(true)
    expect(a.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("A.")
    expect(ctx.textarea.cursorOffset).toBe(1)

    const dot = createEvent("~")
    expect(ctx.handler.handleKey(dot.event)).toBe(true)
    expect(dot.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("A.")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("~ on last char stays on that char", () => {
    const ctx = createHandler("ab")
    ctx.textarea.cursorOffset = 1

    expect(ctx.handler.handleKey(createEvent("~").event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("aB")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("x on empty string is a no-op", () => {
    const ctx = createHandler("")
    const x = createEvent("x")
    expect(ctx.handler.handleKey(x.event)).toBe(true)
    expect(x.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("")
  })

  test("S clears current line and enters insert", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5
    const s = createEvent("S")

    expect(ctx.handler.handleKey(s.event)).toBe(true)
    expect(s.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("one\n\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("S clears single line", () => {
    const ctx = createHandler("abc")
    const s = createEvent("S")

    expect(ctx.handler.handleKey(s.event)).toBe(true)
    expect(s.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("S keeps empty buffer", () => {
    const ctx = createHandler("")
    const s = createEvent("S")

    expect(ctx.handler.handleKey(s.event)).toBe(true)
    expect(s.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("D deletes to end of line and populates charwise register", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5
    const d = createEvent("D")

    expect(ctx.handler.handleKey(d.event)).toBe(true)
    expect(d.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.textarea.plainText).toBe("one\nt\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.register()).toEqual({ text: "wo", linewise: false })
  })

  test("C deletes to end of line, enters insert, and populates register", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5
    const c = createEvent("C")

    expect(ctx.handler.handleKey(c.event)).toBe(true)
    expect(c.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("one\nt\nthree")
    expect(ctx.textarea.cursorOffset).toBe(5)
    expect(ctx.state.register()).toEqual({ text: "wo", linewise: false })
  })

  test("C on empty line enters insert without changes", () => {
    const ctx = createHandler("one\n\nthree")
    ctx.textarea.cursorOffset = 4
    const c = createEvent("C")

    expect(ctx.handler.handleKey(c.event)).toBe(true)
    expect(c.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("one\n\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.register()).toBeNull()
  })

  test("cc clears current line and enters insert", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    const c1 = createEvent("c")
    expect(ctx.handler.handleKey(c1.event)).toBe(true)
    expect(c1.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("c")

    const c2 = createEvent("c")
    expect(ctx.handler.handleKey(c2.event)).toBe(true)
    expect(c2.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.textarea.plainText).toBe("one\n\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.pending()).toBe("")
  })

  test("cw changes to end of word and enters insert", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 0

    const c = createEvent("c")
    expect(ctx.handler.handleKey(c.event)).toBe(true)
    expect(ctx.state.pending()).toBe("c")

    const w = createEvent("w")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe(" world test")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("cw from mid-word changes to end of word", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.plainText).toBe("he world")
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "llo", linewise: false })
  })

  test("cw on punctuation changes punctuation word", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.plainText).toBe("foobar")
    expect(ctx.textarea.cursorOffset).toBe(3)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "!!!", linewise: false })
  })

  test("cw from whitespace changes through next word start", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.plainText).toBe("helloworld")
    expect(ctx.textarea.cursorOffset).toBe(5)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: " ", linewise: false })
  })

  test("cW changes through end of big word and enters insert", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("c").event)
    const w = createEvent("W")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe(" baz")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "foo.bar", linewise: false })
  })

  test("cW from whitespace changes through next big word start", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 7

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("W").event)
    expect(ctx.textarea.plainText).toBe("foo.barbaz")
    expect(ctx.textarea.cursorOffset).toBe(7)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: " ", linewise: false })
  })

  test("pending c clears on escape", () => {
    const ctx = createHandler("hello world")

    expect(ctx.handler.handleKey(createEvent("c").event)).toBe(true)
    expect(ctx.state.pending()).toBe("c")

    const esc = createEvent("escape")
    expect(ctx.handler.handleKey(esc.event)).toBe(true)
    expect(esc.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.textarea.plainText).toBe("hello world")
  })

  test("pending c clears on modifier key", () => {
    const ctx = createHandler("abc")

    expect(ctx.handler.handleKey(createEvent("c").event)).toBe(true)
    expect(ctx.state.pending()).toBe("c")

    const mod = createEvent("j", { ctrl: true })
    expect(ctx.handler.handleKey(mod.event)).toBe(false)
    expect(mod.prevented()).toBe(false)
    expect(ctx.state.pending()).toBe("")
  })

  test("pending c clears on non-motion key and key is handled", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 2

    expect(ctx.handler.handleKey(createEvent("c").event)).toBe(true)
    expect(ctx.state.pending()).toBe("c")

    const h = createEvent("h")
    expect(ctx.handler.handleKey(h.event)).toBe(true)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("escape in normal mode with no pending returns false", () => {
    const ctx = createHandler("abc")
    const esc = createEvent("escape")
    expect(ctx.handler.handleKey(esc.event)).toBe(false)
    expect(esc.prevented()).toBe(false)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("insert mode only handles escape", () => {
    const ctx = createHandler("abc", { mode: "insert" })

    const w = createEvent("w")
    expect(ctx.handler.handleKey(w.event)).toBe(false)
    expect(w.prevented()).toBe(false)

    const esc = createEvent("escape")
    expect(ctx.handler.handleKey(esc.event)).toBe(true)
    expect(esc.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("R enters replace mode and escape exits", () => {
    const ctx = createHandler("abc")

    const enter = createEvent("R")
    expect(ctx.handler.handleKey(enter.event)).toBe(true)
    expect(enter.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("replace")

    const esc = createEvent("escape")
    expect(ctx.handler.handleKey(esc.event)).toBe(true)
    expect(esc.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("shift+r also enters replace mode", () => {
    const ctx = createHandler("abc")

    const enter = createEvent("r", { shift: true })
    expect(ctx.handler.handleKey(enter.event)).toBe(true)
    expect(enter.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("replace")
  })

  test("R clears pending operator when entering replace mode", () => {
    const ctx = createHandler("abc")
    ctx.state.setPending("d")

    expect(ctx.handler.handleKey(createEvent("R").event)).toBe(true)
    expect(ctx.state.mode()).toBe("replace")
    expect(ctx.state.pending()).toBe("")
  })

  test("replace mode overwrites characters and advances", () => {
    const ctx = createHandler("abcd")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("R").event)
    ctx.handler.handleKey(createEvent("X").event)
    ctx.handler.handleKey(createEvent("Y").event)

    expect(ctx.textarea.plainText).toBe("aXYd")
    expect(ctx.textarea.cursorOffset).toBe(3)
    expect(ctx.state.mode()).toBe("replace")
  })

  test("replace mode overwrites with space key", () => {
    const ctx = createHandler("abcd", { mode: "replace" })
    ctx.textarea.cursorOffset = 1

    const key = createEvent("space")
    expect(ctx.handler.handleKey(key.event)).toBe(true)
    expect(key.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("a cd")
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("replace mode inserts at line end without removing newline", () => {
    const ctx = createHandler("ab\ncd", { mode: "replace" })
    ctx.textarea.cursorOffset = 2

    const key = createEvent("X")
    expect(ctx.handler.handleKey(key.event)).toBe(true)
    expect(key.prevented()).toBe(true)

    expect(ctx.textarea.plainText).toBe("abX\ncd")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("replace mode keeps appending before newline", () => {
    const ctx = createHandler("ab\ncd", { mode: "replace" })
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("X").event)
    ctx.handler.handleKey(createEvent("Y").event)

    expect(ctx.textarea.plainText).toBe("abXY\ncd")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("replace mode appends at end of buffer", () => {
    const ctx = createHandler("ab", { mode: "replace" })
    ctx.textarea.cursorOffset = 2

    expect(ctx.handler.handleKey(createEvent("X").event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("abX")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("escape from replace mode moves cursor back like vim", () => {
    const ctx = createHandler("abcd")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("R").event)
    ctx.handler.handleKey(createEvent("X").event)
    ctx.handler.handleKey(createEvent("Y").event)
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("aXYd")
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("escape from replace mode without edits keeps cursor in place", () => {
    const ctx = createHandler("abcd")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("R").event)
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("abcd")
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("escape after appending at line end lands on last inserted char", () => {
    const ctx = createHandler("ab\ncd")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("R").event)
    ctx.handler.handleKey(createEvent("X").event)
    ctx.handler.handleKey(createEvent("Y").event)
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("abXY\ncd")
    expect(ctx.textarea.cursorOffset).toBe(3)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("replace mode ignores modified printable keys", () => {
    const ctx = createHandler("abcd", { mode: "replace" })
    ctx.textarea.cursorOffset = 1

    const key = createEvent("X", { ctrl: true })
    expect(ctx.handler.handleKey(key.event)).toBe(false)
    expect(key.prevented()).toBe(false)
    expect(ctx.textarea.plainText).toBe("abcd")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("replace mode tracks replace session state", () => {
    const ctx = createHandler("abcd")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("R").event)
    expect(ctx.state.replace()).toBe(1)
    expect(ctx.state.typed()).toBe(false)

    ctx.handler.handleKey(createEvent("X").event)
    expect(ctx.state.replace()).toBe(1)
    expect(ctx.state.typed()).toBe(true)

    ctx.handler.handleKey(createEvent("escape").event)
    expect(ctx.state.replace()).toBe(null)
    expect(ctx.state.typed()).toBe(false)
  })

  test("/ and @ stay in normal mode without autocomplete", () => {
    const ctx = createHandler("abc", { mode: "normal" })

    const slash = createEvent("/")
    expect(ctx.handler.handleKey(slash.event)).toBe(true)
    expect(slash.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")

    const at = createEvent("@")
    expect(ctx.handler.handleKey(at.event)).toBe(true)
    expect(at.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("/ enters insert on empty input with autocomplete visible", () => {
    const ctx = createHandler("", {
      mode: "normal",
      autocomplete: () => "/",
    })
    const slash = createEvent("/")

    expect(ctx.handler.handleKey(slash.event)).toBe(false)
    expect(slash.prevented()).toBe(false)
    expect(ctx.state.mode()).toBe("insert")
  })

  test("@ enters insert on empty input with autocomplete visible", () => {
    const ctx = createHandler("", {
      mode: "normal",
      autocomplete: () => "@",
    })
    const at = createEvent("@")

    expect(ctx.handler.handleKey(at.event)).toBe(false)
    expect(at.prevented()).toBe(false)
    expect(ctx.state.mode()).toBe("insert")
  })

  test("/ stays normal on non-empty input with autocomplete visible", () => {
    const ctx = createHandler("abc", {
      mode: "normal",
      autocomplete: () => "/",
    })
    const slash = createEvent("/")

    expect(ctx.handler.handleKey(slash.event)).toBe(true)
    expect(slash.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("submit from normal keeps mode and clears pending", () => {
    let calls = 0
    const ctx = createHandler("", {
      mode: "normal",
      submit() {
        calls++
      },
    })
    ctx.state.setPending("d")

    ctx.handler.handleKey(createEvent("return").event)

    expect(calls).toBe(1)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.pending()).toBe("")
  })

  test("vim disabled does not intercept keys", () => {
    const ctx = createHandler("abc", { enabled: false })
    const keys = [
      createEvent("h"),
      createEvent("x"),
      createEvent("d"),
      createEvent("g"),
      createEvent("d", { ctrl: true }),
    ]

    for (const key of keys) {
      expect(ctx.handler.handleKey(key.event)).toBe(false)
      expect(key.prevented()).toBe(false)
    }

    expect(ctx.scrollCalls.length).toBe(0)
    expect(ctx.jumpCalls.length).toBe(0)
  })

  test("dd deletes current line", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    const d1 = createEvent("d")
    expect(ctx.handler.handleKey(d1.event)).toBe(true)
    expect(d1.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const d2 = createEvent("d")
    expect(ctx.handler.handleKey(d2.event)).toBe(true)
    expect(d2.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.pending()).toBe("")
  })

  test("dd on last line lands at resulting line start", () => {
    const ctx = createHandler("one\ntwo")
    ctx.textarea.cursorOffset = 5

    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("one")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("dw deletes to next word and clears pending", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 0

    const d = createEvent("d")
    expect(ctx.handler.handleKey(d.event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const w = createEvent("w")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("world test")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.pending()).toBe("")
  })

  test("dw at last word deletes to end", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("dw stops before trailing punctuation", () => {
    const ctx = createHandler("changed?")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.plainText).toBe("?")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.register()).toEqual({ text: "changed", linewise: false })
  })

  test("dW deletes through next big word start", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    const w = createEvent("W")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("baz")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "foo.bar ", linewise: false })
  })

  test("dW at final big word deletes to end", () => {
    const ctx = createHandler("foo.bar")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("W").event)
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.register()).toEqual({ text: "foo.bar", linewise: false })
  })

  test("db deletes to current word start", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 8

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.plainText).toBe("hello rld test")
    expect(ctx.textarea.cursorOffset).toBe(6)
    expect(ctx.state.pending()).toBe("")
  })

  test("db at start of text is no-op", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("cb deletes to current word start and enters insert", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 8

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.plainText).toBe("hello rld test")
    expect(ctx.textarea.cursorOffset).toBe(6)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.pending()).toBe("")
  })

  test("cb at start of text does not delete text", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.pending()).toBe("")
  })

  test("db with register captures deleted text", () => {
    let reg = null as { text: string; linewise: boolean } | null
    const ctx = createHandler("hello world test", {
      register: {
        set(next) {
          reg = next
        },
      },
    })
    ctx.textarea.cursorOffset = 8

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(reg).toEqual({ text: "wo", linewise: false })
  })

  test("de deletes to end of word and clears pending", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 0

    const d = createEvent("d")
    expect(ctx.handler.handleKey(d.event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const e = createEvent("e")
    expect(ctx.handler.handleKey(e.event)).toBe(true)
    expect(e.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe(" world test")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.pending()).toBe("")
  })

  test("de from mid-word deletes to end of current word", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("he world")
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("de from whitespace deletes through next word", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("hello test")
    expect(ctx.textarea.cursorOffset).toBe(5)
  })

  test("de at last word deletes to end", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("de populates register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("dE deletes through end of BIG word across punctuation", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    const e = createEvent("E")
    expect(ctx.handler.handleKey(e.event)).toBe(true)
    expect(e.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe(" baz")
    expect(ctx.state.register()).toEqual({ text: "foo.bar", linewise: false })
    expect(ctx.state.pending()).toBe("")
  })

  test("dE from mid big-word deletes to end of current big-word", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("E").event)
    expect(ctx.textarea.plainText).toBe("fo baz")
    expect(ctx.state.register()).toEqual({ text: "o.bar", linewise: false })
  })

  test("de at last char of buffer deletes that char", () => {
    const ctx = createHandler("one two")
    ctx.textarea.cursorOffset = 6

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("one tw")
    expect(ctx.state.register()).toEqual({ text: "o", linewise: false })
  })

  test("de past end of buffer is a no-op and clears pending", () => {
    const ctx = createHandler("hi")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("hi")
    expect(ctx.state.pending()).toBe("")
  })

  test("ce deletes to end of word and enters insert", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 0

    const c = createEvent("c")
    expect(ctx.handler.handleKey(c.event)).toBe(true)
    expect(ctx.state.pending()).toBe("c")

    const e = createEvent("e")
    expect(ctx.handler.handleKey(e.event)).toBe(true)
    expect(e.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe(" world test")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.pending()).toBe("")
  })

  test("ce from mid-word changes to end of current word", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("he world")
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(ctx.state.mode()).toBe("insert")
  })

  test("ce populates register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("cE changes through end of BIG word and enters insert", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("E").event)
    expect(ctx.textarea.plainText).toBe(" baz")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "foo.bar", linewise: false })
  })

  test("cE from mid big-word changes to end of current big-word", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("E").event)
    expect(ctx.textarea.plainText).toBe("fo baz")
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "o.bar", linewise: false })
  })

  test("de from end of word deletes through punct cluster", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("fobar")
    expect(ctx.state.register()).toEqual({ text: "o!!!", linewise: false })
  })

  test("de from start of punct cluster deletes the cluster", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("foobar")
    expect(ctx.state.register()).toEqual({ text: "!!!", linewise: false })
  })

  test("de from mid punct cluster deletes to end of cluster", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("foo!bar")
    expect(ctx.state.register()).toEqual({ text: "!!", linewise: false })
  })

  test("de from end of punct cluster advances into next word", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("foo!!")
    expect(ctx.state.register()).toEqual({ text: "!bar", linewise: false })
  })

  test("de on punct surrounded by spaces deletes only cluster", () => {
    const ctx = createHandler("a !!! b")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("a ! b")
    expect(ctx.state.register()).toEqual({ text: "!!", linewise: false })
  })

  test("de on trailing punct deletes the punct", () => {
    const ctx = createHandler("hello!")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("hello")
    expect(ctx.state.register()).toEqual({ text: "!", linewise: false })
  })

  test("ce on punct cluster changes the cluster", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("foobar")
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "!!!", linewise: false })
  })

  test("ye yanks punct cluster only", () => {
    const ctx = createHandler("foo!!!bar")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.textarea.plainText).toBe("foo!!!bar")
    expect(ctx.state.register()).toEqual({ text: "!!!", linewise: false })
  })

  test("cb with register captures deleted text", () => {
    let reg = null as { text: string; linewise: boolean } | null
    const ctx = createHandler("hello world test", {
      register: {
        set(next) {
          reg = next
        },
      },
    })
    ctx.textarea.cursorOffset = 8

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(reg).toEqual({ text: "wo", linewise: false })
  })

  test("J joins current line with next", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 1

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(j.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.textarea.plainText).toBe("one two\nthree")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("J strips leading whitespace on next line", () => {
    const ctx = createHandler("one\n  two")
    ctx.textarea.cursorOffset = 0

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("one two")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("J on last line is a no-op", () => {
    const ctx = createHandler("only line")
    ctx.textarea.cursorOffset = 2

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(j.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("only line")
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("J with empty next line", () => {
    const ctx = createHandler("one\n\nthree")
    ctx.textarea.cursorOffset = 0

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("one \nthree")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("J strips tab indentation on next line", () => {
    const ctx = createHandler("one\n\t\ttwo")
    ctx.textarea.cursorOffset = 0

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("one two")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("J skips space when current line has trailing whitespace", () => {
    const ctx = createHandler("one \ntwo")
    ctx.textarea.cursorOffset = 0

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("one two")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("J skips space when next line starts with )", () => {
    const ctx = createHandler("foo(\n)")
    ctx.textarea.cursorOffset = 0

    const j = createEvent("J")
    expect(ctx.handler.handleKey(j.event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("foo()")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("f finds character forward", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    expect(ctx.state.pending()).toBe("f")

    const o = createEvent("o")
    expect(ctx.handler.handleKey(o.event)).toBe(true)
    expect(o.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.pending()).toBe("")
  })

  test("F finds character backward", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 8

    ctx.handler.handleKey(createEvent("F").event)
    expect(ctx.state.pending()).toBe("F")

    const o = createEvent("o")
    expect(ctx.handler.handleKey(o.event)).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(7)
  })

  test("f not found stays put", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    ctx.handler.handleKey(createEvent("z").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("f stays on current line", () => {
    const ctx = createHandler("abc\ndef")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("f clears pending after char", () => {
    const ctx = createHandler("abcabc")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    expect(ctx.state.pending()).toBe("f")
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.state.pending()).toBe("")
  })

  test("f pending clears on escape", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    expect(ctx.state.pending()).toBe("f")
    ctx.handler.handleKey(createEvent("escape").event)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("; repeats last find forward", () => {
    const ctx = createHandler("abcabc")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(1)

    ctx.handler.handleKey(createEvent(";").event)
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test(", repeats last find in reverse", () => {
    const ctx = createHandler("abcabc")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("f").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(1)

    ctx.handler.handleKey(createEvent(";").event)
    expect(ctx.textarea.cursorOffset).toBe(4)

    const comma = createEvent(",")
    expect(ctx.handler.handleKey(comma.event)).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("; with no previous find is no-op", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 2

    const semi = createEvent(";")
    expect(ctx.handler.handleKey(semi.event)).toBe(true)
    expect(semi.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("F then ; repeats backward", () => {
    const ctx = createHandler("abcabc")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("F").event)
    ctx.handler.handleKey(createEvent("a").event)
    expect(ctx.textarea.cursorOffset).toBe(3)

    ctx.handler.handleKey(createEvent(";").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("t stops one before target", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("t").event)
    expect(ctx.state.pending()).toBe("t")

    const o = createEvent("o")
    expect(ctx.handler.handleKey(o.event)).toBe(true)
    expect(o.prevented()).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(3)
    expect(ctx.state.pending()).toBe("")
  })

  test("T stops one after target backward", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 8

    ctx.handler.handleKey(createEvent("T").event)
    expect(ctx.state.pending()).toBe("T")

    const o = createEvent("o")
    expect(ctx.handler.handleKey(o.event)).toBe(true)
    expect(ctx.textarea.cursorOffset).toBe(8)
  })

  test("t not found stays put", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("t").event)
    ctx.handler.handleKey(createEvent("z").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("t stays on current line", () => {
    const ctx = createHandler("abc\ndef")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("t").event)
    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("; after t repeats as till", () => {
    const ctx = createHandler("axbxbx")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("t").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(1)

    ctx.handler.handleKey(createEvent(";").event)
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test(", after t reverses as till", () => {
    const ctx = createHandler("axbxxbxc")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("t").event)
    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.textarea.cursorOffset).toBe(1)

    ctx.handler.handleKey(createEvent(";").event)
    expect(ctx.textarea.cursorOffset).toBe(4)

    ctx.handler.handleKey(createEvent(",").event)
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("yy yanks current line into register", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.state.pending()).toBe("y")

    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
    expect(ctx.textarea.cursorOffset).toBe(5)
    expect(ctx.textarea.plainText).toBe("one\ntwo\nthree")
  })

  test("yy flashes current line span", () => {
    const spans: Array<{ start: number; end: number }> = []
    const ctx = createHandler("one\ntwo\nthree", {
      flash(span) {
        spans.push(span)
      },
    })
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("y").event)

    expect(spans).toEqual([{ start: 4, end: 7 }])
  })

  test("yw yanks word into register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.state.register()).toEqual({ text: "hello ", linewise: false })
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.textarea.plainText).toBe("hello world")
  })

  test("yw stops before trailing punctuation", () => {
    const ctx = createHandler("changed?")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.state.register()).toEqual({ text: "changed", linewise: false })
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.textarea.plainText).toBe("changed?")
  })

  test("yW yanks through next big word start", () => {
    const ctx = createHandler("foo.bar baz")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    const w = createEvent("W")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.state.register()).toEqual({ text: "foo.bar ", linewise: false })
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.textarea.plainText).toBe("foo.bar baz")
    expect(ctx.state.pending()).toBe("")
  })

  test("yW flashes yanked big word span", () => {
    const spans: Array<{ start: number; end: number }> = []
    const ctx = createHandler("foo.bar baz", {
      flash(span) {
        spans.push(span)
      },
    })
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("W").event)

    expect(spans).toEqual([{ start: 0, end: 8 }])
  })

  test("yw flashes yanked word span", () => {
    const spans: Array<{ start: number; end: number }> = []
    const ctx = createHandler("hello world", {
      flash(span) {
        spans.push(span)
      },
    })
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("w").event)

    expect(spans).toEqual([{ start: 0, end: 6 }])
  })

  test("ye yanks to end of word into register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    const y = createEvent("y")
    expect(ctx.handler.handleKey(y.event)).toBe(true)
    expect(ctx.state.pending()).toBe("y")

    const e = createEvent("e")
    expect(ctx.handler.handleKey(e.event)).toBe(true)
    expect(e.prevented()).toBe(true)
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.state.pending()).toBe("")
  })

  test("ye from mid-word yanks to end of current word", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.state.register()).toEqual({ text: "llo", linewise: false })
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(ctx.textarea.plainText).toBe("hello world")
  })

  test("ye flashes yanked span", () => {
    const spans: Array<{ start: number; end: number }> = []
    const ctx = createHandler("hello world", {
      flash(span) {
        spans.push(span)
      },
    })
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("e").event)

    expect(spans).toEqual([{ start: 0, end: 5 }])
  })

  test("yE yanks through end of BIG word across punctuation", () => {
    const spans: Array<{ start: number; end: number }> = []
    const ctx = createHandler("foo.bar baz", {
      flash(span) {
        spans.push(span)
      },
    })
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("E").event)
    expect(ctx.state.register()).toEqual({ text: "foo.bar", linewise: false })
    expect(ctx.textarea.plainText).toBe("foo.bar baz")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(spans).toEqual([{ start: 0, end: 7 }])
  })

  test("yE from mid big-word yanks to end of current big-word", () => {
    const spans: Array<{ start: number; end: number }> = []
    const ctx = createHandler("foo.bar baz", {
      flash(span) {
        spans.push(span)
      },
    })
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("E").event)
    expect(ctx.state.register()).toEqual({ text: "o.bar", linewise: false })
    expect(ctx.textarea.plainText).toBe("foo.bar baz")
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect(spans).toEqual([{ start: 2, end: 7 }])
  })

  test("p pastes linewise below current line", () => {
    const ctx = createHandler("one\ntwo")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("y").event)

    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("one\none\ntwo")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("P pastes linewise above current line", () => {
    const ctx = createHandler("one\ntwo")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("y").event)

    ctx.handler.handleKey(createEvent("P").event)
    expect(ctx.textarea.plainText).toBe("one\ntwo\ntwo")
    expect(ctx.textarea.cursorOffset).toBe(4)
  })

  test("p pastes characterwise after cursor", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("w").event)

    ctx.textarea.cursorOffset = 6
    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("hello whello orld")
    expect(ctx.textarea.cursorOffset).toBe(12)
  })

  test("uses custom register getter for paste", () => {
    const ctx = createHandler("abc", {
      register: {
        get() {
          return { text: "z", linewise: false }
        },
      },
    })

    expect(ctx.handler.handleKey(createEvent("p").event)).toBe(true)
    expect(ctx.textarea.plainText).toBe("azbc")
    expect(ctx.state.register()).toBe(null)
  })

  test("P pastes characterwise before cursor", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("w").event)

    ctx.textarea.cursorOffset = 6
    ctx.handler.handleKey(createEvent("P").event)
    expect(ctx.textarea.plainText).toBe("hello hello world")
    expect(ctx.textarea.cursorOffset).toBe(11)
  })

  test("p with empty register is no-op", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 2

    const p = createEvent("p")
    expect(ctx.handler.handleKey(p.event)).toBe(true)
    expect(p.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("hello")
    expect(ctx.textarea.cursorOffset).toBe(2)
  })

  test("yy then p multiple times", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("y").event)

    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("abc\nabc")

    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("abc\nabc\nabc")
  })

  test("dd populates register", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("dw populates register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.state.register()).toEqual({ text: "hello ", linewise: false })
  })

  test("x populates register", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("x").event)
    expect(ctx.state.register()).toEqual({ text: "b", linewise: false })
  })

  test("pending y clears on escape", () => {
    const ctx = createHandler("hello")

    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.state.pending()).toBe("y")

    ctx.handler.handleKey(createEvent("escape").event)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toBe(null)
  })

  test("pending y clears on invalid key", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.state.pending()).toBe("y")

    ctx.handler.handleKey(createEvent("h").event)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("pending y clears on modifier key", () => {
    const ctx = createHandler("abc")

    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.state.pending()).toBe("y")

    const mod = createEvent("j", { ctrl: true })
    expect(ctx.handler.handleKey(mod.event)).toBe(false)
    expect(mod.prevented()).toBe(false)
    expect(ctx.state.pending()).toBe("")
  })

  test("dd then p pastes deleted line below", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("one\nthree")

    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("one\nthree\ntwo")
  })

  test("pending d clears on escape", () => {
    const ctx = createHandler("hello world")

    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const esc = createEvent("escape")
    expect(ctx.handler.handleKey(esc.event)).toBe(true)
    expect(esc.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.textarea.plainText).toBe("hello world")
  })

  test("pending d clears on invalid key and key is handled normally", () => {
    const ctx = createHandler("abc")

    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const i = createEvent("i")
    expect(ctx.handler.handleKey(i.event)).toBe(true)
    expect(i.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.mode()).toBe("insert")
  })

  test("mode switch clears pending state", () => {
    const ctx = createHandler("abc")
    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    expect(ctx.handler.handleKey(createEvent("i").event)).toBe(true)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.pending()).toBe("")

    expect(ctx.handler.handleKey(createEvent("escape").event)).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.pending()).toBe("")

    const h = createEvent("h")
    expect(ctx.handler.handleKey(h.event)).toBe(true)
    expect(h.prevented()).toBe(true)
  })

  test("pending d clears on modifier key and event is not consumed", () => {
    const ctx = createHandler("abc")

    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const mod = createEvent("j", { ctrl: true })
    expect(ctx.handler.handleKey(mod.event)).toBe(false)
    expect(mod.prevented()).toBe(false)
    expect(ctx.state.pending()).toBe("")
  })

  test("ctrl scroll keys trigger actions", () => {
    const ctx = createHandler("abc")
    const keys: Array<[string, VimScroll]> = [
      ["e", "line-down"],
      ["y", "line-up"],
      ["d", "half-down"],
      ["u", "half-up"],
      ["f", "page-down"],
      ["b", "page-up"],
    ]

    for (const [key, action] of keys) {
      const evt = createEvent(key, { ctrl: true })
      expect(ctx.handler.handleKey(evt.event)).toBe(true)
      expect(evt.prevented()).toBe(true)
      expect(ctx.scrollCalls.at(-1)).toBe(action)
    }
  })

  test("ctrl scroll clears pending operator", () => {
    const ctx = createHandler("abc")
    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const evt = createEvent("d", { ctrl: true })
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.scrollCalls.at(-1)).toBe("half-down")
    expect(ctx.state.pending()).toBe("")
  })

  test("ctrl scroll not handled in insert mode", () => {
    const ctx = createHandler("abc", { mode: "insert" })
    const evt = createEvent("e", { ctrl: true })
    expect(ctx.handler.handleKey(evt.event)).toBe(false)
    expect(evt.prevented()).toBe(false)
    expect(ctx.scrollCalls.length).toBe(0)
  })

  test("ctrl scroll not handled when vim disabled", () => {
    const ctx = createHandler("abc", { enabled: false })
    const evt = createEvent("e", { ctrl: true })
    expect(ctx.handler.handleKey(evt.event)).toBe(false)
    expect(evt.prevented()).toBe(false)
    expect(ctx.scrollCalls.length).toBe(0)
  })

  test("g and G jump to top or bottom", () => {
    const ctx = createHandler("abc")

    const g = createEvent("g")
    expect(ctx.handler.handleKey(g.event)).toBe(true)
    expect(g.prevented()).toBe(true)
    expect(ctx.jumpCalls.length).toBe(0)
    expect(ctx.state.pending()).toBe("g")

    const g2 = createEvent("g")
    expect(ctx.handler.handleKey(g2.event)).toBe(true)
    expect(g2.prevented()).toBe(true)
    expect(ctx.jumpCalls.at(-1)).toBe("top")
    expect(ctx.state.pending()).toBe("")

    const G = createEvent("G")
    expect(ctx.handler.handleKey(G.event)).toBe(true)
    expect(G.prevented()).toBe(true)
    expect(ctx.jumpCalls.at(-1)).toBe("bottom")
  })

  test("H, M, L jump to high, middle, and low", () => {
    const ctx = createHandler("abc")

    ctx.handler.handleKey(createEvent("H").event)
    ctx.handler.handleKey(createEvent("M").event)
    ctx.handler.handleKey(createEvent("L").event)

    expect(ctx.jumpCalls).toEqual(["high", "middle", "low"])
  })

  test("pending g cancels on other keys", () => {
    const ctx = createHandler("abc")
    expect(ctx.handler.handleKey(createEvent("g").event)).toBe(true)
    expect(ctx.state.pending()).toBe("g")

    const w = createEvent("w")
    expect(ctx.handler.handleKey(w.event)).toBe(true)
    expect(w.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")
  })

  test("pending transition d to g", () => {
    const ctx = createHandler("abc")
    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const g = createEvent("g")
    expect(ctx.handler.handleKey(g.event)).toBe(true)
    expect(g.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("g")

    const g2 = createEvent("g")
    expect(ctx.handler.handleKey(g2.event)).toBe(true)
    expect(g2.prevented()).toBe(true)
    expect(ctx.jumpCalls.at(-1)).toBe("top")
    expect(ctx.scrollCalls.length).toBe(0)
    expect(ctx.state.pending()).toBe("")
  })

  test("pending d then G clears and jumps", () => {
    const ctx = createHandler("abc")
    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const G = createEvent("G")
    expect(ctx.handler.handleKey(G.event)).toBe(true)
    expect(G.prevented()).toBe(true)
    expect(ctx.jumpCalls.at(-1)).toBe("bottom")
    expect(ctx.state.pending()).toBe("")
  })

  test("g not handled in insert mode", () => {
    const ctx = createHandler("abc", { mode: "insert" })
    const g = createEvent("g")
    expect(ctx.handler.handleKey(g.event)).toBe(false)
    expect(g.prevented()).toBe(false)
    expect(ctx.jumpCalls.length).toBe(0)
  })

  test("g not handled when vim disabled", () => {
    const ctx = createHandler("abc", { enabled: false })
    const g = createEvent("g")
    expect(ctx.handler.handleKey(g.event)).toBe(false)
    expect(g.prevented()).toBe(false)
    expect(ctx.jumpCalls.length).toBe(0)
  })

  test("repeated ctrl scroll keeps pending clear", () => {
    const ctx = createHandler("abc")
    expect(ctx.handler.handleKey(createEvent("d").event)).toBe(true)
    expect(ctx.state.pending()).toBe("d")

    const first = createEvent("d", { ctrl: true })
    expect(ctx.handler.handleKey(first.event)).toBe(true)
    expect(first.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")

    const second = createEvent("d", { ctrl: true })
    expect(ctx.handler.handleKey(second.event)).toBe(true)
    expect(second.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")

    expect(ctx.scrollCalls).toEqual(["half-down", "half-down"])
  })

  test("repeated G does not create pending", () => {
    const ctx = createHandler("abc")

    const first = createEvent("G")
    expect(ctx.handler.handleKey(first.event)).toBe(true)
    expect(first.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")

    const second = createEvent("G")
    expect(ctx.handler.handleKey(second.event)).toBe(true)
    expect(second.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("")

    expect(ctx.jumpCalls).toEqual(["bottom", "bottom"])
  })

  test("v enters visual mode and sets selection", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    const v = createEvent("v")
    expect(ctx.handler.handleKey(v.event)).toBe(true)
    expect(v.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("visual")
    expect(ctx.state.anchor()).toBe(2)
  })

  test("v then motion extends selection", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("visual")

    ctx.handler.handleKey(createEvent("l").event)
    expect(ctx.textarea.cursorOffset).toBe(1)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 2 })

    ctx.handler.handleKey(createEvent("l").event)
    expect(ctx.textarea.cursorOffset).toBe(2)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 3 })
  })

  test("v then w extends selection by word", () => {
    const ctx = createHandler("hello world test")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.textarea.cursorOffset).toBe(6)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 7 })
  })

  test("visual j preserves desired column across short lines", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 0))

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 5))
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({
      start: rowColToOffset(text, 0, 5),
      end: rowColToOffset(text, 2, 5) + 1,
    })
  })

  test("visual arrow down preserves desired column across short lines", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("down").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 0))

    ctx.handler.handleKey(createEvent("down").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 5))
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({
      start: rowColToOffset(text, 0, 5),
      end: rowColToOffset(text, 2, 5) + 1,
    })

    ctx.handler.handleKey(createEvent("up").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 1, 0))

    ctx.handler.handleKey(createEvent("up").event)
    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 0, 5))
  })

  test("entering visual mode preserves desired column", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("j").event)

    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 5))
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({
      start: rowColToOffset(text, 1, 0),
      end: rowColToOffset(text, 2, 5) + 1,
    })
  })

  test("entering visual-line mode preserves desired column", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("j").event)

    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 5))
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({
      start: rowColToOffset(text, 1, 0),
      end: text.length,
    })
  })

  test("exiting visual mode with v preserves desired column", () => {
    const text = "abcdef\nx\nabcdef"
    const ctx = createHandler(text)
    ctx.textarea.cursorOffset = rowColToOffset(text, 0, 5)

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("j").event)

    expect(ctx.textarea.cursorOffset).toBe(rowColToOffset(text, 2, 5))
    expect(ctx.state.mode()).toBe("normal")
  })

  test("v then escape exits visual mode", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("visual")

    ctx.handler.handleKey(createEvent("escape").event)
    expect(ctx.state.mode()).toBe("normal")
    expect((ctx.textarea as any).editorView.getSelection()).toBe(null)
  })

  test("i does not enter insert in visual mode", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("visual")

    const i = createEvent("i")
    expect(ctx.handler.handleKey(i.event)).toBe(true)
    expect(i.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("visual")
  })

  test("v twice toggles back to normal", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("visual")

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("normal")
    expect((ctx.textarea as any).editorView.getSelection()).toBe(null)
  })

  test("visual d deletes selection and populates register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe(" world")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("visual d falls back to anchor when editor selection is cleared", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("v").event)
    ;(ctx.textarea as any).editorView.resetSelection()

    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("hllo")
    expect(ctx.state.register()).toEqual({ text: "e", linewise: false })
    expect(ctx.state.mode()).toBe("normal")
  })

  test("visual y yanks selection without deleting", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("visual e then y yanks through end of word", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("e").event)
    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("visual c deletes selection and enters insert", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("c").event)
    expect(ctx.textarea.plainText).toBe(" world")
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "hello", linewise: false })
  })

  test("visual C wipes selected line and enters insert", () => {
    const ctx = createHandler("one two three")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("w").event)

    ctx.handler.handleKey(createEvent("C").event)
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "one two three", linewise: true })
  })

  test("visual C across multiple lines collapses to one empty line", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("j").event)

    ctx.handler.handleKey(createEvent("C").event)
    expect(ctx.textarea.plainText).toBe("\nthree")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo", linewise: true })
  })

  test("visual D removes selected line and exits visual", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("D").event)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("visual D across multiple lines removes all selected lines", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("j").event)

    ctx.handler.handleKey(createEvent("D").event)
    expect(ctx.textarea.plainText).toBe("three")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "one\ntwo", linewise: true })
  })

  test("visual shift+d still triggers linewise delete", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("d", { shift: true }).event)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("visual shift+c still triggers linewise change", () => {
    const ctx = createHandler("one two three")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("w").event)

    ctx.handler.handleKey(createEvent("c", { shift: true }).event)
    expect(ctx.textarea.plainText).toBe("")
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "one two three", linewise: true })
  })

  test("visual-line C wipes line content and enters insert", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("V").event)

    ctx.handler.handleKey(createEvent("C").event)
    expect(ctx.textarea.plainText).toBe("one\n\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("visual-line D removes the selected line entirely", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("V").event)

    ctx.handler.handleKey(createEvent("D").event)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("visual D on last line removes line and trailing buffer", () => {
    const ctx = createHandler("one\ntwo")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("D").event)
    expect(ctx.textarea.plainText).toBe("one")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("visual C on last line empties content and stays on line", () => {
    const ctx = createHandler("one\ntwo")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("C").event)
    expect(ctx.textarea.plainText).toBe("one\n")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.mode()).toBe("insert")
    expect(ctx.state.register()).toEqual({ text: "two", linewise: true })
  })

  test("visual x is same as d", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 0

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("x").event)
    expect(ctx.textarea.plainText).toBe("lo world")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "hel", linewise: false })
  })

  test("visual p replaces selection with register", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 6

    ctx.handler.handleKey(createEvent("y").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.state.register()).toEqual({ text: "world", linewise: false })

    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)

    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("world world")
    expect(ctx.state.mode()).toBe("normal")
  })

  test("visual ~ toggles selected text and exits visual mode", () => {
    const ctx = createHandler("abCD ef")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("l").event)
    ctx.handler.handleKey(createEvent("l").event)

    const tilde = createEvent("~")
    expect(ctx.handler.handleKey(tilde.event)).toBe(true)
    expect(tilde.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("aBcd ef")
    expect(ctx.textarea.cursorOffset).toBe(1)
    expect(ctx.state.mode()).toBe("normal")
    expect((ctx.textarea as any).editorView.getSelection()).toBe(null)
  })

  test("visual mode with backward motion", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("h").event)
    ctx.handler.handleKey(createEvent("h").event)
    expect(ctx.textarea.cursorOffset).toBe(3)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 3, end: 6 })
  })

  test("visual d deletes backward selection", () => {
    const ctx = createHandler("abcdef")
    ctx.textarea.cursorOffset = 4

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("h").event)
    ctx.handler.handleKey(createEvent("h").event)

    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("abf")
    expect(ctx.state.register()).toEqual({ text: "cde", linewise: false })
    expect(ctx.state.mode()).toBe("normal")
  })

  test("visual w d deletes selection through end of text", () => {
    const ctx = createHandler("hello world", { strict: true })

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("w").event)
    ctx.handler.handleKey(createEvent("d").event)

    expect(ctx.textarea.plainText).toBe("orld")
    expect(ctx.state.register()).toEqual({ text: "hello w", linewise: false })
    expect(ctx.state.mode()).toBe("normal")
  })

  test("deleteSelection uses anchor range for charwise delete", () => {
    const textarea = createTextarea("word1 word2 word3")
    textarea.cursorOffset = 10

    const reg = deleteSelection(textarea, false, 6)

    expect(textarea.plainText).toBe("word1  word3")
    expect(reg).toEqual({ text: "word2", linewise: false })
  })

  test("deleteSelection ignores stale editor selection", () => {
    const textarea = createTextarea("word1 word2 word3")
    ;(textarea as any).editorView.setSelection(0, 5)
    textarea.cursorOffset = 10

    const reg = deleteSelection(textarea, false, 6)

    expect(textarea.plainText).toBe("word1  word3")
    expect(reg).toEqual({ text: "word2", linewise: false })
  })

  test("visual mode $ selects to end of line", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 6

    ctx.handler.handleKey(createEvent("v").event)
    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(10)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 6, end: 11 })
  })

  test("V enters visual-line mode", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    const v = createEvent("V")
    expect(ctx.handler.handleKey(v.event)).toBe(true)
    expect(v.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("visual-line")
    expect(ctx.state.anchor()).toBe(5)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 4, end: 8 })
  })

  test("V selects full current line on single line", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 2

    ctx.handler.handleKey(createEvent("V").event)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 5 })
  })

  test("V then j extends by full line", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("V").event)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 4 })

    ctx.handler.handleKey(createEvent("j").event)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 8 })
  })

  test("V then k extends upward by full line", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("k").event)
    expect((ctx.textarea as any).editorView.getSelection()).toEqual({ start: 0, end: 8 })
  })

  test("V then d deletes full lines with linewise register", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()?.linewise).toBe(true)
  })

  test("V then d falls back to anchor when editor selection is cleared", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)
    ;(ctx.textarea as any).editorView.resetSelection()

    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.state.register()).toEqual({ text: "two\n", linewise: true })
    expect(ctx.state.mode()).toBe("normal")
  })

  test("V then y yanks full lines with linewise register", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("y").event)
    expect(ctx.textarea.plainText).toBe("one\ntwo\nthree")
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.register()).toEqual({ text: "two\n", linewise: true })
  })

  test("V then ~ toggles selected lines and exits visual-line", () => {
    const ctx = createHandler("one\nTwo\nTHREE")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)

    const tilde = createEvent("~")
    expect(ctx.handler.handleKey(tilde.event)).toBe(true)
    expect(tilde.prevented()).toBe(true)
    expect(ctx.textarea.plainText).toBe("one\ntWO\nTHREE")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.mode()).toBe("normal")
    expect((ctx.textarea as any).editorView.getSelection()).toBe(null)
  })

  test("V select lines 2-4 then d places cursor at line 1 start", () => {
    const ctx = createHandler("line 1\nline 2\nline 3\nline 4")
    ctx.textarea.cursorOffset = 7

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("j").event)

    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("line 1")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("V delete middle line places cursor at next line start", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)
    ctx.handler.handleKey(createEvent("d").event)
    expect(ctx.textarea.plainText).toBe("one\nthree")
    expect(ctx.textarea.cursorOffset).toBe(4)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("V then escape exits", () => {
    const ctx = createHandler("hello")
    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.state.mode()).toBe("visual-line")

    ctx.handler.handleKey(createEvent("escape").event)
    expect(ctx.state.mode()).toBe("normal")
    expect((ctx.textarea as any).editorView.getSelection()).toBe(null)
  })

  test("V twice toggles off", () => {
    const ctx = createHandler("hello")
    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.state.mode()).toBe("visual-line")

    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("v in visual-line switches to characterwise", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.state.mode()).toBe("visual-line")

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("visual")
    expect(ctx.state.anchor()).toBe(5)
  })

  test("V in characterwise visual switches to visual-line", () => {
    const ctx = createHandler("one\ntwo\nthree")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("v").event)
    expect(ctx.state.mode()).toBe("visual")

    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.state.mode()).toBe("visual-line")
    expect(ctx.state.anchor()).toBe(5)
  })
})

// vim parity fixtures for `{` and `}` operators. Each row is a behavior
// observed from nvim (--clean, nofixendofline). Fixtures drive the same
// handler path as normal operator-pending input.
//
// (row, col) are 1-indexed vim coordinates. buf is the buffer after the op.
// reg is the expected register content, with linewise flag.
type ParaFixture = {
  text: string
  row: number
  col: number
  op: "d" | "c" | "y"
  motion: "}" | "{"
  buf: string
  reg: { text: string; linewise: boolean }
}

function rowColToOffsetPara(text: string, row: number, col: number) {
  const lines = text.split("\n")
  let offset = 0
  for (let i = 0; i < row - 1; i++) offset += lines[i]!.length + 1
  return offset + (col - 1)
}

function runFixture(f: ParaFixture) {
  const ctx = createHandler(f.text)
  ctx.textarea.cursorOffset = rowColToOffsetPara(f.text, f.row, f.col)
  ctx.handler.handleKey(createEvent(f.op).event)
  ctx.handler.handleKey(createEvent(f.motion).event)
  expect(ctx.textarea.plainText).toBe(f.buf)
  expect(ctx.state.register()).toEqual(f.reg)
}

describe("vim paragraph operator parity", () => {
  test("d} col 0 multi-line no trailing \\n: linewise", () => {
    runFixture({
      text: "one\ntwo",
      row: 1,
      col: 1,
      op: "d",
      motion: "}",
      buf: "",
      reg: { text: "one\ntwo\n", linewise: true },
    })
  })

  test("d} col 0 multi-line trailing \\n: linewise consumes trailing \\n", () => {
    runFixture({
      text: "one\ntwo\n",
      row: 1,
      col: 1,
      op: "d",
      motion: "}",
      buf: "",
      reg: { text: "one\ntwo\n", linewise: true },
    })
  })

  test("y} col 0 multi-line trailing \\n: char-wise (not linewise)", () => {
    runFixture({
      text: "one\ntwo\n",
      row: 1,
      col: 1,
      op: "y",
      motion: "}",
      buf: "one\ntwo\n",
      reg: { text: "one\ntwo", linewise: false },
    })
  })

  test("c} col 0 multi-line trailing \\n: char-wise", () => {
    runFixture({
      text: "one\ntwo\n",
      row: 1,
      col: 1,
      op: "c",
      motion: "}",
      buf: "\n",
      reg: { text: "one\ntwo", linewise: false },
    })
  })

  test("d} col 0 single line trailing \\n: char-wise (no multi-line promotion)", () => {
    runFixture({
      text: "abc\n",
      row: 1,
      col: 1,
      op: "d",
      motion: "}",
      buf: "\n",
      reg: { text: "abc", linewise: false },
    })
  })

  test("d} col > 0: char-wise with exclusive-to-inclusive (end-of-prev-line)", () => {
    runFixture({
      text: "one\n\nb",
      row: 1,
      col: 2,
      op: "d",
      motion: "}",
      buf: "o\n\nb",
      reg: { text: "ne", linewise: false },
    })
  })

  test("d} col 0 blank target: linewise through blank's \\n", () => {
    runFixture({
      text: "one\ntwo\n\nthree",
      row: 1,
      col: 1,
      op: "d",
      motion: "}",
      buf: "\nthree",
      reg: { text: "one\ntwo\n", linewise: true },
    })
  })

  test("y} col 0 blank target: linewise", () => {
    runFixture({
      text: "one\ntwo\n\nthree",
      row: 1,
      col: 1,
      op: "y",
      motion: "}",
      buf: "one\ntwo\n\nthree",
      reg: { text: "one\ntwo\n", linewise: true },
    })
  })

  test("c} col 0 blank target: linewise strips trailing \\n", () => {
    runFixture({
      text: "one\ntwo\n\nthree",
      row: 1,
      col: 1,
      op: "c",
      motion: "}",
      buf: "\n\nthree",
      reg: { text: "one\ntwo\n", linewise: true },
    })
  })

  test("d} cursor on blank, target blank: linewise delete of content paragraph", () => {
    runFixture({
      text: "a\n\n\nb\n\nc",
      row: 2,
      col: 1,
      op: "d",
      motion: "}",
      buf: "a\n\nc",
      reg: { text: "\n\nb\n", linewise: true },
    })
  })

  test("c} cursor on blank, target blank: linewise strip trailing \\n", () => {
    runFixture({
      text: "a\n\n\nb\n\nc",
      row: 2,
      col: 1,
      op: "c",
      motion: "}",
      buf: "a\n\n\nc",
      reg: { text: "\n\nb\n", linewise: true },
    })
  })

  test("d} cursor on blank, target EOF no trailing \\n: extends start backward", () => {
    runFixture({
      text: "one\n\ntwo",
      row: 2,
      col: 1,
      op: "d",
      motion: "}",
      buf: "one",
      reg: { text: "\ntwo\n", linewise: true },
    })
  })

  test("y} cursor on blank, target EOF: char-wise", () => {
    runFixture({
      text: "one\n\ntwo",
      row: 2,
      col: 1,
      op: "y",
      motion: "}",
      buf: "one\n\ntwo",
      reg: { text: "\ntwo", linewise: false },
    })
  })

  test("d} cursor on blank, target EOF trailing \\n: no backward extension", () => {
    runFixture({
      text: "one\n\ntwo\n",
      row: 2,
      col: 1,
      op: "d",
      motion: "}",
      buf: "one\n",
      reg: { text: "\ntwo\n", linewise: true },
    })
  })

  test("d} on last char EOF no trailing \\n: char-wise single char", () => {
    runFixture({
      text: "abc",
      row: 1,
      col: 3,
      op: "d",
      motion: "}",
      buf: "ab",
      reg: { text: "c", linewise: false },
    })
  })

  test("d} on single-char buffer: deletes everything", () => {
    runFixture({
      text: "a",
      row: 1,
      col: 1,
      op: "d",
      motion: "}",
      buf: "",
      reg: { text: "a", linewise: false },
    })
  })

  test("d} content col 0, blank line 2 target: linewise delete of single line", () => {
    runFixture({
      text: "one\n\n",
      row: 1,
      col: 1,
      op: "d",
      motion: "}",
      buf: "\n",
      reg: { text: "one\n", linewise: true },
    })
  })

  test("y} from blank with only blanks ahead: linewise single step", () => {
    runFixture({
      text: "a\n\n\n",
      row: 2,
      col: 1,
      op: "y",
      motion: "}",
      buf: "a\n\n\n",
      reg: { text: "\n", linewise: true },
    })
  })

  // c} on blank-only buffer with adjacent blank target produces an empty
  // linewise span, so Vim no-ops the operator (no edit, no insert mode).
  test("c} blank-only buffer: no-op, mode unchanged, register unchanged", () => {
    const ctx = createHandler("\n\n")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.textarea.plainText).toBe("\n\n")
    expect(ctx.textarea.cursorOffset).toBe(0)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.register()).toBeNull()
  })

  test("d{ col 0, target 0: linewise", () => {
    runFixture({
      text: "one\ntwo",
      row: 2,
      col: 1,
      op: "d",
      motion: "{",
      buf: "two",
      reg: { text: "one\n", linewise: true },
    })
  })

  test("y{ col 0, target 0: linewise", () => {
    runFixture({
      text: "one\ntwo",
      row: 2,
      col: 1,
      op: "y",
      motion: "{",
      buf: "one\ntwo",
      reg: { text: "one\n", linewise: true },
    })
  })

  test("c{ col 0, target 0: linewise strips trailing \\n", () => {
    runFixture({
      text: "one\ntwo",
      row: 2,
      col: 1,
      op: "c",
      motion: "{",
      buf: "\ntwo",
      reg: { text: "one\n", linewise: true },
    })
  })

  test("d{ col > 0: char-wise", () => {
    runFixture({
      text: "one\ntwo\n\nthree",
      row: 4,
      col: 2,
      op: "d",
      motion: "{",
      buf: "one\ntwo\nhree",
      reg: { text: "\nt", linewise: false },
    })
  })

  test("d{ cursor on blank, target 0: linewise", () => {
    runFixture({
      text: "one\n\ntwo",
      row: 2,
      col: 1,
      op: "d",
      motion: "{",
      buf: "\ntwo",
      reg: { text: "one\n", linewise: true },
    })
  })

  test("c{ cursor on blank, target 0: linewise strips \\n", () => {
    runFixture({
      text: "one\n\ntwo",
      row: 2,
      col: 1,
      op: "c",
      motion: "{",
      buf: "\n\ntwo",
      reg: { text: "one\n", linewise: true },
    })
  })

  test("d{ content col 0 between paragraphs: deletes blank separator", () => {
    runFixture({
      text: "one\n\ntwo",
      row: 3,
      col: 1,
      op: "d",
      motion: "{",
      buf: "one\ntwo",
      reg: { text: "\n", linewise: true },
    })
  })

  test("d{ cursor at start of buffer: no-op, register unchanged", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 0
    ctx.handler.handleKey(createEvent("d").event)
    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.textarea.plainText).toBe("abc")
    expect(ctx.state.register()).toBeNull()
  })

  test("d{ crosses multiple paragraphs from col 0: linewise delete to blank", () => {
    runFixture({
      text: "one\ntwo\n\nthree",
      row: 3,
      col: 1,
      op: "d",
      motion: "{",
      buf: "\nthree",
      reg: { text: "one\ntwo\n", linewise: true },
    })
  })

  test("d{ col > 0 crossing paragraphs: char-wise to prev blank \\n", () => {
    runFixture({
      text: "one\ntwo\n\nthree\nfour",
      row: 5,
      col: 4,
      op: "d",
      motion: "{",
      buf: "one\ntwo\nr",
      reg: { text: "\nthree\nfou", linewise: false },
    })
  })
})

describe("vim undo redo", () => {
  test("u undoes and ctrl+r redoes normal mode edits", () => {
    const ctx = createHandler("abcd")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("x").event)
    expect(ctx.textarea.plainText).toBe("acd")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("abcd")
    expect(ctx.textarea.cursorOffset).toBe(1)

    ctx.handler.handleKey(createEvent("r", { ctrl: true }).event)
    expect(ctx.textarea.plainText).toBe("acd")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("insert session undoes in one step", () => {
    const ctx = createHandler("ab")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("i").event)
    expect(ctx.state.mode()).toBe("insert")
    ctx.textarea.insertText("X")
    ctx.textarea.insertText("Y")
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("aXYb")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("ab")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("replace session undoes in one step", () => {
    const ctx = createHandler("abcd")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("R", { shift: true }).event)
    expect(ctx.state.mode()).toBe("replace")
    ctx.handler.handleKey(createEvent("X").event)
    ctx.handler.handleKey(createEvent("Y").event)
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("aXYd")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("abcd")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("multiple undo steps work across insert sessions", () => {
    const ctx = createHandler("")

    ctx.handler.handleKey(createEvent("i").event)
    ctx.textarea.insertText("hello")
    ctx.handler.handleKey(createEvent("escape").event)

    ctx.handler.handleKey(createEvent("i").event)
    ctx.handler.handleKey(createEvent("escape").event)

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("")

    ctx.handler.handleKey(createEvent("r", { ctrl: true }).event)
    expect(ctx.textarea.plainText).toBe("hello")

    ctx.handler.handleKey(createEvent("i").event)
    ctx.textarea.insertText("hello2")
    ctx.handler.handleKey(createEvent("escape").event)

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("hello")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("")
  })

  test("open line and typed text undo together", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1

    ctx.handler.handleKey(createEvent("o").event)
    expect(ctx.state.mode()).toBe("insert")
    ctx.textarea.insertText("hello")
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("abc\nhello")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("abc")
    expect(ctx.textarea.cursorOffset).toBe(1)
  })

  test("undo restores structured snapshot data", () => {
    const ctx = createHandler("abc", { data: [{ kind: "file", name: "a" }] })
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("i").event)
    ctx.textarea.insertText("x")
    ctx.setMeta([{ kind: "file", name: "a" }, { kind: "file", name: "b" }])
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("abcx")
    expect(ctx.meta()).toEqual([{ kind: "file", name: "a" }, { kind: "file", name: "b" }])

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("abc")
    expect(ctx.meta()).toEqual([{ kind: "file", name: "a" }])

    ctx.handler.handleKey(createEvent("r", { ctrl: true }).event)
    expect(ctx.textarea.plainText).toBe("abcx")
    expect(ctx.meta()).toEqual([{ kind: "file", name: "a" }, { kind: "file", name: "b" }])
  })

  test("empty insert sessions do not create undo entries", () => {
    const ctx = createHandler("hello")
    ctx.textarea.cursorOffset = 5

    ctx.handler.handleKey(createEvent("i").event)
    ctx.handler.handleKey(createEvent("escape").event)

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("hello")
    expect(ctx.textarea.cursorOffset).toBe(5)
  })

  test("redo is cleared after a new edit", () => {
    const ctx = createHandler("")

    ctx.handler.handleKey(createEvent("i").event)
    ctx.textarea.insertText("hello")
    ctx.handler.handleKey(createEvent("escape").event)

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("")

    ctx.handler.handleKey(createEvent("i").event)
    ctx.textarea.insertText("world")
    ctx.handler.handleKey(createEvent("escape").event)
    expect(ctx.textarea.plainText).toBe("world")

    ctx.handler.handleKey(createEvent("r", { ctrl: true }).event)
    expect(ctx.textarea.plainText).toBe("world")
  })

  test("cw groups delete and insert into one undo step", () => {
    const ctx = createHandler("hello world")

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.state.mode()).toBe("insert")
    ctx.textarea.insertText("hi")
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("hi world")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.textarea.cursorOffset).toBe(0)
  })

  test("cc groups clear and insert into one undo step", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("c").event)
    ctx.handler.handleKey(createEvent("c").event)
    expect(ctx.state.mode()).toBe("insert")
    ctx.textarea.insertText("hi")
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("hi")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("S groups substitute line and insert into one undo step", () => {
    const ctx = createHandler("hello world")
    ctx.textarea.cursorOffset = 3

    ctx.handler.handleKey(createEvent("S", { shift: true }).event)
    expect(ctx.state.mode()).toBe("insert")
    ctx.textarea.insertText("hi")
    ctx.handler.handleKey(createEvent("escape").event)

    expect(ctx.textarea.plainText).toBe("hi")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("hello world")
    expect(ctx.textarea.cursorOffset).toBe(3)
  })

  test("p undo and redo work", () => {
    const ctx = createHandler("abc")
    ctx.textarea.cursorOffset = 1
    ctx.state.setRegister({ text: "XY", linewise: false })

    ctx.handler.handleKey(createEvent("p").event)
    expect(ctx.textarea.plainText).toBe("abXYc")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("abc")

    ctx.handler.handleKey(createEvent("r", { ctrl: true }).event)
    expect(ctx.textarea.plainText).toBe("abXYc")
  })

  test("J undo and redo work", () => {
    const ctx = createHandler("one\ntwo")

    ctx.handler.handleKey(createEvent("J", { shift: true }).event)
    expect(ctx.textarea.plainText).toBe("one two")

    ctx.handler.handleKey(createEvent("u").event)
    expect(ctx.textarea.plainText).toBe("one\ntwo")

    ctx.handler.handleKey(createEvent("r", { ctrl: true }).event)
    expect(ctx.textarea.plainText).toBe("one two")
  })

  test("wrapped logical line motions stay on same logical line", () => {
    const ctx = createHandler("this is a very long logical line without a newline")
    ctx.textarea.cursorOffset = 10

    ctx.handler.handleKey(createEvent("j").event)
    expect(ctx.textarea.cursorOffset).toBe(10)

    ctx.handler.handleKey(createEvent("k").event)
    expect(ctx.textarea.cursorOffset).toBe(10)

    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.textarea.cursorOffset).toBe(ctx.textarea.plainText.length - 1)
  })
})

describe("vim scroll mapping", () => {
  test("vimScroll maps ctrl keys to actions", () => {
    expect(vimScroll(createEvent("e", { ctrl: true }).event)).toBe("line-down")
    expect(vimScroll(createEvent("y", { ctrl: true }).event)).toBe("line-up")
    expect(vimScroll(createEvent("d", { ctrl: true }).event)).toBe("half-down")
    expect(vimScroll(createEvent("u", { ctrl: true }).event)).toBe("half-up")
    expect(vimScroll(createEvent("f", { ctrl: true }).event)).toBe("page-down")
    expect(vimScroll(createEvent("b", { ctrl: true }).event)).toBe("page-up")
    expect(vimScroll(createEvent("b", { ctrl: true, meta: true }).event)).toBe(undefined)
    expect(vimScroll(createEvent("b", { ctrl: false }).event)).toBe(undefined)
  })
})

describe("copy mode", () => {
  test("copyWordNext advances to next row when next word is on following line", () => {
    const next = copyWordNext([{ col: 0 }, { col: 0 }], (idx) => ["alpha", "beta gamma"][idx]!, 0, 4, false)
    expect(next).toEqual({ idx: 1, col: 5 })
  })

  test("w advances to next copy row like vim", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 4,
        rows: [{ col: 0 }, { col: 0 }],
        texts: ["alpha", "beta gamma"],
      },
    })

    const evt = createEvent("w")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(1)
    expect(ctx.copyCol()).toBe(5)
  })

  test("b retreats to previous copy row like vim", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 1,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }],
        texts: ["alpha beta", "gamma"],
      },
    })

    const evt = createEvent("b")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(0)
    expect(ctx.copyCol()).toBe(6)
  })

  test("B retreats to previous copy row with big word", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 1,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }],
        texts: ["foo,bar baz", "qux"],
      },
    })

    const evt = createEvent("B")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(0)
    expect(ctx.copyCol()).toBe(8)
  })

  test("} advances to next blank copy row", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }],
        texts: ["one", "two", "", "three", "four"],
      },
    })

    const evt = createEvent("}")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(2)
  })

  test("} from blank skips blanks then jumps to next blank", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }],
        texts: ["a", "", "", "b", "", "c"],
      },
    })

    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.copyIdx()).toBe(1)

    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.copyIdx()).toBe(4)
  })

  test("{ retreats to previous blank copy row", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 4,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }],
        texts: ["one", "two", "", "three", "four"],
      },
    })

    const evt = createEvent("{")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(2)
  })

  test("{ on first copy row moves to row start", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 7,
        rows: [{ col: 3 }, { col: 3 }],
        texts: ["one", "two"],
      },
    })

    const evt = createEvent("{")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(0)
    expect(ctx.copyCol()).toBe(3)
  })

  test("} with no blank rows lands on last row", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }, { col: 0 }],
        texts: ["one", "two", "three"],
      },
    })

    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.copyIdx()).toBe(2)
  })

  test("{ with no blank rows lands on first row", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 2,
        col: 0,
        rows: [{ col: 0 }, { col: 0 }, { col: 0 }],
        texts: ["one", "two", "three"],
      },
    })

    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.copyIdx()).toBe(0)
  })

  test("} extends selection in visual copy mode", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 0,
        isVisual: true,
        rows: [{ col: 0 }, { col: 0 }, { col: 0 }, { col: 0 }],
        texts: ["one", "two", "", "three"],
      },
    })

    const evt = createEvent("}")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyIdx()).toBe(2)
    expect(ctx.copyVisual()).toBe("char")
  })

  test("} resets column to the target row's minimum col", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 0,
        col: 5,
        rows: [{ col: 3 }, { col: 3 }, { col: 7 }, { col: 3 }],
        texts: ["one", "two", "", "three"],
      },
    })

    ctx.handler.handleKey(createEvent("}").event)
    expect(ctx.copyIdx()).toBe(2)
    expect(ctx.copyCol()).toBe(7)
  })

  test("{ resets column to the target row's minimum col", () => {
    const ctx = createHandler("abc", {
      mode: "copy",
      copy: {
        idx: 4,
        col: 9,
        rows: [{ col: 2 }, { col: 2 }, { col: 5 }, { col: 2 }, { col: 2 }],
        texts: ["one", "two", "", "three", "four"],
      },
    })

    ctx.handler.handleKey(createEvent("{").event)
    expect(ctx.copyIdx()).toBe(2)
    expect(ctx.copyCol()).toBe(5)
  })

  test("q exits copy mode", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("q")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("escape exits copy mode when not visual", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("escape")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("normal")
    expect(ctx.copyExitVisuals()).toBe(0)
  })

  test("escape exits visual submode without leaving copy mode", () => {
    const ctx = createHandler("abc", { mode: "copy", copy: { isVisual: true } })

    const evt = createEvent("escape")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.state.mode()).toBe("copy")
    expect(ctx.copyExitVisuals()).toBe(1)
    expect(ctx.copyVisual()).toBe(undefined)
  })

  test("v enters character visual copy mode", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("v")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyVisualCalls).toEqual(["char"])
    expect(ctx.copyVisual()).toBe("char")
  })

  test("V enters line visual copy mode", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("V")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyVisualCalls).toEqual(["line"])
    expect(ctx.copyVisual()).toBe("line")
  })

  test("V is not consumed by plain v branch", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("V").event)
    expect(ctx.copyVisualCalls).toEqual(["line"])
    expect(ctx.copyVisualCalls).not.toContain("char")
  })

  test("y yanks copy selection and exits copy mode", () => {
    const ctx = createHandler("abc", { mode: "copy", copy: { text: "picked text", isVisual: true } })

    const evt = createEvent("y")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyYanks()).toBe(1)
    expect(ctx.copyCopies()).toBe(0)
    expect(ctx.state.register()).toEqual({ text: "picked text", linewise: false })
    expect(ctx.state.mode()).toBe("normal")
  })

  test("return copies selection to clipboard path and exits copy mode", () => {
    const ctx = createHandler("abc", { mode: "copy", copy: { isVisual: true } })

    const evt = createEvent("return")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyCopies()).toBe(1)
    expect(ctx.copyYanks()).toBe(0)
    expect(ctx.state.mode()).toBe("normal")
  })

  test("hjkl route to copy movement callbacks", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("h").event)
    ctx.handler.handleKey(createEvent("j").event)
    ctx.handler.handleKey(createEvent("k").event)
    ctx.handler.handleKey(createEvent("l").event)

    expect(ctx.copyMoves).toEqual(["left", "down", "up", "right"])
  })

  test("arrow keys route to copy movement callbacks", () => {
    const ctx = createHandler("abc", { mode: "copy", copy: { isVisual: true } })

    ctx.handler.handleKey(createEvent("left").event)
    ctx.handler.handleKey(createEvent("down").event)
    ctx.handler.handleKey(createEvent("up").event)
    ctx.handler.handleKey(createEvent("right").event)

    expect(ctx.copyMoves).toEqual(["left", "down", "up", "right"])
  })

  test("arrow keys route to copy movement callbacks outside visual", () => {
    const ctx = createHandler("abc", { mode: "copy", copy: { isVisual: false } })

    ctx.handler.handleKey(createEvent("left").event)
    ctx.handler.handleKey(createEvent("down").event)
    ctx.handler.handleKey(createEvent("up").event)
    ctx.handler.handleKey(createEvent("right").event)

    expect(ctx.copyMoves).toEqual(["left", "down", "up", "right"])
  })

  test("other printable keys do not trigger copy movement", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("x")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyMoves).toEqual([])
  })

  test("gg and G route to copy jump callbacks", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const g1 = createEvent("g")
    expect(ctx.handler.handleKey(g1.event)).toBe(true)
    expect(g1.prevented()).toBe(true)
    expect(ctx.state.pending()).toBe("g")

    const g2 = createEvent("g")
    expect(ctx.handler.handleKey(g2.event)).toBe(true)
    expect(g2.prevented()).toBe(true)

    const G = createEvent("G")
    expect(ctx.handler.handleKey(G.event)).toBe(true)
    expect(G.prevented()).toBe(true)

    expect(ctx.copyJumps).toEqual(["top", "bottom"])
  })

  test("H, M, L route to copy jump callbacks", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("H").event)
    ctx.handler.handleKey(createEvent("M").event)
    ctx.handler.handleKey(createEvent("L").event)

    expect(ctx.copyJumps).toEqual(["high", "middle", "low"])
  })

  test("z sets pending, zz dispatches center scroll", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("z").event)
    expect(ctx.state.pending()).toBe("z")

    ctx.handler.handleKey(createEvent("z").event)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.copyScrollCalls).toEqual(["center"])
  })

  test("zt dispatches top scroll", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("z").event)
    ctx.handler.handleKey(createEvent("t").event)

    expect(ctx.copyScrollCalls).toEqual(["top"])
  })

  test("zb dispatches bottom scroll", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("z").event)
    ctx.handler.handleKey(createEvent("b").event)

    expect(ctx.copyScrollCalls).toEqual(["bottom"])
  })

  test("z followed by unknown key clears pending without scrolling", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    ctx.handler.handleKey(createEvent("z").event)
    expect(ctx.state.pending()).toBe("z")

    ctx.handler.handleKey(createEvent("x").event)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.copyScrollCalls).toEqual([])
  })

  test("copy mode line motions update column from copy text", () => {
    const ctx = createHandler("  alpha beta", { mode: "copy", copy: { text: "  alpha beta", col: 4 } })

    ctx.handler.handleKey(createEvent("0").event)
    expect(ctx.copyCol()).toBe(0)

    ctx.handler.handleKey(createEvent("$").event)
    expect(ctx.copyCol()).toBe(11)

    ctx.handler.handleKey(createEvent("^").event)
    expect(ctx.copyCol()).toBe(2)
  })

  test("copy mode word motions update column", () => {
    const ctx = createHandler("alpha beta gamma", { mode: "copy", copy: { text: "alpha beta gamma", col: 0 } })

    ctx.handler.handleKey(createEvent("w").event)
    expect(ctx.copyCol()).toBe(6)

    ctx.handler.handleKey(createEvent("e").event)
    expect(ctx.copyCol()).toBe(9)

    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.copyCol()).toBe(6)
  })

  test("copy mode find and repeat update column", () => {
    const ctx = createHandler("alpha beta gamma", { mode: "copy", copy: { text: "alpha beta gamma", col: 0 } })

    ctx.handler.handleKey(createEvent("f").event)
    expect(ctx.state.pending()).toBe("f")

    ctx.handler.handleKey(createEvent("b").event)
    expect(ctx.copyCol()).toBe(6)
    expect(ctx.state.pending()).toBe("")
    expect(ctx.state.lastFind()).toEqual({ char: "b", forward: true, till: false })

    ctx.handler.handleKey(createEvent(";").event)
    expect(ctx.copyCol()).toBe(6)

    ctx.handler.handleKey(createEvent(",").event)
    expect(ctx.copyCol()).toBe(6)
  })

  test("copy mode ctrl scroll still scrolls", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("d", { ctrl: true })
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.scrollCalls.at(-1)).toBe("half-down")
  })

  test("copy mode ignores printable keys without side effects", () => {
    const ctx = createHandler("abc", { mode: "copy" })

    const evt = createEvent("x")
    expect(ctx.handler.handleKey(evt.event)).toBe(true)
    expect(evt.prevented()).toBe(true)
    expect(ctx.copyMoves).toEqual([])
    expect(ctx.copyYanks()).toBe(0)
    expect(ctx.copyCopies()).toBe(0)
    expect(ctx.state.mode()).toBe("copy")
  })
})

describe("copy mode cursor state", () => {
  function createCopyCtx(lines: Array<{ min: number; text: string }>, opts?: { col?: number; idx?: number }) {
    const textarea = createTextarea("")
    const [enabled] = createSignal(true)
    const [mode, setMode] = createSignal<"normal" | "insert" | "replace" | "visual" | "visual-line" | "copy">("copy")
    const [pending, setPending] = createSignal<"" | "c" | "d" | "g" | "z" | "f" | "F" | "t" | "T" | "y">("")
    const [lastFind, setLastFind] = createSignal<{ char: string; forward: boolean; till: boolean } | null>(null)
    const [register, setRegister] = createSignal<{ text: string; linewise: boolean } | null>(null)
    const [anchor, setAnchor] = createSignal<number | null>(null)
    const [replace, setReplace] = createSignal<number | null>(null)
    const [typed, setTyped] = createSignal(false)
    const [undos, setUndos] = createSignal<Array<{ before: { text: string; cursor: number }; after: { text: string; cursor: number } }>>([])
    const [redos, setRedos] = createSignal<Array<{ text: string; cursor: number }>>([])
    const [editState, setEditState] = createSignal<{ text: string; cursor: number } | null>(null)

    let idx = opts?.idx ?? 0
    let col = opts?.col ?? lines[0]!.min
    let stick: "start" | "first" | "end" | number | undefined = undefined

    function padded(i: number) {
      const row = lines[i]
      if (!row) return ""
      return " ".repeat(row.min) + row.text
    }

    function resolve(i: number, s: typeof stick): number {
      const row = lines[i]
      if (!row) return 0
      const text = padded(i)
      const max = text.length > 0 ? text.length - 1 : row.min
      if (s === "start") return row.min
      if (s === "first") {
        let pos = row.min
        while (pos < text.length && /\s/.test(text[pos]!)) pos++
        return Math.max(row.min, Math.min(max, pos))
      }
      if (s === "end") return max
      if (typeof s === "number") return Math.max(row.min, Math.min(max, row.min + s))
      return row.min
    }

    function clearPending() {
      setPending("")
    }

    function changeMode(next: "normal" | "insert" | "replace" | "visual" | "visual-line" | "copy") {
      clearPending()
      if (next !== "visual" && next !== "visual-line") setAnchor(null)
      if (next !== "replace") {
        setReplace(null)
        setTyped(false)
      }
      setMode(next)
    }

    const state: ReturnType<typeof createVimState> = {
      mode,
      setMode: changeMode,
      pending,
      setPending,
      clearPending,
      lastFind,
      setLastFind,
      register,
      setRegister,
      anchor,
      setAnchor,
      replace,
      setReplace,
      typed,
      setTyped,
      beginEdit(snapshot) {
        setEditState(snapshot)
      },
      commitEdit(snapshot) {
        const start = editState()
        setEditState(null)
        if (!start) return
        if (start.text === snapshot.text && start.cursor === snapshot.cursor) return
        setUndos((list) => [...list, { before: start, after: snapshot }])
        setRedos([])
      },
      cancelEdit() {
        setEditState(null)
      },
      push(before, after) {
        setEditState(null)
        if (before.text === after.text && before.cursor === after.cursor) return
        setUndos((list) => [...list, { before, after }])
        setRedos([])
      },
      undo(snapshot) {
        const item = undos()[undos().length - 1]
        if (!item) return
        setUndos((list) => list.slice(0, -1))
        setRedos((list) => [...list, snapshot])
        setEditState(null)
        return item.before
      },
      redo(snapshot) {
        const item = redos()[redos().length - 1]
        if (!item) return
        setRedos((list) => list.slice(0, -1))
        setUndos((list) => [...list, { before: snapshot, after: item }])
        setEditState(null)
        return item
      },
      resetHistory() {
        setUndos([])
        setRedos([])
        setEditState(null)
      },
      canUndo: () => undos().length > 0,
      canRedo: () => redos().length > 0,
      reset() {
        clearPending()
        setAnchor(null)
        setReplace(null)
        setTyped(false)
        setUndos([])
        setRedos([])
        setEditState(null)
        setMode("insert")
      },
      isInsert: () => mode() === "insert",
      isReplace: () => mode() === "replace",
      isVisual: () => mode() === "visual" || mode() === "visual-line",
      isVisualLine: () => mode() === "visual-line",
      isCopy: () => mode() === "copy",
    } as ReturnType<typeof createVimState>

    const handler = createVimHandler({
      enabled,
      state,
      textarea: () => textarea,
      submit: () => {},
      scroll() {},
      jump() {},
      copy(action) {
        if (action === "up" || action === "down") {
          const next = idx + (action === "up" ? -1 : 1)
          idx = Math.max(0, Math.min(next, lines.length - 1))
          col = resolve(idx, stick)
          return
        }
        const row = lines[idx]!
        const text = padded(idx)
        const max = text.length > 0 ? text.length - 1 : row.min
        if (action === "left") {
          col = Math.max(row.min, col - 1)
          stick = col - row.min
          return
        }
        col = Math.min(max, col + 1)
        stick = col - row.min
      },
      copyVisual() {},
      copyExitVisual() {},
      copyYank() {},
      copyCopy() {},
      copyIsVisual() {
        return false
      },
      copyJump(action) {
        idx = action === "top" ? 0 : lines.length - 1
        col = resolve(idx, stick)
      },
      copyWordNext() {
        return false
      },
      copyWordPrev() {
        return false
      },
      copyText() {
        return padded(idx)
      },
      copyCol() {
        return col
      },
      setCopyCol(offset) {
        const row = lines[idx]!
        const text = padded(idx)
        const max = text.length > 0 ? text.length - 1 : row.min
        col = Math.max(row.min, Math.min(max, offset))
        stick = col - row.min
      },
      setCopyStick(s) {
        stick = s
      },
      copyScroll() {},
    })

    function key(name: string, opts?: { shift?: boolean; ctrl?: boolean }) {
      handler.handleKey(createEvent(name, opts).event)
    }

    return {
      key,
      handler,
      state,
      col: () => col,
      idx: () => idx,
      stick: () => stick,
    }
  }

  test("0 goes to content start", () => {
    const ctx = createCopyCtx([{ min: 3, text: "  hello world" }], { col: 10 })
    ctx.key("0")
    expect(ctx.col()).toBe(3)
  })

  test("^ goes to first non-whitespace", () => {
    const ctx = createCopyCtx([{ min: 3, text: "  hello world" }], { col: 10 })
    ctx.key("^")
    expect(ctx.col()).toBe(5)
  })

  test("$ goes to end of line", () => {
    const ctx = createCopyCtx([{ min: 3, text: "hello world" }], { col: 3 })
    ctx.key("$")
    expect(ctx.col()).toBe(13)
  })

  test("_ behaves same as ^", () => {
    const ctx = createCopyCtx([{ min: 2, text: "   abc" }], { col: 8 })
    ctx.key("_")
    expect(ctx.col()).toBe(5)
  })

  test("0 differs from ^ when line has leading whitespace", () => {
    const ctx = createCopyCtx([{ min: 3, text: "  hello" }], { col: 8 })
    ctx.key("0")
    expect(ctx.col()).toBe(3)
    ctx.key("^")
    expect(ctx.col()).toBe(5)
  })

  test("0 and ^ agree when no leading whitespace", () => {
    const ctx = createCopyCtx([{ min: 3, text: "hello" }], { col: 6 })
    ctx.key("0")
    expect(ctx.col()).toBe(3)
    ctx.key("^")
    expect(ctx.col()).toBe(3)
  })

  test("$ sticks to end of line when moving down", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "short" },
      { min: 3, text: "much longer line" },
      { min: 3, text: "tiny" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(7)
    ctx.key("j")
    expect(ctx.col()).toBe(18)
    ctx.key("j")
    expect(ctx.col()).toBe(6)
  })

  test("$ sticks to end when moving up", () => {
    const ctx = createCopyCtx(
      [
        { min: 3, text: "long line here" },
        { min: 3, text: "ab" },
      ],
      { idx: 1 },
    )
    ctx.key("$")
    expect(ctx.col()).toBe(4)
    ctx.key("k")
    expect(ctx.col()).toBe(16)
  })

  test("0 sticks to start of line when moving down", () => {
    const ctx = createCopyCtx(
      [
        { min: 3, text: "  hello" },
        { min: 5, text: "  world" },
        { min: 0, text: "  test" },
      ],
      { col: 7 },
    )
    ctx.key("0")
    expect(ctx.col()).toBe(3)
    ctx.key("j")
    expect(ctx.col()).toBe(5)
    ctx.key("j")
    expect(ctx.col()).toBe(0)
  })

  test("^ sticks to first non-whitespace when moving down", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "  hello" },
      { min: 3, text: "    world" },
      { min: 3, text: "abc" },
    ])
    ctx.key("^")
    expect(ctx.col()).toBe(5)
    ctx.key("j")
    expect(ctx.col()).toBe(7)
    ctx.key("j")
    expect(ctx.col()).toBe(3)
  })

  test("horizontal movement sets numeric stick that persists across rows", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "abcdefghij" },
      { min: 3, text: "1234567890" },
      { min: 3, text: "xyz" },
    ])
    ctx.key("l")
    ctx.key("l")
    ctx.key("l")
    ctx.key("l")
    expect(ctx.col()).toBe(7)
    ctx.key("j")
    expect(ctx.col()).toBe(7)
    ctx.key("j")
    expect(ctx.col()).toBe(5)
  })

  test("word motion sets numeric stick", () => {
    const ctx = createCopyCtx(
      [
        { min: 0, text: "alpha beta gamma" },
        { min: 0, text: "one two" },
      ],
      { col: 0 },
    )
    ctx.key("w")
    expect(ctx.col()).toBe(6)
    ctx.key("j")
    expect(ctx.col()).toBe(6)
  })

  test("numeric stick clamps to end of shorter line then recovers", () => {
    const ctx = createCopyCtx([
      { min: 0, text: "abcdefghij" },
      { min: 0, text: "ab" },
      { min: 0, text: "abcdefghij" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(9)
    ctx.key("j")
    expect(ctx.col()).toBe(1)
    ctx.key("j")
    expect(ctx.col()).toBe(9)
  })

  test("switching from $ to ^ changes stick", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "  hello" },
      { min: 3, text: "  world" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(9)
    ctx.key("^")
    expect(ctx.col()).toBe(5)
    ctx.key("j")
    expect(ctx.col()).toBe(5)
  })

  test("switching from ^ to 0 changes stick", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "  abc" },
      { min: 5, text: "  def" },
    ])
    ctx.key("^")
    expect(ctx.col()).toBe(5)
    ctx.key("0")
    expect(ctx.col()).toBe(3)
    ctx.key("j")
    expect(ctx.col()).toBe(5)
  })

  test("h/l after $ resets stick to numeric", () => {
    const ctx = createCopyCtx([
      { min: 0, text: "abcdef" },
      { min: 0, text: "abcdefghij" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(5)
    ctx.key("h")
    expect(ctx.col()).toBe(4)
    ctx.key("j")
    expect(ctx.col()).toBe(4)
  })

  test("stick start adapts to different gutter widths", () => {
    const ctx = createCopyCtx([
      { min: 2, text: "line one" },
      { min: 5, text: "line two" },
      { min: 0, text: "line three" },
    ])
    ctx.key("0")
    expect(ctx.col()).toBe(2)
    ctx.key("j")
    expect(ctx.col()).toBe(5)
    ctx.key("j")
    expect(ctx.col()).toBe(0)
  })

  test("numeric stick is relative to min, not absolute column", () => {
    const ctx = createCopyCtx([
      { min: 2, text: "abcdef" },
      { min: 5, text: "abcdef" },
    ])
    ctx.key("l")
    ctx.key("l")
    expect(ctx.col()).toBe(4)
    ctx.key("j")
    expect(ctx.col()).toBe(7)
  })

  test("$ persists through many lines", () => {
    const lines = [
      { min: 0, text: "a" },
      { min: 0, text: "ab" },
      { min: 0, text: "abc" },
      { min: 0, text: "abcd" },
      { min: 0, text: "abcde" },
    ]
    const ctx = createCopyCtx(lines)
    ctx.key("$")
    expect(ctx.col()).toBe(0)
    ctx.key("j")
    expect(ctx.col()).toBe(1)
    ctx.key("j")
    expect(ctx.col()).toBe(2)
    ctx.key("j")
    expect(ctx.col()).toBe(3)
    ctx.key("j")
    expect(ctx.col()).toBe(4)
  })

  test("0 persists through many lines with varying min", () => {
    const lines = [
      { min: 0, text: "a" },
      { min: 3, text: "b" },
      { min: 1, text: "c" },
      { min: 7, text: "d" },
    ]
    const ctx = createCopyCtx(lines)
    ctx.key("0")
    ctx.key("j")
    expect(ctx.col()).toBe(3)
    ctx.key("j")
    expect(ctx.col()).toBe(1)
    ctx.key("j")
    expect(ctx.col()).toBe(7)
  })

  test("gg preserves stick", () => {
    const ctx = createCopyCtx(
      [
        { min: 0, text: "  first" },
        { min: 0, text: "  second" },
        { min: 0, text: "  third" },
      ],
      { idx: 2 },
    )
    ctx.key("$")
    expect(ctx.col()).toBe(6)
    ctx.key("g")
    ctx.key("g")
    expect(ctx.col()).toBe(6)
  })

  test("G preserves stick", () => {
    const ctx = createCopyCtx([
      { min: 0, text: "  first" },
      { min: 0, text: "  second" },
      { min: 0, text: "  third" },
    ])
    ctx.key("^")
    expect(ctx.col()).toBe(2)
    ctx.key("G")
    expect(ctx.col()).toBe(2)
  })

  test("k at first row stays put", () => {
    const ctx = createCopyCtx([
      { min: 0, text: "only" },
      { min: 0, text: "two" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(3)
    ctx.key("k")
    expect(ctx.idx()).toBe(0)
    expect(ctx.col()).toBe(3)
  })

  test("j at last row stays put", () => {
    const ctx = createCopyCtx(
      [
        { min: 0, text: "one" },
        { min: 0, text: "two" },
      ],
      { idx: 1 },
    )
    ctx.key("$")
    expect(ctx.col()).toBe(2)
    ctx.key("j")
    expect(ctx.idx()).toBe(1)
    expect(ctx.col()).toBe(2)
  })

  test("$ on empty line clamps then recovers", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "hello" },
      { min: 3, text: "" },
      { min: 3, text: "world" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(7)
    ctx.key("j")
    expect(ctx.col()).toBe(2)
    ctx.key("j")
    expect(ctx.col()).toBe(7)
  })

  test("^ on empty line resolves to min", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "  abc" },
      { min: 3, text: "" },
    ])
    ctx.key("^")
    expect(ctx.col()).toBe(5)
    ctx.key("j")
    expect(ctx.col()).toBe(3)
  })

  test("vertical movement on single line is a no-op", () => {
    const ctx = createCopyCtx([{ min: 0, text: "only line" }])
    ctx.key("$")
    expect(ctx.col()).toBe(8)
    ctx.key("j")
    expect(ctx.col()).toBe(8)
    expect(ctx.idx()).toBe(0)
    ctx.key("k")
    expect(ctx.col()).toBe(8)
    expect(ctx.idx()).toBe(0)
  })

  test("complex sequence: $, j, h, j uses numeric stick not end", () => {
    const ctx = createCopyCtx([
      { min: 0, text: "abcdef" },
      { min: 0, text: "1234567890" },
      { min: 0, text: "xyz" },
    ])
    ctx.key("$")
    expect(ctx.col()).toBe(5)
    ctx.key("j")
    expect(ctx.col()).toBe(9)
    ctx.key("h")
    expect(ctx.col()).toBe(8)
    ctx.key("j")
    expect(ctx.col()).toBe(2)
  })

  test("0, l, j keeps numeric offset from start", () => {
    const ctx = createCopyCtx([
      { min: 3, text: "hello" },
      { min: 3, text: "world" },
    ])
    ctx.key("0")
    expect(ctx.col()).toBe(3)
    ctx.key("l")
    expect(ctx.col()).toBe(4)
    ctx.key("j")
    expect(ctx.col()).toBe(4)
  })

  test("^, j, $, k: stick changes between motions", () => {
    const ctx = createCopyCtx([
      { min: 0, text: "  alpha" },
      { min: 0, text: "  beta" },
    ])
    ctx.key("^")
    expect(ctx.col()).toBe(2)
    ctx.key("j")
    expect(ctx.col()).toBe(2)
    ctx.key("$")
    expect(ctx.col()).toBe(5)
    ctx.key("k")
    expect(ctx.col()).toBe(6)
  })

  describe("wrapped lines", () => {
    test("$ on a wrapped row lands at end of the slice, not the source line", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "hello worl" },
        { min: 3, text: "d foo bar" },
      ])
      ctx.key("$")
      expect(ctx.col()).toBe(12)
      expect(ctx.idx()).toBe(0)
    })

    test("$ on the continuation row lands at end of that slice", () => {
      const ctx = createCopyCtx(
        [
          { min: 3, text: "hello worl" },
          { min: 3, text: "d foo bar" },
        ],
        { idx: 1, col: 3 },
      )
      ctx.key("$")
      expect(ctx.col()).toBe(11)
      expect(ctx.idx()).toBe(1)
    })

    test("0 on a continuation row goes to that row's start, not row 0", () => {
      const ctx = createCopyCtx(
        [
          { min: 3, text: "hello worl" },
          { min: 3, text: "d foo bar" },
        ],
        { idx: 1, col: 8 },
      )
      ctx.key("0")
      expect(ctx.col()).toBe(3)
      expect(ctx.idx()).toBe(1)
    })

    test("^ on a wrapped continuation row with no leading whitespace goes to min", () => {
      const ctx = createCopyCtx(
        [
          { min: 3, text: "hello worl" },
          { min: 3, text: "d foo bar" },
        ],
        { idx: 1, col: 8 },
      )
      ctx.key("^")
      expect(ctx.col()).toBe(3)
    })

    test("^ on a wrapped continuation with leading whitespace skips it", () => {
      const ctx = createCopyCtx(
        [
          { min: 3, text: "hello worl" },
          { min: 3, text: "  d foo" },
        ],
        { idx: 1, col: 10 },
      )
      ctx.key("^")
      expect(ctx.col()).toBe(5)
    })

    test("w within a wrapped row stops at word boundaries in the slice", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "hello worl" },
        { min: 3, text: "d foo bar" },
      ])
      ctx.key("w")
      expect(ctx.col()).toBe(9)
      ctx.key("w")
      expect(ctx.col()).toBe(12)
    })

    test("b on a continuation row stops at word boundaries in its slice", () => {
      const ctx = createCopyCtx(
        [
          { min: 3, text: "hello worl" },
          { min: 3, text: "d foo bar" },
        ],
        { idx: 1, col: 11 },
      )
      ctx.key("b")
      expect(ctx.col()).toBe(9)
      ctx.key("b")
      expect(ctx.col()).toBe(5)
      ctx.key("b")
      expect(ctx.col()).toBe(3)
    })

    test("e within a wrapped row finds word ends in the slice", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "hello worl" },
        { min: 3, text: "d foo bar" },
      ])
      ctx.key("e")
      expect(ctx.col()).toBe(7)
      ctx.key("e")
      expect(ctx.col()).toBe(12)
    })

    test("f{char} is limited to the current wrapped slice", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "hello worl" },
        { min: 3, text: "d foo bar" },
      ])
      ctx.key("f")
      ctx.key("d")
      expect(ctx.col()).toBe(3)
      expect(ctx.idx()).toBe(0)
    })

    test("f{char} finds a char within the wrapped slice", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "hello worl" },
        { min: 3, text: "d foo bar" },
      ])
      ctx.key("f")
      ctx.key("w")
      expect(ctx.col()).toBe(9)
    })

    test("j/k between wrapped rows preserves $ stick", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "hello worl" },
        { min: 3, text: "d foo bar" },
      ])
      ctx.key("$")
      expect(ctx.col()).toBe(12)
      ctx.key("j")
      expect(ctx.col()).toBe(11)
      ctx.key("k")
      expect(ctx.col()).toBe(12)
    })

    test("j/k between wrapped rows preserves ^ stick", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "  hello" },
        { min: 3, text: "world" },
      ])
      ctx.key("^")
      expect(ctx.col()).toBe(5)
      ctx.key("j")
      expect(ctx.col()).toBe(3)
    })

    test("non-wrapped: $ reaches the true end of the full line", () => {
      const ctx = createCopyCtx([{ min: 3, text: "hello world foo bar" }])
      ctx.key("$")
      expect(ctx.col()).toBe(21)
    })

    test("non-wrapped: w traverses all words in one line", () => {
      const ctx = createCopyCtx([{ min: 3, text: "hello world foo bar" }])
      ctx.key("w")
      expect(ctx.col()).toBe(9)
      ctx.key("w")
      expect(ctx.col()).toBe(15)
      ctx.key("w")
      expect(ctx.col()).toBe(19)
    })

    test("non-wrapped: f{char} can find chars anywhere in the line", () => {
      const ctx = createCopyCtx([{ min: 3, text: "hello world foo bar" }])
      ctx.key("f")
      ctx.key("b")
      expect(ctx.col()).toBe(19)
    })

    test("mixed wrapped and non-wrapped rows: stick persists across boundary", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "alpha be" },
        { min: 3, text: "gamma delta epsilon zeta" },
        { min: 3, text: "ta conti" },
      ])
      ctx.key("$")
      expect(ctx.col()).toBe(10)
      ctx.key("j")
      expect(ctx.col()).toBe(26)
      ctx.key("j")
      expect(ctx.col()).toBe(10)
    })

    test("mixed: 0 stick adapts across wrapped and non-wrapped rows", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "alpha be" },
        { min: 5, text: "full line here" },
        { min: 3, text: "ta conti" },
      ])
      ctx.key("0")
      expect(ctx.col()).toBe(3)
      ctx.key("j")
      expect(ctx.col()).toBe(5)
      ctx.key("j")
      expect(ctx.col()).toBe(3)
    })

    test("wrapped row with partial word: w clamps to slice end", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "call func" },
        { min: 3, text: "tion next" },
      ])
      ctx.key("w")
      expect(ctx.col()).toBe(8)
      ctx.key("w")
      expect(ctx.col()).toBe(11)
    })

    test("continuation row starting mid-word: b goes to row start", () => {
      const ctx = createCopyCtx(
        [
          { min: 3, text: "call func" },
          { min: 3, text: "tion next" },
        ],
        { idx: 1, col: 7 },
      )
      ctx.key("b")
      expect(ctx.col()).toBe(3)
    })

    test("vertical movement between rows of very different widths clamps correctly", () => {
      const ctx = createCopyCtx([
        { min: 3, text: "ab" },
        { min: 3, text: "a very long non-wrapped line with many words" },
        { min: 3, text: "cd" },
      ])
      ctx.key("j")
      ctx.key("$")
      expect(ctx.col()).toBe(46)
      ctx.key("k")
      expect(ctx.col()).toBe(4)
      ctx.key("j")
      expect(ctx.col()).toBe(46)
      ctx.key("j")
      expect(ctx.col()).toBe(4)
    })
  })
})