diff --git a/dev/test.html b/dev/test.html
index 327cebd..01101c6 100644
--- a/dev/test.html
+++ b/dev/test.html
@@ -2,8 +2,6 @@
 <meta charset=utf8>
 <title>CodeMirror view tests</title>
 
-<link rel=stylesheet href="mocha/mocha.css">
-
 <h1>CodeMirror view tests</h1>
 
 <div id="workspace" style="opacity: 0; position: fixed; top: 0; left: 0; width: 20em;"></div>
@@ -28,7 +26,7 @@ <h1>CodeMirror view tests</h1>
     })
   }
   mocha.setup(options)
-  await import("../test/webtest-vim")
+  await import("../test/webtest-emacs")
   mocha.run()
 </script>
  
\ No newline at end of file
diff --git a/dev/web-demo.html b/dev/web-demo.html
index 07c4f33..4d304f0 100644
--- a/dev/web-demo.html
+++ b/dev/web-demo.html
@@ -4,7 +4,7 @@
     <style>
       #editor {
         height: min(540px, 50vh); width: min(960px, 90vw);
-        position: absolute; resize: both; overflow: hidden
+        resize: both; overflow: hidden
       }
       #editor>.cm-editor {width: 100%; height: 100%}
       #editor.split>.cm-editor {height: 50%}
@@ -469,7 +469,7 @@
         if (!/^\w+:/.test(path)) path = host + path;
         var onLoad = function(e, val) {
             if (e) return processLoadQueue({id: id, path: path});
-            if (path.slice(-3) == ".ts") {
+            if (path.slice(-3) == ".ts" || /^import \{/m.test(val)) {
                 val = ts.transpileModule(val, {
                     compilerOptions: {
                         target: "ES2022",
@@ -520,7 +520,12 @@
             }
         } else {
             var url = require.toUrl(module, ".js");
-            if (define.fetchedUrls[url] & 1) return false;
+            if (define.fetchedUrls[url] & 1) {
+                setTimeout(function() {
+                    processLoadQueue(null, module);
+                });
+                return false;
+            }
             define.fetchedUrls[url] |= 1;
             loadScript(url, module, processLoadQueue);
         }
@@ -604,6 +609,9 @@
     <input type="checkbox" id="wrap"> <label for="wrap">wrap</label>
     <input type="checkbox" id="html"> <label for="html">html</label>
     <div id="editor"></div>
+    <br>
+    <br>
+    <a href="#test.html" onclick="runTests()">tests</a><br>
 <script>
     // console.log(ts)
     require.config({
@@ -638,5 +646,80 @@
         "dev/index.ts",
     ], function() {})
 </script>
+<script>
+    var it, describe
+    var old 
+    function runTests() {
+        if (!old) {
+            old = {};
+            Object.keys(define.modules).forEach(k=> old[k] = 1)
+        } else {
+            Object.keys(define.modules)
+            .concat(Object.keys(define.errors))
+            .forEach(k=> {
+                if (!old[k])
+                    require.undef(k)
+            })
+        }
+
+        require.config({
+            paths: {
+                "test/webtest-emacs": require.config.baseUrl.replace("dev", "test/webtest-emacs.js"),
+            }
+        });
+        define("test/..", function(require, exports, module) {
+            module.exports = require("src/index")
+        });
+        var suites = Object.create(null)
+        describe = function(name, fn) {
+            var suite = {
+                name,
+                construct: fn,
+                tests: Object.create(null),
+                skipped: Object.create(null),
+                it: function (name, fn) {
+                    this.tests[name] = fn;
+                },
+                skip: function (name, fn) {
+                    this.skipped[name] = fn;
+                },
+            };
+            suites[name] = suite;
+            it = suite.it = suite.it.bind(suite);
+            it.skip = suite.skip.bind(suite);
+            suite.construct();        
+        }
+        
+        require(["test/webtest-emacs"], async function() {
+            var total = 0;
+            var skipped = 0;
+            var failed = 0;
+            var passed = 0;
+            for (var suite of Object.values(suites)) {
+                var skippedFromSuite = Object.keys(suite.skipped).length;
+                skipped += skippedFromSuite
+                total += Object.keys(suite.tests).length
+                    + skippedFromSuite;
+                for (var i in suite.tests) {
+                    console.log(i)
+                    try {
+                        await suite.tests[i]()
+                        passed++
+                    } catch(e) {
+                        failed++
+                        console.error(e)
+                    }
+                }
+            }
+            console.log(`
+                failed: ${failed}
+                passed: ${passed},
+                skipped: ${skipped},
+                from: ${total}
+            `)
+        });
+    }
+    if (/#test.html/.test(location.hash)) runTests()
+</script>
 </body>
 </html>
\ No newline at end of file
diff --git a/src/index.ts b/src/index.ts
index e762be7..ce39eb0 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -2,7 +2,7 @@ import { BlockCursorPlugin, hideNativeSelection } from "./block-cursor"
 import { StateField, StateEffect, ChangeDesc, EditorSelection, Extension, MapMode } from "@codemirror/state"
 import { showPanel, EditorView, ViewPlugin, PluginValue, ViewUpdate, keymap } from "@codemirror/view"
 import * as commands from "@codemirror/commands"
-import { startCompletion } from "@codemirror/autocomplete"
+import { startCompletion, completionStatus } from "@codemirror/autocomplete"
 import { openSearchPanel } from "@codemirror/search"
 
 const emacsStyle = EditorView.theme({
@@ -22,7 +22,7 @@ const emacsStyle = EditorView.theme({
 }) 
 
 const emacsPlugin = ViewPlugin.fromClass(class implements PluginValue {
-   public view: EditorView;
+  public view: EditorView;
   public status = ""
   public em: EmacsHandler
   blockCursor: BlockCursorPlugin
@@ -65,19 +65,14 @@ const emacsPlugin = ViewPlugin.fromClass(class implements PluginValue {
   }
 }, {
   eventHandlers: {
+    keydown: function (e: KeyboardEvent, view: EditorView) {
+      var result = this.em.handleKeyboard(e)
+      return !!result;
+    },
     mousedown: function() {
       this.em.$emacsMark = null
     }
   },
-  provide: plugin => {
-    return keymap.of([
-      {
-        any: function(view, e) {
-          return !!view.plugin(plugin)?.em.handleKeyboard(e)
-        }
-      }
-    ])
-  }
 })
 
 
@@ -176,6 +171,7 @@ class EmacsHandler {
   }
   static execCommand(command: any, handler: EmacsHandler, args: any, count: number = 1) {
     var commandResult = undefined;
+    if (count < 0) count = -count;
     if (typeof command === "function") {
       for (var i = 0; i < count; i++) command(handler.view);
     } else if (command === "null") {
@@ -197,6 +193,10 @@ class EmacsHandler {
   handleKeyboard(e: KeyboardEvent) {
     var keyData = EmacsHandler.getKey(e)
     var result = this.findCommand(keyData)
+
+    if (/Up|Down/.test(keyData?.[0]) && completionStatus(this.view.state))
+      return;
+
     if (result && result.command) {
       var commandResult = EmacsHandler.execCommand(result.command, this, result.args, result.count)
       if (commandResult === false)
@@ -335,9 +335,9 @@ class EmacsHandler {
   pushEmacsMark(p?: EmacsMark, activate?: boolean) {
     var prevMark = this.$emacsMark;
     if (prevMark)
-      this.$emacsMarkRing.push(prevMark);
+      pushUnique(this.$emacsMarkRing, prevMark);
     if (!p || activate) this.setEmacsMark(p);
-    else this.$emacsMarkRing.push(p);
+    else pushUnique(this.$emacsMarkRing, p);
   };
 
   popEmacsMark() {
@@ -391,6 +391,16 @@ class EmacsHandler {
     })
     view.dispatch(specs)
   }
+  selectionToEmacsMark() {
+    var selection = this.view.state.selection;
+    return selection.ranges.map(x => x.head)
+  }
+}
+
+function pushUnique<T>(array: T[], item:T) {
+  if (array.length && array[array.length - 1] + "" == item + "")
+    return;
+  array.push(item);
 }
 
 export const emacsKeys: Record<string, any> = {
@@ -618,6 +628,7 @@ EmacsHandler.addCommands({
       // in multi select mode, ea selection is handled individually
 
       if (args && args.count) {
+        var newMark = handler.selectionToEmacsMark();
         var mark = handler.popEmacsMark();
         if (mark) {
           var newRanges = mark.map((p: number)=> {
@@ -626,12 +637,13 @@ EmacsHandler.addCommands({
           view.dispatch({
             selection: EditorSelection.create(newRanges)
           })
+          handler.$emacsMarkRing.unshift(newMark);
         }
         return;
       }
 
       var mark = handler.emacsMark();
-      var rangePositions = ranges.map(function (r) { return r.from; });
+      var rangePositions = ranges.map(function (r) { return r.head; });
       var transientMarkModeActive = true;
       var hasNoSelection = ranges.every(function (range) { return range.from == range.to; });
       // if transientMarkModeActive then mark behavior is a little
@@ -655,7 +667,7 @@ EmacsHandler.addCommands({
     handlesCount: true
   },
   exchangePointAndMark: {
-    exec: function exchangePointAndMark$exec(handler: EmacsHandler, args: any) {
+    exec: function(handler: EmacsHandler, args: any) {
       var view = handler.view;
       var selection = view.state.selection;
       var isEmpty = !selection.ranges.some(r => r.from != r.to)
@@ -674,6 +686,8 @@ EmacsHandler.addCommands({
       if (!lastMark) return;
 
       if (args.count) { // replace mark and point
+        markRing[markRing.length - 1] = handler.selectionToEmacsMark()
+
         handler.clearSelection();
         
         var newRanges = lastMark.map(x => {
@@ -682,7 +696,6 @@ EmacsHandler.addCommands({
         view.dispatch({
           selection: EditorSelection.create(newRanges, selection.mainIndex)
         })
-
       } else { // create selection to last mark
         var n = Math.min(lastMark.length, selection.ranges.length)
         newRanges = []
@@ -723,22 +736,21 @@ EmacsHandler.addCommands({
       handler.pushEmacsMark(null);
       // don't delete the selection if it's before the cursor
       handler.clearSelection();
-      commands.selectLineEnd(handler.view);
-
       var view = handler.view;
       var state = view.state
 
-
       var text: string[] = [];
-      var changes = handler.view.state.selection.ranges.map(function(range) {
-        var from = range.from;
-        var to = range.to;
+      var changes = state.selection.ranges.map(function(range) {
+        var from = range.head;
+        var lineObject = state.doc.lineAt(from)
+
+        var to = lineObject.to;
         var line = state.sliceDoc(from, to)
 
         // remove EOL if only whitespace remains after the cursor
-        if (/^\s*$/.test(line)) {
+        if (/^\s*$/.test(line) && to < state.doc.length - 1) {
           to += 1;
-          text.push("\n")
+          text.push(line + "\n")
         } else {
           text.push(line)
         }
diff --git a/test/webtest-emacs.js b/test/webtest-emacs.js
index 7663ff7..7fb57dd 100644
--- a/test/webtest-emacs.js
+++ b/test/webtest-emacs.js
@@ -1,10 +1,11 @@
 import {EditorView, basicSetup} from "codemirror"
 import {xml} from "@codemirror/lang-xml"
 import {javascript} from "@codemirror/lang-javascript"
-import ist from "ist";
 import { indentUnit } from "@codemirror/language";
 import { keymap } from "@codemirror/view";
-
+import { emacs } from ".."
+import { EditorState, EditorSelection } from "@codemirror/state";
+import {indentWithTab} from "@codemirror/commands";
 
 describe("Emacs keybinding", () => {
     /**@type {HTMLDivElement}*/
@@ -17,12 +18,418 @@ describe("Emacs keybinding", () => {
             root.style.position = "fixed"
             root.style.top = "100px"
             root.style.left = "200px"
-            root.style.width = "500px"
+            root.style.width = "500px" 
         }
         document.body.appendChild(root)
     }
     addRoot()
-    it("does nothing", function() {
+    
+    function test(name, fn) {
+        it(name, function() {
+            fn();
+        })
+    }
+    function eqCursorPos(a, b) {
+        if (a.line != b.line || a.ch != b.ch)
+            throw failure(
+                "Expected cursor position " + JSON.stringify([a.line, a.ch]) +
+                " to be equal to " + JSON.stringify([b.line, b.ch]),
+                eqCursorPos
+            );
+    }
+    function eq(a, b, _reason) {
+        if (a != b)
+            throw failure("Expected " + a + " to be equal to " + b, eq);
+    }
+    function is(a) {
+        if (!a) throw failure("Expected " + a + " to be truthy", is);
+    }
+    function failure(message, root) {
+        var error = new Error(message);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(error, root);
+        return error;
+    }
+    
 
+    var editor;
+    function initEditor(value, options = {}) {
+        addRoot();
+        if (editor) editor.destroy();
+
+        var view = new EditorView({
+            doc: value,
+            extensions: [
+                emacs(),
+                basicSetup,
+                options.mode == "xml" ? xml() : javascript(),
+                EditorState.tabSize.of(options.tabSize || 4),
+                indentUnit.of(
+                    options.indentWithTabs ? "\t" : " ".repeat(options.indentUnit || 2)
+                ),
+                options.lineWrapping && EditorView.lineWrapping,
+                keymap.of([indentWithTab]),
+            ].filter(Boolean),
+            parent: root,
+        });
+        editor = view;
+        window.view = view;
+
+        view.contentDOM._handleInputEventForTest = function(text) {           
+            view.dispatch(view.state.replaceSelection(text))
+        };
+
+        view.dom.style.backgroundColor = "white";        
+        view.dom.style.width = "420px"
+        view.dom.style.height = "300px"
+        // without calling refresh cursor movement commands of codemirror 6 do not work
+        view.measure()
+        view.contentDOM.focus()
+
+        var plugins = view.plugins.filter(x=>x.value.em)
+        if (plugins.length != 1) throw new Error("Couldn't find emacs")
+        view.em = plugins[0].value.em;
+    }
+    function getSelectedText() {        
+        var state = editor.state
+        return state.selection.ranges.map(r => state.sliceDoc(r.from, r.to)).join("\n")
+    }
+    function getValue() {
+        return editor.state.doc.toString()
+    }
+    function getSelections() {        
+        var state = editor.state
+        return state.selection.ranges.map(r => r.anchor+ ">" +r.head).join(",")
+    }
+    function setSelections(ranges, primIndex = 0) {
+        ranges = ranges.map(range => {
+            if (typeof range == "number")
+                return EditorSelection.cursor(range, 1)
+            return EditorSelection.range(range[0], range[1])
+        })
+        editor.dispatch({
+            selection: EditorSelection.create(ranges, primIndex)
+        })
+    }
+    
+    test("keyboardQuit clears selection", function() {
+        initEditor('foo');
+        typeKey('Ctrl-x', 'Ctrl-p');
+        eq(getSelectedText(), "foo")
+        typeKey('Ctrl-g');
+        eq(getSelectedText(), "")
+    })
+    test("exchangePointAndMark without mark set", function() {
+        initEditor('foo');
+        setSelections([[1, 3]]);
+        eq(getSelections(), "1>3");
+        typeKey('Ctrl-x', 'Ctrl-x');
+        eq(getSelections(), "3>1");
+    });
+
+    test("exchangePointAndMark with mark set", function() {
+        initEditor('foo bar');
+        setSelections([[1, 1]]);
+        typeKey('Ctrl-Space', 'Ctrl-Space');
+        setSelections([[2, 2]]);
+        typeKey('Ctrl-Space', 'Ctrl-Space');
+        setSelections([[3, 3]]);
+        typeKey('Ctrl-4', 'Ctrl-x', 'Ctrl-x');
+        eq('2>2', getSelections());
+        typeKey('Ctrl-4', 'Ctrl-x', 'Ctrl-x');
+        eq('3>3', getSelections());
+
+        typeKey('Ctrl-u', 'Ctrl-Space');
+        eq('2>2', getSelections());
+        typeKey('Ctrl-u', 'Ctrl-Space');
+        eq('1>1', getSelections());
+        typeKey('Ctrl-u', 'Ctrl-Space');
+        eq('3>3', getSelections());
+        typeKey('Ctrl-u', 'Ctrl-Space');
+        eq('2>2', getSelections());
     });
+
+    test("exchangePointAndMark with selection", function() {
+        initEditor('foo');
+        setSelections([[1, 1]]);
+        typeKey('Ctrl-Space', 'Ctrl-Space');
+        setSelections([[2, 2]]);
+        typeKey('Ctrl-Space', 'Ctrl-Space');
+        
+        setSelections([[1, 0]]);
+        typeKey('Ctrl-x', 'Ctrl-x');
+        eq('0>1', getSelections());
+        typeKey('Ctrl-x', 'Ctrl-x');
+        eq('1>0', getSelections());
+    });
+
+    test("exchangePointAndMark with multi selection", function() {
+        initEditor('foo\nhello world\n123');
+        setSelections([[0, 3], [4, 9], [18, 19]]);
+        eq("0>3,4>9,18>19", getSelections());
+        typeKey('Ctrl-x', 'Ctrl-x');
+        eq("3>0,9>4,19>18", getSelections());
+    });
+
+    test("setMark with multi cursors", function() {
+        initEditor('foo\nhello world\n123');
+        setSelections([0, 4, 9]);
+        typeKey('Ctrl-Space');
+        typeKey('Right');
+        eq("0>1,4>5,9>10", getSelections());
+        typeKey('Ctrl-Space');
+        eq("1>1,5>5,10>10", getSelections());
+        typeKey('Left');
+        eq("0>0,4>4,9>9", getSelections());
+    });
+
+    test("killLine", function() {
+        initEditor("foo  \n Hello world\n  \n  123");
+        setSelections([[0, 2]]);
+        typeKey('Ctrl-k');
+        eq(getValue(),"fo\n Hello world\n  \n  123");
+        typeKey('Ctrl-k');
+        eq(getValue(),"fo Hello world\n  \n  123");
+        typeKey('Ctrl-k');
+        eq(getValue(),"fo\n  \n  123");
+        typeKey('Ctrl-k');
+        eq(getValue(),"fo  \n  123");
+        typeKey('Ctrl-k');
+        eq(getValue(),"fo  123");
+        typeKey('Ctrl-k');
+        eq(getValue(),"fo");
+        typeKey('Ctrl-k');
+        typeKey('Ctrl-y');
+        eq(getValue(),"foo  \n Hello world\n  \n  123");
+    });
+
 });
+
+
+
+var typeKey = function() {
+    var keyCodeToKey = {};
+    var keyCodeToCode = {};
+  
+    var alias = {};
+    alias.Ctrl = "Control";
+    alias.Option = "Alt";
+    alias.Cmd = alias.Super = alias.Meta = "Command";
+  
+    var controlKeys = {
+      Shift: 16, Control: 17, Alt: 18, Meta: 224, Command: 224,
+      Backspace:8, Tab:9, Return: 13, Enter: 13,
+      Pause: 19, Escape: 27, PageUp: 33, PageDown: 34, End: 35, Home: 36,
+      Left: 37, Up: 38, Right: 39, Down: 40, Insert: 45, Delete: 46,
+      ArrowLeft: 37, ArrowUp: 38, ArrowRight: 39, ArrowDown: 40,
+    };
+    var shiftedKeys = {};
+    var printableKeys = {};
+    var specialKeys = {
+      Backquote: [192, "`", "~"], Minus: [189, "-", "_"], Equal: [187, "=", "+"],
+      BracketLeft: [219, "[", "{"], Backslash: [220, "\\", "|"], BracketRight: [221, "]", "}"],
+      Semicolon: [186, ";", ":"], Quote: [222, "'", '"'], Comma: [188, ",", "<"],
+      Period: [190, ".", ">"], Slash: [191, "/", "?"], Space: [32, " ", " "], NumpadAdd: [107, "+"],
+      NumpadDecimal: [110, "."], NumpadSubtract: [109, "-"], NumpadDivide: [111, "/"], NumpadMultiply: [106, "*"]
+    };
+    for (var i in specialKeys) {
+      var key = specialKeys[i];
+      printableKeys[i] = printableKeys[key[1]] = shiftedKeys[key[2]] = key[0];
+      keyCodeToCode[key[0]] = i;
+      keyCodeToKey[key[0]] = key[1];
+      keyCodeToKey["s-" + key[0]] = key[2];
+    }
+    for (var i = 0; i < 10; i++) {
+      var shifted = "!@#$%^&*()"[i];
+      printableKeys[i] = shiftedKeys[shifted] = 48 + i;
+      keyCodeToCode[48 + i] = "Digit" + i;
+      keyCodeToKey[48 + i] = i.toString();
+      keyCodeToKey["s-" + (48 + i)] = shifted;
+    }
+    for (var i = 65; i < 91; i++) {
+      var chr = String.fromCharCode(i + 32);
+      printableKeys[chr] = shiftedKeys[chr.toUpperCase()] = i;
+      keyCodeToCode[i] = "Key" + chr.toUpperCase();
+      keyCodeToKey[i] = chr;
+      keyCodeToKey["s-" + i] = chr.toUpperCase();
+    }
+    for (var i = 1; i < 13; i++) {
+      controlKeys["F" + i] = 111 + i;
+    }
+  
+    for (var i in controlKeys) {
+      keyCodeToKey[controlKeys[i]] = i;
+      keyCodeToCode[controlKeys[i]] = i;
+    }
+    controlKeys["\t"] = controlKeys.Tab;
+    controlKeys["\n"] = controlKeys.Return;
+    controlKeys.Del = controlKeys.Delete;
+    controlKeys.Esc = controlKeys.Escape;
+    controlKeys.Ins = controlKeys.Insert;
+  
+    var shift = false;
+    var ctrl = false;
+    var meta = false;
+    var alt = false;
+    function reset() {
+      shift = ctrl = meta = alt = false;
+    }
+    function updateModifierStates(keyCode) {
+      if (keyCode == controlKeys.Shift)
+        return shift = true;
+      if (keyCode == controlKeys.Control)
+        return ctrl = true;
+      if (keyCode == controlKeys.Meta)
+        return meta = true;
+      if (keyCode == controlKeys.Alt)
+        return alt = true;
+    }
+  
+    function sendKey(letter, options) {
+      var keyCode = controlKeys[letter] || printableKeys[letter] || shiftedKeys[letter];
+      var isModifier = updateModifierStates(keyCode);
+  
+      var text = letter;
+      var isTextInput = true;
+      if (ctrl || alt || meta) {
+        isTextInput = false;
+      } else if (controlKeys[letter]) {
+          if (keyCode == controlKeys.Return) {
+              text = "\n";
+              isTextInput = true;
+          } else {
+              isTextInput = false;
+          }
+      } else if (shift) {
+        text = text.toUpperCase();
+      }
+  
+      if (keyCodeToKey[keyCode] != text && keyCodeToKey["s-" + keyCode] == text) {
+        shift = true;
+      }
+      var key = keyCodeToKey[(shift ? "s-" : "") + keyCode];
+      
+      if (options && options.macAltText) {
+        alt = true;
+        text = key = options.macAltText;
+        isTextInput = true;
+      }
+  
+      var target = document.activeElement;
+      var prevented = emit("keydown", true);
+      if (isModifier) return;
+      if (!prevented && isTextInput) prevented = emit("keypress", true);
+      if (!prevented && ctrl && !alt && !meta && letter == "c") emitClipboard("copy");
+      if (!prevented) updateTextInput();
+      emit("keyup", true);
+  
+      function emitClipboard(eventType) {
+        var data = {bubbles: true, cancelable:true};
+        var event = new KeyboardEvent(eventType, data);
+        event.clipboardData = {
+          setData: function(mime, text) {
+            type.clipboard.$data = text;
+          },
+          getData: function() {
+            return type.clipboard.$data;
+          },
+          clearData: function() {},
+        };
+        target.dispatchEvent(event);
+      }
+      function emit(type, bubbles) {
+        var el = document.activeElement;
+        var data = {bubbles: bubbles, cancelable:true};
+        data.charCode = text.charCodeAt(0);
+        data.keyCode = type == "keypress" ? data.charCode : keyCode;
+        data.which = data.keyCode;
+        data.shiftKey = shift || (shiftedKeys[text] && !printableKeys[text]);
+        data.ctrlKey = ctrl;
+        data.altKey = alt;
+        data.metaKey = meta;
+        data.key = key;
+        data.code = keyCodeToCode[keyCode];
+        var event = new KeyboardEvent(type, data);
+  
+        var el = document.activeElement;
+        el.dispatchEvent(event);
+        return event.defaultPrevented;
+      }
+      function updateTextInput() {
+        if (!isTextInput && keyCode == controlKeys.Return) {
+          text = "\n";
+        }
+        if (target._handleInputEventForTest) {
+          if (!isTextInput) return;
+          return target._handleInputEventForTest(text);
+        }
+        var isTextarea = "selectionStart" in target && typeof target.value == "string";
+        if (!isTextarea) return;
+  
+        var start = target.selectionStart;
+        var end = target.selectionEnd;
+        var value = target.value;
+  
+        if (!isTextInput) {
+          if (keyCode == controlKeys.Backspace) {
+            if (start != end) start = Math.max(start - 1, 0);
+          } else if (keyCode == controlKeys.Delete) {
+            if (start != end) end = Math.min(end + 1, value.length);
+          } else {
+            return;
+          }
+        }
+        var newValue = value.slice(0, start) + text + value.slice(end);
+        var newStart = start + text.length;
+        var newEnd = newStart;
+        if (newValue != value || newStart != start || newEnd != end) {
+          target.value = newValue;
+          target.setSelectionRange(newStart, newEnd);
+          emit("input", false);
+        }
+      }
+    }
+  
+    function type() {
+      var keys = Array.prototype.slice.call(arguments);
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (Array.isArray(key)) {
+          type.apply(null, key);
+          continue;
+        }
+        reset();
+        if (key.length > 1) {
+          var isKeyName = controlKeys[key] || printableKeys[key] || shiftedKeys[key];
+          if (!isKeyName) {
+            var parts = key.split("-");
+            var modifiers = parts.slice(0, parts.length - 1).map(function(part) {
+              return controlKeys[alias[part] || part];
+            });
+            var isValid = modifiers.length && modifiers.every(updateModifierStates);
+            if (!isValid) {
+              type.apply(null, key.split(""));
+              continue;
+            }
+            key = parts.pop();
+            parts.forEach(function(part) {
+              var keyCode = controlKeys[part];
+              updateModifierStates(keyCode);
+            });
+          }
+        }
+        sendKey(key);
+      }
+    }
+  
+    // emulates option-9 inputting } on mac swiss keyboard
+    type.optionTextInput = function(letter, altText) {
+      reset();
+      sendKey(letter, {macAltText: altText});
+    };
+  
+    type.clipboard = {};
+  
+    return type;
+  }();
+  
\ No newline at end of file