From 4d36a203c09d2e04bf4304ba4a5b63f66b3e2adf Mon Sep 17 00:00:00 2001
From: Shin'ya Ueoka <ueokande@i-beam.org>
Date: Sat, 21 Sep 2019 15:32:30 +0900
Subject: Use latest lanthan

---
 e2e/clipboard.test.js | 48 ++++++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

(limited to 'e2e/clipboard.test.js')

diff --git a/e2e/clipboard.test.js b/e2e/clipboard.test.js
index 82e45fc..df31770 100644
--- a/e2e/clipboard.test.js
+++ b/e2e/clipboard.test.js
@@ -1,12 +1,11 @@
 const express = require('express');
-const lanthan = require('lanthan');
 const path = require('path');
 const assert = require('assert');
 const eventually = require('./eventually');
 const clipboard = require('./lib/clipboard');
 const settings = require('./settings');
-
-const Key = lanthan.Key;
+const { Builder } = require('lanthan');
+const { By, Key } = require('selenium-webdriver');
 
 const newApp = () => {
   let app = express();
@@ -20,18 +19,19 @@ describe("navigate test", () => {
 
   const port = 12321;
   let http;
-  let firefox;
-  let session;
+  let lanthan;
+  let webdriver;
   let browser;
 
   before(async() => {
     http = newApp().listen(port);
 
-    firefox = await lanthan.firefox({
-      spy: path.join(__dirname, '..'),
-    });
-    session = firefox.session;
-    browser = firefox.browser;
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
 
     await browser.storage.local.set({
       settings,
@@ -39,8 +39,8 @@ describe("navigate test", () => {
   });
 
   after(async() => {
-    if (firefox) {
-      await firefox.close();
+    if (lanthan) {
+      await lanthan.quit();
     }
     http.close();
   });
@@ -53,8 +53,8 @@ describe("navigate test", () => {
   })
 
   it('should copy current URL by y', async () => {
-    await session.navigateTo(`http://127.0.0.1:${port}/#should_copy_url`);
-    let body = await session.findElementByCSS('body');
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/#should_copy_url`);
+    let body = await webdriver.findElement(By.css('body'));
 
     await body.sendKeys('y');
     await eventually(async() => {
@@ -64,8 +64,8 @@ describe("navigate test", () => {
   });
 
   it('should open an URL from clipboard by p', async () => {
-    await session.navigateTo(`http://127.0.0.1:${port}/`);
-    let body = await session.findElementByCSS('body');
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
 
     await clipboard.write(`http://127.0.0.1:${port}/#open_from_clipboard`);
     await body.sendKeys('p');
@@ -77,11 +77,11 @@ describe("navigate test", () => {
   });
 
   it('should open an URL from clipboard to new tab by P', async () => {
-    await session.navigateTo(`http://127.0.0.1:${port}/`);
-    let body = await session.findElementByCSS('body');
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
 
     await clipboard.write(`http://127.0.0.1:${port}/#open_to_new_tab`);
-    await body.sendKeys(Key.Shift, 'p');
+    await body.sendKeys(Key.SHIFT, 'p');
 
     await eventually(async() => {
       let tabs = await browser.tabs.query({});
@@ -93,8 +93,8 @@ describe("navigate test", () => {
   });
 
   it('should open search result with keywords in clipboard by p', async () => {
-    await session.navigateTo(`http://127.0.0.1:${port}/`);
-    let body = await session.findElementByCSS('body');
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
 
     await clipboard.write(`an apple`);
     await body.sendKeys('p');
@@ -106,11 +106,11 @@ describe("navigate test", () => {
   });
 
   it('should open search result with keywords in clipboard to new tabby P', async () => {
-    await session.navigateTo(`http://127.0.0.1:${port}/`);
-    let body = await session.findElementByCSS('body');
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
 
     await clipboard.write(`an apple`);
-    await body.sendKeys(Key.Shift, 'p');
+    await body.sendKeys(Key.SHIFT, 'p');
 
     await eventually(async() => {
       let tabs = await browser.tabs.query({});
-- 
cgit v1.2.3


From 7e77e31ad64c3649888eae337e0c984fd9c2ea2a Mon Sep 17 00:00:00 2001
From: Shin'ya Ueoka <ueokande@i-beam.org>
Date: Sun, 22 Sep 2019 16:13:12 +0900
Subject: Migrate e2e tests to TypeScript

---
 e2e/blacklist.test.js           |  76 -----------
 e2e/blacklist.test.ts           |  74 +++++++++++
 e2e/clipboard.test.js           | 123 ------------------
 e2e/clipboard.test.ts           | 125 ++++++++++++++++++
 e2e/command_addbookmark.test.js |  64 ----------
 e2e/command_addbookmark.test.ts |  66 ++++++++++
 e2e/command_bdelete.test.js     | 199 -----------------------------
 e2e/command_bdelete.test.ts     | 201 +++++++++++++++++++++++++++++
 e2e/command_buffer.test.js      | 198 ----------------------------
 e2e/command_buffer.test.ts      | 200 +++++++++++++++++++++++++++++
 e2e/command_open.test.js        | 146 ---------------------
 e2e/command_open.test.ts        | 148 +++++++++++++++++++++
 e2e/command_quit.test.js        | 121 ------------------
 e2e/command_quit.test.ts        | 124 ++++++++++++++++++
 e2e/command_tabopen.test.js     | 157 -----------------------
 e2e/command_tabopen.test.ts     | 160 +++++++++++++++++++++++
 e2e/command_winopen.test.js     | 168 ------------------------
 e2e/command_winopen.test.ts     | 170 +++++++++++++++++++++++++
 e2e/completion.test.js          | 133 -------------------
 e2e/completion.test.ts          | 135 ++++++++++++++++++++
 e2e/completion_buffers.test.js  | 211 ------------------------------
 e2e/completion_buffers.test.ts  | 213 +++++++++++++++++++++++++++++++
 e2e/completion_open.test.js     | 256 -------------------------------------
 e2e/completion_open.test.ts     | 257 +++++++++++++++++++++++++++++++++++++
 e2e/completion_set.test.js      |  73 -----------
 e2e/completion_set.test.ts      |  71 +++++++++++
 e2e/console.test.js             | 128 -------------------
 e2e/console.test.ts             | 126 ++++++++++++++++++
 e2e/eventually.js               |  23 ----
 e2e/eventually.ts               |  30 +++++
 e2e/follow.test.js              | 263 --------------------------------------
 e2e/follow.test.ts              | 265 ++++++++++++++++++++++++++++++++++++++
 e2e/follow_properties.test.js   | 180 --------------------------
 e2e/follow_properties.test.ts   | 174 +++++++++++++++++++++++++
 e2e/lib/Console.js              |  43 -------
 e2e/lib/Console.ts              |  49 +++++++
 e2e/lib/clipboard.js            |  63 ---------
 e2e/lib/clipboard.ts            |  66 ++++++++++
 e2e/mark.test.js                | 124 ------------------
 e2e/mark.test.ts                | 126 ++++++++++++++++++
 e2e/navigate.test.js            | 274 ---------------------------------------
 e2e/navigate.test.ts            | 276 ++++++++++++++++++++++++++++++++++++++++
 e2e/options.test.js             |  97 --------------
 e2e/options.test.ts             |  98 ++++++++++++++
 e2e/options_form.test.js        | 122 ------------------
 e2e/options_form.test.ts        | 124 ++++++++++++++++++
 e2e/repeat.test.js              |  95 --------------
 e2e/repeat.test.ts              |  94 ++++++++++++++
 e2e/scroll.test.js              | 153 ----------------------
 e2e/scroll.test.ts              | 154 ++++++++++++++++++++++
 e2e/settings.js                 |  86 -------------
 e2e/settings.ts                 |  86 +++++++++++++
 e2e/tab.test.js                 | 222 --------------------------------
 e2e/tab.test.ts                 | 222 ++++++++++++++++++++++++++++++++
 e2e/zoom.test.js                |  64 ----------
 e2e/zoom.test.ts                |  65 ++++++++++
 56 files changed, 3899 insertions(+), 3862 deletions(-)
 delete mode 100644 e2e/blacklist.test.js
 create mode 100644 e2e/blacklist.test.ts
 delete mode 100644 e2e/clipboard.test.js
 create mode 100644 e2e/clipboard.test.ts
 delete mode 100644 e2e/command_addbookmark.test.js
 create mode 100644 e2e/command_addbookmark.test.ts
 delete mode 100644 e2e/command_bdelete.test.js
 create mode 100644 e2e/command_bdelete.test.ts
 delete mode 100644 e2e/command_buffer.test.js
 create mode 100644 e2e/command_buffer.test.ts
 delete mode 100644 e2e/command_open.test.js
 create mode 100644 e2e/command_open.test.ts
 delete mode 100644 e2e/command_quit.test.js
 create mode 100644 e2e/command_quit.test.ts
 delete mode 100644 e2e/command_tabopen.test.js
 create mode 100644 e2e/command_tabopen.test.ts
 delete mode 100644 e2e/command_winopen.test.js
 create mode 100644 e2e/command_winopen.test.ts
 delete mode 100644 e2e/completion.test.js
 create mode 100644 e2e/completion.test.ts
 delete mode 100644 e2e/completion_buffers.test.js
 create mode 100644 e2e/completion_buffers.test.ts
 delete mode 100644 e2e/completion_open.test.js
 create mode 100644 e2e/completion_open.test.ts
 delete mode 100644 e2e/completion_set.test.js
 create mode 100644 e2e/completion_set.test.ts
 delete mode 100644 e2e/console.test.js
 create mode 100644 e2e/console.test.ts
 delete mode 100644 e2e/eventually.js
 create mode 100644 e2e/eventually.ts
 delete mode 100644 e2e/follow.test.js
 create mode 100644 e2e/follow.test.ts
 delete mode 100644 e2e/follow_properties.test.js
 create mode 100644 e2e/follow_properties.test.ts
 delete mode 100644 e2e/lib/Console.js
 create mode 100644 e2e/lib/Console.ts
 delete mode 100644 e2e/lib/clipboard.js
 create mode 100644 e2e/lib/clipboard.ts
 delete mode 100644 e2e/mark.test.js
 create mode 100644 e2e/mark.test.ts
 delete mode 100644 e2e/navigate.test.js
 create mode 100644 e2e/navigate.test.ts
 delete mode 100644 e2e/options.test.js
 create mode 100644 e2e/options.test.ts
 delete mode 100644 e2e/options_form.test.js
 create mode 100644 e2e/options_form.test.ts
 delete mode 100644 e2e/repeat.test.js
 create mode 100644 e2e/repeat.test.ts
 delete mode 100644 e2e/scroll.test.js
 create mode 100644 e2e/scroll.test.ts
 delete mode 100644 e2e/settings.js
 create mode 100644 e2e/settings.ts
 delete mode 100644 e2e/tab.test.js
 create mode 100644 e2e/tab.test.ts
 delete mode 100644 e2e/zoom.test.js
 create mode 100644 e2e/zoom.test.ts

(limited to 'e2e/clipboard.test.js')

diff --git a/e2e/blacklist.test.js b/e2e/blacklist.test.js
deleted file mode 100644
index 8a8996e..0000000
--- a/e2e/blacklist.test.js
+++ /dev/null
@@ -1,76 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/*', (req, res) => {
-    res.status(200).send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body style="width:10000px; height:10000px"></body>
-</html>`);
-  });
-  return app;
-};
-
-describe("navigate test", () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    http.close();
-  });
-
-  it('should disable add-on if the URL is in the blacklist', async () => {
-    await browser.storage.local.set({
-      settings: {
-        source: 'json',
-        json: `{
-        "keymaps": {
-          "j": { "type": "scroll.vertically", "count": 1 }
-        },
-        "blacklist": [ "127.0.0.1:${port}/a" ]
-      }`,
-      },
-    });
-
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/a`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('j');
-
-    // not works
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert.equal(pageYOffset, 0);
-
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/ab`);
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('j');
-
-    // works
-    pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert.equal(pageYOffset, 64);
-  });
-});
-
diff --git a/e2e/blacklist.test.ts b/e2e/blacklist.test.ts
new file mode 100644
index 0000000..c88f655
--- /dev/null
+++ b/e2e/blacklist.test.ts
@@ -0,0 +1,74 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By } from 'selenium-webdriver';
+import * as http from 'http';
+
+const newApp = () => {
+  let app = express();
+  app.get('/*', (_req, res) => {
+    res.status(200).send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body style="width:10000px; height:10000px"></body>
+</html>`);
+  });
+  return app;
+};
+
+describe("navigate test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    http.close();
+  });
+
+  it('should disable add-on if the URL is in the blacklist', async () => {
+    await browser.storage.local.set({
+      settings: {
+        source: 'json',
+        json: `{
+        "keymaps": {
+          "j": { "type": "scroll.vertically", "count": 1 }
+        },
+        "blacklist": [ "127.0.0.1:${port}/a" ]
+      }`,
+      },
+    });
+
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/a`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('j');
+
+    // not works
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+    assert.equal(pageYOffset, 0);
+
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/ab`);
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('j');
+
+    // works
+    pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+    assert.equal(pageYOffset, 64);
+  });
+});
diff --git a/e2e/clipboard.test.js b/e2e/clipboard.test.js
deleted file mode 100644
index df31770..0000000
--- a/e2e/clipboard.test.js
+++ /dev/null
@@ -1,123 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const clipboard = require('./lib/clipboard');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.status(200).send(`<html lang="en"></html">`);
-  });
-  return app;
-};
-
-describe("navigate test", () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    http.close();
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-  })
-
-  it('should copy current URL by y', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/#should_copy_url`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await body.sendKeys('y');
-    await eventually(async() => {
-      let data = await clipboard.read();
-      assert.equal(data, `http://127.0.0.1:${port}/#should_copy_url`);
-    });
-  });
-
-  it('should open an URL from clipboard by p', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await clipboard.write(`http://127.0.0.1:${port}/#open_from_clipboard`);
-    await body.sendKeys('p');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].url, `http://127.0.0.1:${port}/#open_from_clipboard`);
-    });
-  });
-
-  it('should open an URL from clipboard to new tab by P', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await clipboard.write(`http://127.0.0.1:${port}/#open_to_new_tab`);
-    await body.sendKeys(Key.SHIFT, 'p');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.deepEqual(tabs.map(t => t.url), [
-        `http://127.0.0.1:${port}/`,
-        `http://127.0.0.1:${port}/#open_to_new_tab`,
-      ]);
-    });
-  });
-
-  it('should open search result with keywords in clipboard by p', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await clipboard.write(`an apple`);
-    await body.sendKeys('p');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs[0].url, `http://127.0.0.1:${port}/google?q=an%20apple`);
-    });
-  });
-
-  it('should open search result with keywords in clipboard to new tabby P', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await clipboard.write(`an apple`);
-    await body.sendKeys(Key.SHIFT, 'p');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.deepEqual(tabs.map(t => t.url), [
-        `http://127.0.0.1:${port}/`,
-        `http://127.0.0.1:${port}/google?q=an%20apple`,
-      ]);
-    });
-  });
-});
diff --git a/e2e/clipboard.test.ts b/e2e/clipboard.test.ts
new file mode 100644
index 0000000..dbc00de
--- /dev/null
+++ b/e2e/clipboard.test.ts
@@ -0,0 +1,125 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import * as clipboard from './lib/clipboard';
+import settings from './settings';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.status(200).send(`<html lang="en"></html">`);
+  });
+  return app;
+};
+
+describe("navigate test", () => {
+
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    http.close();
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+  })
+
+  it('should copy current URL by y', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/#should_copy_url`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await body.sendKeys('y');
+    await eventually(async() => {
+      let data = await clipboard.read();
+      assert.equal(data, `http://127.0.0.1:${port}/#should_copy_url`);
+    });
+  });
+
+  it('should open an URL from clipboard by p', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await clipboard.write(`http://127.0.0.1:${port}/#open_from_clipboard`);
+    await body.sendKeys('p');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].url, `http://127.0.0.1:${port}/#open_from_clipboard`);
+    });
+  });
+
+  it('should open an URL from clipboard to new tab by P', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await clipboard.write(`http://127.0.0.1:${port}/#open_to_new_tab`);
+    await body.sendKeys(Key.SHIFT, 'p');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.deepEqual(tabs.map((t: any) => t.url), [
+        `http://127.0.0.1:${port}/`,
+        `http://127.0.0.1:${port}/#open_to_new_tab`,
+      ]);
+    });
+  });
+
+  it('should open search result with keywords in clipboard by p', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await clipboard.write(`an apple`);
+    await body.sendKeys('p');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs[0].url, `http://127.0.0.1:${port}/google?q=an%20apple`);
+    });
+  });
+
+  it('should open search result with keywords in clipboard to new tabby P', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await clipboard.write(`an apple`);
+    await body.sendKeys(Key.SHIFT, 'p');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.deepEqual(tabs.map((t: any) => t.url), [
+        `http://127.0.0.1:${port}/`,
+        `http://127.0.0.1:${port}/google?q=an%20apple`,
+      ]);
+    });
+  });
+});
diff --git a/e2e/command_addbookmark.test.js b/e2e/command_addbookmark.test.js
deleted file mode 100644
index 68d1c6d..0000000
--- a/e2e/command_addbookmark.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/happy', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <head>
-    <title>how to be happy</title>
-  </head>
-</html">`);
-  });
-  return app;
-};
-
-describe('addbookmark command test', () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/happy`);
-  });
-
-  it('should add a bookmark from the current page', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('addbookmark how to be happy', Key.ENTER);
-
-    await eventually(async() => {
-      var bookmarks = await browser.bookmarks.search({ title: 'how to be happy' });
-      assert.equal(bookmarks.length, 1);
-      assert.equal(bookmarks[0].url, `http://127.0.0.1:${port}/happy`);
-    });
-  });
-});
diff --git a/e2e/command_addbookmark.test.ts b/e2e/command_addbookmark.test.ts
new file mode 100644
index 0000000..ad94494
--- /dev/null
+++ b/e2e/command_addbookmark.test.ts
@@ -0,0 +1,66 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/happy', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <head>
+    <title>how to be happy</title>
+  </head>
+</html">`);
+  });
+  return app;
+};
+
+describe('addbookmark command test', () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/happy`);
+  });
+
+  it('should add a bookmark from the current page', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('addbookmark how to be happy', Key.ENTER);
+
+    await eventually(async() => {
+      var bookmarks = await browser.bookmarks.search({ title: 'how to be happy' });
+      assert.equal(bookmarks.length, 1);
+      assert.equal(bookmarks[0].url, `http://127.0.0.1:${port}/happy`);
+    });
+  });
+});
diff --git a/e2e/command_bdelete.test.js b/e2e/command_bdelete.test.js
deleted file mode 100644
index aae5b67..0000000
--- a/e2e/command_bdelete.test.js
+++ /dev/null
@@ -1,199 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/*', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <head>
-    <title>my_${req.path.slice(1)}</title>
-  </head>
-  <body><h1>${req.path}</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe('bdelete/bdeletes command test', () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1`, pinned: true });
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site2`, pinned: true })
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site3`, pinned: true })
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site4` })
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site5` })
-
-    await eventually(async() => {
-      let handles = await webdriver.getAllWindowHandles();
-      assert.equal(handles.length, 5);
-      await webdriver.switchTo().window(handles[2]);
-      await webdriver.findElement(By.css('iframe'));
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  });
-
-  it('should delete an unpinned tab by bdelete command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdelete site5', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.deepEqual(tabs.map(t => t.url), [
-        `http://127.0.0.1:${port}/site1`,
-        `http://127.0.0.1:${port}/site2`,
-        `http://127.0.0.1:${port}/site3`,
-        `http://127.0.0.1:${port}/site4`,
-      ])
-    });
-  });
-
-  it('should not delete an pinned tab by bdelete command by bdelete command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdelete site1', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 5);
-    });
-  });
-
-  it('should show an error when no tabs are matched by bdelete command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdelete xyz', Key.ENTER);
-
-    await eventually(async() => {
-      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
-      let text = await p.getText();
-      assert.equal(text, 'No matching buffer for xyz');
-    });
-  });
-
-  it('should show an error when more than one tabs are matched by bdelete command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdelete site', Key.ENTER);
-
-    await eventually(async() => {
-      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
-      let text = await p.getText();
-      assert.equal(text, 'More than one match for site');
-    });
-  });
-
-  it('should delete an unpinned tab by bdelete! command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdelete! site5', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.deepEqual(tabs.map(t => t.url), [
-        `http://127.0.0.1:${port}/site1`,
-        `http://127.0.0.1:${port}/site2`,
-        `http://127.0.0.1:${port}/site3`,
-        `http://127.0.0.1:${port}/site4`,
-      ])
-    });
-  });
-
-  it('should delete an pinned tab by bdelete! command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdelete! site1', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.deepEqual(tabs.map(t => t.url), [
-        `http://127.0.0.1:${port}/site2`,
-        `http://127.0.0.1:${port}/site3`,
-        `http://127.0.0.1:${port}/site4`,
-        `http://127.0.0.1:${port}/site5`,
-      ])
-    });
-  });
-
-  it('should delete unpinned tabs by bdeletes command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdeletes site', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.deepEqual(tabs.map(t => t.url), [
-        `http://127.0.0.1:${port}/site1`,
-        `http://127.0.0.1:${port}/site2`,
-        `http://127.0.0.1:${port}/site3`,
-      ])
-    });
-  });
-
-  it('should delete both pinned and unpinned tabs by bdeletes! command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('bdeletes! site', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 1);
-    });
-  });
-});
diff --git a/e2e/command_bdelete.test.ts b/e2e/command_bdelete.test.ts
new file mode 100644
index 0000000..ce54b23
--- /dev/null
+++ b/e2e/command_bdelete.test.ts
@@ -0,0 +1,201 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/*', (req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <head>
+    <title>my_${req.path.slice(1)}</title>
+  </head>
+  <body><h1>${req.path}</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe('bdelete/bdeletes command test', () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1`, pinned: true });
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site2`, pinned: true })
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site3`, pinned: true })
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site4` })
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site5` })
+
+    await eventually(async() => {
+      let handles = await webdriver.getAllWindowHandles();
+      assert.equal(handles.length, 5);
+      await webdriver.switchTo().window(handles[2]);
+      await webdriver.findElement(By.css('iframe'));
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  it('should delete an unpinned tab by bdelete command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdelete site5', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.deepEqual(tabs.map((t: any) => t.url), [
+        `http://127.0.0.1:${port}/site1`,
+        `http://127.0.0.1:${port}/site2`,
+        `http://127.0.0.1:${port}/site3`,
+        `http://127.0.0.1:${port}/site4`,
+      ])
+    });
+  });
+
+  it('should not delete an pinned tab by bdelete command by bdelete command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdelete site1', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 5);
+    });
+  });
+
+  it('should show an error when no tabs are matched by bdelete command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdelete xyz', Key.ENTER);
+
+    await eventually(async() => {
+      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
+      let text = await p.getText();
+      assert.equal(text, 'No matching buffer for xyz');
+    });
+  });
+
+  it('should show an error when more than one tabs are matched by bdelete command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdelete site', Key.ENTER);
+
+    await eventually(async() => {
+      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
+      let text = await p.getText();
+      assert.equal(text, 'More than one match for site');
+    });
+  });
+
+  it('should delete an unpinned tab by bdelete! command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdelete! site5', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.deepEqual(tabs.map((t: any) => t.url), [
+        `http://127.0.0.1:${port}/site1`,
+        `http://127.0.0.1:${port}/site2`,
+        `http://127.0.0.1:${port}/site3`,
+        `http://127.0.0.1:${port}/site4`,
+      ])
+    });
+  });
+
+  it('should delete an pinned tab by bdelete! command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdelete! site1', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.deepEqual(tabs.map((t: any) => t.url), [
+        `http://127.0.0.1:${port}/site2`,
+        `http://127.0.0.1:${port}/site3`,
+        `http://127.0.0.1:${port}/site4`,
+        `http://127.0.0.1:${port}/site5`,
+      ])
+    });
+  });
+
+  it('should delete unpinned tabs by bdeletes command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdeletes site', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.deepEqual(tabs.map((t: any) => t.url), [
+        `http://127.0.0.1:${port}/site1`,
+        `http://127.0.0.1:${port}/site2`,
+        `http://127.0.0.1:${port}/site3`,
+      ])
+    });
+  });
+
+  it('should delete both pinned and unpinned tabs by bdeletes! command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('bdeletes! site', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 1);
+    });
+  });
+});
diff --git a/e2e/command_buffer.test.js b/e2e/command_buffer.test.js
deleted file mode 100644
index b3336dc..0000000
--- a/e2e/command_buffer.test.js
+++ /dev/null
@@ -1,198 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/*', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <head>
-    <title>my_${req.path.slice(1)}</title>
-  </head>
-  <body><h1>${req.path}</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe('buffer command test', () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1` });
-    for (let i = 2; i <= 5; ++i) {
-      await browser.tabs.create({ url: `http://127.0.0.1:${port}/site${i}`})
-    }
-
-    await eventually(async() => {
-      let handles = await webdriver.getAllWindowHandles();
-      assert.equal(handles.length, 5);
-      await webdriver.switchTo().window(handles[2]);
-      await webdriver.findElement(By.css('iframe'));
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  });
-
-  it('should do nothing by buffer command with no parameters', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 2);
-    });
-  });
-
-  it('should select a tab by buffer command with a number', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 2);
-    });
-  });
-
-  it('should should an out of range error by buffer commands', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer 0', Key.ENTER);
-
-    await eventually(async() => {
-      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
-      let text = await p.getText();
-      assert.equal(text, 'tab 0 does not exist');
-    });
-
-    await webdriver.switchTo().parentFrame();
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer 9', Key.ENTER);
-
-    await eventually(async() => {
-      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
-      let text = await p.getText();
-      assert.equal(text, 'tab 9 does not exist');
-    });
-  });
-
-  it('should select a tab by buffer command with a title', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer my_site1', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 0);
-    });
-  });
-
-  it('should select a tab by buffer command with an URL', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer /site1', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 0);
-    });
-  });
-
-  it('should select tabs rotately', async() => {
-    let handles = await webdriver.getAllWindowHandles();
-    await webdriver.switchTo().window(handles[4]);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer site', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 0);
-    });
-  });
-
-  it('should do nothing by ":buffer %"', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer %', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 2);
-    });
-  });
-
-  it('should selects last selected tab by ":buffer #"', async() => {
-    let handles = await webdriver.getAllWindowHandles();
-    await webdriver.switchTo().window(handles[1]);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('buffer #', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      assert.equal(tabs[0].index, 2);
-    });
-  });
-});
diff --git a/e2e/command_buffer.test.ts b/e2e/command_buffer.test.ts
new file mode 100644
index 0000000..e642673
--- /dev/null
+++ b/e2e/command_buffer.test.ts
@@ -0,0 +1,200 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/*', (req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <head>
+    <title>my_${req.path.slice(1)}</title>
+  </head>
+  <body><h1>${req.path}</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe('buffer command test', () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1` });
+    for (let i = 2; i <= 5; ++i) {
+      await browser.tabs.create({ url: `http://127.0.0.1:${port}/site${i}`})
+    }
+
+    await eventually(async() => {
+      let handles = await webdriver.getAllWindowHandles();
+      assert.equal(handles.length, 5);
+      await webdriver.switchTo().window(handles[2]);
+      await webdriver.findElement(By.css('iframe'));
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  it('should do nothing by buffer command with no parameters', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 2);
+    });
+  });
+
+  it('should select a tab by buffer command with a number', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 2);
+    });
+  });
+
+  it('should should an out of range error by buffer commands', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer 0', Key.ENTER);
+
+    await eventually(async() => {
+      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
+      let text = await p.getText();
+      assert.equal(text, 'tab 0 does not exist');
+    });
+
+    await (webdriver.switchTo() as any).parentFrame();
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer 9', Key.ENTER);
+
+    await eventually(async() => {
+      let p = await webdriver.findElement(By.css('.vimvixen-console-error'));
+      let text = await p.getText();
+      assert.equal(text, 'tab 9 does not exist');
+    });
+  });
+
+  it('should select a tab by buffer command with a title', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer my_site1', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 0);
+    });
+  });
+
+  it('should select a tab by buffer command with an URL', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer /site1', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 0);
+    });
+  });
+
+  it('should select tabs rotately', async() => {
+    let handles = await webdriver.getAllWindowHandles();
+    await webdriver.switchTo().window(handles[4]);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer site', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 0);
+    });
+  });
+
+  it('should do nothing by ":buffer %"', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer %', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 2);
+    });
+  });
+
+  it('should selects last selected tab by ":buffer #"', async() => {
+    let handles = await webdriver.getAllWindowHandles();
+    await webdriver.switchTo().window(handles[1]);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('buffer #', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      assert.equal(tabs[0].index, 2);
+    });
+  });
+});
diff --git a/e2e/command_open.test.js b/e2e/command_open.test.js
deleted file mode 100644
index ccf7393..0000000
--- a/e2e/command_open.test.js
+++ /dev/null
@@ -1,146 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-
-  let app = express();
-  for (let name of ['google', 'yahoo', 'bing', 'duckduckgo', 'twitter', 'wikipedia']) {
-    app.get('/' + name, (req, res) => {
-      res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><h1>${name.charAt(0).toUpperCase() + name.slice(1)}</h1></body>
-</html">`);
-    });
-  }
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><h1>home</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("open command test", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    http = newApp().listen(port);
-
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  })
-
-  it('should open default search for keywords by open command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('open an apple', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=an%20apple`)
-    });
-  });
-
-  it('should open certain search page for keywords by open command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('open yahoo an apple', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true })
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=an%20apple`)
-    });
-  });
-
-  it('should open default engine with empty keywords by open command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('open', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true })
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=`)
-    });
-  });
-
-  it('should open certain search page for empty keywords by open command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('open yahoo', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true })
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=`)
-    });
-  });
-
-  it('should open a site with domain by open command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('open i-beam.org', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true })
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, 'https://i-beam.org/')
-    });
-  });
-
-  it('should open a site with URL by open command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('open https://i-beam.org', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({ active: true })
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, 'https://i-beam.org/')
-    });
-  });
-});
diff --git a/e2e/command_open.test.ts b/e2e/command_open.test.ts
new file mode 100644
index 0000000..cfaee15
--- /dev/null
+++ b/e2e/command_open.test.ts
@@ -0,0 +1,148 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+
+  let app = express();
+  for (let name of ['google', 'yahoo', 'bing', 'duckduckgo', 'twitter', 'wikipedia']) {
+    app.get('/' + name, (_req, res) => {
+      res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><h1>${name.charAt(0).toUpperCase() + name.slice(1)}</h1></body>
+</html">`);
+    });
+  }
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><h1>home</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("open command test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    http = newApp().listen(port);
+
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  })
+
+  it('should open default search for keywords by open command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('open an apple', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=an%20apple`)
+    });
+  });
+
+  it('should open certain search page for keywords by open command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('open yahoo an apple', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true })
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=an%20apple`)
+    });
+  });
+
+  it('should open default engine with empty keywords by open command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('open', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true })
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=`)
+    });
+  });
+
+  it('should open certain search page for empty keywords by open command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('open yahoo', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true })
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=`)
+    });
+  });
+
+  it('should open a site with domain by open command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('open i-beam.org', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true })
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, 'https://i-beam.org/')
+    });
+  });
+
+  it('should open a site with URL by open command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('open https://i-beam.org', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({ active: true })
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, 'https://i-beam.org/')
+    });
+  });
+});
diff --git a/e2e/command_quit.test.js b/e2e/command_quit.test.js
deleted file mode 100644
index 07e770a..0000000
--- a/e2e/command_quit.test.js
+++ /dev/null
@@ -1,121 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/*', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <head>
-    <title>my_${req.path.slice(1)}</title>
-  </head>
-  <body><h1>${req.path}</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe('quit/quitall command test', () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1` });
-    for (let i = 2; i <= 5; ++i) {
-      await browser.tabs.create({ url: `http://127.0.0.1:${port}/site${i}`})
-    }
-
-    await eventually(async() => {
-      let handles = await webdriver.getAllWindowHandles();
-      assert.equal(handles.length, 5);
-      await webdriver.switchTo().window(handles[2]);
-      await webdriver.findElement(By.css('iframe'));
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  });
-
-  it('should current tab by q command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('q', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 4)
-    });
-  });
-
-  it('should current tab by quit command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('quit', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 4)
-    });
-  });
-
-  it('should current tab by qa command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('qa', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 1)
-    });
-  });
-
-  it('should current tab by quitall command', async() => {
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    await input.sendKeys('quitall', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 1)
-    });
-  });
-});
diff --git a/e2e/command_quit.test.ts b/e2e/command_quit.test.ts
new file mode 100644
index 0000000..29b947a
--- /dev/null
+++ b/e2e/command_quit.test.ts
@@ -0,0 +1,124 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+
+const newApp = () => {
+  let app = express();
+  app.get('/*', (req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <head>
+    <title>my_${req.path.slice(1)}</title>
+  </head>
+  <body><h1>${req.path}</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe('quit/quitall command test', () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1` });
+    for (let i = 2; i <= 5; ++i) {
+      await browser.tabs.create({ url: `http://127.0.0.1:${port}/site${i}`})
+    }
+
+    await eventually(async() => {
+      let handles = await webdriver.getAllWindowHandles();
+      assert.equal(handles.length, 5);
+      await webdriver.switchTo().window(handles[2]);
+      await webdriver.findElement(By.css('iframe'));
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  it('should current tab by q command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('q', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 4)
+    });
+  });
+
+  it('should current tab by quit command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('quit', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 4)
+    });
+  });
+
+  it('should current tab by qa command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('qa', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 1)
+    });
+  });
+
+  it('should current tab by quitall command', async() => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    await input.sendKeys('quitall', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 1)
+    });
+  });
+});
diff --git a/e2e/command_tabopen.test.js b/e2e/command_tabopen.test.js
deleted file mode 100644
index 78f5d7f..0000000
--- a/e2e/command_tabopen.test.js
+++ /dev/null
@@ -1,157 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-
-  let app = express();
-  for (let name of ['google', 'yahoo', 'bing', 'duckduckgo', 'twitter', 'wikipedia']) {
-    app.get('/' + name, (req, res) => {
-      res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><h1>${name.charAt(0).toUpperCase() + name.slice(1)}</h1></body>
-</html">`);
-    });
-  }
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><h1>home</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("tabopen command test", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  })
-
-  it('should open default search for keywords by tabopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('tabopen an apple', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      let url = new URL(tabs[1].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=an%20apple`)
-    });
-  });
-
-  it('should open certain search page for keywords by tabopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('tabopen yahoo an apple', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      let url = new URL(tabs[1].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=an%20apple`)
-    });
-  });
-
-  it('should open default engine with empty keywords by tabopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('tabopen', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      let url = new URL(tabs[1].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=`)
-    });
-  });
-
-  it('should open certain search page for empty keywords by tabopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('tabopen yahoo', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      let url = new URL(tabs[1].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=`)
-    });
-  });
-
-  it('should open a site with domain by tabopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('tabopen i-beam.org', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      let url = new URL(tabs[1].url);
-      assert.equal(url.href, 'https://i-beam.org/')
-    });
-  });
-
-  it('should open a site with URL by tabopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('tabopen https://i-beam.org', Key.ENTER);
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      let url = new URL(tabs[1].url);
-      assert.equal(url.href, 'https://i-beam.org/')
-    });
-  });
-});
diff --git a/e2e/command_tabopen.test.ts b/e2e/command_tabopen.test.ts
new file mode 100644
index 0000000..ca4ad92
--- /dev/null
+++ b/e2e/command_tabopen.test.ts
@@ -0,0 +1,160 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+
+
+const newApp = () => {
+
+  let app = express();
+  for (let name of ['google', 'yahoo', 'bing', 'duckduckgo', 'twitter', 'wikipedia']) {
+    app.get('/' + name, (_req, res) => {
+      res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><h1>${name.charAt(0).toUpperCase() + name.slice(1)}</h1></body>
+</html">`);
+    });
+  }
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><h1>home</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("tabopen command test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  })
+
+  it('should open default search for keywords by tabopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('tabopen an apple', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      let url = new URL(tabs[1].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=an%20apple`)
+    });
+  });
+
+  it('should open certain search page for keywords by tabopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('tabopen yahoo an apple', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      let url = new URL(tabs[1].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=an%20apple`)
+    });
+  });
+
+  it('should open default engine with empty keywords by tabopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('tabopen', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      let url = new URL(tabs[1].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=`)
+    });
+  });
+
+  it('should open certain search page for empty keywords by tabopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('tabopen yahoo', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      let url = new URL(tabs[1].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=`)
+    });
+  });
+
+  it('should open a site with domain by tabopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('tabopen i-beam.org', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      let url = new URL(tabs[1].url);
+      assert.equal(url.href, 'https://i-beam.org/')
+    });
+  });
+
+  it('should open a site with URL by tabopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('tabopen https://i-beam.org', Key.ENTER);
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      let url = new URL(tabs[1].url);
+      assert.equal(url.href, 'https://i-beam.org/')
+    });
+  });
+});
diff --git a/e2e/command_winopen.test.js b/e2e/command_winopen.test.js
deleted file mode 100644
index 149d775..0000000
--- a/e2e/command_winopen.test.js
+++ /dev/null
@@ -1,168 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-
-  let app = express();
-  for (let name of ['google', 'yahoo', 'bing', 'duckduckgo', 'twitter', 'wikipedia']) {
-    app.get('/' + name, (req, res) => {
-      res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><h1>${name.charAt(0).toUpperCase() + name.slice(1)}</h1></body>
-</html">`);
-    });
-  }
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><h1>home</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("winopen command test", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    let wins = await browser.windows.getAll();
-    for (let win of wins.slice(1)) {
-      await browser.windows.remove(win.id);
-    }
-
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  })
-
-  it('should open default search for keywords by winopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('winopen an apple', Key.ENTER);
-
-    await eventually(async() => {
-      let wins = await browser.windows.getAll();
-      assert.equal(wins.length, 2);
-
-      let tabs = await browser.tabs.query({ windowId: wins[1].id });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=an%20apple`)
-    });
-  });
-
-  it('should open certain search page for keywords by winopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('winopen yahoo an apple', Key.ENTER);
-
-    await eventually(async() => {
-      let wins = await browser.windows.getAll();
-      assert.equal(wins.length, 2);
-
-      let tabs = await browser.tabs.query({ windowId: wins[1].id });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=an%20apple`)
-    });
-  });
-
-  it('should open default engine with empty keywords by winopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('winopen', Key.ENTER);
-
-    await eventually(async() => {
-      let wins = await browser.windows.getAll();
-      assert.equal(wins.length, 2);
-
-      let tabs = await browser.tabs.query({ windowId: wins[1].id });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=`)
-    });
-  });
-
-  it('should open certain search page for empty keywords by winopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('winopen yahoo', Key.ENTER);
-
-    await eventually(async() => {
-      let wins = await browser.windows.getAll();
-      assert.equal(wins.length, 2);
-
-      let tabs = await browser.tabs.query({ windowId: wins[1].id });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=`)
-    });
-  });
-
-  it('should open a site with domain by winopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('winopen i-beam.org', Key.ENTER);
-
-    await eventually(async() => {
-      let wins = await browser.windows.getAll();
-      assert.equal(wins.length, 2);
-
-      let tabs = await browser.tabs.query({ windowId: wins[1].id });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, 'https://i-beam.org/')
-    });
-  });
-
-  it('should open a site with URL by winopen command ', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys('winopen https://i-beam.org', Key.ENTER);
-
-    await eventually(async() => {
-      let wins = await browser.windows.getAll();
-      assert.equal(wins.length, 2);
-
-      let tabs = await browser.tabs.query({ windowId: wins[1].id });
-      let url = new URL(tabs[0].url);
-      assert.equal(url.href, 'https://i-beam.org/')
-    });
-  });
-});
diff --git a/e2e/command_winopen.test.ts b/e2e/command_winopen.test.ts
new file mode 100644
index 0000000..cdd4c1c
--- /dev/null
+++ b/e2e/command_winopen.test.ts
@@ -0,0 +1,170 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+
+  let app = express();
+  for (let name of ['google', 'yahoo', 'bing', 'duckduckgo', 'twitter', 'wikipedia']) {
+    app.get('/' + name, (_req, res) => {
+      res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><h1>${name.charAt(0).toUpperCase() + name.slice(1)}</h1></body>
+</html">`);
+    });
+  }
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><h1>home</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("winopen command test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    let wins = await browser.windows.getAll();
+    for (let win of wins.slice(1)) {
+      await browser.windows.remove(win.id);
+    }
+
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  })
+
+  it('should open default search for keywords by winopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('winopen an apple', Key.ENTER);
+
+    await eventually(async() => {
+      let wins = await browser.windows.getAll();
+      assert.equal(wins.length, 2);
+
+      let tabs = await browser.tabs.query({ windowId: wins[1].id });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=an%20apple`)
+    });
+  });
+
+  it('should open certain search page for keywords by winopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('winopen yahoo an apple', Key.ENTER);
+
+    await eventually(async() => {
+      let wins = await browser.windows.getAll();
+      assert.equal(wins.length, 2);
+
+      let tabs = await browser.tabs.query({ windowId: wins[1].id });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=an%20apple`)
+    });
+  });
+
+  it('should open default engine with empty keywords by winopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('winopen', Key.ENTER);
+
+    await eventually(async() => {
+      let wins = await browser.windows.getAll();
+      assert.equal(wins.length, 2);
+
+      let tabs = await browser.tabs.query({ windowId: wins[1].id });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/google?q=`)
+    });
+  });
+
+  it('should open certain search page for empty keywords by winopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('winopen yahoo', Key.ENTER);
+
+    await eventually(async() => {
+      let wins = await browser.windows.getAll();
+      assert.equal(wins.length, 2);
+
+      let tabs = await browser.tabs.query({ windowId: wins[1].id });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, `http://127.0.0.1:${port}/yahoo?q=`)
+    });
+  });
+
+  it('should open a site with domain by winopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('winopen i-beam.org', Key.ENTER);
+
+    await eventually(async() => {
+      let wins = await browser.windows.getAll();
+      assert.equal(wins.length, 2);
+
+      let tabs = await browser.tabs.query({ windowId: wins[1].id });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, 'https://i-beam.org/')
+    });
+  });
+
+  it('should open a site with URL by winopen command ', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys('winopen https://i-beam.org', Key.ENTER);
+
+    await eventually(async() => {
+      let wins = await browser.windows.getAll();
+      assert.equal(wins.length, 2);
+
+      let tabs = await browser.tabs.query({ windowId: wins[1].id });
+      let url = new URL(tabs[0].url);
+      assert.equal(url.href, 'https://i-beam.org/')
+    });
+  });
+});
diff --git a/e2e/completion.test.js b/e2e/completion.test.js
deleted file mode 100644
index fc87df0..0000000
--- a/e2e/completion.test.js
+++ /dev/null
@@ -1,133 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-const Console = require('./lib/Console');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>ok</body>
-</html">`);
-  });
-  return app;
-};
-
-describe("general completion test", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    http = newApp().listen(port);
-
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-  it('should all commands on empty line', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 10);
-      assert.deepEqual(items[0], { type: 'title', text: 'Console Command' });
-      assert(items[1].text.startsWith('set'))
-      assert(items[2].text.startsWith('open'))
-      assert(items[3].text.startsWith('tabopen'))
-    });
-  });
-
-  it('should only commands filtered by prefix', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('b');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 4);
-      assert.deepEqual(items[0], { type: 'title', text: 'Console Command' });
-      assert(items[1].text.startsWith('buffer'))
-      assert(items[2].text.startsWith('bdelete'))
-      assert(items[3].text.startsWith('bdeletes'))
-    });
-  });
-
-  it('selects completion items by <Tab>/<S-Tab> keys', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('b');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 4);
-    });
-
-    await c.sendKeys(Key.TAB);
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert(items[1].highlight)
-
-      let v = await c.currentValue();
-      assert.equal(v, 'buffer');
-    });
-
-    await c.sendKeys(Key.TAB, Key.TAB);
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert(items[3].highlight)
-
-      let v = await c.currentValue();
-      assert.equal(v, 'bdeletes');
-    });
-
-    await c.sendKeys(Key.TAB);
-    await eventually(async() => {
-      let v = await c.currentValue();
-      assert.equal(v, 'b');
-    });
-
-    await c.sendKeys(Key.SHIFT, Key.TAB);
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert(items[3].highlight)
-
-      let v = await c.currentValue();
-      assert.equal(v, 'bdeletes');
-    });
-  });
-});
diff --git a/e2e/completion.test.ts b/e2e/completion.test.ts
new file mode 100644
index 0000000..fd58f74
--- /dev/null
+++ b/e2e/completion.test.ts
@@ -0,0 +1,135 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+import { Console } from './lib/Console';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>ok</body>
+</html">`);
+  });
+  return app;
+};
+
+describe("general completion test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    http = newApp().listen(port);
+
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+  it('should all commands on empty line', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 10);
+      assert.deepEqual(items[0], { type: 'title', text: 'Console Command' });
+      assert.ok(items[1].text.startsWith('set'))
+      assert.ok(items[2].text.startsWith('open'))
+      assert.ok(items[3].text.startsWith('tabopen'))
+    });
+  });
+
+  it('should only commands filtered by prefix', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('b');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 4);
+      assert.deepEqual(items[0], { type: 'title', text: 'Console Command' });
+      assert.ok(items[1].text.startsWith('buffer'))
+      assert.ok(items[2].text.startsWith('bdelete'))
+      assert.ok(items[3].text.startsWith('bdeletes'))
+    });
+  });
+
+  it('selects completion items by <Tab>/<S-Tab> keys', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('b');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 4);
+    });
+
+    await c.sendKeys(Key.TAB);
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.ok(items[1].highlight)
+
+      let v = await c.currentValue();
+      assert.equal(v, 'buffer');
+    });
+
+    await c.sendKeys(Key.TAB, Key.TAB);
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.ok(items[3].highlight)
+
+      let v = await c.currentValue();
+      assert.equal(v, 'bdeletes');
+    });
+
+    await c.sendKeys(Key.TAB);
+    await eventually(async() => {
+      let v = await c.currentValue();
+      assert.equal(v, 'b');
+    });
+
+    await c.sendKeys(Key.SHIFT, Key.TAB);
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.ok(items[3].highlight)
+
+      let v = await c.currentValue();
+      assert.equal(v, 'bdeletes');
+    });
+  });
+});
diff --git a/e2e/completion_buffers.test.js b/e2e/completion_buffers.test.js
deleted file mode 100644
index 87d2397..0000000
--- a/e2e/completion_buffers.test.js
+++ /dev/null
@@ -1,211 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const Console = require('./lib/Console');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-
-const newApp = () => {
-
-  let app = express();
-  app.get('/*', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <head>
-    <title>title_${req.path.slice(1)}</title>
-  </head>
-  <body><h1>home</h1></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("completion on buffer/bdelete/bdeletes", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    http = newApp().listen(port);
-
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-
-    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1`, pinned: true });
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site2`, pinned: true })
-    for (let i = 3; i <= 5; ++i) {
-      await browser.tabs.create({ url: `http://127.0.0.1:${port}/site${i}` })
-    }
-
-    await eventually(async() => {
-      let handles = await webdriver.getAllWindowHandles();
-      assert.equal(handles.length, 5);
-      await webdriver.switchTo().window(handles[2]);
-      await webdriver.findElement(By.css('iframe'));
-    });
-    body = await webdriver.findElement(By.css('body'));
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  });
-
-  it('should all tabs by "buffer" command with empty params', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('buffer ');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 6);
-      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
-      assert(items[1].text.startsWith('1:'));
-      assert(items[2].text.startsWith('2:'));
-      assert(items[3].text.startsWith('3:'));
-      assert(items[4].text.startsWith('4:'));
-      assert(items[5].text.startsWith('5:'));
-
-      assert(items[3].text.includes('%'));
-      assert(items[5].text.includes('#'));
-    });
-  })
-
-  it('should filter items with URLs by keywords on "buffer" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('buffer title_site2');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
-      assert(items[1].text.startsWith('2:'));
-      assert(items[1].text.includes('title_site2'));
-      assert(items[1].text.includes(`http://127.0.0.1:${port}/site2`));
-    });
-  })
-
-  it('should filter items with titles by keywords on "buffer" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('buffer /site2');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
-      assert(items[1].text.startsWith('2:'));
-    });
-  })
-
-  it('should show one item by number on "buffer" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('buffer 2');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 2);
-      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
-      assert(items[1].text.startsWith('2:'));
-    });
-  })
-
-  it('should show unpinned tabs "bdelete" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('bdelete site');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 4);
-      assert(items[1].text.includes('site3'));
-      assert(items[2].text.includes('site4'));
-      assert(items[3].text.includes('site5'));
-    });
-  })
-
-  it('should show unpinned tabs "bdeletes" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('bdelete site');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 4);
-      assert(items[1].text.includes('site3'));
-      assert(items[2].text.includes('site4'));
-      assert(items[3].text.includes('site5'));
-    });
-  })
-
-  it('should show both pinned and unpinned tabs "bdelete!" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('bdelete! site');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 6);
-      assert(items[1].text.includes('site1'));
-      assert(items[2].text.includes('site2'));
-      assert(items[3].text.includes('site3'));
-      assert(items[4].text.includes('site4'));
-      assert(items[5].text.includes('site5'));
-    });
-  })
-
-  it('should show both pinned and unpinned tabs "bdeletes!" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('bdeletes! site');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 6);
-      assert(items[1].text.includes('site1'));
-      assert(items[2].text.includes('site2'));
-      assert(items[3].text.includes('site3'));
-      assert(items[4].text.includes('site4'));
-      assert(items[5].text.includes('site5'));
-    });
-  })
-});
diff --git a/e2e/completion_buffers.test.ts b/e2e/completion_buffers.test.ts
new file mode 100644
index 0000000..9c212cc
--- /dev/null
+++ b/e2e/completion_buffers.test.ts
@@ -0,0 +1,213 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By } from 'selenium-webdriver';
+import { Console } from './lib/Console';
+
+const newApp = () => {
+
+  let app = express();
+  app.get('/*', (req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <head>
+    <title>title_${req.path.slice(1)}</title>
+  </head>
+  <body><h1>home</h1></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("completion on buffer/bdelete/bdeletes", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    http = newApp().listen(port);
+
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+
+    await browser.tabs.update(tabs[0].id, { url: `http://127.0.0.1:${port}/site1`, pinned: true });
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}/site2`, pinned: true })
+    for (let i = 3; i <= 5; ++i) {
+      await browser.tabs.create({ url: `http://127.0.0.1:${port}/site${i}` })
+    }
+
+    await eventually(async() => {
+      let handles = await webdriver.getAllWindowHandles();
+      assert.equal(handles.length, 5);
+      await webdriver.switchTo().window(handles[2]);
+      await webdriver.findElement(By.css('iframe'));
+    });
+    body = await webdriver.findElement(By.css('body'));
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  it('should all tabs by "buffer" command with empty params', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('buffer ');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 6);
+      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
+      assert.ok(items[1].text.startsWith('1:'));
+      assert.ok(items[2].text.startsWith('2:'));
+      assert.ok(items[3].text.startsWith('3:'));
+      assert.ok(items[4].text.startsWith('4:'));
+      assert.ok(items[5].text.startsWith('5:'));
+
+      assert.ok(items[3].text.includes('%'));
+      assert.ok(items[5].text.includes('#'));
+    });
+  })
+
+  it('should filter items with URLs by keywords on "buffer" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('buffer title_site2');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
+      assert.ok(items[1].text.startsWith('2:'));
+      assert.ok(items[1].text.includes('title_site2'));
+      assert.ok(items[1].text.includes(`http://127.0.0.1:${port}/site2`));
+    });
+  })
+
+  it('should filter items with titles by keywords on "buffer" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('buffer /site2');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
+      assert.ok(items[1].text.startsWith('2:'));
+    });
+  })
+
+  it('should show one item by number on "buffer" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('buffer 2');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 2);
+      assert.deepEqual(items[0], { type: 'title', text: 'Buffers' });
+      assert.ok(items[1].text.startsWith('2:'));
+    });
+  })
+
+  it('should show unpinned tabs "bdelete" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('bdelete site');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 4);
+      assert.ok(items[1].text.includes('site3'));
+      assert.ok(items[2].text.includes('site4'));
+      assert.ok(items[3].text.includes('site5'));
+    });
+  })
+
+  it('should show unpinned tabs "bdeletes" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('bdelete site');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 4);
+      assert.ok(items[1].text.includes('site3'));
+      assert.ok(items[2].text.includes('site4'));
+      assert.ok(items[3].text.includes('site5'));
+    });
+  })
+
+  it('should show both pinned and unpinned tabs "bdelete!" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('bdelete! site');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 6);
+      assert.ok(items[1].text.includes('site1'));
+      assert.ok(items[2].text.includes('site2'));
+      assert.ok(items[3].text.includes('site3'));
+      assert.ok(items[4].text.includes('site4'));
+      assert.ok(items[5].text.includes('site5'));
+    });
+  })
+
+  it('should show both pinned and unpinned tabs "bdeletes!" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('bdeletes! site');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 6);
+      assert.ok(items[1].text.includes('site1'));
+      assert.ok(items[2].text.includes('site2'));
+      assert.ok(items[3].text.includes('site3'));
+      assert.ok(items[4].text.includes('site4'));
+      assert.ok(items[5].text.includes('site5'));
+    });
+  })
+});
diff --git a/e2e/completion_open.test.js b/e2e/completion_open.test.js
deleted file mode 100644
index b2b7484..0000000
--- a/e2e/completion_open.test.js
+++ /dev/null
@@ -1,256 +0,0 @@
-const express = require('express');
-const lanthan = require('lanthan');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const { Builder } = require('lanthan');
-const { By, Key } = require('selenium-webdriver');
-const Console = require('./lib/Console');
-
-const newApp = () => {
-
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>ok</body>
-</html">`);
-  });
-  return app;
-};
-
-describe("completion on open/tabopen/winopen commands", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    http = newApp().listen(port);
-
-    await browser.storage.local.set({
-      settings,
-    });
-    
-    // Add item into hitories
-    await webdriver.navigate().to(`https://i-beam.org/404`);
-  });
-
-  after(async() => {
-    http.close();
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-  it('should show completions from search engines, bookmarks, and histories by "open" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('open ');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      assert(completions.find(x => x.type === 'title' && x.text === 'Search Engines'));
-      assert(completions.find(x => x.type === 'title' && x.text === 'Bookmarks'));
-      assert(completions.find(x => x.type === 'title' && x.text === 'History'));
-    });
-  });
-
-  it('should filter items with URLs by keywords on "open" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('open https://');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let items = completions.filter(x => x.type === 'item').map(x => x.text);
-      assert(items.every(x => x.includes('https://')));
-    });
-  })
-
-  it('should filter items with titles by keywords on "open" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('open getting');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let items = completions.filter(x => x.type === 'item').map(x => x.text);
-      assert(items.every(x => x.toLowerCase().includes('getting')));
-    });
-  })
-
-  it('should filter items with titles by keywords on "tabopen" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('tabopen https://');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let items = completions.filter(x => x.type === 'item').map(x => x.text);
-      assert(items.every(x => x.includes('https://')));
-    });
-  })
-
-  it('should filter items with titles by keywords on "winopen" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('winopen https://');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let items = completions.filter(x => x.type === 'item').map(x => x.text);
-      assert(items.every(x => x.includes('https://')));
-    });
-  })
-
-  it('should display only specified items in "complete" property by set command', async() => {
-    let c = new Console(webdriver);
-
-    const execCommand = async(line) => {
-      await body.sendKeys(':');
-      await webdriver.switchTo().frame(0);
-      await c.sendKeys(line, Key.ENTER);
-      await new Promise(resolve => setTimeout(resolve, 100));
-      await webdriver.switchTo().parentFrame();
-    }
-
-    const typeCommand = async(...keys) => {
-      await body.sendKeys(':');
-      await webdriver.switchTo().frame(0);
-      await c.sendKeys(...keys);
-    }
-
-    const cancel = async() => {
-      await c.sendKeys(Key.ESCAPE);
-      await new Promise(resolve => setTimeout(resolve, 100));
-      await webdriver.switchTo().parentFrame();
-    }
-
-    await execCommand('set complete=sbh');
-    await typeCommand('open ');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
-      assert.deepEqual(titles, ['Search Engines', 'Bookmarks', 'History'])
-    });
-
-    await cancel();
-    await execCommand('set complete=bss');
-    await typeCommand('open ');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
-      assert.deepEqual(titles, ['Bookmarks', 'Search Engines', 'Search Engines'])
-    });
-  })
-
-  it('should display only specified items in "complete" property by setting', async() => {
-    const settings = {
-      source: 'json',
-      json: `{
-        "keymaps": {
-          ":": { "type": "command.show" }
-        },
-        "search": {
-          "default": "google",
-          "engines": { "google": "https://google.com/search?q={}" }
-        },
-        "properties": {
-          "complete": "sbh"
-        }
-      }`,
-    };
-    await browser.storage.local.set({ settings, });
-
-    let c = new Console(webdriver);
-
-    const typeCommand = async(...keys) => {
-      await body.sendKeys(':');
-      await webdriver.switchTo().frame(0);
-      await c.sendKeys(...keys);
-    }
-
-    const cancel = async() => {
-      await c.sendKeys(Key.ESCAPE);
-      await new Promise(resolve => setTimeout(resolve, 100));
-      await webdriver.switchTo().parentFrame();
-    }
-
-    await browser.storage.local.set({ settings: {
-      source: 'json',
-      json: `{
-        "keymaps": {
-          ":": { "type": "command.show" }
-        },
-        "search": {
-          "default": "google",
-          "engines": { "google": "https://google.com/search?q={}" }
-        },
-        "properties": {
-          "complete": "sbh"
-        }
-      }`,
-    }});
-    await typeCommand('open ');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
-      assert.deepEqual(titles, ['Search Engines', 'Bookmarks', 'History'])
-    });
-
-    await cancel();
-
-    await browser.storage.local.set({ settings: {
-      source: 'json',
-      json: `{
-        "keymaps": {
-          ":": { "type": "command.show" }
-        },
-        "search": {
-          "default": "google",
-          "engines": { "google": "https://google.com/search?q={}" }
-        },
-        "properties": {
-          "complete": "bss"
-        }
-      }`,
-    }});
-    await typeCommand('open ');
-
-    await eventually(async() => {
-      let completions = await c.getCompletions();
-      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
-      assert.deepEqual(titles, ['Bookmarks', 'Search Engines', 'Search Engines'])
-    });
-
-
-  })
-});
diff --git a/e2e/completion_open.test.ts b/e2e/completion_open.test.ts
new file mode 100644
index 0000000..dcd1829
--- /dev/null
+++ b/e2e/completion_open.test.ts
@@ -0,0 +1,257 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+import { Console } from './lib/Console';
+
+const newApp = () => {
+
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>ok</body>
+</html">`);
+  });
+  return app;
+};
+
+describe("completion on open/tabopen/winopen commands", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    http = newApp().listen(port);
+
+    await browser.storage.local.set({
+      settings,
+    });
+    
+    // Add item into hitories
+    await webdriver.navigate().to(`https://i-beam.org/404`);
+  });
+
+  after(async() => {
+    http.close();
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+  it('should show completions from search engines, bookmarks, and histories by "open" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('open ');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      assert.ok(completions.find(x => x.type === 'title' && x.text === 'Search Engines'));
+      assert.ok(completions.find(x => x.type === 'title' && x.text === 'Bookmarks'));
+      assert.ok(completions.find(x => x.type === 'title' && x.text === 'History'));
+    });
+  });
+
+  it('should filter items with URLs by keywords on "open" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('open https://');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let items = completions.filter(x => x.type === 'item').map(x => x.text);
+      assert.ok(items.every(x => x.includes('https://')));
+    });
+  })
+
+  it('should filter items with titles by keywords on "open" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('open getting');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let items = completions.filter(x => x.type === 'item').map(x => x.text);
+      assert.ok(items.every(x => x.toLowerCase().includes('getting')));
+    });
+  })
+
+  it('should filter items with titles by keywords on "tabopen" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('tabopen https://');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let items = completions.filter(x => x.type === 'item').map(x => x.text);
+      assert.ok(items.every(x => x.includes('https://')));
+    });
+  })
+
+  it('should filter items with titles by keywords on "winopen" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('winopen https://');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let items = completions.filter(x => x.type === 'item').map(x => x.text);
+      assert.ok(items.every(x => x.includes('https://')));
+    });
+  })
+
+  it('should display only specified items in "complete" property by set command', async() => {
+    let c = new Console(webdriver);
+
+    const execCommand = async(line: string) => {
+      await body.sendKeys(':');
+      await webdriver.switchTo().frame(0);
+      await c.sendKeys(line, Key.ENTER);
+      await new Promise(resolve => setTimeout(resolve, 100));
+      await (webdriver.switchTo() as any).parentFrame();
+    }
+
+    const typeCommand = async(...keys: string[]) => {
+      await body.sendKeys(':');
+      await webdriver.switchTo().frame(0);
+      await c.sendKeys(...keys);
+    }
+
+    const cancel = async() => {
+      await c.sendKeys(Key.ESCAPE);
+      await new Promise(resolve => setTimeout(resolve, 100));
+      await (webdriver.switchTo() as any).parentFrame();
+    }
+
+    await execCommand('set complete=sbh');
+    await typeCommand('open ');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
+      assert.deepEqual(titles, ['Search Engines', 'Bookmarks', 'History'])
+    });
+
+    await cancel();
+    await execCommand('set complete=bss');
+    await typeCommand('open ');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
+      assert.deepEqual(titles, ['Bookmarks', 'Search Engines', 'Search Engines'])
+    });
+  })
+
+  it('should display only specified items in "complete" property by setting', async() => {
+    const settings = {
+      source: 'json',
+      json: `{
+        "keymaps": {
+          ":": { "type": "command.show" }
+        },
+        "search": {
+          "default": "google",
+          "engines": { "google": "https://google.com/search?q={}" }
+        },
+        "properties": {
+          "complete": "sbh"
+        }
+      }`,
+    };
+    await browser.storage.local.set({ settings, });
+
+    let c = new Console(webdriver);
+
+    const typeCommand = async(...keys: string[]) => {
+      await body.sendKeys(':');
+      await webdriver.switchTo().frame(0);
+      await c.sendKeys(...keys);
+    }
+
+    const cancel = async() => {
+      await c.sendKeys(Key.ESCAPE);
+      await new Promise(resolve => setTimeout(resolve, 100));
+      await (webdriver.switchTo() as any).parentFrame();
+    }
+
+    await browser.storage.local.set({ settings: {
+      source: 'json',
+      json: `{
+        "keymaps": {
+          ":": { "type": "command.show" }
+        },
+        "search": {
+          "default": "google",
+          "engines": { "google": "https://google.com/search?q={}" }
+        },
+        "properties": {
+          "complete": "sbh"
+        }
+      }`,
+    }});
+    await typeCommand('open ');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
+      assert.deepEqual(titles, ['Search Engines', 'Bookmarks', 'History'])
+    });
+
+    await cancel();
+
+    await browser.storage.local.set({ settings: {
+      source: 'json',
+      json: `{
+        "keymaps": {
+          ":": { "type": "command.show" }
+        },
+        "search": {
+          "default": "google",
+          "engines": { "google": "https://google.com/search?q={}" }
+        },
+        "properties": {
+          "complete": "bss"
+        }
+      }`,
+    }});
+    await typeCommand('open ');
+
+    await eventually(async() => {
+      let completions = await c.getCompletions();
+      let titles = completions.filter(x => x.type === 'title').map(x => x.text);
+      assert.deepEqual(titles, ['Bookmarks', 'Search Engines', 'Search Engines'])
+    });
+
+
+  })
+});
diff --git a/e2e/completion_set.test.js b/e2e/completion_set.test.js
deleted file mode 100644
index a6ec248..0000000
--- a/e2e/completion_set.test.js
+++ /dev/null
@@ -1,73 +0,0 @@
-const express = require('express');
-const lanthan = require('lanthan');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const settings = require('./settings');
-const Console = require('./lib/Console');
-const { Builder } = require('lanthan');
-const { By } = require('selenium-webdriver');
-
-describe("completion on set commands", () => {
-  const port = 12321;
-  let lanthan;
-  let session;
-  let browser;
-  let body;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-
-    await browser.storage.local.set({
-      settings,
-    });
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`about:blank`);
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-  it('should show all property names by "set" command with empty params', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('set ');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 5);
-      assert.deepEqual(items[0], { type: 'title', text: 'Properties' });
-      assert(items[1].text.startsWith('hintchars'))
-      assert(items[2].text.startsWith('smoothscroll'))
-      assert(items[3].text.startsWith('nosmoothscroll'))
-      assert(items[4].text.startsWith('complete'))
-    });
-  });
-
-  it('should show filtered property names by "set" command', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let c = new Console(webdriver);
-    await c.sendKeys('set no');
-
-    await eventually(async() => {
-      let items = await c.getCompletions();
-      assert.equal(items.length, 2);
-      assert(items[1].text.includes('nosmoothscroll'))
-    });
-  });
-});
diff --git a/e2e/completion_set.test.ts b/e2e/completion_set.test.ts
new file mode 100644
index 0000000..018479f
--- /dev/null
+++ b/e2e/completion_set.test.ts
@@ -0,0 +1,71 @@
+import * as path from 'path';
+import * as assert from 'assert';
+
+import settings from './settings';
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By } from 'selenium-webdriver';
+import { Console } from './lib/Console';
+
+describe("completion on set commands", () => {
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+
+    await browser.storage.local.set({
+      settings,
+    });
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`about:blank`);
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+  it('should show all property names by "set" command with empty params', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('set ');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 5);
+      assert.deepEqual(items[0], { type: 'title', text: 'Properties' });
+      assert.ok(items[1].text.startsWith('hintchars'))
+      assert.ok(items[2].text.startsWith('smoothscroll'))
+      assert.ok(items[3].text.startsWith('nosmoothscroll'))
+      assert.ok(items[4].text.startsWith('complete'))
+    });
+  });
+
+  it('should show filtered property names by "set" command', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let c = new Console(webdriver);
+    await c.sendKeys('set no');
+
+    await eventually(async() => {
+      let items = await c.getCompletions();
+      assert.equal(items.length, 2);
+      assert.ok(items[1].text.includes('nosmoothscroll'))
+    });
+  });
+});
diff --git a/e2e/console.test.js b/e2e/console.test.js
deleted file mode 100644
index 131a4ef..0000000
--- a/e2e/console.test.js
+++ /dev/null
@@ -1,128 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <head>
-    <title>Hello, world!</title>
-  </head>
-</html">`);
-  });
-  return app;
-};
-
-
-describe("console test", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let tab;
-  let body;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    if (http) {
-      http.close();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-  it('open console with :', async() => {
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    
-    let input = await webdriver.findElement(By.css('input'));
-    assert.equal(await input.isDisplayed(), true);
-  });
-
-  it('open console with open command by o', async() => {
-    await body.sendKeys('o');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, 'open ');
-  });
-
-  it('open console with open command and current URL by O', async() => {
-    await body.sendKeys(Key.SHIFT, 'o');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, `open http://127.0.0.1:${port}/`);
-  });
-
-  it('open console with tabopen command by t', async() => {
-    await body.sendKeys('t');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, 'tabopen ');
-  });
-
-  it('open console with tabopen command and current URL by T', async() => {
-    await body.sendKeys(Key.SHIFT, 't');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, `tabopen http://127.0.0.1:${port}/`);
-  });
-
-  it('open console with winopen command by w', async() => {
-    await body.sendKeys('w');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, 'winopen ');
-  });
-
-  it('open console with winopen command and current URL by W', async() => {
-    await body.sendKeys(Key.SHIFT, 'W');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, `winopen http://127.0.0.1:${port}/`);
-  });
-
-  it('open console with buffer command by b', async() => {
-    await body.sendKeys('b');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, `buffer `);
-  });
-
-  it('open console with addbookmark command with title by a', async() => {
-    await body.sendKeys('a');
-
-    await webdriver.switchTo().frame(0);
-    let value = await webdriver.executeScript(() => document.querySelector('input').value);
-    assert.equal(value, `addbookmark Hello, world!`);
-  });
-});
-
diff --git a/e2e/console.test.ts b/e2e/console.test.ts
new file mode 100644
index 0000000..65c5d2d
--- /dev/null
+++ b/e2e/console.test.ts
@@ -0,0 +1,126 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <head>
+    <title>Hello, world!</title>
+  </head>
+</html">`);
+  });
+  return app;
+};
+
+
+describe("console test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let body: WebElement;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    if (http) {
+      http.close();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+  it('open console with :', async() => {
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    
+    let input = await webdriver.findElement(By.css('input'));
+    assert.equal(await input.isDisplayed(), true);
+  });
+
+  it('open console with open command by o', async() => {
+    await body.sendKeys('o');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, 'open ');
+  });
+
+  it('open console with open command and current URL by O', async() => {
+    await body.sendKeys(Key.SHIFT, 'o');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, `open http://127.0.0.1:${port}/`);
+  });
+
+  it('open console with tabopen command by t', async() => {
+    await body.sendKeys('t');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, 'tabopen ');
+  });
+
+  it('open console with tabopen command and current URL by T', async() => {
+    await body.sendKeys(Key.SHIFT, 't');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, `tabopen http://127.0.0.1:${port}/`);
+  });
+
+  it('open console with winopen command by w', async() => {
+    await body.sendKeys('w');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, 'winopen ');
+  });
+
+  it('open console with winopen command and current URL by W', async() => {
+    await body.sendKeys(Key.SHIFT, 'W');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, `winopen http://127.0.0.1:${port}/`);
+  });
+
+  it('open console with buffer command by b', async() => {
+    await body.sendKeys('b');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, `buffer `);
+  });
+
+  it('open console with addbookmark command with title by a', async() => {
+    await body.sendKeys('a');
+
+    await webdriver.switchTo().frame(0);
+    let value = await webdriver.executeScript(() => document.querySelector('input')!!.value);
+    assert.equal(value, `addbookmark Hello, world!`);
+  });
+});
+
diff --git a/e2e/eventually.js b/e2e/eventually.js
deleted file mode 100644
index ab0ae25..0000000
--- a/e2e/eventually.js
+++ /dev/null
@@ -1,23 +0,0 @@
-let defaultInterval = 100;
-let defaultTimeout = 2000;
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
- 
-const eventually = async (fn, timeout = defaultTimeout, interval = defaultInterval) => {
-  let start = Date.now();
-  let loop = async() => {
-    try {
-      await fn();
-    } catch (err) {
-      if (Date.now() - start > timeout) {
-        throw err;
-      }
-      await new Promise((resolve) => setTimeout(resolve, interval))
-      await loop();
-    }
-  };
-  await loop();
-};
-module.exports = eventually;
diff --git a/e2e/eventually.ts b/e2e/eventually.ts
new file mode 100644
index 0000000..12c4552
--- /dev/null
+++ b/e2e/eventually.ts
@@ -0,0 +1,30 @@
+const defaultInterval = 100;
+const defaultTimeout = 2000;
+
+type Handler = () => void
+
+const sleep = (ms: number): Promise<void> => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+ 
+const eventually = async (
+  fn: Handler,
+  timeout = defaultTimeout,
+  interval = defaultInterval,
+): Promise<void> => {
+  let start = Date.now();
+  let loop = async() => {
+    try {
+      await fn();
+    } catch (err) {
+      if (Date.now() - start > timeout) {
+        throw err;
+      }
+      await sleep(interval);
+      await loop();
+    }
+  };
+  await loop();
+};
+
+export default eventually;
diff --git a/e2e/follow.test.js b/e2e/follow.test.js
deleted file mode 100644
index 336d673..0000000
--- a/e2e/follow.test.js
+++ /dev/null
@@ -1,263 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><a href="hello">hello</a></body>
-</html">`);
-  });
-
-  app.get('/follow-input', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><input></body>
-</html">`);
-  });
-
-  app.get('/area', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>
-    <img
-      width="256" height="256"  usemap="#map"
-      src="data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="
-    >
-    <map name="map">
-      <area shape="rect" coords="0,0,64,64" href="/">
-      <area shape="rect" coords="64,64,64,64" href="/">
-      <area shape="rect" coords="128,128,64,64" href="/">
-    </map>
-  </body>
-</html">`);
-  });
-  
-  /*
-   * test case: link2 is out of the viewport
-   * +-----------------+
-   * |   [link1]       |<--- window
-   * |                 |
-   * |=================|<--- viewport
-   * |   [link2]       |
-   * |                 |
-   * +-----------------+
-   */
-  app.get('/test1', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>
-  <div><a href="link1">link1</a></div>
-  <div style="min-height:3000px"></div>
-  <div><a href="link2">link2</a></div>
-  </body>
-</html">`);
-  });
-
-/*
- * test case 2: link2 and link3 are out of window of the frame
- * +-----------------+
- * | +-----------+   |
- * | | [link1]   |   |
- * |=================|
- * | | [link2]   |   |
- * | +-----------+   |
- * |                 |
- * +-----------------+
- */
-  app.get('/test2', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><iframe height="5000" src='/test2-frame'></body>
-</html">`);
-  });
-  app.get('/test2-frame', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>
-  <div><a href="link1">link1</a></div>
-  <div style="min-height:3000px"></div>
-  <div><a href="link2">link2</a></div>
-  </body>
-</html">`);
-  });
-
-/* test case 3: link2 is out of window of the frame
- * +-----------------+
- * | +-----------+   |
- * | | [link1]   |   |
- * | +-----------+   |
- * | : [link2]   :   |
- * | + - - - - - +   |
- * |                 |
- * +-----------------+
- */
-  app.get('/test3', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body><iframe src='/test3-frame'></body>
-</html">`);
-  });
-  app.get('/test3-frame', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>
-  <div><a href="link1">link1</a></div>
-  <div style="min-height:3000px"></div>
-  <div><a href="link2">link2</a></div>
-  </body>
-</html">`);
-  });
-
-  return app;
-};
-
-const waitForHints = async(webdriver) => {
-  await eventually(async() => {
-    let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-    assert(hints.length > 0);
-  });
-};
-
-describe('follow test', () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    if (http) {
-      http.close();
-    }
-  });
-
-  afterEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-  });
-
-  it('should focus an input by f', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/follow-input`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('f');
-    await waitForHints(webdriver);
-    await body.sendKeys('a');
-
-    let tagName = await webdriver.executeScript(() => document.activeElement.tagName);
-    assert.equal(tagName.toLowerCase(), 'input');
-  });
-
-  it('should open a link by f', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('f');
-    await waitForHints(webdriver);
-    await body.sendKeys('a');
-
-    await eventually(async() => {
-      let hash = await webdriver.executeScript('return location.pathname');
-      assert.equal(hash, '/hello');
-    });
-  });
-
-  it('should focus an input by F', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/follow-input`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'f');
-    await waitForHints(webdriver);
-    await body.sendKeys('a');
-
-    let tagName = await webdriver.executeScript(() => document.activeElement.tagName);
-    assert.equal(tagName.toLowerCase(), 'input');
-  });
-
-  it('should open a link to new tab by F', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'f');
-    await waitForHints(webdriver);
-    await body.sendKeys('a');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      assert.equal(new URL(tabs[1].url).pathname, '/hello');
-      assert.equal(tabs[1].openerTabId, tabs[0].id);
-    });
-  });
-
-  it('should show hints of links in area', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/area`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'f');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 3);
-    });
-  });
-
-  it('should shows hints only in viewport', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/test1`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'f');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 1);
-    });
-  });
-
-  it('should shows hints only in window of the frame', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/test2`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'f');
-
-    await webdriver.switchTo().frame(0);
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 1);
-    });
-  });
-
-  it('should shows hints only in the frame', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/test3`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'f');
-
-    await webdriver.switchTo().frame(0);
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 1);
-    });
-  });
-});
diff --git a/e2e/follow.test.ts b/e2e/follow.test.ts
new file mode 100644
index 0000000..5d38085
--- /dev/null
+++ b/e2e/follow.test.ts
@@ -0,0 +1,265 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><a href="hello">hello</a></body>
+</html">`);
+  });
+
+  app.get('/follow-input', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><input></body>
+</html">`);
+  });
+
+  app.get('/area', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>
+    <img
+      width="256" height="256"  usemap="#map"
+      src="data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="
+    >
+    <map name="map">
+      <area shape="rect" coords="0,0,64,64" href="/">
+      <area shape="rect" coords="64,64,64,64" href="/">
+      <area shape="rect" coords="128,128,64,64" href="/">
+    </map>
+  </body>
+</html">`);
+  });
+  
+  /*
+   * test case: link2 is out of the viewport
+   * +-----------------+
+   * |   [link1]       |<--- window
+   * |                 |
+   * |=================|<--- viewport
+   * |   [link2]       |
+   * |                 |
+   * +-----------------+
+   */
+  app.get('/test1', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>
+  <div><a href="link1">link1</a></div>
+  <div style="min-height:3000px"></div>
+  <div><a href="link2">link2</a></div>
+  </body>
+</html">`);
+  });
+
+/*
+ * test case 2: link2 and link3 are out of window of the frame
+ * +-----------------+
+ * | +-----------+   |
+ * | | [link1]   |   |
+ * |=================|
+ * | | [link2]   |   |
+ * | +-----------+   |
+ * |                 |
+ * +-----------------+
+ */
+  app.get('/test2', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><iframe height="5000" src='/test2-frame'></body>
+</html">`);
+  });
+  app.get('/test2-frame', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>
+  <div><a href="link1">link1</a></div>
+  <div style="min-height:3000px"></div>
+  <div><a href="link2">link2</a></div>
+  </body>
+</html">`);
+  });
+
+/* test case 3: link2 is out of window of the frame
+ * +-----------------+
+ * | +-----------+   |
+ * | | [link1]   |   |
+ * | +-----------+   |
+ * | : [link2]   :   |
+ * | + - - - - - +   |
+ * |                 |
+ * +-----------------+
+ */
+  app.get('/test3', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body><iframe src='/test3-frame'></body>
+</html">`);
+  });
+  app.get('/test3-frame', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>
+  <div><a href="link1">link1</a></div>
+  <div style="min-height:3000px"></div>
+  <div><a href="link2">link2</a></div>
+  </body>
+</html">`);
+  });
+
+  return app;
+};
+
+const waitForHints = async(webdriver: WebDriver): Promise<void> => {
+  await eventually(async() => {
+    let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+    assert.ok(hints.length > 0);
+  });
+};
+
+describe('follow test', () => {
+
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    if (http) {
+      http.close();
+    }
+  });
+
+  afterEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+  });
+
+  it('should focus an input by f', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/follow-input`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('f');
+    await waitForHints(webdriver);
+    await body.sendKeys('a');
+
+    let tagName = await webdriver.executeScript(() => document.activeElement!!.tagName) as string;
+    assert.equal(tagName.toLowerCase(), 'input');
+  });
+
+  it('should open a link by f', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('f');
+    await waitForHints(webdriver);
+    await body.sendKeys('a');
+
+    await eventually(async() => {
+      let hash = await webdriver.executeScript('return location.pathname');
+      assert.equal(hash, '/hello');
+    });
+  });
+
+  it('should focus an input by F', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/follow-input`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'f');
+    await waitForHints(webdriver);
+    await body.sendKeys('a');
+
+    let tagName = await webdriver.executeScript(() => document.activeElement!!.tagName) as string;
+    assert.equal(tagName.toLowerCase(), 'input');
+  });
+
+  it('should open a link to new tab by F', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'f');
+    await waitForHints(webdriver);
+    await body.sendKeys('a');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      assert.equal(new URL(tabs[1].url).pathname, '/hello');
+      assert.equal(tabs[1].openerTabId, tabs[0].id);
+    });
+  });
+
+  it('should show hints of links in area', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/area`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'f');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 3);
+    });
+  });
+
+  it('should shows hints only in viewport', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/test1`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'f');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 1);
+    });
+  });
+
+  it('should shows hints only in window of the frame', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/test2`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'f');
+
+    await webdriver.switchTo().frame(0);
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 1);
+    });
+  });
+
+  it('should shows hints only in the frame', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/test3`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'f');
+
+    await webdriver.switchTo().frame(0);
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 1);
+    });
+  });
+});
diff --git a/e2e/follow_properties.test.js b/e2e/follow_properties.test.js
deleted file mode 100644
index 5e22a40..0000000
--- a/e2e/follow_properties.test.js
+++ /dev/null
@@ -1,180 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const Console = require('./lib/Console');
-const { Builder } = require('lanthan');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body>
-    <a href="/">link1</a>
-    <a href="/">link2</a>
-    <a href="/">link3</a>
-    <a href="/">link4</a>
-    <a href="/">link5</a>
-  </body>
-</html">`);
-  });
-  return app;
-};
-
-const waitForHints = async(webdriver) => {
-  await eventually(async() => {
-    let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-    assert(hints.length > 0);
-  });
-};
-
-describe('follow properties test', () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-  let body;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-
-    await browser.storage.local.set({ settings: {
-      source: 'json',
-      json: `{
-        "keymaps": {
-          ":": { "type": "command.show" },
-          "f": { "type": "follow.start", "newTab": false },
-          "F": { "type": "follow.start", "newTab": true, "background": false },
-          "<C-F>": { "type": "follow.start", "newTab": true, "background": true }
-        },
-        "search": {
-          "default": "google",
-          "engines": { "google": "https://google.com/search?q={}" }
-        },
-        "properties": {
-          "hintchars": "jk"
-        }
-      }`,
-    }});
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    http.close();
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-  afterEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-  });
-
-  it('should show hints with hintchars by settings', async () => {
-    await body.sendKeys('f');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 5);
-
-      assert.equal(await hints[0].getText(), 'J');
-      assert.equal(await hints[1].getText(), 'K');
-      assert.equal(await hints[2].getText(), 'JJ');
-      assert.equal(await hints[3].getText(), 'JK');
-      assert.equal(await hints[4].getText(), 'KJ');
-    });
-
-    await body.sendKeys('j');
-
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-
-      assert.equal(await hints[0].getCssValue('display'), 'block');
-      assert.equal(await hints[1].getCssValue('display'), 'none');
-      assert.equal(await hints[2].getCssValue('display'), 'block');
-      assert.equal(await hints[3].getCssValue('display'), 'block');
-      assert.equal(await hints[4].getCssValue('display'), 'none');
-    });
-  });
-
-  it('should open tab in background by background:false', async () => {
-    await body.sendKeys(Key.SHIFT, 'f');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 5);
-    });
-    await body.sendKeys('jj');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs[0].active, false);
-      assert.equal(tabs[1].active, true);
-    });
-  });
-
-  it('should open tab in background by background:true', async () => {
-    await body.sendKeys(Key.CONTROL, 'f');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 5);
-    });
-    await body.sendKeys('jj');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs[0].active, true);
-      assert.equal(tabs[1].active, false);
-    });
-  });
-
-  it('should show hints with hintchars by settings', async () => {
-    let c = new Console(webdriver);
-
-    await body.sendKeys(':');
-    await webdriver.switchTo().frame(0);
-    await c.sendKeys('set hintchars=abc', Key.ENTER);
-    await new Promise(resolve => setTimeout(resolve, 100));
-    await webdriver.switchTo().parentFrame();
-
-    await body.sendKeys('f');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-      assert.equal(hints.length, 5);
-
-      assert.equal(await hints[0].getText(), 'A');
-      assert.equal(await hints[1].getText(), 'B');
-      assert.equal(await hints[2].getText(), 'C');
-      assert.equal(await hints[3].getText(), 'AA');
-      assert.equal(await hints[4].getText(), 'AB');
-    });
-
-    await body.sendKeys('a');
-    await eventually(async() => {
-      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
-
-      assert.equal(await hints[0].getCssValue('display'), 'block');
-      assert.equal(await hints[1].getCssValue('display'), 'none');
-      assert.equal(await hints[2].getCssValue('display'), 'none');
-      assert.equal(await hints[3].getCssValue('display'), 'block');
-      assert.equal(await hints[4].getCssValue('display'), 'block');
-    });
-  });
-});
diff --git a/e2e/follow_properties.test.ts b/e2e/follow_properties.test.ts
new file mode 100644
index 0000000..47556a2
--- /dev/null
+++ b/e2e/follow_properties.test.ts
@@ -0,0 +1,174 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+import { Console } from './lib/Console';
+
+const newApp = () => {
+  let app = express();
+
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body>
+    <a href="/">link1</a>
+    <a href="/">link2</a>
+    <a href="/">link3</a>
+    <a href="/">link4</a>
+    <a href="/">link5</a>
+  </body>
+</html">`);
+  });
+  return app;
+};
+
+describe('follow properties test', () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let body: WebElement;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+
+    await browser.storage.local.set({ settings: {
+      source: 'json',
+      json: `{
+        "keymaps": {
+          ":": { "type": "command.show" },
+          "f": { "type": "follow.start", "newTab": false },
+          "F": { "type": "follow.start", "newTab": true, "background": false },
+          "<C-F>": { "type": "follow.start", "newTab": true, "background": true }
+        },
+        "search": {
+          "default": "google",
+          "engines": { "google": "https://google.com/search?q={}" }
+        },
+        "properties": {
+          "hintchars": "jk"
+        }
+      }`,
+    }});
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    http.close();
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/`);
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+  afterEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+  });
+
+  it('should show hints with hintchars by settings', async () => {
+    await body.sendKeys('f');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 5);
+
+      assert.equal(await hints[0].getText(), 'J');
+      assert.equal(await hints[1].getText(), 'K');
+      assert.equal(await hints[2].getText(), 'JJ');
+      assert.equal(await hints[3].getText(), 'JK');
+      assert.equal(await hints[4].getText(), 'KJ');
+    });
+
+    await body.sendKeys('j');
+
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+
+      assert.equal(await hints[0].getCssValue('display'), 'block');
+      assert.equal(await hints[1].getCssValue('display'), 'none');
+      assert.equal(await hints[2].getCssValue('display'), 'block');
+      assert.equal(await hints[3].getCssValue('display'), 'block');
+      assert.equal(await hints[4].getCssValue('display'), 'none');
+    });
+  });
+
+  it('should open tab in background by background:false', async () => {
+    await body.sendKeys(Key.SHIFT, 'f');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 5);
+    });
+    await body.sendKeys('jj');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs[0].active, false);
+      assert.equal(tabs[1].active, true);
+    });
+  });
+
+  it('should open tab in background by background:true', async () => {
+    await body.sendKeys(Key.CONTROL, 'f');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 5);
+    });
+    await body.sendKeys('jj');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs[0].active, true);
+      assert.equal(tabs[1].active, false);
+    });
+  });
+
+  it('should show hints with hintchars by settings', async () => {
+    let c = new Console(webdriver);
+
+    await body.sendKeys(':');
+    await webdriver.switchTo().frame(0);
+    await c.sendKeys('set hintchars=abc', Key.ENTER);
+    await new Promise(resolve => setTimeout(resolve, 100));
+    await (webdriver.switchTo() as any).parentFrame();
+
+    await body.sendKeys('f');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+      assert.equal(hints.length, 5);
+
+      assert.equal(await hints[0].getText(), 'A');
+      assert.equal(await hints[1].getText(), 'B');
+      assert.equal(await hints[2].getText(), 'C');
+      assert.equal(await hints[3].getText(), 'AA');
+      assert.equal(await hints[4].getText(), 'AB');
+    });
+
+    await body.sendKeys('a');
+    await eventually(async() => {
+      let hints = await webdriver.findElements(By.css(`.vimvixen-hint`));
+
+      assert.equal(await hints[0].getCssValue('display'), 'block');
+      assert.equal(await hints[1].getCssValue('display'), 'none');
+      assert.equal(await hints[2].getCssValue('display'), 'none');
+      assert.equal(await hints[3].getCssValue('display'), 'block');
+      assert.equal(await hints[4].getCssValue('display'), 'block');
+    });
+  });
+});
diff --git a/e2e/lib/Console.js b/e2e/lib/Console.js
deleted file mode 100644
index 6016de1..0000000
--- a/e2e/lib/Console.js
+++ /dev/null
@@ -1,43 +0,0 @@
-const { By } = require('selenium-webdriver');
-
-class Console {
-  constructor(webdriver) {
-    this.webdriver = webdriver;
-  }
-
-  async sendKeys(...keys) {
-    let input = await this.webdriver.findElement(By.css('input'));
-    input.sendKeys(...keys);
-  }
-
-  async currentValue() {
-    return await this.webdriver.executeScript(() => {
-      let input = document.querySelector('input');
-      return input.value;
-    });
-  }
-
-  async getCompletions() {
-    return await this.webdriver.executeScript(() => {
-      let items = document.querySelectorAll('.vimvixen-console-completion > li');
-      if (items.length === 0) {
-        throw new Error('completion items not found');
-      }
-
-      let objs = [];
-      for (let li of items) {
-        if (li.classList.contains('vimvixen-console-completion-title')) {
-          objs.push({ type: 'title', text: li.textContent.trim() });
-        } else if ('vimvixen-console-completion-item') {
-          let highlight = li.classList.contains('vimvixen-completion-selected');
-          objs.push({ type: 'item', text: li.textContent.trim(), highlight });
-        } else {
-          throw new Error(`unexpected class: ${li.className}`);
-        }
-      }
-      return objs;
-    });
-  }
-}
-
-module.exports = Console;
diff --git a/e2e/lib/Console.ts b/e2e/lib/Console.ts
new file mode 100644
index 0000000..37b0597
--- /dev/null
+++ b/e2e/lib/Console.ts
@@ -0,0 +1,49 @@
+import { WebDriver, By } from 'selenium-webdriver';
+
+export type CompletionItem = {
+  type: string;
+  text: string;
+  highlight: boolean;
+}
+
+export class Console {
+  constructor(private webdriver: WebDriver) {
+  }
+
+  async sendKeys(...keys: string[]) {
+    let input = await this.webdriver.findElement(By.css('input'));
+    input.sendKeys(...keys);
+  }
+
+  async currentValue() {
+    return await this.webdriver.executeScript(() => {
+      let input = document.querySelector('input');
+      if (input === null) {
+        throw new Error('could not find input element');
+      }
+      return input.value;
+    });
+  }
+
+  getCompletions(): Promise<CompletionItem[]> {
+    return this.webdriver.executeScript(() => {
+      let items = document.querySelectorAll('.vimvixen-console-completion > li');
+      if (items.length === 0) {
+        throw new Error('completion items not found');
+      }
+
+      let objs = [];
+      for (let li of Array.from(items)) {
+        if (li.classList.contains('vimvixen-console-completion-title')) {
+          objs.push({ type: 'title', text: li.textContent!!.trim() });
+        } else if ('vimvixen-console-completion-item') {
+          let highlight = li.classList.contains('vimvixen-completion-selected');
+          objs.push({ type: 'item', text: li.textContent!!.trim(), highlight });
+        } else {
+          throw new Error(`unexpected class: ${li.className}`);
+        }
+      }
+      return objs;
+    });
+  }
+}
diff --git a/e2e/lib/clipboard.js b/e2e/lib/clipboard.js
deleted file mode 100644
index 4061dbd..0000000
--- a/e2e/lib/clipboard.js
+++ /dev/null
@@ -1,63 +0,0 @@
-'use strict';
-
-const { spawn } = require('child_process');
-
-const readLinux = () => {
-  let stdout = '', stderr = '';
-  return new Promise((resolve, reject) => {
-    let xsel = spawn('xsel', ['--clipboard', '--output']);
-    xsel.stdout.on('data', (data) => {
-      stdout += data;
-    });
-    xsel.stderr.on('data', (data) => {
-      stderr += data;
-    });
-    xsel.on('close', (code) => {
-      if (code !== 0) {
-        throw new Error(`xsel returns ${code}: ${stderr}`)
-      }
-      resolve(stdout);
-    });
-  });
-};
-
-const writeLinux = (data) => {
-  let stdout = '', stderr = '';
-  return new Promise((resolve, reject) => {
-    let xsel = spawn('xsel', ['--clipboard', '--input']);
-    xsel.stderr.on('data', (data) => {
-      stderr += data;
-    });
-    xsel.on('close', (code) => {
-      if (code !== 0) {
-        throw new Error(`xsel returns ${code}: ${stderr}`)
-      }
-      resolve();
-    });
-    xsel.stdin.write(data);
-    xsel.stdin.end();
-  });
-};
-
-const unsupported = (os) => {
-  return () => {
-    throw new Error(`Unsupported os: ${os}`);
-  };
-};
-
-const detect = () => {
-  switch (process.platform) {
-    case 'linux':
-      return {
-        read: readLinux,
-        write: writeLinux,
-      };
-    default:
-      return {
-        read: unsupported(process.platform),
-        write: unsupported(process.platform),
-      };
-  }
-}
-
-module.exports = detect();
diff --git a/e2e/lib/clipboard.ts b/e2e/lib/clipboard.ts
new file mode 100644
index 0000000..13d95df
--- /dev/null
+++ b/e2e/lib/clipboard.ts
@@ -0,0 +1,66 @@
+import { spawn } from 'child_process';
+
+const readLinux = (): Promise<string> => {
+  let stdout = '', stderr = '';
+  return new Promise((resolve) => {
+    let xsel = spawn('xsel', ['--clipboard', '--output']);
+    xsel.stdout.on('data', (data) => {
+      stdout += data;
+    });
+    xsel.stderr.on('data', (data) => {
+      stderr += data;
+    });
+    xsel.on('close', (code) => {
+      if (code !== 0) {
+        throw new Error(`xsel returns ${code}: ${stderr}`)
+      }
+      resolve(stdout);
+    });
+  });
+};
+
+const writeLinux = (data: string): Promise<string> => {
+  let stderr = '';
+  return new Promise((resolve) => {
+    let xsel = spawn('xsel', ['--clipboard', '--input']);
+    xsel.stderr.on('data', (data) => {
+      stderr += data;
+    });
+    xsel.on('close', (code) => {
+      if (code !== 0) {
+        throw new Error(`xsel returns ${code}: ${stderr}`)
+      }
+      resolve();
+    });
+    xsel.stdin.write(data);
+    xsel.stdin.end();
+  });
+};
+
+class UnsupportedError extends Error {
+  constructor(platform: string) {
+    super();
+    this.message = `Unsupported platform: ${platform}`;
+  }
+}
+
+const read = () => {
+  switch (process.platform) {
+  case 'linux':
+    return readLinux();
+  }
+  throw new UnsupportedError(process.platform);
+}
+
+const write = (data: string) => {
+  switch (process.platform) {
+  case 'linux':
+    return writeLinux(data);
+  }
+  throw new UnsupportedError(process.platform);
+}
+
+export {
+  read,
+  write,
+};
diff --git a/e2e/mark.test.js b/e2e/mark.test.js
deleted file mode 100644
index cc32c85..0000000
--- a/e2e/mark.test.js
+++ /dev/null
@@ -1,124 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body style="width:10000px; height:10000px"></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("mark test", () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    if (http) {
-      http.close();
-    }
-  });
-
-  it('should set a local mark and jump to it', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await webdriver.executeScript(() => window.scrollTo(200, 200));
-    await body.sendKeys('m', 'a');
-    await webdriver.executeScript(() => window.scrollTo(500, 500));
-    await body.sendKeys('\'', 'a');
-
-    await eventually(async() => {
-      let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-      assert.equal(pageXOffset, 200);
-      assert.equal(pageYOffset, 200);
-    });
-  });
-
-  it('should set a global mark and jump to it', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}#first`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await webdriver.executeScript(() => window.scrollTo(200, 200));
-    await body.sendKeys('m', 'A');
-    await webdriver.executeScript(() => window.scrollTo(500, 500));
-    await body.sendKeys('\'', 'A');
-
-    await eventually(async() => {
-      let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-      assert.equal(pageXOffset, 200);
-      assert.equal(pageYOffset, 200);
-    });
-
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}#second` });
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('\'', 'A');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({ active: true }))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.hash, '#first');
-
-      let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-      assert.equal(pageXOffset, 200);
-      assert.equal(pageYOffset, 200);
-    });
-  });
-
-  it('set a global mark and creates new tab from gone', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}#first`);
-    await webdriver.executeScript(() => window.scrollTo(500, 500));
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('m', 'A');
-
-    let tab = (await browser.tabs.query({ active: true }))[0];
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}#second` });
-    await browser.tabs.remove(tab.id);
-
-    let handles;
-    await eventually(async() => {
-      handles = await webdriver.getAllWindowHandles();
-      assert.equal(handles.length, 2);
-    });
-    await webdriver.switchTo().window(handles[0]);
-    await webdriver.navigate().to(`http://127.0.0.1:${port}#second`);
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('\'', 'A');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({ active: true }))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.hash, '#first');
-    });
-  });
-});
-
-
diff --git a/e2e/mark.test.ts b/e2e/mark.test.ts
new file mode 100644
index 0000000..14885ee
--- /dev/null
+++ b/e2e/mark.test.ts
@@ -0,0 +1,126 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body style="width:10000px; height:10000px"></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("mark test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    if (http) {
+      http.close();
+    }
+  });
+
+  it('should set a local mark and jump to it', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await webdriver.executeScript(() => window.scrollTo(200, 200));
+    await body.sendKeys('m', 'a');
+    await webdriver.executeScript(() => window.scrollTo(500, 500));
+    await body.sendKeys('\'', 'a');
+
+    await eventually(async() => {
+      let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
+      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+      assert.equal(pageXOffset, 200);
+      assert.equal(pageYOffset, 200);
+    });
+  });
+
+  it('should set a global mark and jump to it', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}#first`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await webdriver.executeScript(() => window.scrollTo(200, 200));
+    await body.sendKeys('m', 'A');
+    await webdriver.executeScript(() => window.scrollTo(500, 500));
+    await body.sendKeys('\'', 'A');
+
+    await eventually(async() => {
+      let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
+      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+      assert.equal(pageXOffset, 200);
+      assert.equal(pageYOffset, 200);
+    });
+
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}#second` });
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('\'', 'A');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({ active: true }))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.hash, '#first');
+
+      let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
+      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+      assert.equal(pageXOffset, 200);
+      assert.equal(pageYOffset, 200);
+    });
+  });
+
+  it('set a global mark and creates new tab from gone', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}#first`);
+    await webdriver.executeScript(() => window.scrollTo(500, 500));
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('m', 'A');
+
+    let tab = (await browser.tabs.query({ active: true }))[0];
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}#second` });
+    await browser.tabs.remove(tab.id);
+
+    let handles: string[];
+    await eventually(async() => {
+      handles = await webdriver.getAllWindowHandles();
+      await webdriver.getAllWindowHandles
+      assert.equal(handles.length, 2);
+    });
+    await webdriver.switchTo().window(handles!![0]);
+    await webdriver.navigate().to(`http://127.0.0.1:${port}#second`);
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('\'', 'A');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({ active: true }))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.hash, '#first');
+    });
+  });
+});
+
+
diff --git a/e2e/navigate.test.js b/e2e/navigate.test.js
deleted file mode 100644
index e4b8f69..0000000
--- a/e2e/navigate.test.js
+++ /dev/null
@@ -1,274 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { Options: FirefoxOptions } = require('selenium-webdriver/firefox');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/pagenation-a/:page', (req, res) => {
-    res.status(200).send(`
-<html lang="en">
-  <a href="/pagenation-a/${Number(req.params.page) - 1}">prev</a>
-  <a href="/pagenation-a/${Number(req.params.page) + 1}">next</a>
-</html">`);
-  });
-  app.get('/pagenation-link/:page', (req, res) => {
-    res.status(200).send(`
-<html lang="en">
-  <head>
-    <link rel="prev" href="/pagenation-link/${Number(req.params.page) - 1}"></link>
-    <link rel="next" href="/pagenation-link/${Number(req.params.page) + 1}"></link>
-  </head>
-</html">`);
-  });
-  app.get('/reload', (req, res) => {
-    res.status(200).send(`
-<html lang="en">
-  <head>
-    <script>window.location.hash = Date.now()</script>
-  </head>
-  <body style="width:10000px; height:10000px"></body>
-</html">`);
-  });
-
-  app.get('/*', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  ${req.path}
-</html">`);
-  });
-  return app;
-};
-
-describe("navigate test", () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  before(async() => {
-    let opts = new FirefoxOptions()
-      .setPreference('browser.startup.homepage', `http://127.0.0.1:${port}#home`);
-    http = newApp().listen(port);
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .setOptions(opts)
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    http.close();
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-  })
-
-  it('should go to parent path without hash by gu', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/a/b/c`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await body.sendKeys('g', 'u');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, `/a/b/`)
-    });
-  });
-
-  it('should remove hash by gu', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/a/b/c#hash`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await body.sendKeys('g', 'u');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.hash, '')
-      assert.equal(url.pathname, `/a/b/c`)
-    });
-  });
-
-  it('should go to root path by gU', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/a/b/c#hash`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await body.sendKeys('g', Key.SHIFT, 'u');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, `/`)
-    });
-  });
-
-  it('should go back and forward in history by H and L', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/first`);
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/second`);
-    let body = await webdriver.findElement(By.css('body'));
-
-    await body.sendKeys(Key.SHIFT, 'h');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, `/first`)
-    });
-
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'l');
-
-    await eventually(async() => {
-      tab = (await browser.tabs.query({}))[0];
-      url = new URL(tab.url);
-      assert.equal(url.pathname, `/second`)
-    });
-  });
-
-  it('should go previous and next page in <a> by [[ and ]]', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-a/10`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('[', '[');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, '/pagenation-a/9');
-    });
-  });
-
-  it('should go next page in <a> by ]]', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-a/10`);
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(']', ']');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, '/pagenation-a/11');
-    });
-  });
-
-  it('should go previous page in <link> by ]]', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-link/10`);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('[', '[');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, '/pagenation-link/9');
-    });
-  });
-
-  it('should go next page by in <link> by [[', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-link/10`);
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(']', ']');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.pathname, '/pagenation-link/11');
-    });
-  });
-
-  it('should go to home page into current tab by gh', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('g', 'h');
-
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      let url = new URL(tab.url);
-      assert.equal(url.hash, '#home');
-    });
-  });
-
-  it('should go to home page into current tab by gH', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('g', Key.SHIFT, 'H');
-
-    await eventually(async() => {
-      let tabs = await browser.tabs.query({});
-      assert.equal(tabs.length, 2);
-      assert.equal(new URL(tabs[0].url).hash, '');
-      assert.equal(new URL(tabs[1].url).hash, '#home');
-      assert.equal(tabs[1].active, true);
-    });
-  });
-
-  it('should reload current tab by r', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/reload`);
-    await webdriver.executeScript(() => window.scrollTo(500, 500));
-    let before
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      before = Number(new URL(tab.url).hash.split('#')[1]);
-      assert(before > 0);
-    });
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('r');
-
-    let after
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      after = Number(new URL(tab.url).hash.split('#')[1]);
-      assert(after > before);
-    });
-
-    await eventually(async() => {
-      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-      assert.equal(pageYOffset, 500);
-    });
-  });
-
-  it('should reload current tab without cache by R', async () => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}/reload`);
-    await webdriver.executeScript(() => window.scrollTo(500, 500));
-    let before
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      before = Number(new URL(tab.url).hash.split('#')[1]);
-      assert(before > 0);
-    });
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'R');
-
-    let after
-    await eventually(async() => {
-      let tab = (await browser.tabs.query({}))[0];
-      after = Number(new URL(tab.url).hash.split('#')[1]);
-      assert(after > before);
-    });
-
-    // assert that the page offset is reset to 0, and 'eventually' is timed-out.
-    await assert.rejects(async () => {
-      await eventually(async() => {
-        let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-        assert.equal(pageYOffset, 500);
-      });
-    });
-  });
-});
diff --git a/e2e/navigate.test.ts b/e2e/navigate.test.ts
new file mode 100644
index 0000000..4b664e4
--- /dev/null
+++ b/e2e/navigate.test.ts
@@ -0,0 +1,276 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+import { Options as FirefoxOptions } from 'selenium-webdriver/firefox';
+
+const newApp = () => {
+  let app = express();
+  app.get('/pagenation-a/:page', (req, res) => {
+    res.status(200).send(`
+<html lang="en">
+  <a href="/pagenation-a/${Number(req.params.page) - 1}">prev</a>
+  <a href="/pagenation-a/${Number(req.params.page) + 1}">next</a>
+</html">`);
+  });
+  app.get('/pagenation-link/:page', (req, res) => {
+    res.status(200).send(`
+<html lang="en">
+  <head>
+    <link rel="prev" href="/pagenation-link/${Number(req.params.page) - 1}"></link>
+    <link rel="next" href="/pagenation-link/${Number(req.params.page) + 1}"></link>
+  </head>
+</html">`);
+  });
+  app.get('/reload', (_req, res) => {
+    res.status(200).send(`
+<html lang="en">
+  <head>
+    <script>window.location.hash = Date.now()</script>
+  </head>
+  <body style="width:10000px; height:10000px"></body>
+</html">`);
+  });
+
+  app.get('/*', (req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  ${req.path}
+</html">`);
+  });
+  return app;
+};
+
+describe("navigate test", () => {
+
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    let opts = (new FirefoxOptions() as any)
+      .setPreference('browser.startup.homepage', `http://127.0.0.1:${port}#home`);
+    http = newApp().listen(port);
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .setOptions(opts)
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    http.close();
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+  })
+
+  it('should go to parent path without hash by gu', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/a/b/c`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await body.sendKeys('g', 'u');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, `/a/b/`)
+    });
+  });
+
+  it('should remove hash by gu', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/a/b/c#hash`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await body.sendKeys('g', 'u');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.hash, '')
+      assert.equal(url.pathname, `/a/b/c`)
+    });
+  });
+
+  it('should go to root path by gU', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/a/b/c#hash`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await body.sendKeys('g', Key.SHIFT, 'u');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, `/`)
+    });
+  });
+
+  it('should go back and forward in history by H and L', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/first`);
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/second`);
+    let body = await webdriver.findElement(By.css('body'));
+
+    await body.sendKeys(Key.SHIFT, 'h');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, `/first`)
+    });
+
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'l');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, `/second`)
+    });
+  });
+
+  it('should go previous and next page in <a> by [[ and ]]', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-a/10`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('[', '[');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, '/pagenation-a/9');
+    });
+  });
+
+  it('should go next page in <a> by ]]', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-a/10`);
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(']', ']');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, '/pagenation-a/11');
+    });
+  });
+
+  it('should go previous page in <link> by ]]', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-link/10`);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('[', '[');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, '/pagenation-link/9');
+    });
+  });
+
+  it('should go next page by in <link> by [[', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/pagenation-link/10`);
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(']', ']');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.pathname, '/pagenation-link/11');
+    });
+  });
+
+  it('should go to home page into current tab by gh', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('g', 'h');
+
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      let url = new URL(tab.url);
+      assert.equal(url.hash, '#home');
+    });
+  });
+
+  it('should go to home page into current tab by gH', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('g', Key.SHIFT, 'H');
+
+    await eventually(async() => {
+      let tabs = await browser.tabs.query({});
+      assert.equal(tabs.length, 2);
+      assert.equal(new URL(tabs[0].url).hash, '');
+      assert.equal(new URL(tabs[1].url).hash, '#home');
+      assert.equal(tabs[1].active, true);
+    });
+  });
+
+  it('should reload current tab by r', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/reload`);
+    await webdriver.executeScript(() => window.scrollTo(500, 500));
+    let before: number;
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      before = Number(new URL(tab.url).hash.split('#')[1]);
+      assert.ok(before > 0);
+    });
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('r');
+
+    let after
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      after = Number(new URL(tab.url).hash.split('#')[1]);
+      assert.ok(after > before);
+    });
+
+    await eventually(async() => {
+      let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+      assert.equal(pageYOffset, 500);
+    });
+  });
+
+  it('should reload current tab without cache by R', async () => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}/reload`);
+    await webdriver.executeScript(() => window.scrollTo(500, 500));
+    let before: number;
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      before = Number(new URL(tab.url).hash.split('#')[1]);
+      assert.ok(before > 0);
+    });
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'R');
+
+    let after
+    await eventually(async() => {
+      let tab = (await browser.tabs.query({}))[0];
+      after = Number(new URL(tab.url).hash.split('#')[1]);
+      assert.ok(after > before);
+    });
+
+    // assert that the page offset is reset to 0, and 'eventually' is timed-out.
+    await assert.rejects(async () => {
+      await eventually(async() => {
+        let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
+        assert.equal(pageYOffset, 500);
+      });
+    });
+  });
+});
diff --git a/e2e/options.test.js b/e2e/options.test.js
deleted file mode 100644
index 456c80b..0000000
--- a/e2e/options.test.js
+++ /dev/null
@@ -1,97 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body style="width:10000px; height:10000px"></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("options page", () => {
-  const port = 12321;
-  let http;
-  let lanthan;
-  let session;
-  let browser;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    if (http) {
-      http.close();
-    }
-  });
-
-  beforeEach(async() => {
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-  })
-
-  const updateTextarea = async(value) => {
-    let textarea = await webdriver.findElement(By.css('textarea'));
-    await webdriver.executeScript(`document.querySelector('textarea').value = '${value}'`)
-    await textarea.sendKeys(' ');
-    await webdriver.executeScript(() => document.querySelector('textarea').blur());
-  }
-
-  it('saves current config on blur', async () => {
-    let url = await browser.runtime.getURL("build/settings.html")
-    await webdriver.navigate().to(url);
-
-    await updateTextarea(`{ "blacklist": [ "https://example.com" ] }`);
-
-    let { settings } = await browser.storage.local.get('settings');
-    assert.equal(settings.source, 'json')
-    assert.equal(settings.json, '{ "blacklist": [ "https://example.com" ] } ')
-
-    await updateTextarea(`invalid json`);
-
-    settings = (await browser.storage.local.get('settings')).settings;
-    assert.equal(settings.source, 'json')
-    assert.equal(settings.json, '{ "blacklist": [ "https://example.com" ] } ')
-
-    let error = await webdriver.findElement(By.css('.settings-ui-input-error'));
-    let text = await error.getText();
-    assert.ok(text.startsWith('SyntaxError:'))
-  });
-
-  it('updates keymaps without reloading', async () => {
-    await browser.tabs.create({ url: `http://127.0.0.1:${port}`, active: false });
-    let url = await browser.runtime.getURL("build/settings.html")
-    await webdriver.navigate().to(url);
-
-    await updateTextarea(`{ "keymaps": { "zz": { "type": "scroll.vertically", "count": 10 } } }`);
-
-    let handles = await webdriver.getAllWindowHandles();
-    await webdriver.switchTo().window(handles[1]);
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('zz')
-
-    let y = await webdriver.executeScript(() => window.pageYOffset);
-    assert.equal(y, 640);
-  })
-});
diff --git a/e2e/options.test.ts b/e2e/options.test.ts
new file mode 100644
index 0000000..dba6992
--- /dev/null
+++ b/e2e/options.test.ts
@@ -0,0 +1,98 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body style="width:10000px; height:10000px"></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("options page", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    if (http) {
+      http.close();
+    }
+  });
+
+  beforeEach(async() => {
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+  })
+
+  const updateTextarea = async(value: string) => {
+    let textarea = await webdriver.findElement(By.css('textarea'));
+    await webdriver.executeScript(`document.querySelector('textarea').value = '${value}'`)
+    await textarea.sendKeys(' ');
+    await webdriver.executeScript(() => document.querySelector('textarea')!!.blur());
+  }
+
+  it('saves current config on blur', async () => {
+    let url = await browser.runtime.getURL("build/settings.html")
+    await webdriver.navigate().to(url);
+
+    await updateTextarea(`{ "blacklist": [ "https://example.com" ] }`);
+
+    let { settings } = await browser.storage.local.get('settings');
+    assert.equal(settings.source, 'json')
+    assert.equal(settings.json, '{ "blacklist": [ "https://example.com" ] } ')
+
+    await updateTextarea(`invalid json`);
+
+    settings = (await browser.storage.local.get('settings')).settings;
+    assert.equal(settings.source, 'json')
+    assert.equal(settings.json, '{ "blacklist": [ "https://example.com" ] } ')
+
+    let error = await webdriver.findElement(By.css('.settings-ui-input-error'));
+    let text = await error.getText();
+    assert.ok(text.startsWith('SyntaxError:'))
+  });
+
+  it('updates keymaps without reloading', async () => {
+    await browser.tabs.create({ url: `http://127.0.0.1:${port}`, active: false });
+    let url = await browser.runtime.getURL("build/settings.html")
+    await webdriver.navigate().to(url);
+
+    await updateTextarea(`{ "keymaps": { "zz": { "type": "scroll.vertically", "count": 10 } } }`);
+
+    let handles = await webdriver.getAllWindowHandles();
+    await webdriver.switchTo().window(handles[1]);
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('zz')
+
+    let y = await webdriver.executeScript(() => window.pageYOffset);
+    assert.equal(y, 640);
+  })
+});
diff --git a/e2e/options_form.test.js b/e2e/options_form.test.js
deleted file mode 100644
index 4f41738..0000000
--- a/e2e/options_form.test.js
+++ /dev/null
@@ -1,122 +0,0 @@
-const path = require('path');
-const assert = require('assert');
-const { Builder } = require('lanthan');
-const { By } = require('selenium-webdriver');
-
-describe("options form page", () => {
-  let lanthan;
-  let webdriver;
-  let browser;
-
-  beforeEach(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-
-    let tabs = await browser.tabs.query({});
-    for (let tab of tabs.slice(1)) {
-      await browser.tabs.remove(tab.id);
-    }
-  })
-
-  afterEach(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  })
-
-  const setBlacklistValue = async(nth, value) => {
-    let selector = '.form-blacklist-form .column-url';
-    let input = (await webdriver.findElements(By.css(selector)))[nth];
-    await input.sendKeys(value);
-    await webdriver.executeScript(`document.querySelectorAll('${selector}')[${nth}].blur()`);
-  }
-
-  const setSearchEngineValue = async(nth, name, url) => {
-    let selector = '.form-search-form input.column-name';
-    let input = (await webdriver.findElements(By.css(selector)))[nth];
-    await input.sendKeys(name);
-    await webdriver.executeScript(`document.querySelectorAll('${selector}')[${nth}].blur()`);
-
-    selector = '.form-search-form input.column-url';
-    input = (await webdriver.findElements(By.css(selector)))[nth];
-    await input.sendKeys(url);
-    await webdriver.executeScript(`document.querySelectorAll('${selector}')[${nth}].blur()`);
-  }
-
-  it('switch to form settings', async () => {
-    let url = await browser.runtime.getURL("build/settings.html")
-    await webdriver.navigate().to(url);
-
-    let useFormInput = await webdriver.findElement(By.css('#setting-source-form'));
-    await useFormInput.click();
-    await webdriver.switchTo().alert().accept();
-
-    let { settings } = await browser.storage.local.get('settings');
-    assert.equal(settings.source, 'form')
-  })
-
-  it('add blacklist', async () => {
-    let url = await browser.runtime.getURL("build/settings.html")
-    await webdriver.navigate().to(url);
-
-    let useFormInput = await webdriver.findElement(By.css('#setting-source-form'));
-    await useFormInput.click();
-    await webdriver.switchTo().alert().accept();
-    await webdriver.executeScript(() => window.scrollBy(0, 1000));
-
-    // assert default
-    let settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.blacklist, [])
-
-    // add blacklist items
-    let addButton = await webdriver.findElement(By.css('.form-blacklist-form .ui-add-button'))
-    await addButton.click();
-    await setBlacklistValue(0, 'google.com')
-
-    settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.blacklist, ['google.com'])
-
-    await addButton.click();
-    await setBlacklistValue(1, 'yahoo.com')
-
-    settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.blacklist, ['google.com', 'yahoo.com'])
-
-    // delete first item
-    let deleteButton = (await webdriver.findElements(By.css('.form-blacklist-form .ui-delete-button')))[0];
-    await deleteButton.click()
-
-    settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.blacklist, ['yahoo.com'])
-  });
-
-  it('add search engines', async () => {
-    let url = await browser.runtime.getURL("build/settings.html")
-    await webdriver.navigate().to(url);
-
-    let useFormInput = await webdriver.findElement(By.css('#setting-source-form'));
-    await useFormInput.click();
-    await webdriver.switchTo().alert().accept();
-
-    // assert default
-    let settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.search.default, 'google');
-
-    // change default
-    let radio = (await webdriver.findElements(By.css('.form-search-form input[type=radio]')))[2];
-    await radio.click();
-    settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.search.default, 'bing');
-
-    let addButton = await webdriver.findElement(By.css('.form-search-form .ui-add-button'))
-    await addButton.click();
-    await setSearchEngineValue(6, 'yippy', 'https://www.yippy.com/search?query={}');
-
-    settings = (await browser.storage.local.get('settings')).settings;
-    assert.deepEqual(settings.form.search.engines[6], ['yippy', 'https://www.yippy.com/search?query={}']);
-  });
-});
diff --git a/e2e/options_form.test.ts b/e2e/options_form.test.ts
new file mode 100644
index 0000000..04803da
--- /dev/null
+++ b/e2e/options_form.test.ts
@@ -0,0 +1,124 @@
+import * as path from 'path';
+import * as assert from 'assert';
+
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By } from 'selenium-webdriver';
+
+
+describe("options form page", () => {
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  beforeEach(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+
+    let tabs = await browser.tabs.query({});
+    for (let tab of tabs.slice(1)) {
+      await browser.tabs.remove(tab.id);
+    }
+  })
+
+  afterEach(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  })
+
+  const setBlacklistValue = async(nth: number, value: string) => {
+    let selector = '.form-blacklist-form .column-url';
+    let input = (await webdriver.findElements(By.css(selector)))[nth];
+    await input.sendKeys(value);
+    await webdriver.executeScript(`document.querySelectorAll('${selector}')[${nth}].blur()`);
+  }
+
+  const setSearchEngineValue = async(nth: number, name: string, url: string) => {
+    let selector = '.form-search-form input.column-name';
+    let input = (await webdriver.findElements(By.css(selector)))[nth];
+    await input.sendKeys(name);
+    await webdriver.executeScript(`document.querySelectorAll('${selector}')[${nth}].blur()`);
+
+    selector = '.form-search-form input.column-url';
+    input = (await webdriver.findElements(By.css(selector)))[nth];
+    await input.sendKeys(url);
+    await webdriver.executeScript(`document.querySelectorAll('${selector}')[${nth}].blur()`);
+  }
+
+  it('switch to form settings', async () => {
+    let url = await browser.runtime.getURL("build/settings.html")
+    await webdriver.navigate().to(url);
+
+    let useFormInput = await webdriver.findElement(By.css('#setting-source-form'));
+    await useFormInput.click();
+    await webdriver.switchTo().alert().accept();
+
+    let { settings } = await browser.storage.local.get('settings');
+    assert.equal(settings.source, 'form')
+  })
+
+  it('add blacklist', async () => {
+    let url = await browser.runtime.getURL("build/settings.html")
+    await webdriver.navigate().to(url);
+
+    let useFormInput = await webdriver.findElement(By.css('#setting-source-form'));
+    await useFormInput.click();
+    await webdriver.switchTo().alert().accept();
+    await webdriver.executeScript(() => window.scrollBy(0, 1000));
+
+    // assert default
+    let settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.blacklist, [])
+
+    // add blacklist items
+    let addButton = await webdriver.findElement(By.css('.form-blacklist-form .ui-add-button'))
+    await addButton.click();
+    await setBlacklistValue(0, 'google.com')
+
+    settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.blacklist, ['google.com'])
+
+    await addButton.click();
+    await setBlacklistValue(1, 'yahoo.com')
+
+    settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.blacklist, ['google.com', 'yahoo.com'])
+
+    // delete first item
+    let deleteButton = (await webdriver.findElements(By.css('.form-blacklist-form .ui-delete-button')))[0];
+    await deleteButton.click()
+
+    settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.blacklist, ['yahoo.com'])
+  });
+
+  it('add search engines', async () => {
+    let url = await browser.runtime.getURL("build/settings.html")
+    await webdriver.navigate().to(url);
+
+    let useFormInput = await webdriver.findElement(By.css('#setting-source-form'));
+    await useFormInput.click();
+    await webdriver.switchTo().alert().accept();
+
+    // assert default
+    let settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.search.default, 'google');
+
+    // change default
+    let radio = (await webdriver.findElements(By.css('.form-search-form input[type=radio]')))[2];
+    await radio.click();
+    settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.search.default, 'bing');
+
+    let addButton = await webdriver.findElement(By.css('.form-search-form .ui-add-button'))
+    await addButton.click();
+    await setSearchEngineValue(6, 'yippy', 'https://www.yippy.com/search?query={}');
+
+    settings = (await browser.storage.local.get('settings')).settings;
+    assert.deepEqual(settings.form.search.engines[6], ['yippy', 'https://www.yippy.com/search?query={}']);
+  });
+});
diff --git a/e2e/repeat.test.js b/e2e/repeat.test.js
deleted file mode 100644
index b068b18..0000000
--- a/e2e/repeat.test.js
+++ /dev/null
@@ -1,95 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send('ok');
-  });
-  return app;
-};
-
-describe("tab test", () => {
-
-  const port = 12321;
-  const url = `http://127.0.0.1:${port}/`;
-
-  let http;
-  let lanthan;
-  let webdriver
-  let browser;
-  let tabs;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    http = newApp().listen(port);
-
-    await webdriver.navigate().to(`${url}`);
-  });
-
-  after(async() => {
-    if (http) {
-      http.close();
-    }
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  it('repeats last operation', async () => {
-    let before = await browser.tabs.query({});
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(':');
-
-    await webdriver.switchTo().frame(0);
-    let input = await webdriver.findElement(By.css('input'));
-    input.sendKeys(`tabopen ${url}newtab`, Key.ENTER);
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({ url: `*://*/newtab` });
-      assert.equal(current.length, 1);
-    });
-
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('.');
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({ url: `*://*/newtab` });
-      assert.equal(current.length, 2);
-    });
-  });
-
-  it('repeats last operation', async () => {
-    for (let i = 1; i < 5; ++i) {
-      await browser.tabs.create({ url: `${url}#${i}` });
-    }
-    let before = await browser.tabs.query({});
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('d');
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({});
-      assert.equal(current.length,  before.length - 1);
-    });
-
-    await browser.tabs.update(before[2].id, { active: true });
-    body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('.');
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({});
-      assert.equal(current.length, before.length - 2);
-    });
-  });
-});
diff --git a/e2e/repeat.test.ts b/e2e/repeat.test.ts
new file mode 100644
index 0000000..2280ed8
--- /dev/null
+++ b/e2e/repeat.test.ts
@@ -0,0 +1,94 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send('ok');
+  });
+  return app;
+};
+
+describe("tab test", () => {
+  const port = 12321;
+  const url = `http://127.0.0.1:${port}/`;
+
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    http = newApp().listen(port);
+
+    await webdriver.navigate().to(`${url}`);
+  });
+
+  after(async() => {
+    if (http) {
+      http.close();
+    }
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  it('repeats last operation', async () => {
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(':');
+
+    await webdriver.switchTo().frame(0);
+    let input = await webdriver.findElement(By.css('input'));
+    input.sendKeys(`tabopen ${url}newtab`, Key.ENTER);
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({ url: `*://*/newtab` });
+      assert.equal(current.length, 1);
+    });
+
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('.');
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({ url: `*://*/newtab` });
+      assert.equal(current.length, 2);
+    });
+  });
+
+  it('repeats last operation', async () => {
+    for (let i = 1; i < 5; ++i) {
+      await browser.tabs.create({ url: `${url}#${i}` });
+    }
+    let before = await browser.tabs.query({});
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('d');
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({});
+      assert.equal(current.length,  before.length - 1);
+    });
+
+    await browser.tabs.update(before[2].id, { active: true });
+    body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('.');
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({});
+      assert.equal(current.length, before.length - 2);
+    });
+  });
+});
diff --git a/e2e/scroll.test.js b/e2e/scroll.test.js
deleted file mode 100644
index b728f47..0000000
--- a/e2e/scroll.test.js
+++ /dev/null
@@ -1,153 +0,0 @@
-const express = require('express');
-const path = require('path');
-const assert = require('assert');
-const { Builder } = require('lanthan');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send(`<!DOCTYPEhtml>
-<html lang="en">
-  <body style="width:10000px; height:10000px"></body>
-</html">`);
-  });
-  return app;
-};
-
-describe("scroll test", () => {
-
-  const port = 12321;
-  let http;
-  let lanthan;
-  let webdriver;
-  let body;
-
-  before(async() => {
-    http = newApp().listen(port);
-
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-  });
-
-  after(async() => {
-    if (lanthan) {
-      await lanthan.quit();
-    }
-    if (http) {
-      http.close();
-    }
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-
-  it('scrolls up by k', async () => {
-    await body.sendKeys('j');
-
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert.equal(pageYOffset, 64);
-  });
-
-  it('scrolls down by j', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 200));
-    await body.sendKeys('k');
-
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert.equal(pageYOffset, 136);
-  });
-
-  it('scrolls left by h', async () => {
-    await webdriver.executeScript(() => window.scrollTo(100, 100));
-    await body.sendKeys('h');
-
-    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-    assert.equal(pageXOffset, 36);
-  });
-
-  it('scrolls left by l', async () => {
-    await webdriver.executeScript(() => window.scrollTo(100, 100));
-    await body.sendKeys('l');
-
-    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-    assert.equal(pageXOffset, 164);
-  });
-
-  it('scrolls top by gg', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 100));
-    await body.sendKeys('g', 'g');
-
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert.equal(pageYOffset, 0);
-  });
-
-  it('scrolls bottom by G', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 100));
-    await body.sendKeys(Key.SHIFT, 'g');
-
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert(pageYOffset > 5000);
-  });
-
-  it('scrolls bottom by 0', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 100));
-    await body.sendKeys(Key.SHIFT, '0');
-
-    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-    assert(pageXOffset === 0);
-  });
-
-  it('scrolls bottom by $', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 100));
-    await body.sendKeys(Key.SHIFT, '$');
-
-    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset);
-    assert(pageXOffset > 5000);
-  });
-
-  it('scrolls bottom by <C-U>', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 1000));
-    await body.sendKeys(Key.CONTROL, 'u');
-
-    let pageHeight = 
-      await webdriver.executeScript(() => window.document.documentElement.clientHeight);
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert(Math.abs(pageYOffset - (1000 - Math.floor(pageHeight / 2))) < 5);
-  });
-
-  it('scrolls bottom by <C-D>', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 1000));
-    await body.sendKeys(Key.CONTROL, 'd');
-
-    let pageHeight = 
-      await webdriver.executeScript(() => window.document.documentElement.clientHeight);
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert(Math.abs(pageYOffset - (1000 + Math.floor(pageHeight / 2))) < 5);
-  });
-
-  it('scrolls bottom by <C-B>', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 1000));
-    await body.sendKeys(Key.CONTROL, 'b');
-
-    let pageHeight = 
-      await webdriver.executeScript(() => window.document.documentElement.clientHeight);
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert(Math.abs(pageYOffset - (1000 - pageHeight)) < 5);
-  });
-
-  it('scrolls bottom by <C-F>', async () => {
-    await webdriver.executeScript(() => window.scrollTo(0, 1000));
-    await body.sendKeys(Key.CONTROL, 'f');
-
-    let pageHeight = 
-      await webdriver.executeScript(() => window.document.documentElement.clientHeight);
-    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset);
-    assert(Math.abs(pageYOffset - (1000 + pageHeight)) < 5);
-  });
-});
diff --git a/e2e/scroll.test.ts b/e2e/scroll.test.ts
new file mode 100644
index 0000000..63ac8a8
--- /dev/null
+++ b/e2e/scroll.test.ts
@@ -0,0 +1,154 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send(`<!DOCTYPEhtml>
+<html lang="en">
+  <body style="width:10000px; height:10000px"></body>
+</html">`);
+  });
+  return app;
+};
+
+describe("scroll test", () => {
+  const port = 12321;
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let body: WebElement;
+
+  before(async() => {
+    http = newApp().listen(port);
+
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+  });
+
+  after(async() => {
+    if (lanthan) {
+      await lanthan.quit();
+    }
+    if (http) {
+      http.close();
+    }
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to(`http://127.0.0.1:${port}`);
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+
+  it('scrolls up by k', async () => {
+    await body.sendKeys('j');
+
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.equal(pageYOffset, 64);
+  });
+
+  it('scrolls down by j', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 200));
+    await body.sendKeys('k');
+
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.equal(pageYOffset, 136);
+  });
+
+  it('scrolls left by h', async () => {
+    await webdriver.executeScript(() => window.scrollTo(100, 100));
+    await body.sendKeys('h');
+
+    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset) as number;
+    assert.equal(pageXOffset, 36);
+  });
+
+  it('scrolls left by l', async () => {
+    await webdriver.executeScript(() => window.scrollTo(100, 100));
+    await body.sendKeys('l');
+
+    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset) as number;
+    assert.equal(pageXOffset, 164);
+  });
+
+  it('scrolls top by gg', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 100));
+    await body.sendKeys('g', 'g');
+
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.equal(pageYOffset, 0);
+  });
+
+  it('scrolls bottom by G', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 100));
+    await body.sendKeys(Key.SHIFT, 'g');
+
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.ok(pageYOffset > 5000);
+  });
+
+  it('scrolls bottom by 0', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 100));
+    await body.sendKeys(Key.SHIFT, '0');
+
+    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset) as number;
+    assert.ok(pageXOffset === 0);
+  });
+
+  it('scrolls bottom by $', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 100));
+    await body.sendKeys(Key.SHIFT, '$');
+
+    let pageXOffset = await webdriver.executeScript(() => window.pageXOffset) as number;
+    assert.ok(pageXOffset > 5000);
+  });
+
+  it('scrolls bottom by <C-U>', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 1000));
+    await body.sendKeys(Key.CONTROL, 'u');
+
+    let pageHeight = 
+      await webdriver.executeScript(() => window.document.documentElement.clientHeight) as number;
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.ok(Math.abs(pageYOffset - (1000 - Math.floor(pageHeight / 2))) < 5);
+  });
+
+  it('scrolls bottom by <C-D>', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 1000));
+    await body.sendKeys(Key.CONTROL, 'd');
+
+    let pageHeight = 
+      await webdriver.executeScript(() => window.document.documentElement.clientHeight) as number;
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.ok(Math.abs(pageYOffset - (1000 + Math.floor(pageHeight / 2))) < 5);
+  });
+
+  it('scrolls bottom by <C-B>', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 1000));
+    await body.sendKeys(Key.CONTROL, 'b');
+
+    let pageHeight = 
+      await webdriver.executeScript(() => window.document.documentElement.clientHeight) as number;
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.ok(Math.abs(pageYOffset - (1000 - pageHeight)) < 5);
+  });
+
+  it('scrolls bottom by <C-F>', async () => {
+    await webdriver.executeScript(() => window.scrollTo(0, 1000));
+    await body.sendKeys(Key.CONTROL, 'f');
+
+    let pageHeight = 
+      await webdriver.executeScript(() => window.document.documentElement.clientHeight) as number;
+    let pageYOffset = await webdriver.executeScript(() => window.pageYOffset) as number;
+    assert.ok(Math.abs(pageYOffset - (1000 + pageHeight)) < 5);
+  });
+});
diff --git a/e2e/settings.js b/e2e/settings.js
deleted file mode 100644
index e78add0..0000000
--- a/e2e/settings.js
+++ /dev/null
@@ -1,86 +0,0 @@
-module.exports = {
-  source: 'json',
-  json: `{
-  "keymaps": {
-    "0": { "type": "scroll.home" },
-    ":": { "type": "command.show" },
-    "o": { "type": "command.show.open", "alter": false },
-    "O": { "type": "command.show.open", "alter": true },
-    "t": { "type": "command.show.tabopen", "alter": false },
-    "T": { "type": "command.show.tabopen", "alter": true },
-    "w": { "type": "command.show.winopen", "alter": false },
-    "W": { "type": "command.show.winopen", "alter": true },
-    "b": { "type": "command.show.buffer" },
-    "a": { "type": "command.show.addbookmark", "alter": true },
-    "k": { "type": "scroll.vertically", "count": -1 },
-    "j": { "type": "scroll.vertically", "count": 1 },
-    "h": { "type": "scroll.horizonally", "count": -1 },
-    "l": { "type": "scroll.horizonally", "count": 1 },
-    "<C-U>": { "type": "scroll.pages", "count": -0.5 },
-    "<C-D>": { "type": "scroll.pages", "count": 0.5 },
-    "<C-B>": { "type": "scroll.pages", "count": -1 },
-    "<C-F>": { "type": "scroll.pages", "count": 1 },
-    "gg": { "type": "scroll.top" },
-    "G": { "type": "scroll.bottom" },
-    "$": { "type": "scroll.end" },
-    "d": { "type": "tabs.close" },
-    "D": { "type": "tabs.close", "select": "left" },
-    "x$": { "type": "tabs.close.right" },
-    "!d": { "type": "tabs.close.force" },
-    "u": { "type": "tabs.reopen" },
-    "K": { "type": "tabs.prev", "count": 1 },
-    "J": { "type": "tabs.next", "count": 1 },
-    "gT": { "type": "tabs.prev", "count": 1 },
-    "gt": { "type": "tabs.next", "count": 1 },
-    "g0": { "type": "tabs.first" },
-    "g$": { "type": "tabs.last" },
-    "<C-6>": { "type": "tabs.prevsel" },
-    "r": { "type": "tabs.reload", "cache": false },
-    "R": { "type": "tabs.reload", "cache": true },
-    "zp": { "type": "tabs.pin.toggle" },
-    "zd": { "type": "tabs.duplicate" },
-    "zi": { "type": "zoom.in" },
-    "zo": { "type": "zoom.out" },
-    "zz": { "type": "zoom.neutral" },
-    "f": { "type": "follow.start", "newTab": false },
-    "F": { "type": "follow.start", "newTab": true, "background": false },
-    "m": { "type": "mark.set.prefix" },
-    "'": { "type": "mark.jump.prefix" },
-    "H": { "type": "navigate.history.prev" },
-    "L": { "type": "navigate.history.next" },
-    "[[": { "type": "navigate.link.prev" },
-    "]]": { "type": "navigate.link.next" },
-    "gu": { "type": "navigate.parent" },
-    "gU": { "type": "navigate.root" },
-    "gi": { "type": "focus.input" },
-    "gf": { "type": "page.source" },
-    "gh": { "type": "page.home" },
-    "gH": { "type": "page.home", "newTab": true },
-    "y": { "type": "urls.yank" },
-    "p": { "type": "urls.paste", "newTab": false },
-    "P": { "type": "urls.paste", "newTab": true },
-    "/": { "type": "find.start" },
-    "n": { "type": "find.next" },
-    "N": { "type": "find.prev" },
-    "<S-Esc>": { "type": "addon.toggle.enabled" }
-  },
-  "search": {
-    "default": "google",
-    "engines": {
-      "google": "http://127.0.0.1:12321/google?q={}",
-      "yahoo": "http://127.0.0.1:12321/yahoo?q={}",
-      "bing": "http://127.0.0.1:12321/bind?q={}",
-      "duckduckgo": "http://127.0.0.1:12321/duplicate?q={}",
-      "twitter": "http://127.0.0.1:12321/twitter?q={}",
-      "wikipedia": "http://127.0.0.1:12321/wikipedia?q={}"
-    }
-  },
-  "properties": {
-    "hintchars": "abcdefghijklmnopqrstuvwxyz",
-    "smoothscroll": false,
-    "complete": "sbh"
-  },
-  "blacklist": [
-  ]
-}`,
-}
diff --git a/e2e/settings.ts b/e2e/settings.ts
new file mode 100644
index 0000000..b88caf0
--- /dev/null
+++ b/e2e/settings.ts
@@ -0,0 +1,86 @@
+export default {
+  source: 'json',
+  json: `{
+  "keymaps": {
+    "0": { "type": "scroll.home" },
+    ":": { "type": "command.show" },
+    "o": { "type": "command.show.open", "alter": false },
+    "O": { "type": "command.show.open", "alter": true },
+    "t": { "type": "command.show.tabopen", "alter": false },
+    "T": { "type": "command.show.tabopen", "alter": true },
+    "w": { "type": "command.show.winopen", "alter": false },
+    "W": { "type": "command.show.winopen", "alter": true },
+    "b": { "type": "command.show.buffer" },
+    "a": { "type": "command.show.addbookmark", "alter": true },
+    "k": { "type": "scroll.vertically", "count": -1 },
+    "j": { "type": "scroll.vertically", "count": 1 },
+    "h": { "type": "scroll.horizonally", "count": -1 },
+    "l": { "type": "scroll.horizonally", "count": 1 },
+    "<C-U>": { "type": "scroll.pages", "count": -0.5 },
+    "<C-D>": { "type": "scroll.pages", "count": 0.5 },
+    "<C-B>": { "type": "scroll.pages", "count": -1 },
+    "<C-F>": { "type": "scroll.pages", "count": 1 },
+    "gg": { "type": "scroll.top" },
+    "G": { "type": "scroll.bottom" },
+    "$": { "type": "scroll.end" },
+    "d": { "type": "tabs.close" },
+    "D": { "type": "tabs.close", "select": "left" },
+    "x$": { "type": "tabs.close.right" },
+    "!d": { "type": "tabs.close.force" },
+    "u": { "type": "tabs.reopen" },
+    "K": { "type": "tabs.prev", "count": 1 },
+    "J": { "type": "tabs.next", "count": 1 },
+    "gT": { "type": "tabs.prev", "count": 1 },
+    "gt": { "type": "tabs.next", "count": 1 },
+    "g0": { "type": "tabs.first" },
+    "g$": { "type": "tabs.last" },
+    "<C-6>": { "type": "tabs.prevsel" },
+    "r": { "type": "tabs.reload", "cache": false },
+    "R": { "type": "tabs.reload", "cache": true },
+    "zp": { "type": "tabs.pin.toggle" },
+    "zd": { "type": "tabs.duplicate" },
+    "zi": { "type": "zoom.in" },
+    "zo": { "type": "zoom.out" },
+    "zz": { "type": "zoom.neutral" },
+    "f": { "type": "follow.start", "newTab": false },
+    "F": { "type": "follow.start", "newTab": true, "background": false },
+    "m": { "type": "mark.set.prefix" },
+    "'": { "type": "mark.jump.prefix" },
+    "H": { "type": "navigate.history.prev" },
+    "L": { "type": "navigate.history.next" },
+    "[[": { "type": "navigate.link.prev" },
+    "]]": { "type": "navigate.link.next" },
+    "gu": { "type": "navigate.parent" },
+    "gU": { "type": "navigate.root" },
+    "gi": { "type": "focus.input" },
+    "gf": { "type": "page.source" },
+    "gh": { "type": "page.home" },
+    "gH": { "type": "page.home", "newTab": true },
+    "y": { "type": "urls.yank" },
+    "p": { "type": "urls.paste", "newTab": false },
+    "P": { "type": "urls.paste", "newTab": true },
+    "/": { "type": "find.start" },
+    "n": { "type": "find.next" },
+    "N": { "type": "find.prev" },
+    "<S-Esc>": { "type": "addon.toggle.enabled" }
+  },
+  "search": {
+    "default": "google",
+    "engines": {
+      "google": "http://127.0.0.1:12321/google?q={}",
+      "yahoo": "http://127.0.0.1:12321/yahoo?q={}",
+      "bing": "http://127.0.0.1:12321/bind?q={}",
+      "duckduckgo": "http://127.0.0.1:12321/duplicate?q={}",
+      "twitter": "http://127.0.0.1:12321/twitter?q={}",
+      "wikipedia": "http://127.0.0.1:12321/wikipedia?q={}"
+    }
+  },
+  "properties": {
+    "hintchars": "abcdefghijklmnopqrstuvwxyz",
+    "smoothscroll": false,
+    "complete": "sbh"
+  },
+  "blacklist": [
+  ]
+}`,
+};
diff --git a/e2e/tab.test.js b/e2e/tab.test.js
deleted file mode 100644
index 4e3a681..0000000
--- a/e2e/tab.test.js
+++ /dev/null
@@ -1,222 +0,0 @@
-const express = require('express');
-const lanthan = require('lanthan');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Builder } = require('lanthan');
-const { Key, By } = require('selenium-webdriver');
-
-const newApp = () => {
-  let app = express();
-  app.get('/', (req, res) => {
-    res.send('ok');
-  });
-  return app;
-};
-
-describe("tab test", () => {
-
-  const port = 12321;
-  const url = `http://127.0.0.1:${port}/`;
-
-  let http;
-  let lanthan;
-  let webdriver
-  let browser;
-  let win;
-  let tabs;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    http = newApp().listen(port);
-  });
-
-  after(async() => {
-    if (http) {
-      http.close();
-    }
-    if (lanthan) {
-      await lanthan.quit();
-    }
-  });
-
-  beforeEach(async() => {
-    win = await browser.windows.create({ url: `${url}#0` });
-    for (let i = 1; i < 5; ++i) {
-      await browser.tabs.create({ url: `${url}#${i}`, windowId: win.id });
-      await webdriver.navigate().to(`${url}#${i}`);
-    }
-    tabs = await browser.tabs.query({ windowId: win.id });
-    tabs.sort((t1, t2) => t1.index - t2.index);
-  });
-
-  afterEach(async() => {
-    await browser.windows.remove(win.id);
-  });
-
-  it('deletes tab and selects right by d', async () => {
-    await browser.tabs.update(tabs[3].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('d');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current.length === tabs.length - 1);
-    assert(current[3].active);
-    assert(current[3].url === tabs[4].url);
-  });
-
-  it('deletes tab and selects left by D', async () => {
-    await browser.tabs.update(tabs[3].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'D');
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({ windowId: win.id });
-      assert(current.length === tabs.length - 1);
-      assert(current[2].active);
-      assert(current[2].url === tabs[2].url);
-    })
-  });
-
-  it('deletes all tabs to the right by x$', async () => {
-    await browser.tabs.update(tabs[1].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('x', '$');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current.length === 2);
-  });
-
-  it('duplicates tab by zd', async () => {
-    await browser.tabs.update(tabs[0].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('z', 'd');
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({ windowId: win.id });
-      current.sort((t1, t2) => t1.index - t2.index);
-      assert(current.length === tabs.length + 1);
-      assert(current[0].url === current[1].url);
-    });
-  });
-
-  it('makes pinned by zp', async () => {
-    await browser.tabs.update(tabs[0].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('z', 'p');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[0].pinned);
-  });
-
-  it('selects previous tab by K', async () => {
-    await browser.tabs.update(tabs[2].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'K');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[1].active);
-  });
-
-  it('selects previous tab by K rotatory', async () => {
-    await browser.tabs.update(tabs[0].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'K');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[current.length - 1].active)
-  });
-
-  it('selects next tab by J', async () => {
-    await browser.tabs.update(tabs[2].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'J');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[3].active);
-  });
-
-  it('selects previous tab by J rotatory', async () => {
-    await browser.tabs.update(tabs[tabs.length - 1].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.SHIFT, 'J');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[0].active)
-  });
-
-  it('selects first tab by g0', async () => {
-    await browser.tabs.update(tabs[2].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('g', '0');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[0].active)
-  });
-
-  it('selects last tab by g$', async () => {
-    await browser.tabs.update(tabs[2].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('g', '$');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[current.length - 1].active)
-  });
-
-  it('selects last selected tab by <C-6>', async () => {
-    await browser.tabs.update(tabs[1].id, { active: true });
-    await browser.tabs.update(tabs[4].id, { active: true });
-
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys(Key.CONTROL, '6');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current[1].active)
-  });
-
-  // browser.sessions.getRecentlyClosed() sometime throws "An unexpected error occurred"
-  // This might be a bug in Firefox.
-  it.skip('reopen tab by u', async () => {
-    await browser.tabs.remove(tabs[1].id);
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('u');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current.length === tabs.length);
-  });
-
-  it('does not delete pinned tab by d', async () => {
-    await browser.tabs.update(tabs[0].id, { active: true, pinned: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('d');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current.length === tabs.length);
-  });
-
-  it('deletes pinned tab by !d', async () => {
-    await browser.tabs.update(tabs[0].id, { active: true, pinned: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('!', 'd');
-
-    let current = await browser.tabs.query({ windowId: win.id });
-    assert(current.length === tabs.length - 1);
-  });
-
-  it('opens view-source by gf', async () => {
-    await browser.tabs.update(tabs[0].id, { active: true });
-    let body = await webdriver.findElement(By.css('body'));
-    await body.sendKeys('g', 'f');
-
-    await eventually(async() => {
-      let current = await browser.tabs.query({ windowId: win.id });
-      assert(current.length === tabs.length + 1);
-      assert(current[current.length - 1].url === `view-source:${url}#0`);
-    });
-  });
-});
diff --git a/e2e/tab.test.ts b/e2e/tab.test.ts
new file mode 100644
index 0000000..c75541b
--- /dev/null
+++ b/e2e/tab.test.ts
@@ -0,0 +1,222 @@
+import express from 'express';
+import * as path from 'path';
+import * as assert from 'assert';
+import * as http from 'http';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, By, Key } from 'selenium-webdriver';
+
+const newApp = () => {
+  let app = express();
+  app.get('/', (_req, res) => {
+    res.send('ok');
+  });
+  return app;
+};
+
+describe("tab test", () => {
+  const port = 12321;
+  const url = `http://127.0.0.1:${port}/`;
+
+  let http: http.Server;
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let win: any;
+  let tabs: any[];
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    http = newApp().listen(port);
+  });
+
+  after(async() => {
+    if (http) {
+      http.close();
+    }
+    if (lanthan) {
+      await lanthan.quit();
+    }
+  });
+
+  beforeEach(async() => {
+    win = await browser.windows.create({ url: `${url}#0` });
+    for (let i = 1; i < 5; ++i) {
+      await browser.tabs.create({ url: `${url}#${i}`, windowId: win.id });
+      await webdriver.navigate().to(`${url}#${i}`);
+    }
+    tabs = await browser.tabs.query({ windowId: win.id });
+    tabs.sort((t1: any, t2: any) => t1.index - t2.index);
+  });
+
+  afterEach(async() => {
+    await browser.windows.remove(win.id);
+  });
+
+  it('deletes tab and selects right by d', async () => {
+    await browser.tabs.update(tabs[3].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('d');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current.length === tabs.length - 1);
+    assert.ok(current[3].active);
+    assert.ok(current[3].url === tabs[4].url);
+  });
+
+  it('deletes tab and selects left by D', async () => {
+    await browser.tabs.update(tabs[3].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'D');
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({ windowId: win.id });
+      assert.ok(current.length === tabs.length - 1);
+      assert.ok(current[2].active);
+      assert.ok(current[2].url === tabs[2].url);
+    })
+  });
+
+  it('deletes all tabs to the right by x$', async () => {
+    await browser.tabs.update(tabs[1].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('x', '$');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current.length === 2);
+  });
+
+  it('duplicates tab by zd', async () => {
+    await browser.tabs.update(tabs[0].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('z', 'd');
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({ windowId: win.id });
+      current.sort((t1: any, t2: any) => t1.index - t2.index);
+      assert.ok(current.length === tabs.length + 1);
+      assert.ok(current[0].url === current[1].url);
+    });
+  });
+
+  it('makes pinned by zp', async () => {
+    await browser.tabs.update(tabs[0].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('z', 'p');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[0].pinned);
+  });
+
+  it('selects previous tab by K', async () => {
+    await browser.tabs.update(tabs[2].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'K');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[1].active);
+  });
+
+  it('selects previous tab by K rotatory', async () => {
+    await browser.tabs.update(tabs[0].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'K');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[current.length - 1].active)
+  });
+
+  it('selects next tab by J', async () => {
+    await browser.tabs.update(tabs[2].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'J');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[3].active);
+  });
+
+  it('selects previous tab by J rotatory', async () => {
+    await browser.tabs.update(tabs[tabs.length - 1].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.SHIFT, 'J');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[0].active)
+  });
+
+  it('selects first tab by g0', async () => {
+    await browser.tabs.update(tabs[2].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('g', '0');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[0].active)
+  });
+
+  it('selects last tab by g$', async () => {
+    await browser.tabs.update(tabs[2].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('g', '$');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[current.length - 1].active)
+  });
+
+  it('selects last selected tab by <C-6>', async () => {
+    await browser.tabs.update(tabs[1].id, { active: true });
+    await browser.tabs.update(tabs[4].id, { active: true });
+
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys(Key.CONTROL, '6');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current[1].active)
+  });
+
+  // browser.sessions.getRecentlyClosed() sometime throws "An unexpected error occurred"
+  // This might be a bug in Firefox.
+  it.skip('reopen tab by u', async () => {
+    await browser.tabs.remove(tabs[1].id);
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('u');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current.length === tabs.length);
+  });
+
+  it('does not delete pinned tab by d', async () => {
+    await browser.tabs.update(tabs[0].id, { active: true, pinned: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('d');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current.length === tabs.length);
+  });
+
+  it('deletes pinned tab by !d', async () => {
+    await browser.tabs.update(tabs[0].id, { active: true, pinned: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('!', 'd');
+
+    let current = await browser.tabs.query({ windowId: win.id });
+    assert.ok(current.length === tabs.length - 1);
+  });
+
+  it('opens view-source by gf', async () => {
+    await browser.tabs.update(tabs[0].id, { active: true });
+    let body = await webdriver.findElement(By.css('body'));
+    await body.sendKeys('g', 'f');
+
+    await eventually(async() => {
+      let current = await browser.tabs.query({ windowId: win.id });
+      assert.ok(current.length === tabs.length + 1);
+      assert.ok(current[current.length - 1].url === `view-source:${url}#0`);
+    });
+  });
+});
diff --git a/e2e/zoom.test.js b/e2e/zoom.test.js
deleted file mode 100644
index c11ed1e..0000000
--- a/e2e/zoom.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-const express = require('express');
-const { Builder } = require('lanthan');
-const path = require('path');
-const assert = require('assert');
-const eventually = require('./eventually');
-const { Key, By } = require('selenium-webdriver');
-
-describe("zoom test", () => {
-  let lanthan;
-  let webdriver;
-  let browser;
-  let tab;
-  let body;
-
-  before(async() => {
-    lanthan = await Builder
-      .forBrowser('firefox')
-      .spyAddon(path.join(__dirname, '..'))
-      .build();
-    webdriver = lanthan.getWebDriver();
-    browser = lanthan.getWebExtBrowser();
-    tab = (await browser.tabs.query({}))[0]
-  });
-
-  after(async() => {
-    await lanthan.quit();
-  });
-
-  beforeEach(async() => {
-    await webdriver.navigate().to('about:blank');
-    body = await webdriver.findElement(By.css('body'));
-  });
-
-  it('should zoom in by zi', async () => {
-    let before = await browser.tabs.getZoom(tab.id);
-    await body.sendKeys('z', 'i');
-
-    await eventually(async() => {
-      let actual = await browser.tabs.getZoom(tab.id);
-      assert(before < actual);
-    });
-  });
-
-  it('should zoom out by zo', async () => {
-    let before = await browser.tabs.getZoom(tab.id);
-    await body.sendKeys('z', 'o');
-
-    await eventually(async() => {
-      let actual = await browser.tabs.getZoom(tab.id);
-      assert(before > actual);
-    });
-  });
-
-  it('scrolls left by h', async () => {
-    await browser.tabs.setZoom(tab.id, 2);
-    await body.sendKeys('z', 'z');
-
-    await eventually(async() => {
-      let actual = await browser.tabs.getZoom(tab.id);
-      assert(actual === 1);
-    });
-  });
-});
-
diff --git a/e2e/zoom.test.ts b/e2e/zoom.test.ts
new file mode 100644
index 0000000..0b55a4d
--- /dev/null
+++ b/e2e/zoom.test.ts
@@ -0,0 +1,65 @@
+import * as path from 'path';
+import * as assert from 'assert';
+
+import eventually from './eventually';
+import { Builder, Lanthan } from 'lanthan';
+import { WebDriver, WebElement, By } from 'selenium-webdriver';
+
+
+describe("zoom test", () => {
+  let lanthan: Lanthan;
+  let webdriver: WebDriver;
+  let browser: any;
+  let tab: any;
+  let body: WebElement;
+
+  before(async() => {
+    lanthan = await Builder
+      .forBrowser('firefox')
+      .spyAddon(path.join(__dirname, '..'))
+      .build();
+    webdriver = lanthan.getWebDriver();
+    browser = lanthan.getWebExtBrowser();
+    tab = (await browser.tabs.query({}))[0]
+  });
+
+  after(async() => {
+    await lanthan.quit();
+  });
+
+  beforeEach(async() => {
+    await webdriver.navigate().to('about:blank');
+    body = await webdriver.findElement(By.css('body'));
+  });
+
+  it('should zoom in by zi', async () => {
+    let before = await browser.tabs.getZoom(tab.id);
+    await body.sendKeys('z', 'i');
+
+    await eventually(async() => {
+      let actual = await browser.tabs.getZoom(tab.id);
+      assert.ok(before < actual);
+    });
+  });
+
+  it('should zoom out by zo', async () => {
+    let before = await browser.tabs.getZoom(tab.id);
+    await body.sendKeys('z', 'o');
+
+    await eventually(async() => {
+      let actual = await browser.tabs.getZoom(tab.id);
+      assert.ok(before > actual);
+    });
+  });
+
+  it('scrolls left by h', async () => {
+    await browser.tabs.setZoom(tab.id, 2);
+    await body.sendKeys('z', 'z');
+
+    await eventually(async() => {
+      let actual = await browser.tabs.getZoom(tab.id);
+      assert.ok(actual === 1);
+    });
+  });
+});
+
-- 
cgit v1.2.3