vim-handler.ts

import type { Accessor } from "solid-js"
import type { createVimState, VimRegister, VimSnapshot } from "./vim-state"
import type { TextareaRenderable } from "@opentui/core"
import { vimScroll, type VimScroll } from "./vim-scroll"
import { vimJump, type VimJump } from "./vim-motion-jump"
import {
  appendAfterCursor,
  appendLineEnd,
  clampCursorToLine,
  clearSelection,
  deleteLine,
  deleteLineEnd,
  deleteSelection,
  deleteSpan,
  deleteUnderCursor,
  deleteWord,
  deleteWordBackward,
  deleteWordEnd,
  findChar,
  findCharInLine,
  firstNonWhitespace,
  getLineColumn,
  insertLineStart,
  joinLines,
  moveBigWordEnd,
  moveBigWordNext,
  moveBigWordPrev,
  moveFirstNonWhitespace,
  moveLeft,
  moveLineBeginning,
  moveLineDown,
  moveLineUp,
  moveNextParagraph,
  movePreviousParagraph,
  moveRight,
  moveLineEnd,
  moveWordEnd,
  moveWordNext,
  moveWordPrev,
  nextParagraphOperation,
  nextWordStart,
  openLineAbove,
  openLineBelow,
  type ParagraphOperation,
  type ParagraphResult,
  type VimWantedColumn,
  pasteAfter,
  pasteBefore,
  previousParagraphOperation,
  prevWordStart,
  replaceUnderCursor,
  substituteLine,
  substituteLineEnd,
  syncSelection,
  toggleCase,
  toggleSelectionCase,
  wordEnd,
  yankLine,
  yankLineSpan,
  yankSelection,
  yankWord,
  yankWordEnd,
  yankWordEndSpan,
  yankWordSpan,
} from "./vim-motions"

export type VimEvent = {
  name?: string
  shift?: boolean
  ctrl?: boolean
  meta?: boolean
  super?: boolean
  preventDefault: () => void
}

export type VimCopyMove = "up" | "down" | "left" | "right"

export function createVimHandler(input: {
  enabled: Accessor<boolean>
  state: ReturnType<typeof createVimState>
  textarea: Accessor<TextareaRenderable>
  submit: () => void
  scroll: (action: VimScroll) => void
  jump: (action: VimJump) => void
  copy?: (action: VimCopyMove) => void
  copyVisual?: (mode: "char" | "line") => void
  copyExitVisual?: () => void
  copyYank?: () => void
  copyCopy?: () => void
  copyIsVisual?: () => boolean
  copyJump?: (action: VimJump) => void
  copyWordNext?: (big: boolean) => boolean
  copyWordPrev?: (big: boolean) => boolean
  copyNextParagraph?: () => boolean
  copyPreviousParagraph?: () => boolean
  copyText?: () => string
  copyCol?: () => number
  setCopyCol?: (offset: number) => void
  setCopyStick?: (stick: "start" | "first" | "end") => void
  copyScroll?: (action: "center" | "top" | "bottom") => void
  autocomplete?: () => false | "@" | "/"
  flash?: (span: { start: number; end: number }) => void
  history?: () => boolean
  snapshot?: () => VimSnapshot
  restore?: (next: VimSnapshot) => void
  register?: () => VimRegister
  setRegister?: (register: VimRegister, notify?: boolean) => void
}) {
  let wantedColumn: VimWantedColumn | undefined

  function hasModifier(event: VimEvent) {
    return !!event.ctrl || !!event.meta || !!event.super
  }

  function isPrintable(event: VimEvent) {
    return !!event.name && (event.name.length === 1 || event.name === "space")
  }

  function value(event: VimEvent) {
    if (event.name === "space") return " "
    return event.name ?? ""
  }

  function isShifted(event: VimEvent, key: string) {
    return event.name === key.toUpperCase() || (event.name === key && !!event.shift)
  }

  function tracked() {
    return input.history?.() ?? true
  }

  function register() {
    if (input.register) return input.register()
    return input.state.register()
  }

  function setRegister(next: VimRegister, notify = false) {
    if (input.setRegister) {
      input.setRegister(next, notify)
      return
    }
    input.state.setRegister(next)
  }

  function clearWantedColumn() {
    wantedColumn = undefined
  }

  function moveVertical(direction: "up" | "down") {
    const column = wantedColumn ?? getLineColumn(input.textarea())
    if (direction === "up") moveLineUp(input.textarea(), column)
    else moveLineDown(input.textarea(), column)
    wantedColumn = column
  }

  function preservesWantedColumn(event: VimEvent, key: string) {
    if ((key === "j" || key === "k" || key === "down" || key === "up") && !event.shift && !hasModifier(event)) return true
    return (key === "v" || isShifted(event, "v")) && !hasModifier(event)
  }

  function snapshot(): VimSnapshot {
    if (input.snapshot) return input.snapshot()
    return {
      text: input.textarea().plainText,
      cursor: input.textarea().cursorOffset,
    }
  }

  function restore(next: VimSnapshot) {
    clearWantedColumn()
    clearSelection(input.textarea())
    input.state.clearPending()
    input.state.setMode("normal")
    input.state.cancelEdit()
    if (input.restore) {
      input.restore(next)
      return
    }
    input.textarea().setText(next.text)
    input.textarea().cursorOffset = Math.max(0, Math.min(next.cursor, next.text.length))
  }

  function edit(run: () => void) {
    if (!tracked()) {
      run()
      return
    }
    const before = snapshot()
    run()
    input.state.push(before, snapshot())
  }

  function begin(run?: () => void) {
    if (!tracked()) {
      run?.()
      return
    }
    input.state.beginEdit(snapshot())
    run?.()
  }

  function applyParagraphYank(result: ParagraphResult) {
    if (result.register) setRegister(result.register, true)
    if (result.span && result.span.end > result.span.start) input.flash?.(result.span)
    input.state.clearPending()
  }

  function applyParagraphEdit(textarea: TextareaRenderable, result: ParagraphResult, operation: "d" | "c") {
    const apply = () => {
      if (result.span) deleteSpan(textarea, result.span)
      if (result.register) setRegister(result.register)
      input.state.clearPending()
      if (operation === "c") input.state.setMode("insert")
    }
    if (operation === "c") begin(apply)
    else edit(apply)
  }

  function paragraphOperator(key: string, operation: ParagraphOperation): boolean {
    if (key !== "{" && key !== "}") return false

    const textarea = input.textarea()

    const result =
      key === "}" ? nextParagraphOperation(textarea, operation) : previousParagraphOperation(textarea, operation)

    // no motion: vim no-ops the operator without editing or changing mode.
    if (!result.span && !result.register) input.state.clearPending()
    else if (operation === "y") applyParagraphYank(result)
    else applyParagraphEdit(textarea, result, operation)

    return true
  }

  function changeWord(big: boolean) {
    const textarea = input.textarea()
    const char = textarea.plainText[textarea.cursorOffset]
    return char && !/\s/.test(char) ? deleteWordEnd(textarea, big) : deleteWord(textarea)
  }

  function undo() {
    if (!tracked()) return false
    const next = input.state.undo(snapshot())
    if (!next) return false
    restore(next)
    return true
  }

  function redo() {
    if (!tracked()) return false
    const next = input.state.redo(snapshot())
    if (!next) return false
    restore(next)
    return true
  }

  function dispatch(event: VimEvent, key: string): boolean {
    if (!preservesWantedColumn(event, key)) clearWantedColumn()

    const scroll = vimScroll(event)
    if (scroll) {
      input.state.clearPending()
      input.scroll(scroll)
      event.preventDefault()
      return true
    }

    const jump = vimJump(event, input.state)
    if (jump.handled) {
      if (jump.action) {
        input.state.clearPending()
        input.jump(jump.action)
      }
      event.preventDefault()
      return true
    }

    if (key === "escape") {
      if (input.state.isVisual()) {
        clearSelection(input.textarea())
        input.state.setMode("normal")
        event.preventDefault()
        return true
      }
      if (!input.state.pending()) return false
      input.state.clearPending()
      event.preventDefault()
      return true
    }

    if (key === "u" && !event.shift && !hasModifier(event) && !input.state.isVisual() && !input.state.pending()) {
      undo()
      event.preventDefault()
      return true
    }

    if (key === "r" && !!event.ctrl && !event.shift && !event.meta && !event.super && !input.state.isVisual() && !input.state.pending()) {
      redo()
      event.preventDefault()
      return true
    }

    if (input.state.isVisual()) {
      const a = input.state.anchor()
      const lw = input.state.isVisualLine()

      if (key === "~" && !hasModifier(event)) {
        edit(() => {
          toggleSelectionCase(input.textarea(), lw, a ?? undefined)
          clearSelection(input.textarea())
          input.state.setMode("normal")
        })
        event.preventDefault()
        return true
      }

      if ((key === "i" || key === "a" || key === "o") && !event.shift && !hasModifier(event)) {
        event.preventDefault()
        return true
      }

      if ((isShifted(event, "i") || isShifted(event, "a") || isShifted(event, "o")) && !hasModifier(event)) {
        event.preventDefault()
        return true
      }

      if ((key === "d" || key === "x") && !event.shift && !hasModifier(event)) {
        edit(() => {
          const reg = deleteSelection(input.textarea(), lw, a ?? undefined)
          if (reg) setRegister(reg)
          clearSelection(input.textarea())
          input.state.setMode("normal")
        })
        event.preventDefault()
        return true
      }

      if (isShifted(event, "d") && !hasModifier(event)) {
        edit(() => {
          const reg = deleteLine(input.textarea(), a ?? undefined)
          if (reg) setRegister(reg)
          clearSelection(input.textarea())
          input.state.setMode("normal")
        })
        event.preventDefault()
        return true
      }

      if (key === "y" && !event.shift && !hasModifier(event)) {
        const reg = yankSelection(input.textarea(), lw, a ?? undefined)
        if (reg) setRegister(reg, true)
        clearSelection(input.textarea())
        input.state.setMode("normal")
        event.preventDefault()
        return true
      }

      if (key === "c" && !event.shift && !hasModifier(event)) {
        begin(() => {
          const reg = deleteSelection(input.textarea(), lw, a ?? undefined)
          if (reg) setRegister(reg)
          clearSelection(input.textarea())
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if (isShifted(event, "c") && !hasModifier(event)) {
        begin(() => {
          const reg = substituteLine(input.textarea(), a ?? undefined)
          if (reg) setRegister(reg)
          clearSelection(input.textarea())
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if (key === "p" && !event.shift && !hasModifier(event)) {
        edit(() => {
          const reg = register()
          if (reg) {
            deleteSelection(input.textarea(), false, a ?? undefined)
            clearSelection(input.textarea())
            input.textarea().insertText(reg.text)
            input.textarea().cursorOffset = input.textarea().cursorOffset - 1
          }
          input.state.setMode("normal")
        })
        event.preventDefault()
        return true
      }

      if (key === "v" && !event.shift && !hasModifier(event)) {
        if (lw) {
          input.state.setMode("visual")
          event.preventDefault()
          return true
        }
        clearSelection(input.textarea())
        input.state.setMode("normal")
        event.preventDefault()
        return true
      }

      if (isShifted(event, "v") && !hasModifier(event)) {
        if (lw) {
          clearSelection(input.textarea())
          input.state.setMode("normal")
          event.preventDefault()
          return true
        }
        input.state.setMode("visual-line")
        event.preventDefault()
        return true
      }
    }

    if (input.state.pending() === "c") {
      if (hasModifier(event)) {
        input.state.clearPending()
        return false
      }

      if (key === "c" && !event.shift) {
        begin(() => {
          const reg = substituteLine(input.textarea())
          if (reg) setRegister(reg)
          input.state.clearPending()
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if (key === "w" && !event.shift) {
        begin(() => {
          const reg = changeWord(false)
          if (reg) setRegister(reg)
          input.state.clearPending()
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if (isShifted(event, "w") && !hasModifier(event)) {
        begin(() => {
          const reg = changeWord(true)
          if (reg) setRegister(reg)
          input.state.clearPending()
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if (key === "b" && !event.shift) {
        begin(() => {
          const reg = deleteWordBackward(input.textarea())
          if (reg) setRegister(reg)
          input.state.clearPending()
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if ((key === "e" || key === "E") && !hasModifier(event)) {
        const big = key === "E" || !!event.shift
        begin(() => {
          const reg = deleteWordEnd(input.textarea(), big)
          if (reg) setRegister(reg)
          input.state.clearPending()
          input.state.setMode("insert")
        })
        event.preventDefault()
        return true
      }

      if (paragraphOperator(key, "c")) {
        event.preventDefault()
        return true
      }

      input.state.clearPending()
    }

    if (input.state.pending() === "d") {
      if (hasModifier(event)) {
        input.state.clearPending()
        return false
      }

      if (key === "d" && !event.shift) {
        edit(() => {
          const reg = deleteLine(input.textarea())
          if (reg) setRegister(reg)
          input.state.clearPending()
        })
        event.preventDefault()
        return true
      }

      if (key === "w" && !event.shift) {
        edit(() => {
          const reg = deleteWord(input.textarea())
          if (reg) setRegister(reg)
          input.state.clearPending()
        })
        event.preventDefault()
        return true
      }

      if (isShifted(event, "w") && !hasModifier(event)) {
        edit(() => {
          const reg = deleteWord(input.textarea(), true)
          if (reg) setRegister(reg)
          input.state.clearPending()
        })
        event.preventDefault()
        return true
      }

      if (key === "b" && !event.shift && !hasModifier(event)) {
        edit(() => {
          const reg = deleteWordBackward(input.textarea())
          if (reg) setRegister(reg)
          input.state.clearPending()
        })
        event.preventDefault()
        return true
      }

      if ((key === "e" || key === "E") && !hasModifier(event)) {
        const big = key === "E" || !!event.shift
        edit(() => {
          const reg = deleteWordEnd(input.textarea(), big)
          if (reg) setRegister(reg)
          input.state.clearPending()
        })
        event.preventDefault()
        return true
      }

      if (paragraphOperator(key, "d")) {
        event.preventDefault()
        return true
      }

      input.state.clearPending()
    }

    if (input.state.pending() === "y") {
      if (hasModifier(event)) {
        input.state.clearPending()
        return false
      }

      if (key === "y" && !event.shift) {
        const span = yankLineSpan(input.textarea())
        const reg = yankLine(input.textarea())
        if (reg) setRegister(reg, true)
        if (span.end > span.start) input.flash?.(span)
        input.state.clearPending()
        event.preventDefault()
        return true
      }

      if (key === "w" && !event.shift) {
        const span = yankWordSpan(input.textarea())
        const reg = yankWord(input.textarea())
        if (reg) setRegister(reg, true)
        if (span && span.end > span.start) input.flash?.(span)
        input.state.clearPending()
        event.preventDefault()
        return true
      }

      if (isShifted(event, "w") && !hasModifier(event)) {
        const span = yankWordSpan(input.textarea(), true)
        const reg = yankWord(input.textarea(), true)
        if (reg) setRegister(reg, true)
        if (span && span.end > span.start) input.flash?.(span)
        input.state.clearPending()
        event.preventDefault()
        return true
      }

      if ((key === "e" || key === "E") && !hasModifier(event)) {
        const big = key === "E" || !!event.shift
        const span = yankWordEndSpan(input.textarea(), big)
        const reg = yankWordEnd(input.textarea(), big)
        if (reg) setRegister(reg, true)
        if (span && span.end > span.start) input.flash?.(span)
        input.state.clearPending()
        event.preventDefault()
        return true
      }

      if (paragraphOperator(key, "y")) {
        event.preventDefault()
        return true
      }

      input.state.clearPending()
    }

    const find = input.state.pending()
    if (find === "f" || find === "F" || find === "t" || find === "T") {
      if (isPrintable(event) && !hasModifier(event)) {
        const forward = find === "f" || find === "t"
        const till = find === "t" || find === "T"
        findChar(input.textarea(), key, forward, till)
        input.state.setLastFind({ char: key, forward, till })
        input.state.clearPending()
        event.preventDefault()
        return true
      }
      input.state.clearPending()
      event.preventDefault()
      return true
    }

    if (key === "return" && !hasModifier(event)) {
      input.submit()
      input.state.clearPending()
      event.preventDefault()
      return true
    }

    if ((key === "/" || key === "@") && !hasModifier(event)) {
      if (input.autocomplete?.() && input.textarea().cursorOffset === 0 && input.textarea().plainText.length === 0) {
        input.state.setMode("insert")
        return false
      }
      event.preventDefault()
      return true
    }

    if (key === "c" && !event.shift && !hasModifier(event)) {
      input.state.setPending("c")
      event.preventDefault()
      return true
    }

    if (key === "d" && !event.shift && !hasModifier(event)) {
      input.state.setPending("d")
      event.preventDefault()
      return true
    }

    if (key === "y" && !event.shift && !hasModifier(event)) {
      input.state.setPending("y")
      event.preventDefault()
      return true
    }

    if (key === "p" && !event.shift && !hasModifier(event)) {
      edit(() => {
        pasteAfter(input.textarea(), register())
      })
      event.preventDefault()
      return true
    }

    if (isShifted(event, "p") && !hasModifier(event)) {
      edit(() => {
        pasteBefore(input.textarea(), register())
      })
      event.preventDefault()
      return true
    }

    if (key === "f" && !event.shift && !hasModifier(event)) {
      input.state.setPending("f")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "f") && !hasModifier(event)) {
      input.state.setPending("F")
      event.preventDefault()
      return true
    }

    if (key === "t" && !event.shift && !hasModifier(event)) {
      input.state.setPending("t")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "t") && !hasModifier(event)) {
      input.state.setPending("T")
      event.preventDefault()
      return true
    }

    if (key === ";" && !event.shift && !hasModifier(event)) {
      const last = input.state.lastFind()
      if (last) findChar(input.textarea(), last.char, last.forward, last.till, true)
      event.preventDefault()
      return true
    }

    if (key === "," && !event.shift && !hasModifier(event)) {
      const last = input.state.lastFind()
      if (last) findChar(input.textarea(), last.char, !last.forward, last.till, true)
      event.preventDefault()
      return true
    }

    if (isShifted(event, "s") && !hasModifier(event)) {
      begin(() => {
        input.state.clearPending()
        const reg = substituteLine(input.textarea())
        if (reg) setRegister(reg)
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (isShifted(event, "d") && !hasModifier(event)) {
      edit(() => {
        const reg = deleteLineEnd(input.textarea())
        if (reg) setRegister(reg)
      })
      event.preventDefault()
      return true
    }

    if (isShifted(event, "c") && !hasModifier(event)) {
      begin(() => {
        const reg = substituteLineEnd(input.textarea())
        if (reg) setRegister(reg)
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (isShifted(event, "r") && !hasModifier(event)) {
      begin()
      input.state.setReplace(input.textarea().cursorOffset)
      input.state.setTyped(false)
      input.state.setMode("replace")
      event.preventDefault()
      return true
    }

    if (key === "v" && !event.shift && !hasModifier(event)) {
      input.state.setAnchor(input.textarea().cursorOffset)
      input.state.setMode("visual")
      syncSelection(input.textarea(), input.textarea().cursorOffset)
      event.preventDefault()
      return true
    }

    if (isShifted(event, "v") && !hasModifier(event)) {
      input.state.setAnchor(input.textarea().cursorOffset)
      input.state.setMode("visual-line")
      syncSelection(input.textarea(), input.textarea().cursorOffset, true)
      event.preventDefault()
      return true
    }

    if (key === "i" && !event.shift && !hasModifier(event)) {
      begin()
      input.state.setMode("insert")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "i") && !hasModifier(event)) {
      begin(() => {
        insertLineStart(input.textarea())
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (key === "a" && !event.shift && !hasModifier(event)) {
      begin(() => {
        appendAfterCursor(input.textarea())
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (isShifted(event, "a") && !hasModifier(event)) {
      begin(() => {
        appendLineEnd(input.textarea())
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (key === "o" && !event.shift && !hasModifier(event)) {
      begin(() => {
        openLineBelow(input.textarea())
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (isShifted(event, "o") && !hasModifier(event)) {
      begin(() => {
        openLineAbove(input.textarea())
        input.state.setMode("insert")
      })
      event.preventDefault()
      return true
    }

    if (key === "h" && !event.shift && !hasModifier(event)) {
      moveLeft(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "l" && !event.shift && !hasModifier(event)) {
      moveRight(input.textarea())
      event.preventDefault()
      return true
    }

    if (isShifted(event, "j") && !hasModifier(event)) {
      edit(() => {
        input.state.clearPending()
        joinLines(input.textarea())
      })
      event.preventDefault()
      return true
    }

    if ((key === "j" || key === "down") && !event.shift && !hasModifier(event)) {
      moveVertical("down")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "h") && !hasModifier(event)) {
      input.jump("high")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "m") && !hasModifier(event)) {
      input.jump("middle")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "l") && !hasModifier(event)) {
      input.jump("low")
      event.preventDefault()
      return true
    }

    if ((key === "k" || key === "up") && !event.shift && !hasModifier(event)) {
      moveVertical("up")
      event.preventDefault()
      return true
    }

    if (key === "0" && !event.shift && !hasModifier(event)) {
      moveLineBeginning(input.textarea())
      event.preventDefault()
      return true
    }

    if ((key === "^" || key === "_") && !hasModifier(event)) {
      moveFirstNonWhitespace(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "$" && !hasModifier(event)) {
      moveLineEnd(input.textarea())
      wantedColumn = "end"
      event.preventDefault()
      return true
    }

    if (key === "{" && !hasModifier(event)) {
      movePreviousParagraph(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "}" && !hasModifier(event)) {
      moveNextParagraph(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "x" && !event.shift && !hasModifier(event)) {
      edit(() => {
        const reg = deleteUnderCursor(input.textarea())
        if (reg) setRegister(reg)
      })
      event.preventDefault()
      return true
    }

    if (key === "~" && !hasModifier(event)) {
      edit(() => {
        toggleCase(input.textarea())
      })
      event.preventDefault()
      return true
    }

    if (key === "w" && !event.shift && !hasModifier(event)) {
      moveWordNext(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "b" && !event.shift && !hasModifier(event)) {
      moveWordPrev(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "e" && !event.shift && !hasModifier(event)) {
      moveWordEnd(input.textarea())
      event.preventDefault()
      return true
    }

    if (isShifted(event, "w") && !hasModifier(event)) {
      moveBigWordNext(input.textarea())
      event.preventDefault()
      return true
    }

    if (isShifted(event, "b") && !hasModifier(event)) {
      moveBigWordPrev(input.textarea())
      event.preventDefault()
      return true
    }

    if (isShifted(event, "e") && !hasModifier(event)) {
      moveBigWordEnd(input.textarea())
      event.preventDefault()
      return true
    }

    if (key === "backspace" || key === "delete") {
      event.preventDefault()
      return true
    }

    if (isPrintable(event) && !hasModifier(event)) {
      event.preventDefault()
      return true
    }

    return false
  }

  function copyMotion(offset: number) {
    input.setCopyCol?.(offset)
  }

  function copy(event: VimEvent, key: string): boolean {
    if (key === "q") {
      input.state.setMode("normal")
      event.preventDefault()
      return true
    }

    if (key === "escape") {
      if (input.copyIsVisual?.()) {
        input.copyExitVisual?.()
        event.preventDefault()
        return true
      }
      input.state.setMode("normal")
      event.preventDefault()
      return true
    }

    const scroll = vimScroll(event)
    if (scroll) {
      input.scroll(scroll)
      event.preventDefault()
      return true
    }

    const jump = vimJump(event, input.state)
    if (jump.handled) {
      if (jump.action) input.copyJump ? input.copyJump(jump.action) : input.jump(jump.action)
      event.preventDefault()
      return true
    }

    if (hasModifier(event)) return false

    if (isShifted(event, "h")) {
      input.copyJump?.("high")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "m")) {
      input.copyJump?.("middle")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "l")) {
      input.copyJump?.("low")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "v")) {
      input.copyVisual?.("line")
      event.preventDefault()
      return true
    }

    if (key === "v" && !event.shift) {
      input.copyVisual?.("char")
      event.preventDefault()
      return true
    }

    if (key === "y") {
      input.copyYank?.()
      input.state.setMode("normal")
      event.preventDefault()
      return true
    }

    if (key === "return") {
      input.copyCopy?.()
      input.state.setMode("normal")
      event.preventDefault()
      return true
    }

    const pending = input.state.pending()
    if (pending === "f" || pending === "F" || pending === "t" || pending === "T") {
      if (key.length === 1) {
        const forward = pending === "f" || pending === "t"
        const till = pending === "t" || pending === "T"
        const text = input.copyText?.() ?? ""
        const pos = input.copyCol?.() ?? 0
        const col = findCharInLine(text, pos, key, forward, till)
        input.state.setLastFind({ char: key, forward, till })
        input.state.clearPending()
        copyMotion(col)
        event.preventDefault()
        return true
      }
      input.state.clearPending()
      event.preventDefault()
      return true
    }

    if (pending === "z") {
      input.state.clearPending()
      if (key === "z") input.copyScroll?.("center")
      else if (key === "t") input.copyScroll?.("top")
      else if (key === "b") input.copyScroll?.("bottom")
      event.preventDefault()
      return true
    }

    if (key === "j" || key === "down") {
      input.copy?.("down")
      event.preventDefault()
      return true
    }

    if (key === "k" || key === "up") {
      input.copy?.("up")
      event.preventDefault()
      return true
    }

    if (key === "h" || key === "left") {
      input.copy?.("left")
      event.preventDefault()
      return true
    }

    if (key === "l" || key === "right") {
      input.copy?.("right")
      event.preventDefault()
      return true
    }

    // line motions
    if (key === "0") {
      copyMotion(0)
      input.setCopyStick?.("start")
      event.preventDefault()
      return true
    }

    if (key === "^" || key === "_") {
      const text = input.copyText?.() ?? ""
      copyMotion(firstNonWhitespace(text, 0))
      input.setCopyStick?.("first")
      event.preventDefault()
      return true
    }

    if (key === "$") {
      const text = input.copyText?.() ?? ""
      copyMotion(Math.max(0, text.length - 1))
      input.setCopyStick?.("end")
      event.preventDefault()
      return true
    }

    if (key === "z" && !event.shift) {
      input.state.setPending("z")
      event.preventDefault()
      return true
    }

    // word motions
    const pos = input.copyCol?.() ?? 0

    if (key === "w" && !event.shift) {
      if (input.copyWordNext?.(false)) {
        event.preventDefault()
        return true
      }
      const text = input.copyText?.() ?? ""
      const col = nextWordStart(text, pos, false)
      copyMotion(Math.min(col, Math.max(0, text.length - 1)))
      event.preventDefault()
      return true
    }

    if (key === "b" && !event.shift) {
      if (input.copyWordPrev?.(false)) {
        event.preventDefault()
        return true
      }
      const text = input.copyText?.() ?? ""
      copyMotion(prevWordStart(text, pos, false))
      event.preventDefault()
      return true
    }

    if (key === "e" && !event.shift) {
      const text = input.copyText?.() ?? ""
      copyMotion(wordEnd(text, pos, false))
      event.preventDefault()
      return true
    }

    if (isShifted(event, "w")) {
      if (input.copyWordNext?.(true)) {
        event.preventDefault()
        return true
      }
      const text = input.copyText?.() ?? ""
      const col = nextWordStart(text, pos, true)
      copyMotion(Math.min(col, Math.max(0, text.length - 1)))
      event.preventDefault()
      return true
    }

    if (isShifted(event, "b")) {
      if (input.copyWordPrev?.(true)) {
        event.preventDefault()
        return true
      }
      const text = input.copyText?.() ?? ""
      copyMotion(prevWordStart(text, pos, true))
      event.preventDefault()
      return true
    }

    if (isShifted(event, "e")) {
      const text = input.copyText?.() ?? ""
      copyMotion(wordEnd(text, pos, true))
      event.preventDefault()
      return true
    }

    // paragraph motions
    if (key === "{" && !hasModifier(event)) {
      input.copyPreviousParagraph?.()
      event.preventDefault()
      return true
    }

    if (key === "}" && !hasModifier(event)) {
      input.copyNextParagraph?.()
      event.preventDefault()
      return true
    }

    // find-char pending
    if ((key === "f" || key === "t") && !event.shift) {
      input.state.setPending(key)
      event.preventDefault()
      return true
    }

    if (isShifted(event, "f")) {
      input.state.setPending("F")
      event.preventDefault()
      return true
    }

    if (isShifted(event, "t")) {
      input.state.setPending("T")
      event.preventDefault()
      return true
    }

    // repeat find
    if (key === ";") {
      const last = input.state.lastFind()
      if (last) {
        const text = input.copyText?.() ?? ""
        copyMotion(findCharInLine(text, pos, last.char, last.forward, last.till, true))
      }
      event.preventDefault()
      return true
    }

    if (key === ",") {
      const last = input.state.lastFind()
      if (last) {
        const text = input.copyText?.() ?? ""
        copyMotion(findCharInLine(text, pos, last.char, !last.forward, last.till, true))
      }
      event.preventDefault()
      return true
    }

    if (isPrintable(event)) {
      event.preventDefault()
      return true
    }

    return false
  }

  return {
    handleKey(event: VimEvent) {
      if (!input.enabled()) return false

      if (input.state.isReplace()) {
        if (event.name === "escape") {
          const start = input.state.replace()
          const typed = input.state.typed()
          input.state.setMode("normal")
          if (typed && start !== null) {
            input.textarea().cursorOffset = Math.max(start, input.textarea().cursorOffset - 1)
          }
          input.state.commitEdit(snapshot())
          event.preventDefault()
          return true
        }

        if (isPrintable(event) && !hasModifier(event)) {
          replaceUnderCursor(input.textarea(), value(event))
          input.state.setTyped(true)
          event.preventDefault()
          return true
        }

        return false
      }

      if (input.state.isCopy()) {
        return copy(event, event.name ?? "")
      }

      if (input.state.isInsert()) {
        if (event.name !== "escape") return false
        clampCursorToLine(input.textarea())
        input.state.setMode("normal")
        input.state.commitEdit(snapshot())
        event.preventDefault()
        return true
      }

      const key = event.name ?? ""
      const result = dispatch(event, key)

      if (result && input.state.isVisual()) {
        const a = input.state.anchor()
        if (a !== null) syncSelection(input.textarea(), a, input.state.isVisualLine())
      }

      return result
    },
  }
}