One-Line Editor

Replay a stream of editing commands on a one-line text box that has a cursor, a selection, and undo/redo.

The text box starts empty. It has a cursor, a position from 0 to the text length (0 is before the first character), and an optional anchor. When an anchor is set and differs from the cursor, the characters between the two positions are selected. If there is no anchor, or the anchor equals the cursor, nothing is selected. Each command is a string: a command name, optionally followed by one space and an argument (the argument is everything after that first space, so it may itself contain spaces).

• type <text>: with a non-empty selection, replace the selection with <text>; otherwise insert <text> at the cursor. The cursor ends right after the inserted text and the anchor is cleared.
• backspace: with a non-empty selection, delete it (the cursor goes to the start of the selection). Otherwise delete the character before the cursor, if there is one. The anchor is cleared (even if nothing was deleted).
• delete: the same, but without a selection it deletes the character after the cursor, if there is one. The anchor is cleared.
• left <k> / right <k>: move the cursor k characters, stopping at the ends of the text. The anchor stays where it is, so moving after mark grows or shrinks the selection.
• home / end: move the cursor to the start / end of the text. The anchor stays.
• mark: set the anchor at the cursor, replacing any earlier anchor.
• undo / redo: described below.

Undo history. Every command that actually changes the text is an edit: a type, backspace or delete that left the text different from before. Each edit is recorded with the full state (text, cursor and anchor) from just before it and just after it. Moves, mark, and commands that change nothing are not edits.

• undo takes the most recent recorded step that has not been undone and restores the text, cursor and anchor that existed just before it. If there is nothing to undo, it does nothing.
• redo re-applies the most recently undone step, restoring the text, cursor and anchor that existed just after it. If there is nothing to redo, it does nothing.
• Any new edit discards everything that could still be redone.
• Typing is grouped. A type command is *plain* if it replaced no selection. A plain type that comes immediately after another plain type in the command list (no other command of any kind between them, even one that changed nothing) is merged into that earlier step instead of creating a new one: the merged step restores the state from before the first type of the run, and re-does to the state after the last. A type that replaced a selection is never merged, and the type after it starts a new step.

Anything else (an unknown command, a missing argument, type with nothing after it, a left or right whose argument is not a whole number) is ignored. It still counts as a command, so it breaks up a run of typing.

Input: commands, a list of command strings.

Output: a list [text, cursor] with the final text and the final cursor position.