import ist from "ist"

import {EditorState, EditorSelection, SelectionRange, Transaction,
        StateEffect, StateEffectType, StateField, Mapping, Change} from "@codemirror/next/state"
import {isolateHistory, history, redo, redoDepth, redoSelection, undo, undoDepth,
        undoSelection, invertedEffects} from "@codemirror/next/history"

function mkState(config?: any, doc?: string) {
  return EditorState.create({
    extensions: [history(config), EditorState.allowMultipleSelections.of(true)],
    doc
  })
}

function type(state: EditorState, text: string, at = state.doc.length) {
  return state.t().replace(at, at, text).apply()
}
function timedType(state: EditorState, text: string, atTime: number) {
  return state.t(atTime).replace(state.doc.length, state.doc.length, text).apply()
}
function receive(state: EditorState, text: string, from: number, to = from) {
  return state.t().replace(from, to, text).annotate(Transaction.addToHistory, false).apply()
}
function command(state: EditorState, cmd: any, success: boolean = true) {
  ist(cmd({state, dispatch(tr: Transaction) { state = tr.apply() }}), success)
  return state
}

describe("history", () => {
  it("allows to undo a change", () => {
    let state = mkState()
    state = type(state, "newtext")
    state = command(state, undo)
    ist(state.doc.toString(), "")
  })

  it("allows to undo nearby changes in one change", () => {
    let state = mkState()
    state = type(state, "new")
    state = type(state, "text")
    state = command(state, undo)
    ist(state.doc.toString(), "")
  })

  it("allows to redo a change", () => {
    let state = mkState()
    state = type(state, "newtext")
    state = command(state, undo)
    state = command(state, redo)
    ist(state.doc.toString(), "newtext")
  })

  it("allows to redo nearby changes in one change", () => {
    let state = mkState()
    state = type(state, "new")
    state = type(state, "text")
    state = command(state, undo)
    state = command(state, redo)
    ist(state.doc.toString(), "newtext")
  })

  it("tracks multiple levels of history", () => {
    let state = mkState()
    state = type(state, "new")
    state = type(state, "text")
    state = type(state, "some", 0)
    ist(state.doc.toString(), "somenewtext")
    state = command(state, undo)
    ist(state.doc.toString(), "newtext")
    state = command(state, undo)
    ist(state.doc.toString(), "")
    state = command(state, redo)
    ist(state.doc.toString(), "newtext")
    state = command(state, redo)
    ist(state.doc.toString(), "somenewtext")
    state = command(state, undo)
    ist(state.doc.toString(), "newtext")
  })

  it("starts a new event when newGroupDelay elapses", () => {
    let state = mkState({newGroupDelay: 1000})
    state = timedType(state, "a", 1000)
    state = timedType(state, "b", 1600)
    ist(undoDepth(state), 1)
    state = timedType(state, "c", 2700)
    ist(undoDepth(state), 2)
    state = command(state, undo)
    state = timedType(state, "d", 2800)
    ist(undoDepth(state), 2)
  })

  it("allows changes that aren't part of the history", () => {
    let state = mkState()
    state = type(state, "hello")
    state = receive(state, "oops", 0)
    state = receive(state, "!", 9)
    state = command(state, undo)
    ist(state.doc.toString(), "oops!")
  })

  it("doesn't get confused by an undo not adding any redo item", () => {
    let state = mkState({}, "ab")
    state = type(state, "cd", 1)
    state = receive(state, "123", 0, 4)
    state = command(state, undo, false)
    command(state, redo, false)
  })

  it("accurately maps changes through each other", () => {
    let state = mkState({}, "123")
    state = state.t().replace(1, 2, "cd").replace(3, 4, "ef").replace(0, 1, "ab").apply()
    state = receive(state, "!!!!!!!!", 2, 2)
    state = command(state, undo)
    state = command(state, redo)
    ist(state.doc.toString(), "ab!!!!!!!!cdef")
  })

  it("can handle complex editing sequences", () => {
    let state = mkState()
    state = type(state, "hello")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = type(state, "!")
    state = receive(state, "....", 0)
    state = type(state, "\n\n", 2)
    ist(state.doc.toString(), "..\n\n..hello!")
    state = receive(state, "\n\n", 1)
    state = command(state, undo)
    state = command(state, undo)
    ist(state.doc.toString(), ".\n\n...hello")
    state = command(state, undo)
    ist(state.doc.toString(), ".\n\n...")
  })

  it("supports overlapping edits", () => {
    let state = mkState()
    state = type(state, "hello")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = state.t().replace(0, 5, "").apply()
    ist(state.doc.toString(), "")
    state = command(state, undo)
    ist(state.doc.toString(), "hello")
    state = command(state, undo)
    ist(state.doc.toString(), "")
  })

  it("supports overlapping edits that aren't collapsed", () => {
    let state = mkState()
    state = receive(state, "h", 0)
    state = type(state, "ello")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = state.t().replace(0, 5, "").apply()
    ist(state.doc.toString(), "")
    state = command(state, undo)
    ist(state.doc.toString(), "hello")
    state = command(state, undo)
    ist(state.doc.toString(), "h")
  })

  it("supports overlapping unsynced deletes", () => {
    let state = mkState()
    state = type(state, "hi")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = type(state, "hello")
    state = state.t().replace(0, 7, "").annotate(Transaction.addToHistory, false).apply()
    ist(state.doc.toString(), "")
    state = command(state, undo, false)
    ist(state.doc.toString(), "")
  })

  it("can go back and forth through history multiple times", () => {
    let state = mkState()
    state = type(state, "one")
    state = type(state, " two")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = type(state, " three")
    state = type(state, "zero ", 0)
    state = state.t().annotate(isolateHistory, "before").apply()
    state = type(state, "\n\n", 0)
    state = type(state, "top", 0)
    for (let i = 0; i < 6; i++) {
      let re = i % 2
      for (let j = 0; j < 4; j++) state = command(state, re ? redo : undo)
      ist(state.doc.toString(), re ? "top\n\nzero one two three" : "")
    }
  })

  it("supports non-tracked changes next to tracked changes", () => {
    let state = mkState()
    state = type(state, "o")
    state = type(state, "\n\n", 0)
    state = receive(state, "zzz", 3)
    state = command(state, undo)
    ist(state.doc.toString(), "zzz")
  })

  it("can go back and forth through history when preserving items", () => {
    let state = mkState()
    state = type(state, "one")
    state = type(state, " two")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = receive(state, "xxx", state.doc.length)
    state = type(state, " three")
    state = type(state, "zero ", 0)
    state = state.t().annotate(isolateHistory, "before").apply()
    state = type(state, "\n\n", 0)
    state = type(state, "top", 0)
    state = receive(state, "yyy", 0)
    for (let i = 0; i < 3; i++) {
      for (let j = 0; j < 4; j++) state = command(state, undo)
      ist(state.doc.toString(), "yyyxxx")
      for (let j = 0; j < 4; j++) state = command(state, redo)
      ist(state.doc.toString(), "yyytop\n\nzero one twoxxx three")
    }
  })

  it("restores selection on undo", () => {
    let state = mkState()
    state = type(state, "hi")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = state.t().setSelection(EditorSelection.single(0, 2)).apply()
    const selection = state.selection
    state = state.t().replaceSelection("hello").apply()
    const selection2 = state.selection
    state = command(state, undo)
    ist(state.selection.eq(selection))
    state = command(state, redo)
    ist(state.selection.eq(selection2))
  })

  it("restores the selection before the first change in an item (#46)", () => {
    let state = mkState()
    state = state.t().replace(0, 0, "a").setSelection(EditorSelection.single(1)).apply()
    state = state.t().replace(1, 1, "b").setSelection(EditorSelection.single(2)).apply()
    state = command(state, undo)
    ist(state.doc.toString(), "")
    ist(state.selection.primary.anchor, 0)
  })

  it("doesn't merge document changes if there's a selection change in between", () => {
    let state = mkState()
    state = type(state, "hi")
    state = state.t().setSelection(EditorSelection.single(0, 2)).apply()
    state = state.t().replaceSelection("hello").apply()
    ist(undoDepth(state), 2)
  })

  it("rebases selection on undo", () => {
    let state = mkState()
    state = type(state, "hi")
    state = state.t().annotate(isolateHistory, "before").apply()
    state = state.t().setSelection(EditorSelection.single(0, 2)).apply()
    state = type(state, "hello", 0)
    state = receive(state, "---", 0)
    state = command(state, undo)
    ist(state.selection.ranges[0].head, 5)
  })

  it("supports querying for the undo and redo depth", () => {
    let state = mkState()
    state = type(state, "a")
    ist(undoDepth(state), 1)
    ist(redoDepth(state), 0)
    state = receive(state, "b", 0)
    ist(undoDepth(state), 1)
    ist(redoDepth(state), 0)
    state = command(state, undo)
    ist(undoDepth(state), 0)
    ist(redoDepth(state), 1)
    state = command(state, redo)
    ist(undoDepth(state), 1)
    ist(redoDepth(state), 0)
  })

  it("all functions gracefully handle EditorStates without history", () => {
    let state = EditorState.create()
    ist(undoDepth(state), 0)
    ist(redoDepth(state), 0)
    command(state, undo, false)
    command(state, redo, false)
  })

  it("truncates history", () => {
    let state = mkState({minDepth: 10})
    for (let i = 0; i < 40; ++i) {
      state = type(state, "a")
      state = state.t().annotate(isolateHistory, "before").apply()
    }
    ist(undoDepth(state) < 40)
  })

  it("supports transactions with multiple changes", () => {
    let state = mkState()
    state = state.t().replace(0, 0, "a").replace(1, 1, "b").apply()
    state = type(state, "c", 0)
    ist(state.doc.toString(), "cab")
    state = command(state, undo)
    ist(state.doc.toString(), "ab")
    state = command(state, undo)
    ist(state.doc.toString(), "")
    state = command(state, redo)
    ist(state.doc.toString(), "ab")
    state = command(state, redo)
    ist(state.doc.toString(), "cab")
    state = command(state, undo)
    ist(state.doc.toString(), "ab")
  })

  it("doesn't undo selection-only transactions", () => {
    let state = mkState(undefined, "abc")
    ist(state.selection.primary.head, 0)
    state = state.t().setSelection(EditorSelection.single(2)).apply()
    state = command(state, undo, false)
    ist(state.selection.primary.head, 2)
  })

  it("isolates transactions when asked to", () => {
    let state = mkState()
    state = state.t().replace(0, 0, "a").annotate(isolateHistory, "after").apply()
    state = state.t().replace(1, 1, "b").apply()
    state = state.t().replace(2, 2, "c").annotate(isolateHistory, "after").apply()
    state = state.t().replace(3, 3, "d").apply()
    state = state.t().replace(4, 4, "e").annotate(isolateHistory, "full").apply()
    state = state.t().replace(5, 5, "f").apply()
    ist(undoDepth(state), 5)
  })

  it("can group events around a non-history transaction", () => {
    let state = mkState()
    state = state.t().replace(0, 0, "a").apply()
    state = state.t().replace(1, 1, "b").annotate(Transaction.addToHistory, false).apply()
    state = state.t().replace(1, 1, "c").apply()
    state = command(state, undo)
    ist(state.doc.toString(), "b")
  })

  it("survives compression", () => {
    let state = mkState()
    state = state.t().replace(0, 0, "a").apply()
    state = state.t().replace(1, 1, "b").annotate(Transaction.addToHistory, false).apply()
    state = state.t().replace(2, 2, "c").apply()
    state = state.t().replace(3, 3, "d").apply()
    state = state.t().replace(4, 4, "e").apply()
    state = state.t().replace(0, 0, ">").apply()
    for (let i = 0; i < 500; i++) state = state.t().replace(0, 0, "*").annotate(Transaction.addToHistory, false).apply()
    state = state.t().replace(0, 500, "=").annotate(Transaction.addToHistory, false).apply()
    ist(state.doc.toString(), "=>abcde")
    state = command(state, undo)
    state = command(state, undo)
    ist(state.doc.toString(), "=ab")
    state = command(state, undo)
    ist(state.doc.toString(), "=b")
    state = command(state, redo)
    state = command(state, redo)
    state = command(state, redo)
    ist(state.doc.toString(), "=>abcde")
  })

  describe("undoSelection", () => {
    it("allows to undo a change", () => {
      let state = mkState()
      state = type(state, "newtext")
      state = command(state, undoSelection)
      ist(state.doc.toString(), "")
    })

    it("allows to undo selection-only transactions", () => {
      let state = mkState(undefined, "abc")
      ist(state.selection.primary.head, 0)
      state = state.t().setSelection(EditorSelection.single(2)).apply()
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 0)
    })

    it("merges selection-only transactions from keyboard", () => {
      let state = mkState(undefined, "abc")
      ist(state.selection.primary.head, 0)
      state = state.t().setSelection(EditorSelection.single(2)).annotate(Transaction.userEvent, "keyboard").apply()
      state = state.t().setSelection(EditorSelection.single(3)).annotate(Transaction.userEvent, "keyboard").apply()
      state = state.t().setSelection(EditorSelection.single(1)).annotate(Transaction.userEvent, "keyboard").apply()
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 0)
    })

    it("doesn't merge selection-only transactions from other sources", () => {
      let state = mkState(undefined, "abc")
      ist(state.selection.primary.head, 0)
      state = state.t().setSelection(EditorSelection.single(2)).apply()
      state = state.t().setSelection(EditorSelection.single(3)).apply()
      state = state.t().setSelection(EditorSelection.single(1)).apply()
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 3)
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 2)
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 0)
    })

    it("doesn't merge selection-only transactions if they change the number of selections", () => {
      let state = mkState(undefined, "abc")
      ist(state.selection.primary.head, 0)
      state = state.t().setSelection(EditorSelection.single(2)).annotate(Transaction.userEvent, "keyboard").apply()
      state = state.t().setSelection(EditorSelection.create([new SelectionRange(1, 1), new SelectionRange(3, 3)])).
        annotate(Transaction.userEvent, "keyboard").apply()
      state = state.t().setSelection(EditorSelection.single(1)).annotate(Transaction.userEvent, "keyboard").apply()
      state = command(state, undoSelection)
      ist(state.selection.ranges.length, 2)
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 0)
    })

    it("doesn't merge selection-only transactions if a selection changes empty state", () => {
      let state = mkState(undefined, "abc")
      ist(state.selection.primary.head, 0)
      state = state.t().setSelection(EditorSelection.single(2)).annotate(Transaction.userEvent, "keyboard").apply()
      state = state.t().setSelection(EditorSelection.single(2, 3)).annotate(Transaction.userEvent, "keyboard").apply()
      state = state.t().setSelection(EditorSelection.single(1)).annotate(Transaction.userEvent, "keyboard").apply()
      state = command(state, undoSelection)
      ist(state.selection.primary.anchor, 2)
      ist(state.selection.primary.head, 3)
      state = command(state, undoSelection)
      ist(state.selection.primary.head, 0)
    })

    it("allows to redo a change", () => {
      let state = mkState()
      state = type(state, "newtext")
      state = command(state, undoSelection)
      state = command(state, redoSelection)
      ist(state.doc.toString(), "newtext")
    })

    it("allows to redo selection-only transactions", () => {
      let state = mkState(undefined, "abc")
      ist(state.selection.primary.head, 0)
      state = state.t().setSelection(EditorSelection.single(2)).apply()
      state = command(state, undoSelection)
      state = command(state, redoSelection)
      ist(state.selection.primary.head, 2)
    })

    it("only changes selection", () => {
      let state = mkState()
      state = type(state, "hi")
      state = state.t().annotate(isolateHistory, "before").apply()
      const selection = state.selection
      state = state.t().setSelection(EditorSelection.single(0, 2)).apply()
      const selection2 = state.selection
      state = command(state, undoSelection)
      ist(state.selection.eq(selection))
      ist(state.doc.toString(), "hi")
      state = command(state, redoSelection)
      ist(state.selection.eq(selection2))
      state = state.t().replaceSelection("hello").apply()
      const selection3 = state.selection
      state = command(state, undoSelection)
      ist(state.selection.eq(selection2))
      state = command(state, redo)
      ist(state.selection.eq(selection3))
    })

    it("can undo a selection through remote changes", () => {
      let state = mkState()
      state = type(state, "hello")
      const selection = state.selection
      state = state.t().setSelection(EditorSelection.single(0, 2)).apply()
      state = receive(state, "oops", 0)
      state = receive(state, "!", 9)
      ist(state.selection.eq(EditorSelection.single(0, 6)))
      state = command(state, undoSelection)
      ist(state.doc.toString(), "oopshello!")
      ist(state.selection.eq(selection))
    })
  })

  describe("effects", () => {
    it("includes inverted effects in the history", () => {
      let set = StateEffect.define<number>()
      let field = StateField.define({
        create: () => 0,
        update(val, tr) {
          for (let effect of tr.effects) if (effect.is(set)) val = effect.value
          return val
        }
      })
      let invert = invertedEffects.of(tr => {
        for (let e of tr.effects) if (e.is(set)) return [set.of(tr.startState.field(field))]
        return []
      })
      let state = EditorState.create({extensions: [history(), field, invert]})
      state = state.t().effect(set.of(10)).annotate(isolateHistory, "before").apply()
      state = state.t().effect(set.of(20)).annotate(isolateHistory, "before").apply()
      ist(state.field(field), 20)
      state = command(state, undo)
      ist(state.field(field), 10)
      state = command(state, undo)
      ist(state.field(field), 0)
      state = command(state, redo)
      ist(state.field(field), 10)
      state = command(state, redo)
      ist(state.field(field), 20)
      state = command(state, undo)
      ist(state.field(field), 10)
      state = command(state, redo)
      ist(state.field(field), 20)
    })

    class Comment {
      constructor(readonly from: number,
                  readonly to: number,
                  readonly text: string) {}

      eq(other: Comment) { return this.from == other.from && this.to == other.to && this.text == other.text }
    }
    function mapComment(comment: Comment, mapping: Mapping) {
      let from = mapping.mapPos(comment.from, 1), to = mapping.mapPos(comment.to, -1)
      return from >= to ? undefined : new Comment(from, to, comment.text)
    }
    let addComment: StateEffectType<Comment> = StateEffect.define<Comment>({map: mapComment})
    let rmComment: StateEffectType<Comment> = StateEffect.define<Comment>({map: mapComment})
    let comments = StateField.define<Comment[]>({
      create: () => [],
      update(value, tr) {
        value = value.map(c => mapComment(c, tr.changes)).filter(x => x) as any
        for (let effect of tr.effects) {
          if (effect.is(addComment)) value = value.concat(effect.value)
          else if (effect.is(rmComment)) value = value.filter(c => !c.eq(effect.value))
        }
        return value.sort((a, b) => a.from - b.from)
      }
    })
    let invertComments = invertedEffects.of(tr => {
      let effects = []
      for (let effect of tr.effects) {
        if (effect.is(addComment) || effect.is(rmComment)) {
          let src = mapComment(effect.value, tr.invertedChanges())
          if (src) effects.push((effect.is(addComment) ? rmComment : addComment).of(src))
        }
      }
      for (let comment of tr.startState.field(comments)) {
        if (!mapComment(comment, tr.changes)) effects.push(addComment.of(comment))
      }
      return effects
    })

    function commentStr(state: EditorState) { return state.field(comments).map(c => c.text + "@" + c.from).join(",") }

    it("can map effects", () => {
      let state = EditorState.create({extensions: [history(), comments, invertComments],
                                      doc: "one two foo"})
      state = state.t().effect(addComment.of(new Comment(0, 3, "c1"))).annotate(isolateHistory, "full").apply()
      ist(commentStr(state), "c1@0")
      state = state.t().replace(3, 4, "---").annotate(isolateHistory, "full").
        effect(addComment.of(new Comment(6, 9, "c2"))).apply()
      ist(commentStr(state), "c1@0,c2@6")
      state = state.t().replace(0, 0, "---").annotate(Transaction.addToHistory, false).apply()
      ist(commentStr(state), "c1@3,c2@9")
      state = command(state, undo)
      ist(state.doc.toString(), "---one two foo")
      ist(commentStr(state), "c1@3")
      state = command(state, undo)
      ist(commentStr(state), "")
      state = command(state, redo)
      ist(commentStr(state), "c1@3")
      state = command(state, redo)
      ist(commentStr(state), "c1@3,c2@9")
      ist(state.doc.toString(), "---one---two foo")
      state = command(state, undo).t().replace(10, 11, "---").annotate(Transaction.addToHistory, false).apply()
      state = state.t().effect(addComment.of(new Comment(13, 16, "c3"))).annotate(isolateHistory, "full").apply()
      ist(commentStr(state), "c1@3,c3@13")
      state = command(state, undo)
      ist(state.doc.toString(), "---one two---foo")
      ist(commentStr(state), "c1@3")
      state = command(state, redo)
      ist(commentStr(state), "c1@3,c3@13")
    })

    it("can restore comments lost through deletion", () => {
      let state = EditorState.create({extensions: [history(), comments, invertComments],
                                      doc: "123456"})
      state = state.t().effect(addComment.of(new Comment(3, 5, "c1"))).annotate(isolateHistory, "full").apply()
      state = state.t().replace(2, 6, "").apply()
      ist(commentStr(state), "")
      state = command(state, undo)
      ist(commentStr(state), "c1@3")
    })
  })

  it("behaves properly with rebasing changes", () => {
    let state = EditorState.create({extensions: [history()], doc: "one three", selection: {anchor: 3}})
    let changes: {forward: Change, backward: Change}[] = []
    function dispatch(tr: Transaction) {
      for (let inv = tr.invertedChanges(), i = 0, j = inv.length - 1; j >= 0; i++, j--)
        changes.push({forward: tr.changes.changes[i], backward: inv.changes[j]})
      state = tr.apply()
    }
    function receive(confirmedTo: number, f: (tr: Transaction) => void) {
      let tr = state.t(), newChanges = changes.slice(0, confirmedTo)
      for (let i = changes.length - 1; i >= confirmedTo; i--) tr.changeNoFilter(changes[i].backward)
      f(tr)
      for (let i = confirmedTo, refIndex = changes.length - confirmedTo; i < changes.length; i++) {
        let mapped = changes[i].forward.map(tr.changes.partialMapping(refIndex))
        refIndex--
        if (mapped) {
          newChanges.push({forward: mapped, backward: mapped.invert(tr.doc)})
          tr.changeNoFilter(mapped, refIndex)
        }          
      }
      state = tr.annotate(Transaction.rebasedChanges, changes.length - confirmedTo)
        .annotate(Transaction.addToHistory, false).apply()
      changes = newChanges
    }

    for (let ch of " two") dispatch(state.t().replaceSelection(ch))
    dispatch(state.t().setSelection(13).replaceSelection("!"))
    ist(changes.length, 5)
    ist(state.doc.toString(), "one two three!")
    // Say the last 3 changes (adding "wo" and "!") are unconfirmed,
    // and remote changes come in replacing "three" -> "four"
    receive(2, tr => tr.replace(6, 11, "four"))
    ist(state.doc.toString(), "one two four!")
    // Another remote change, adding " five" after "four"
    receive(2, tr => tr.replace(10, 10, " five"))
    dispatch(state.t().replace(18, 18, "?").annotate(isolateHistory, "full"))
    ist(state.doc.toString(), "one two four five!?")

    undo({state, dispatch})
    ist(state.doc.toString(), "one two four five!")
    undo({state, dispatch})
    ist(state.doc.toString(), "one two four five")

    // Run through the full undo/redo to verify that still works, but
    // leave `state` at two undos
    let undone3 = command(state, undo)
    ist(undone3.doc.toString(), "one four five")
    let redone = command(undone3, redo), redone2 = command(redone, redo), redone3 = command(redone2, redo)
    ist(redone.doc.toString(), "one two four five")
    ist(redone2.doc.toString(), "one two four five!")
    ist(redone3.doc.toString(), "one two four five!?")

    receive(3, tr => tr.replace(16, 16, " six"))
    ist(state.doc.toString(), "one two four five six")
    undo({state, dispatch})
    ist(state.doc.toString(), "one four five six")
    redo({state, dispatch})
    ist(state.doc.toString(), "one two four five six")
    redo({state, dispatch})
    ist(state.doc.toString(), "one two four five six!")
    redo({state, dispatch})
    ist(state.doc.toString(), "one two four five six!?")
  })
})