vim.ts

/*
 * vim.ts - mode state machine + key dispatcher.
 */

import { afterRender, afterSelectionSync, deleteRange, extendSelection, getCaret, getLines, getText, insertLineBreak, insertText, lineColToOffset, redo, replaceRange, setCaret, undo } from "./editor";
import {
    applyVisualOperator,
    changeLines,
    deleteCharBackward,
    deleteCharForward,
    handleOperatorKey,
    Op,
    OpPending,
    opResult,
    paste,
    toLineEnd,
} from "./operators";
import {
    findChar,
    FindCmd,
    moveDown,
    moveFirstLine,
    moveFirstNonBlank,
    moveLastLine,
    moveLeft,
    moveLineEnd,
    moveLineStart,
    moveRight,
    moveUp,
    moveWordBackward,
    moveWordEnd,
    moveWordForward,
    moveWORDBackward,
    moveWORDEnd,
    moveWORDForward,
    repeatFind,
} from "./motions";
import { settings } from "./settings";
import { updateIndicator } from "./statusline";

export const enum Mode {
    Normal = "NORMAL",
    Insert = "INSERT",
    Visual = "VISUAL",
    Replace = "REPLACE",
}

export interface EditorState {
    mode: Mode;
    /** goal column for j/k, null when invalidated by horizontal movement */
    goalCol: number | null;
    /** timestamp of last Escape consumed in NORMAL mode (for double-Escape) */
    lastEscape: number;
    /** accumulated numeric count prefix (0 = none) */
    count: number;
    /** pending multi-key state: awaiting second key of gg, r's char, or operator */
    pending: null | { kind: "g"; } | { kind: "r"; count: number; }
    | { kind: "f"; cmd: FindCmd; count: number; } | OpPending;
    /** visual mode: fixed end of the selection (absolute offset) */
    visualAnchor: number;
    /** visual mode: moving end of the selection (absolute offset) */
    visualHead: number;
    /** replace mode: original chars overwritten (null = appended past EOL) */
    replaceStack: (string | null)[];
}

const DOUBLE_ESCAPE_MS = 500;

/* ------------------------------------------------------------------ */
/* `.` repeat: record the key sequence of the last buffer-changing     */
/* command and replay it.                                              */
/* ------------------------------------------------------------------ */

/** Keys in recording order for the change currently being typed. */
let recordBuffer: string[] = [];
/** Key sequence of the last completed change, for `.`. */
let lastChange: string[] | null = null;
/** True while `.` is replaying keys (suppress re-recording). */
let replaying = false;
/** True while recording insert-mode text after a change/insert command
 * (vim replays the typed text on `.`). Committed on Escape. */
let recordingInsert = false;
/** recordBuffer index where the insert-mode segment starts (for
 * Backspace handling while recording). */
let recordInsertStart = 0;

/** Simple normal-mode commands that count as repeatable changes. */
const CHANGE_KEYS = new Set(["x", "X", "D", "p", "P", "~", "J"]);
/** Normal-mode commands that enter INSERT mode; the typed text is part
 * of the repeatable change. */
const INSERT_KEYS = new Set(["i", "a", "I", "A", "o", "O", "s", "C", "S"]);

function startInsertRecording(): void {
    if (replaying) return;
    recordingInsert = true;
    recordInsertStart = recordBuffer.length;
}

function commitChange(): void {
    if (!replaying) lastChange = recordBuffer.slice();
}

const states = new WeakMap<HTMLElement, EditorState>();

export function getState(editor: HTMLElement): EditorState {
    let s = states.get(editor);
    if (!s) {
        s = {
            mode: Mode.Insert, goalCol: null, lastEscape: 0,
            count: 0, pending: null,
            visualAnchor: 0, visualHead: 0,
            replaceStack: [],
        };
        states.set(editor, s);
    }
    return s;
}

function setMode(editor: HTMLElement, mode: Mode): void {
    const s = getState(editor);
    s.mode = mode;
    s.goalCol = null;
    s.count = 0;
    s.pending = null;
    updateIndicator(editor, mode);
}

/**
 * Bindings receive `count`: the numeric prefix, or undefined when none was
 * typed (some commands like G distinguish "no count" from "count 1").
 */
const normalBindings: Record<string, (editor: HTMLElement, count?: number) => void> = {
    h: (e, c) => moveLeft(e, c ?? 1),
    l: (e, c) => moveRight(e, c ?? 1),
    j: (e, c) => moveDown(e, c ?? 1),
    k: (e, c) => moveUp(e, c ?? 1),
    ArrowLeft: (e, c) => moveLeft(e, c ?? 1),
    ArrowRight: (e, c) => moveRight(e, c ?? 1),
    ArrowDown: (e, c) => moveDown(e, c ?? 1),
    ArrowUp: (e, c) => moveUp(e, c ?? 1),
    w: (e, c) => moveWordForward(e, c ?? 1),
    b: (e, c) => moveWordBackward(e, c ?? 1),
    e: (e, c) => moveWordEnd(e, c ?? 1),
    W: (e, c) => moveWORDForward(e, c ?? 1),
    B: (e, c) => moveWORDBackward(e, c ?? 1),
    E: (e, c) => moveWORDEnd(e, c ?? 1),
    0: moveLineStart,
    "^": moveFirstNonBlank,
    $: (e, c) => moveLineEnd(e, c ?? 1),
    G: moveLastLine,
    ";": (e, c) => repeatFind(e, c ?? 1, false),
    ",": (e, c) => repeatFind(e, c ?? 1, true),
    i: editor => setMode(editor, Mode.Insert),
    a: appendAfter,
    I: insertLineStart,
    A: appendLineEnd,
    o: openBelow,
    O: openAbove,
    x: (e, c) => deleteCharForward(e, c ?? 1, () => { }),
    X: (e, c) => deleteCharBackward(e, c ?? 1),
    s: (e, c) => deleteCharForward(e, c ?? 1, () => setMode(e, Mode.Insert), true),
    D: e => toLineEnd(e, "d", () => { }),
    C: e => toLineEnd(e, "c", () => setMode(e, Mode.Insert)),
    S: (e, c) => changeLines(e, c ?? 1, () => setMode(e, Mode.Insert)),
    p: (e, c) => paste(e, true, c ?? 1),
    P: (e, c) => paste(e, false, c ?? 1),
    v: enterVisual,
    u: e => undo(e),
    "~": (e, c) => toggleCase(e, c ?? 1),
    J: (e, c) => joinLines(e, c ?? 1),
    R: enterReplace,
};

/** True when `editor` is waiting for r's replacement char (for the
 * underline cursor overlay). */
export function isReplacePending(editor: HTMLElement): boolean {
    return states.get(editor)?.pending?.kind === "r";
}

/** R - enter replace (overtype) mode. */
function enterReplace(editor: HTMLElement): void {
    getState(editor).replaceStack = [];
    setMode(editor, Mode.Replace);
}

/** Overtype one character in REPLACE mode; caret advances. */
function replaceModeChar(editor: HTMLElement, state: EditorState, ch: string): void {
    const pos = getCaret(editor);
    if (!pos) return;
    const lines = getLines(editor);
    if (pos.col < lines[pos.line].length) {
        state.replaceStack.push(lines[pos.line][pos.col]);
        replaceRange(editor, pos.offset, pos.offset + 1, ch);
    } else {
        // past end of line: append (vim behavior)
        state.replaceStack.push(null);
        insertText(editor, ch, pos.offset);
    }
}

/** Handle a key in REPLACE mode. Consumes everything except modifiers. */
function handleReplaceKey(editor: HTMLElement, state: EditorState, key: string): boolean {
    if (key === "Shift" || key === "CapsLock") return false;
    if (!replaying) recordBuffer.push(key);

    if (key === "Escape") {
        commitChange();
        setMode(editor, Mode.Normal);
        moveLeft(editor, 1);
        return true;
    }

    if (key === "Backspace") {
        const pos = getCaret(editor);
        if (!pos) return true;
        if (state.replaceStack.length === 0) {
            // before the replace start: just move left, nothing to restore
            moveLeft(editor, 1);
            return true;
        }
        if (pos.col === 0) return true; // don't cross line boundaries
        const orig = state.replaceStack.pop()!;
        if (orig === null) {
            // char was appended past EOL: remove it (caret lands before it)
            deleteRange(editor, pos.offset - 1, pos.offset);
        } else {
            replaceRange(editor, pos.offset - 1, pos.offset, orig);
            const target = pos.offset - 1;
            afterRender(editor, () => setCaret(editor, target));
        }
        return true;
    }

    if (key.length === 1) {
        replaceModeChar(editor, state, key);
        return true;
    }

    // swallow everything else (arrows, Enter, Delete, ...) to keep the
    // replace stack consistent
    return true;
}

/** Motions available in visual mode (they move the selection head). */
const visualMotions: Record<string, (editor: HTMLElement, count?: number) => void> = {
    h: (e, c) => moveLeft(e, c ?? 1),
    l: (e, c) => moveRight(e, c ?? 1),
    j: (e, c) => moveDown(e, c ?? 1),
    k: (e, c) => moveUp(e, c ?? 1),
    ArrowLeft: (e, c) => moveLeft(e, c ?? 1),
    ArrowRight: (e, c) => moveRight(e, c ?? 1),
    ArrowDown: (e, c) => moveDown(e, c ?? 1),
    ArrowUp: (e, c) => moveUp(e, c ?? 1),
    w: (e, c) => moveWordForward(e, c ?? 1),
    b: (e, c) => moveWordBackward(e, c ?? 1),
    e: (e, c) => moveWordEnd(e, c ?? 1),
    W: (e, c) => moveWORDForward(e, c ?? 1),
    B: (e, c) => moveWORDBackward(e, c ?? 1),
    E: (e, c) => moveWORDEnd(e, c ?? 1),
    0: moveLineStart,
    "^": moveFirstNonBlank,
    $: (e, c) => moveLineEnd(e, c ?? 1),
    G: moveLastLine,
    ";": (e, c) => repeatFind(e, c ?? 1, false),
    ",": (e, c) => repeatFind(e, c ?? 1, true),
};

/** v - enter charwise visual mode, anchored at the caret. */
function enterVisual(editor: HTMLElement): void {
    const pos = getCaret(editor);
    if (!pos) return;
    setMode(editor, Mode.Visual);
    const s = getState(editor);
    s.visualAnchor = pos.offset;
    s.visualHead = pos.offset;
    renderVisualSelection(editor, s);
}

/** Re-extend the DOM selection to cover [anchor, head] inclusively. */
function renderVisualSelection(editor: HTMLElement, s: EditorState): void {
    const len = getText(editor).length;
    const a = Math.min(s.visualAnchor, len);
    const h = Math.min(s.visualHead, len);
    if (h >= a) extendSelection(editor, a, Math.min(h + 1, len));
    else extendSelection(editor, Math.min(a + 1, len), h);
}

/** Leave visual mode, collapsing the caret to the selection head. */
function exitVisual(editor: HTMLElement, s: EditorState): void {
    setCaret(editor, Math.min(s.visualHead, Math.max(getText(editor).length - 1, 0)));
    setMode(editor, Mode.Normal);
}

/** Handle a key in VISUAL mode. Always consumes unless stated otherwise. */
function handleVisualKey(editor: HTMLElement, state: EditorState, e: KeyboardEvent): boolean {
    const key = e.key;

    if (key === "Escape" || key === "v") {
        exitVisual(editor, state);
        return true;
    }

    // numeric count prefix
    if (/^[0-9]$/.test(key) && !(key === "0" && state.count === 0)) {
        state.count = Math.min(state.count * 10 + Number(key), 999999);
        return true;
    }

    // pending f/F/t/T: next key is the target char
    if (state.pending?.kind === "f") {
        const { cmd, count } = state.pending;
        state.pending = null;
        state.count = 0;
        if (key.length === 1) {
            setCaret(editor, Math.min(state.visualHead, Math.max(getText(editor).length - 1, 0)));
            findChar(editor, cmd, key, count);
            const pos = getCaret(editor);
            if (pos) state.visualHead = pos.offset;
            renderVisualSelection(editor, state);
        }
        return true;
    }

    if (key === "f" || key === "F" || key === "t" || key === "T") {
        state.pending = { kind: "f", cmd: key, count: state.count || 1 };
        state.count = 0;
        return true;
    }

    // pending g -> gg
    if (state.pending?.kind === "g") {
        state.pending = null;
        if (key === "g") {
            const count = state.count || undefined;
            state.count = 0;
            setCaret(editor, Math.min(state.visualHead, Math.max(getText(editor).length - 1, 0)));
            moveFirstLine(editor, count);
            const pos = getCaret(editor);
            if (pos) state.visualHead = pos.offset;
            renderVisualSelection(editor, state);
        }
        state.count = 0;
        return true;
    }

    if (key === "g") {
        state.pending = { kind: "g" };
        return true;
    }

    // o - swap anchor and head
    if (key === "o") {
        state.count = 0;
        [state.visualAnchor, state.visualHead] = [state.visualHead, state.visualAnchor];
        renderVisualSelection(editor, state);
        return true;
    }

    // operators on the selection
    if (key === "d" || key === "x" || key === "c" || key === "s" || key === "y") {
        const op: Op = key === "x" ? "d" : key === "s" ? "c" : key as Op;
        const len = getText(editor).length;
        const a = Math.min(state.visualAnchor, len);
        const h = Math.min(state.visualHead, len);
        const start = Math.min(a, h);
        const end = Math.min(Math.max(a, h) + 1, len);
        setMode(editor, Mode.Normal);
        applyVisualOperator(editor, op, start, end, () => setMode(editor, Mode.Insert));
        return true;
    }

    const motion = visualMotions[key];
    if (motion) {
        const count = state.count || undefined;
        state.count = 0;
        // collapse to the head so motions read the right caret position,
        // move, then re-extend the selection from the anchor
        setCaret(editor, Math.min(state.visualHead, Math.max(getText(editor).length - 1, 0)));
        motion(editor, count);
        const pos = getCaret(editor);
        if (pos) state.visualHead = pos.offset;
        renderVisualSelection(editor, state);
        return true;
    }
    state.count = 0;

    // block printable/editing keys from modifying the box
    if (key.length === 1) return true;
    if (key === "Backspace" || key === "Delete") return true;
    if (key === "Enter") return e.shiftKey;
    return false;
}

/** r<char> - replace count characters under the caret with `ch`. */
function replaceChars(editor: HTMLElement, ch: string, count: number): void {
    const pos = getCaret(editor);
    if (!pos) return;
    const lines = getLines(editor);
    // vim: r fails when there aren't enough characters on the line
    if (pos.col + count > lines[pos.line].length) return;
    replaceRange(editor, pos.offset, pos.offset + count, ch.repeat(count));
    const target = pos.offset + count - 1;
    afterRender(editor, () => setCaret(editor, target));
}

/** ~ - toggle case of count characters, moving the caret right. */
function toggleCase(editor: HTMLElement, count: number): void {
    const pos = getCaret(editor);
    if (!pos) return;
    const lines = getLines(editor);
    const lineEnd = pos.offset - pos.col + lines[pos.line].length;
    const end = Math.min(pos.offset + count, lineEnd);
    if (end <= pos.offset) return;
    const text = getText(editor).slice(pos.offset, end);
    const toggled = Array.from(text, c => {
        const lower = c.toLowerCase();
        return c === lower ? c.toUpperCase() : lower;
    }).join("");
    replaceRange(editor, pos.offset, end, toggled);
    const target = Math.min(end, Math.max(lineEnd - 1, pos.offset - pos.col));
    afterRender(editor, () => setCaret(editor, target));
}

/** J - join count lines (min 2) with a single space, vim-style. */
function joinLines(editor: HTMLElement, count: number): void {
    const pos = getCaret(editor);
    if (!pos) return;
    const lines = getLines(editor);
    const last = Math.min(pos.line + Math.max(count, 2) - 1, lines.length - 1);
    if (last === pos.line) return;
    let joined = lines[pos.line];
    const caretCol = joined.length; // caret lands at the first join point
    for (let i = pos.line + 1; i <= last; i++) {
        const next = lines[i].replace(/^\s+/, "");
        joined = joined.replace(/\s+$/, "");
        joined = next ? joined + " " + next : joined;
    }
    const lineStart = pos.offset - pos.col;
    replaceRange(editor, lineStart, lineColToOffset(lines, last, lines[last].length), joined);
    const target = lineStart + Math.min(caretCol, Math.max(joined.length - 1, 0));
    afterRender(editor, () => setCaret(editor, target));
}

/** a - enter insert mode one character to the right. */
function appendAfter(editor: HTMLElement): void {
    const pos = getCaret(editor);
    if (pos) {
        const lines = getLines(editor);
        if (pos.col < lines[pos.line].length) setCaret(editor, pos.offset + 1);
    }
    setMode(editor, Mode.Insert);
}

/** I - enter insert mode at the first non-blank character of the line. */
function insertLineStart(editor: HTMLElement): void {
    moveFirstNonBlank(editor);
    setMode(editor, Mode.Insert);
}

/** A - enter insert mode at the end of the line. */
function appendLineEnd(editor: HTMLElement): void {
    const pos = getCaret(editor);
    if (pos) {
        const lines = getLines(editor);
        setCaret(editor, lineColToOffset(lines, pos.line, lines[pos.line].length));
    }
    setMode(editor, Mode.Insert);
}

/** o - open a new line below the current one and enter insert mode. */
function openBelow(editor: HTMLElement): void {
    const pos = getCaret(editor);
    if (!pos) {
        setMode(editor, Mode.Insert);
        return;
    }
    const lines = getLines(editor);
    setCaret(editor, lineColToOffset(lines, pos.line, lines[pos.line].length));
    afterSelectionSync(() => {
        insertLineBreak(editor);
        // caret ends up on the new (empty) line after the break
        setMode(editor, Mode.Insert);
    });
}

/** O - open a new line above the current one and enter insert mode. */
function openAbove(editor: HTMLElement): void {
    const pos = getCaret(editor);
    if (!pos) {
        setMode(editor, Mode.Insert);
        return;
    }
    setCaret(editor, lineColToOffset(getLines(editor), pos.line, 0));
    afterSelectionSync(() => {
        insertLineBreak(editor);
        // caret is now at the start of the pushed-down original line;
        // move it up onto the new empty line above.
        setCaret(editor, lineColToOffset(getLines(editor), pos.line, 0));
        setMode(editor, Mode.Insert);
    });
}

/**
 * Handle a keydown aimed at a slate editor.
 * Returns true if the event was consumed (caller should preventDefault +
 * stopImmediatePropagation).
 */
export function handleKey(editor: HTMLElement, e: KeyboardEvent): boolean {
    const state = getState(editor);
    updateIndicator(editor, state.mode);

    if (state.mode === Mode.Insert) {
        if (e.key === "Escape" && !e.ctrlKey && !e.altKey && !e.metaKey) {
            if (!replaying && recordingInsert) {
                recordBuffer.push("Escape");
                commitChange();
            }
            recordingInsert = false;
            setMode(editor, Mode.Normal);
            // vim moves the caret one left when leaving insert mode
            moveLeft(editor, 1);
            return true; // swallow so Discord doesn't clear reply state
        }
        // record typed text so `.` can replay the whole change
        if (!replaying && recordingInsert && !e.ctrlKey && !e.altKey && !e.metaKey) {
            if (e.key.length === 1) recordBuffer.push(e.key);
            else if (e.key === "Backspace" && recordBuffer.length > recordInsertStart) {
                recordBuffer.pop();
            }
        }
        return false;
    }

    if (state.mode === Mode.Replace) {
        if (e.ctrlKey || e.altKey || e.metaKey) return false;
        return handleReplaceKey(editor, state, e.key);
    }

    // Ctrl-R -> redo in NORMAL mode (consumed so Discord doesn't refresh)
    if (state.mode === Mode.Normal && e.ctrlKey && !e.altKey && !e.metaKey && e.key === "r") {
        redo(editor);
        return true;
    }

    if (e.ctrlKey || e.altKey || e.metaKey) return false;
    // ignore bare modifier presses so they don't clear pending state
    if (e.key === "Shift" || e.key === "CapsLock") return false;

    if (state.mode === Mode.Visual) return handleVisualKey(editor, state, e);

    // NORMAL mode

    if (e.key === "Escape") {
        if (state.pending || state.count) {
            state.pending = null;
            state.count = 0;
            return true;
        }
        switch (settings.store.escapeInNormal) {
            case "passthrough":
                return false;
            case "double": {
                const now = Date.now();
                if (now - state.lastEscape <= DOUBLE_ESCAPE_MS) {
                    state.lastEscape = 0;
                    return false; // second escape passes through
                }
                state.lastEscape = now;
                return true;
            }
            default: // "swallow"
                return true;
        }
    }

    return handleNormalKey(editor, state, e.key, e.shiftKey);
}

/** Handle a single NORMAL-mode key (also used by `.` replay). */
function handleNormalKey(editor: HTMLElement, state: EditorState, key: string, shiftKey: boolean): boolean {
    // record keys for `.`: a fresh command starts when nothing is pending
    if (!replaying) {
        if (!state.pending && state.count === 0) {
            recordBuffer = [key];
            recordingInsert = false;
        } else {
            recordBuffer.push(key);
        }
    }

    // r-pending: the next printable key replaces characters
    if (state.pending?.kind === "r") {
        const rCount = state.pending.count;
        state.pending = null;
        if (key.length === 1) {
            replaceChars(editor, key, rCount);
            commitChange();
        }
        return true;
    }

    // f/F/t/T-pending: the next printable key is the search char
    if (state.pending?.kind === "f") {
        const { cmd, count } = state.pending;
        state.pending = null;
        if (key.length === 1) findChar(editor, cmd, key, count);
        return true;
    }

    // operator-pending: feed everything to the operator handler
    if (state.pending?.kind === "op") {
        const wasChange = state.pending.op === "c";
        opResult.applied = false;
        state.pending = handleOperatorKey(
            editor, state.pending, key,
            () => setMode(editor, Mode.Insert)
        );
        if (!state.pending && opResult.applied) {
            // c enters insert mode: keep recording the typed text and
            // commit on Escape instead
            if (wasChange) startInsertRecording();
            else commitChange();
        }
        return true;
    }

    // pending multi-key sequences (gg)
    if (state.pending) {
        state.pending = null;
        if (key === "g") {
            const count = state.count || undefined;
            state.count = 0;
            moveFirstLine(editor, count);
        }
        return true; // swallow unknown g-sequences too
    }

    // numeric count prefix (0 is a motion unless a count is in progress)
    if (/^[0-9]$/.test(key) && !(key === "0" && state.count === 0)) {
        state.count = Math.min(state.count * 10 + Number(key), 999999);
        return true;
    }

    const count = state.count || undefined;

    if (key === "g") {
        state.pending = { kind: "g" };
        return true;
    }

    if (key === "f" || key === "F" || key === "t" || key === "T") {
        state.pending = { kind: "f", cmd: key, count: state.count || 1 };
        state.count = 0;
        return true;
    }

    if (key === "r") {
        state.pending = { kind: "r", count: state.count || 1 };
        state.count = 0;
        // show the REPLACE indicator while waiting for the char; the next
        // keydown re-syncs the badge to the real mode (top of handleKey)
        updateIndicator(editor, Mode.Replace);
        return true;
    }

    if (key === ".") {
        state.count = 0;
        if (!replaying && lastChange) {
            replaying = true;
            replayKeys(editor, state, lastChange, 0);
        }
        return true;
    }

    if (key === "d" || key === "c" || key === "y") {
        state.pending = {
            kind: "op", op: key as Op,
            count: state.count, motionCount: 0,
        };
        state.count = 0;
        return true;
    }

    const binding = normalBindings[key];
    if (binding) {
        state.count = 0;
        binding(editor, count);
        if (INSERT_KEYS.has(key)) startInsertRecording();
        else if (CHANGE_KEYS.has(key)) commitChange();
        return true;
    }
    state.count = 0;

    // Block printable keys and editing keys from modifying the box.
    if (key.length === 1) return true;
    if (key === "Backspace" || key === "Delete") return true;
    // Enter sends the message (allowed); Shift+Enter would insert a newline.
    if (key === "Enter") return shiftKey;

    // Let non-printable keys (Enter, Tab, Escape, ...) through.
    return false;
}

/**
 * Replay recorded keys for `.`, one per macrotask: mode changes triggered
 * by operators (c entering insert) happen in afterSelectionSync/afterRender
 * callbacks, so each replayed key must wait for the previous one's async
 * effects to settle.
 */
function replayKeys(editor: HTMLElement, state: EditorState, keys: string[], i: number): void {
    if (i >= keys.length) {
        replaying = false;
        return;
    }
    const k = keys[i];
    if (state.mode === Mode.Replace) {
        handleReplaceKey(editor, state, k);
    } else if (state.mode === Mode.Insert) {
        if (k === "Escape") {
            setMode(editor, Mode.Normal);
            moveLeft(editor, 1);
        } else if (k.length === 1) {
            insertText(editor, k);
        }
    } else {
        handleNormalKey(editor, state, k, false);
    }
    setTimeout(() => replayKeys(editor, state, keys, i + 1), 0);
}

export function resetOnFocus(editor: HTMLElement): void {
    const s = getState(editor);
    switch (settings.store.defaultMode) {
        case "normal":
            setMode(editor, Mode.Normal);
            return;
        case "remember":
            // keep whatever mode the editor was left in, but never resume
            // visual/replace (their transient state is gone)
            if (s.mode === Mode.Visual || s.mode === Mode.Replace) {
                setMode(editor, Mode.Normal);
                return;
            }
            break;
        default: // "insert"
            setMode(editor, Mode.Insert);
            return;
    }
    updateIndicator(editor, s.mode);
}