Use plugin:prettier/recommended

7 files changed, 345 insertions, 275 deletions

diff --git a/test/content/usecases/AddonEnabledUseCase.test.ts b/test/content/usecases/AddonEnabledUseCase.test.ts
index 8c15099..885da83 100644
--- a/test/content/usecases/AddonEnabledUseCase.test.ts
+++ b/test/content/usecases/AddonEnabledUseCase.test.ts
@@ -1,7 +1,7 @@
-import AddonEnabledRepository from '../../../src/content/repositories/AddonEnabledRepository';
-import AddonEnabledUseCase from '../../../src/content/usecases/AddonEnabledUseCase';
-import AddonIndicatorClient from '../../../src/content/client/AddonIndicatorClient';
-import { expect } from 'chai';
+import AddonEnabledRepository from "../../../src/content/repositories/AddonEnabledRepository";
+import AddonEnabledUseCase from "../../../src/content/usecases/AddonEnabledUseCase";
+import AddonIndicatorClient from "../../../src/content/client/AddonIndicatorClient";
+import { expect } from "chai";
 
 class MockAddonEnabledRepository implements AddonEnabledRepository {
   private enabled: boolean;
@@ -28,11 +28,11 @@ class MockAddonIndicatorClient implements AddonIndicatorClient {
 
   async setEnabled(enabled: boolean): Promise<void> {
     this.enabled = enabled;
-    return
+    return;
   }
 }
 
-describe('AddonEnabledUseCase', () => {
+describe("AddonEnabledUseCase", () => {
   let repository: MockAddonEnabledRepository;
   let indicator: MockAddonIndicatorClient;
   let sut: AddonEnabledUseCase;
@@ -43,8 +43,8 @@ describe('AddonEnabledUseCase', () => {
     sut = new AddonEnabledUseCase(indicator, repository);
   });
 
-  describe('#enable', () => {
-    it('store and indicate as enabled', async() => {
+  describe("#enable", () => {
+    it("store and indicate as enabled", async () => {
       await sut.enable();
 
       expect(repository.get()).to.be.true;
@@ -52,8 +52,8 @@ describe('AddonEnabledUseCase', () => {
     });
   });
 
-  describe('#disable', async() => {
-    it('store and indicate as disabled', async() => {
+  describe("#disable", async () => {
+    it("store and indicate as disabled", async () => {
       await sut.disable();
 
       expect(repository.get()).to.be.false;
@@ -61,8 +61,8 @@ describe('AddonEnabledUseCase', () => {
     });
   });
 
-  describe('#toggle', () => {
-    it('toggled enabled and disabled', async() => {
+  describe("#toggle", () => {
+    it("toggled enabled and disabled", async () => {
       repository.set(true);
       await sut.toggle();
 
@@ -78,8 +78,8 @@ describe('AddonEnabledUseCase', () => {
     });
   });
 
-  describe('#getEnabled', () => {
-    it('returns current addon enabled', () => {
+  describe("#getEnabled", () => {
+    it("returns current addon enabled", () => {
       repository.set(true);
       expect(sut.getEnabled()).to.be.true;
 
diff --git a/test/content/usecases/ClipboardUseCase.test.ts b/test/content/usecases/ClipboardUseCase.test.ts
index 3cc82fe..5de3e69 100644
--- a/test/content/usecases/ClipboardUseCase.test.ts
+++ b/test/content/usecases/ClipboardUseCase.test.ts
@@ -1,14 +1,14 @@
-import ClipboardRepository from '../../../src/content/repositories/ClipboardRepository';
-import { SettingRepositoryImpl } from '../../../src/content/repositories/SettingRepository';
-import ClipboardUseCase from '../../../src/content/usecases/ClipboardUseCase';
-import OperationClient from '../../../src/content/client/OperationClient';
-import ConsoleClient from '../../../src/content/client/ConsoleClient';
+import ClipboardRepository from "../../../src/content/repositories/ClipboardRepository";
+import { SettingRepositoryImpl } from "../../../src/content/repositories/SettingRepository";
+import ClipboardUseCase from "../../../src/content/usecases/ClipboardUseCase";
+import OperationClient from "../../../src/content/client/OperationClient";
+import ConsoleClient from "../../../src/content/client/ConsoleClient";
 
-import * as sinon from 'sinon';
-import { expect } from 'chai';
-import {Operation} from "../../../src/shared/operations";
+import * as sinon from "sinon";
+import { expect } from "chai";
+import { Operation } from "../../../src/shared/operations";
 
-describe('ClipboardUseCase', () => {
+describe("ClipboardUseCase", () => {
   let clipboardRepository: ClipboardRepository;
 
   let operationClient: OperationClient;
@@ -18,34 +18,48 @@ describe('ClipboardUseCase', () => {
   let sut: ClipboardUseCase;
 
   beforeEach(() => {
-    clipboardRepository = new class implements ClipboardRepository {
-      read(): string { return ""; }
+    clipboardRepository = new (class implements ClipboardRepository {
+      read(): string {
+        return "";
+      }
       write(_text: string) {}
-    };
-    operationClient = new class implements OperationClient {
-      execBackgroundOp(_repeat: number, _op: Operation): Promise<void> { return Promise.resolve() }
-      internalOpenUrl(_url: string, _newTab?: boolean, _background?: boolean): Promise<void> { return Promise.resolve() }
-    };
-    consoleClient = new class implements ConsoleClient {
-      error(_text: string): Promise<void> { return Promise.resolve() }
-      info(_text: string): Promise<void> { return Promise.resolve() }
-    };
+    })();
+    operationClient = new (class implements OperationClient {
+      execBackgroundOp(_repeat: number, _op: Operation): Promise<void> {
+        return Promise.resolve();
+      }
+      internalOpenUrl(
+        _url: string,
+        _newTab?: boolean,
+        _background?: boolean
+      ): Promise<void> {
+        return Promise.resolve();
+      }
+    })();
+    consoleClient = new (class implements ConsoleClient {
+      error(_text: string): Promise<void> {
+        return Promise.resolve();
+      }
+      info(_text: string): Promise<void> {
+        return Promise.resolve();
+      }
+    })();
 
     sut = new ClipboardUseCase(
       clipboardRepository,
       new SettingRepositoryImpl(),
       consoleClient,
-      operationClient,
-   );
+      operationClient
+    );
   });
 
-  describe('#yankCurrentURL', () => {
-    it('yanks current url', async () => {
+  describe("#yankCurrentURL", () => {
+    it("yanks current url", async () => {
       const href = window.location.href;
       const mockRepository = sinon.mock(clipboardRepository);
-      mockRepository.expects('write').withArgs(href);
+      mockRepository.expects("write").withArgs(href);
       const mockConsoleClient = sinon.mock(consoleClient);
-      mockConsoleClient.expects('info').withArgs('Yanked ' + href);
+      mockConsoleClient.expects("info").withArgs("Yanked " + href);
 
       const yanked = await sut.yankCurrentURL();
 
@@ -55,23 +69,23 @@ describe('ClipboardUseCase', () => {
     });
   });
 
-  describe('#openOrSearch', () => {
-    it('opens url from the clipboard', async () => {
-      const url = 'https://github.com/ueokande/vim-vixen'
-      sinon.stub(clipboardRepository, 'read').returns(url);
+  describe("#openOrSearch", () => {
+    it("opens url from the clipboard", async () => {
+      const url = "https://github.com/ueokande/vim-vixen";
+      sinon.stub(clipboardRepository, "read").returns(url);
       const mockOperationClient = sinon.mock(operationClient);
-      mockOperationClient.expects('internalOpenUrl').withArgs(url, true);
+      mockOperationClient.expects("internalOpenUrl").withArgs(url, true);
 
       await sut.openOrSearch(true);
 
       mockOperationClient.verify();
     });
 
-    it('opens search results from the clipboard', async () => {
-      const url = 'https://google.com/search?q=banana';
-      sinon.stub(clipboardRepository, 'read').returns('banana');
+    it("opens search results from the clipboard", async () => {
+      const url = "https://google.com/search?q=banana";
+      sinon.stub(clipboardRepository, "read").returns("banana");
       const mockOperationClient = sinon.mock(operationClient);
-      mockOperationClient.expects('internalOpenUrl').withArgs(url, true);
+      mockOperationClient.expects("internalOpenUrl").withArgs(url, true);
 
       await sut.openOrSearch(true);
 
diff --git a/test/content/usecases/FindUseCase.test.ts b/test/content/usecases/FindUseCase.test.ts
index 3978dbc..b53ef74 100644
--- a/test/content/usecases/FindUseCase.test.ts
+++ b/test/content/usecases/FindUseCase.test.ts
@@ -1,9 +1,9 @@
-import FindRepository from '../../../src/content/repositories/FindRepository';
-import FindPresenter from '../../../src/content/presenters/FindPresenter';
-import FindClient from '../../../src/content/client/FindClient';
-import FindUseCase from '../../../src/content/usecases/FindUseCase';
-import MockConsoleClient from '../mock/MockConsoleClient';
-import { expect } from 'chai';
+import FindRepository from "../../../src/content/repositories/FindRepository";
+import FindPresenter from "../../../src/content/presenters/FindPresenter";
+import FindClient from "../../../src/content/client/FindClient";
+import FindUseCase from "../../../src/content/usecases/FindUseCase";
+import MockConsoleClient from "../mock/MockConsoleClient";
+import { expect } from "chai";
 
 class MockFindRepository implements FindRepository {
   public keyword: string | null;
@@ -27,7 +27,7 @@ class MockFindPresenter implements FindPresenter {
   public highlighted: boolean;
 
   constructor() {
-    this.document = '';
+    this.document = "";
     this.highlighted = false;
   }
 
@@ -59,7 +59,7 @@ class MockFindClient implements FindClient {
   }
 }
 
-describe('FindUseCase', () => {
+describe("FindUseCase", () => {
   let repository: MockFindRepository;
   let presenter: MockFindPresenter;
   let client: MockFindClient;
@@ -74,88 +74,87 @@ describe('FindUseCase', () => {
     sut = new FindUseCase(presenter, repository, client, consoleClient);
   });
 
-  describe('#startFind', () => {
-    it('find next by ketword', async() => {
-      presenter.document = 'monkey punch';
+  describe("#startFind", () => {
+    it("find next by ketword", async () => {
+      presenter.document = "monkey punch";
 
-      await sut.startFind('monkey');
+      await sut.startFind("monkey");
 
       expect(await presenter.highlighted).to.be.true;
-      expect(await consoleClient.text).to.equal('Pattern found: monkey');
-      expect(await repository.getLastKeyword()).to.equal('monkey');
-      expect(await client.getGlobalLastKeyword()).to.equal('monkey');
+      expect(await consoleClient.text).to.equal("Pattern found: monkey");
+      expect(await repository.getLastKeyword()).to.equal("monkey");
+      expect(await client.getGlobalLastKeyword()).to.equal("monkey");
     });
 
-    it('find next by last keyword', async() => {
-      presenter.document = 'gorilla kick';
-      repository.keyword = 'gorilla';
+    it("find next by last keyword", async () => {
+      presenter.document = "gorilla kick";
+      repository.keyword = "gorilla";
 
       await sut.startFind(undefined);
 
       expect(await presenter.highlighted).to.be.true;
-      expect(await consoleClient.text).to.equal('Pattern found: gorilla');
-      expect(await repository.getLastKeyword()).to.equal('gorilla');
-      expect(await client.getGlobalLastKeyword()).to.equal('gorilla');
+      expect(await consoleClient.text).to.equal("Pattern found: gorilla");
+      expect(await repository.getLastKeyword()).to.equal("gorilla");
+      expect(await client.getGlobalLastKeyword()).to.equal("gorilla");
     });
 
-    it('find next by global last keyword', async() => {
-      presenter.document = 'chimpanzee typing';
+    it("find next by global last keyword", async () => {
+      presenter.document = "chimpanzee typing";
 
       repository.keyword = null;
-      client.keyword = 'chimpanzee';
+      client.keyword = "chimpanzee";
 
       await sut.startFind(undefined);
 
       expect(await presenter.highlighted).to.be.true;
-      expect(await consoleClient.text).to.equal('Pattern found: chimpanzee');
-      expect(await repository.getLastKeyword()).to.equal('chimpanzee');
-      expect(await client.getGlobalLastKeyword()).to.equal('chimpanzee');
+      expect(await consoleClient.text).to.equal("Pattern found: chimpanzee");
+      expect(await repository.getLastKeyword()).to.equal("chimpanzee");
+      expect(await client.getGlobalLastKeyword()).to.equal("chimpanzee");
     });
 
-    it('find not found error', async() => {
-      presenter.document = 'zoo';
+    it("find not found error", async () => {
+      presenter.document = "zoo";
 
-      await sut.startFind('giraffe');
+      await sut.startFind("giraffe");
 
       expect(await presenter.highlighted).to.be.false;
-      expect(await consoleClient.text).to.equal('Pattern not found: giraffe');
-      expect(await repository.getLastKeyword()).to.equal('giraffe');
-      expect(await client.getGlobalLastKeyword()).to.equal('giraffe');
+      expect(await consoleClient.text).to.equal("Pattern not found: giraffe");
+      expect(await repository.getLastKeyword()).to.equal("giraffe");
+      expect(await client.getGlobalLastKeyword()).to.equal("giraffe");
     });
 
-    it('show errors when no last keywords', async() => {
+    it("show errors when no last keywords", async () => {
       repository.keyword = null;
       client.keyword = null;
 
       await sut.startFind(undefined);
 
-      expect(await consoleClient.text).to.equal('No previous search keywords');
+      expect(await consoleClient.text).to.equal("No previous search keywords");
       expect(await consoleClient.isError).to.be.true;
     });
   });
 
-  describe('#findNext', () => {
-    it('finds by last keyword', async() => {
-      presenter.document = 'monkey punch';
-      repository.keyword = 'monkey';
+  describe("#findNext", () => {
+    it("finds by last keyword", async () => {
+      presenter.document = "monkey punch";
+      repository.keyword = "monkey";
 
       await sut.findNext();
 
       expect(await presenter.highlighted).to.be.true;
-      expect(await consoleClient.text).to.equal('Pattern found: monkey');
+      expect(await consoleClient.text).to.equal("Pattern found: monkey");
     });
 
-    it('show errors when no last keywords', async() => {
+    it("show errors when no last keywords", async () => {
       repository.keyword = null;
       client.keyword = null;
 
       await sut.findNext();
 
-      expect(await consoleClient.text).to.equal('No previous search keywords');
+      expect(await consoleClient.text).to.equal("No previous search keywords");
       expect(await consoleClient.isError).to.be.true;
     });
   });
 
-  describe('#findPrev', () => {
-  });
+  describe("#findPrev", () => {});
 });
diff --git a/test/content/usecases/HintKeyProducer.test.ts b/test/content/usecases/HintKeyProducer.test.ts
index 5841ae9..f7e02ea 100644
--- a/test/content/usecases/HintKeyProducer.test.ts
+++ b/test/content/usecases/HintKeyProducer.test.ts
@@ -1,20 +1,34 @@
-import HintKeyProducer from '../../../src/content/usecases/HintKeyProducer';
-import { expect } from 'chai';
+import HintKeyProducer from "../../../src/content/usecases/HintKeyProducer";
+import { expect } from "chai";
 
-describe('HintKeyProducer class', () => {
-  describe('#constructor', () => {
-    it('throws an exception on empty charset', () => {
-      expect(() => new HintKeyProducer('')).to.throw(TypeError);
+describe("HintKeyProducer class", () => {
+  describe("#constructor", () => {
+    it("throws an exception on empty charset", () => {
+      expect(() => new HintKeyProducer("")).to.throw(TypeError);
     });
   });
 
-  describe('#produce', () => {
-    it('produce incremented keys', () => {
-      const charset = 'abc';
+  describe("#produce", () => {
+    it("produce incremented keys", () => {
+      const charset = "abc";
       const sequences = [
-        'a', 'b', 'c',
-        'aa', 'ab', 'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc',
-        'aaa', 'aab', 'aac', 'aba']
+        "a",
+        "b",
+        "c",
+        "aa",
+        "ab",
+        "ac",
+        "ba",
+        "bb",
+        "bc",
+        "ca",
+        "cb",
+        "cc",
+        "aaa",
+        "aab",
+        "aac",
+        "aba",
+      ];
 
       const producer = new HintKeyProducer(charset);
       for (let i = 0; i < sequences.length; ++i) {
diff --git a/test/content/usecases/KeymapUseCase.test.ts b/test/content/usecases/KeymapUseCase.test.ts
index 032d4fc..24ac6d8 100644
--- a/test/content/usecases/KeymapUseCase.test.ts
+++ b/test/content/usecases/KeymapUseCase.test.ts
@@ -1,62 +1,52 @@
 import "reflect-metadata";
-import KeymapUseCase from '../../../src/content/usecases/KeymapUseCase';
-import {expect} from 'chai';
+import KeymapUseCase from "../../../src/content/usecases/KeymapUseCase";
+import { expect } from "chai";
 import SettingRepository from "../../../src/content/repositories/SettingRepository";
 import Settings from "../../../src/shared/settings/Settings";
 import AddonEnabledRepository from "../../../src/content/repositories/AddonEnabledRepository";
-import {KeymapRepositoryImpl} from "../../../src/content/repositories/KeymapRepository";
+import { KeymapRepositoryImpl } from "../../../src/content/repositories/KeymapRepository";
 import Key from "../../../src/shared/settings/Key";
 import AddressRepository from "../../../src/content/repositories/AddressRepository";
 
 class MockSettingRepository implements SettingRepository {
-  constructor(
-    private readonly settings: Settings,
-  ) {
-  }
+  constructor(private readonly settings: Settings) {}
 
   get(): Settings {
     return this.settings;
   }
 
   set(_setting: Settings): void {
-    throw new Error('TODO');
+    throw new Error("TODO");
   }
 }
 
 class MockAddonEnabledRepository implements AddonEnabledRepository {
-  constructor(
-    private readonly enabled: boolean,
-  ) {
-  }
+  constructor(private readonly enabled: boolean) {}
 
   get(): boolean {
     return this.enabled;
   }
 
   set(_on: boolean): void {
-    throw new Error('TODO');
+    throw new Error("TODO");
   }
 }
 
 class MockAddressRepository implements AddressRepository {
-  constructor(
-    private url: URL,
-  ) {
-  }
+  constructor(private url: URL) {}
 
   getCurrentURL(): URL {
     return this.url;
   }
 }
 
-
-describe('KeymapUseCase', () => {
-  context('with no-digis keymaps', () => {
+describe("KeymapUseCase", () => {
+  context("with no-digis keymaps", () => {
     const settings = Settings.fromJSON({
       keymaps: {
-        k: {type: 'scroll.vertically', count: -1},
-        j: {type: 'scroll.vertically', count: 1},
-        gg: {type: 'scroll.top'},
+        k: { type: "scroll.vertically", count: -1 },
+        j: { type: "scroll.vertically", count: 1 },
+        gg: { type: "scroll.top" },
       },
     });
 
@@ -64,34 +54,46 @@ describe('KeymapUseCase', () => {
 
     before(() => {
       sut = new KeymapUseCase(
-          new KeymapRepositoryImpl(),
-          new MockSettingRepository(settings),
-          new MockAddonEnabledRepository(true),
-          new MockAddressRepository(new URL('https://example.com')),
+        new KeymapRepositoryImpl(),
+        new MockSettingRepository(settings),
+        new MockAddonEnabledRepository(true),
+        new MockAddressRepository(new URL("https://example.com"))
       );
     });
 
-    it('returns matched operation', () => {
-      expect(sut.nextOps(Key.fromMapKey('k'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.vertically', count: -1}});
-      expect(sut.nextOps(Key.fromMapKey('j'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.vertically', count: 1}});
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.top'}});
-      expect(sut.nextOps(Key.fromMapKey('z'))).to.be.null;
+    it("returns matched operation", () => {
+      expect(sut.nextOps(Key.fromMapKey("k"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.vertically", count: -1 },
+      });
+      expect(sut.nextOps(Key.fromMapKey("j"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.vertically", count: 1 },
+      });
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.top" },
+      });
+      expect(sut.nextOps(Key.fromMapKey("z"))).to.be.null;
     });
 
-    it('repeats n-times by numeric prefix and multiple key operations', () => {
-      expect(sut.nextOps(Key.fromMapKey('1'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('0'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.deep.equal({ repeat: 10, op: {type: "scroll.top"}});
+    it("repeats n-times by numeric prefix and multiple key operations", () => {
+      expect(sut.nextOps(Key.fromMapKey("1"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("0"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.deep.equal({
+        repeat: 10,
+        op: { type: "scroll.top" },
+      });
     });
   });
 
-  context('when keymaps containing numeric mappings', () => {
+  context("when keymaps containing numeric mappings", () => {
     const settings = Settings.fromJSON({
       keymaps: {
-        20: {type: "scroll.top"},
-        g5: {type: 'scroll.bottom'},
+        20: { type: "scroll.top" },
+        g5: { type: "scroll.bottom" },
       },
     });
 
@@ -99,43 +101,55 @@ describe('KeymapUseCase', () => {
 
     before(() => {
       sut = new KeymapUseCase(
-          new KeymapRepositoryImpl(),
-          new MockSettingRepository(settings),
-          new MockAddonEnabledRepository(true),
-          new MockAddressRepository(new URL('https://example.com')),
+        new KeymapRepositoryImpl(),
+        new MockSettingRepository(settings),
+        new MockAddonEnabledRepository(true),
+        new MockAddressRepository(new URL("https://example.com"))
       );
     });
 
-    it('returns the matched operation ends with digit', () => {
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('5'))).to.be.deep.equal({ repeat: 1, op: { type: 'scroll.bottom'}});
+    it("returns the matched operation ends with digit", () => {
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("5"))).to.be.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.bottom" },
+      });
     });
 
-    it('returns an operation matched the operation with digit keymaps', () => {
-      expect(sut.nextOps(Key.fromMapKey('2'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('0'))).to.be.deep.equal({ repeat: 1, op: { type: 'scroll.top'}});
+    it("returns an operation matched the operation with digit keymaps", () => {
+      expect(sut.nextOps(Key.fromMapKey("2"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("0"))).to.be.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.top" },
+      });
     });
 
-    it('returns operations repeated by numeric prefix', () => {
-      expect(sut.nextOps(Key.fromMapKey('2'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('5'))).to.be.deep.equal({ repeat: 2, op: { type: 'scroll.bottom'}});
+    it("returns operations repeated by numeric prefix", () => {
+      expect(sut.nextOps(Key.fromMapKey("2"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("5"))).to.be.deep.equal({
+        repeat: 2,
+        op: { type: "scroll.bottom" },
+      });
     });
 
-    it('does not matches with digit operation with numeric prefix', () => {
-      expect(sut.nextOps(Key.fromMapKey('3'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('2'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('0'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('5'))).to.be.deep.equal({ repeat: 320, op: { type: 'scroll.bottom'}});
+    it("does not matches with digit operation with numeric prefix", () => {
+      expect(sut.nextOps(Key.fromMapKey("3"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("2"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("0"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("5"))).to.be.deep.equal({
+        repeat: 320,
+        op: { type: "scroll.bottom" },
+      });
     });
   });
 
-  context('when the keys are mismatched with the operations', () => {
+  context("when the keys are mismatched with the operations", () => {
     const settings = Settings.fromJSON({
       keymaps: {
-        gg: {type: "scroll.top"},
-        G: {type: "scroll.bottom"},
+        gg: { type: "scroll.top" },
+        G: { type: "scroll.bottom" },
       },
     });
 
@@ -143,38 +157,44 @@ describe('KeymapUseCase', () => {
 
     before(() => {
       sut = new KeymapUseCase(
-          new KeymapRepositoryImpl(),
-          new MockSettingRepository(settings),
-          new MockAddonEnabledRepository(true),
-          new MockAddressRepository(new URL('https://example.com')),
+        new KeymapRepositoryImpl(),
+        new MockSettingRepository(settings),
+        new MockAddonEnabledRepository(true),
+        new MockAddressRepository(new URL("https://example.com"))
       );
     });
 
-    it('clears input keys with no-matched operations', () => {
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('x'))).to.be.null; // clear
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.deep.equal({repeat: 1, op: {type: "scroll.top"}});
+    it("clears input keys with no-matched operations", () => {
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("x"))).to.be.null; // clear
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.top" },
+      });
     });
 
-    it('clears input keys and the prefix with no-matched operations', () => {
-      expect(sut.nextOps(Key.fromMapKey('1'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('0'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('x'))).to.be.null;   // clear
-      expect(sut.nextOps(Key.fromMapKey('1'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('0'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.deep.equal({ repeat: 10, op: {type: "scroll.top"}});
+    it("clears input keys and the prefix with no-matched operations", () => {
+      expect(sut.nextOps(Key.fromMapKey("1"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("0"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("x"))).to.be.null; // clear
+      expect(sut.nextOps(Key.fromMapKey("1"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("0"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.deep.equal({
+        repeat: 10,
+        op: { type: "scroll.top" },
+      });
     });
   });
 
-  context('when the site matches to the blacklist', () => {
+  context("when the site matches to the blacklist", () => {
     const settings = Settings.fromJSON({
       keymaps: {
-        k: {type: 'scroll.vertically', count: -1},
-        a: {type: 'addon.enable'},
-        b: {type: 'addon.toggle.enabled'},
+        k: { type: "scroll.vertically", count: -1 },
+        a: { type: "addon.enable" },
+        b: { type: "addon.toggle.enabled" },
       },
     });
 
@@ -182,58 +202,76 @@ describe('KeymapUseCase', () => {
 
     before(() => {
       sut = new KeymapUseCase(
-          new KeymapRepositoryImpl(),
-          new MockSettingRepository(settings),
-          new MockAddonEnabledRepository(false),
-          new MockAddressRepository(new URL('https://example.com')),
+        new KeymapRepositoryImpl(),
+        new MockSettingRepository(settings),
+        new MockAddonEnabledRepository(false),
+        new MockAddressRepository(new URL("https://example.com"))
       );
     });
 
-    it('returns only ADDON_ENABLE and ADDON_TOGGLE_ENABLED operation', () => {
-      expect(sut.nextOps(Key.fromMapKey('k'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('a'))).to.deep.equal({ repeat: 1, op: {type: 'addon.enable'}});
-      expect(sut.nextOps(Key.fromMapKey('b'))).to.deep.equal({ repeat: 1, op: {type: 'addon.toggle.enabled'}});
+    it("returns only ADDON_ENABLE and ADDON_TOGGLE_ENABLED operation", () => {
+      expect(sut.nextOps(Key.fromMapKey("k"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("a"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "addon.enable" },
+      });
+      expect(sut.nextOps(Key.fromMapKey("b"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "addon.toggle.enabled" },
+      });
     });
   });
 
-  context('when the site matches to the partial blacklist', () => {
+  context("when the site matches to the partial blacklist", () => {
     const settings = Settings.fromJSON({
       keymaps: {
-        k: {type: 'scroll.vertically', count: -1},
-        j: {type: 'scroll.vertically', count: 1},
-        gg: {type: "scroll.top"},
-        G: {type: "scroll.bottom"},
+        k: { type: "scroll.vertically", count: -1 },
+        j: { type: "scroll.vertically", count: 1 },
+        gg: { type: "scroll.top" },
+        G: { type: "scroll.bottom" },
       },
       blacklist: [
-        { url: "example.com", keys: ['g'] },
-        { url: "example.org", keys: ['<S-G>'] }
+        { url: "example.com", keys: ["g"] },
+        { url: "example.org", keys: ["<S-G>"] },
       ],
     });
 
-    it('blocks keys in the partial blacklist', () => {
+    it("blocks keys in the partial blacklist", () => {
       let sut = new KeymapUseCase(
-          new KeymapRepositoryImpl(),
-          new MockSettingRepository(settings),
-          new MockAddonEnabledRepository(true),
-          new MockAddressRepository(new URL('https://example.com')),
+        new KeymapRepositoryImpl(),
+        new MockSettingRepository(settings),
+        new MockAddonEnabledRepository(true),
+        new MockAddressRepository(new URL("https://example.com"))
       );
 
-      expect(sut.nextOps(Key.fromMapKey('k'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.vertically', count: -1}});
-      expect(sut.nextOps(Key.fromMapKey('j'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.vertically', count: 1}});
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('G'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.bottom'}});
+      expect(sut.nextOps(Key.fromMapKey("k"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.vertically", count: -1 },
+      });
+      expect(sut.nextOps(Key.fromMapKey("j"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.vertically", count: 1 },
+      });
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("G"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.bottom" },
+      });
 
       sut = new KeymapUseCase(
-          new KeymapRepositoryImpl(),
-          new MockSettingRepository(settings),
-          new MockAddonEnabledRepository(true),
-          new MockAddressRepository(new URL('https://example.org')),
+        new KeymapRepositoryImpl(),
+        new MockSettingRepository(settings),
+        new MockAddonEnabledRepository(true),
+        new MockAddressRepository(new URL("https://example.org"))
       );
 
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.be.null;
-      expect(sut.nextOps(Key.fromMapKey('g'))).to.deep.equal({ repeat: 1, op: {type: 'scroll.top'}});
-      expect(sut.nextOps(Key.fromMapKey('G'))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.be.null;
+      expect(sut.nextOps(Key.fromMapKey("g"))).to.deep.equal({
+        repeat: 1,
+        op: { type: "scroll.top" },
+      });
+      expect(sut.nextOps(Key.fromMapKey("G"))).to.be.null;
     });
   });
 });
diff --git a/test/content/usecases/MarkUseCase.test.ts b/test/content/usecases/MarkUseCase.test.ts
index 494497a..df3f7bf 100644
--- a/test/content/usecases/MarkUseCase.test.ts
+++ b/test/content/usecases/MarkUseCase.test.ts
@@ -1,14 +1,14 @@
-import MarkRepository from '../../../src/content/repositories/MarkRepository';
-import { SettingRepositoryImpl } from '../../../src/content/repositories/SettingRepository';
-import MarkUseCase from '../../../src/content/usecases/MarkUseCase';
-import MarkClient from '../../../src/content/client/MarkClient';
-import MockConsoleClient from '../mock/MockConsoleClient';
-import MockScrollPresenter from '../mock/MockScrollPresenter';
-import Mark from '../../../src/content/domains/Mark';
-import { expect } from 'chai';
+import MarkRepository from "../../../src/content/repositories/MarkRepository";
+import { SettingRepositoryImpl } from "../../../src/content/repositories/SettingRepository";
+import MarkUseCase from "../../../src/content/usecases/MarkUseCase";
+import MarkClient from "../../../src/content/client/MarkClient";
+import MockConsoleClient from "../mock/MockConsoleClient";
+import MockScrollPresenter from "../mock/MockScrollPresenter";
+import Mark from "../../../src/content/domains/Mark";
+import { expect } from "chai";
 
 class MockMarkRepository implements MarkRepository {
-  private current: {[key: string]: Mark};
+  private current: { [key: string]: Mark };
 
   constructor() {
     this.current = {};
@@ -24,12 +24,12 @@ class MockMarkRepository implements MarkRepository {
 }
 
 class MockMarkClient implements MarkClient {
-  public marks: {[key: string]: Mark};
+  public marks: { [key: string]: Mark };
   public last: string;
 
   constructor() {
     this.marks = {};
-    this.last = '';
+    this.last = "";
   }
 
   setGloablMark(key: string, mark: Mark): Promise<void> {
@@ -38,12 +38,12 @@ class MockMarkClient implements MarkClient {
   }
 
   jumpGlobalMark(key: string): Promise<void> {
-    this.last = key
+    this.last = key;
     return Promise.resolve();
   }
 }
 
-describe('MarkUseCase', () => {
+describe("MarkUseCase", () => {
   let repository: MockMarkRepository;
   let client: MockMarkClient;
   let consoleClient: MockConsoleClient;
@@ -60,53 +60,56 @@ describe('MarkUseCase', () => {
       client,
       repository,
       new SettingRepositoryImpl(),
-      consoleClient,
+      consoleClient
     );
   });
 
-  describe('#set', () => {
-    it('sets local mark', async() => {
+  describe("#set", () => {
+    it("sets local mark", async () => {
       scrollPresenter.scrollTo(10, 20, false);
 
-      await sut.set('x');
+      await sut.set("x");
 
-      expect(repository.get('x')).to.deep.equals({ x: 10, y: 20 });
+      expect(repository.get("x")).to.deep.equals({ x: 10, y: 20 });
       expect(consoleClient.text).to.equal("Set local mark to 'x'");
     });
 
-    it('sets global mark', async() => {
+    it("sets global mark", async () => {
       scrollPresenter.scrollTo(30, 40, false);
 
-      await sut.set('Z');
+      await sut.set("Z");
 
-      expect(client.marks['Z']).to.deep.equals({ x: 30, y: 40 });
+      expect(client.marks["Z"]).to.deep.equals({ x: 30, y: 40 });
       expect(consoleClient.text).to.equal("Set global mark to 'Z'");
     });
   });
 
-  describe('#jump', () => {
-    it('jumps to local mark', async() => {
-      repository.set('x', { x: 20, y: 40 });
+  describe("#jump", () => {
+    it("jumps to local mark", async () => {
+      repository.set("x", { x: 20, y: 40 });
 
-      await sut.jump('x');
+      await sut.jump("x");
 
       expect(scrollPresenter.getScroll()).to.deep.equals({ x: 20, y: 40 });
     });
 
-    it('throws an error when no local marks', () => {
-      return sut.jump('a').then(() => {
-        throw new Error('error');
-      }).catch((e) => {
-        expect(e).to.be.instanceof(Error);
-      })
-    })
+    it("throws an error when no local marks", () => {
+      return sut
+        .jump("a")
+        .then(() => {
+          throw new Error("error");
+        })
+        .catch((e) => {
+          expect(e).to.be.instanceof(Error);
+        });
+    });
 
-    it('jumps to global mark', async() => {
-      client.marks['Z'] = { x: 20, y: 0 };
+    it("jumps to global mark", async () => {
+      client.marks["Z"] = { x: 20, y: 0 };
 
-      await sut.jump('Z');
+      await sut.jump("Z");
 
-      expect(client.last).to.equal('Z')
+      expect(client.last).to.equal("Z");
     });
   });
 });
diff --git a/test/content/usecases/SettingUseCaase.test.ts b/test/content/usecases/SettingUseCaase.test.ts
index cf14e6e..19a167a 100644
--- a/test/content/usecases/SettingUseCaase.test.ts
+++ b/test/content/usecases/SettingUseCaase.test.ts
@@ -1,8 +1,10 @@
-import SettingRepository from '../../../src/content/repositories/SettingRepository';
-import SettingClient from '../../../src/content/client/SettingClient';
-import SettingUseCase from '../../../src/content/usecases/SettingUseCase';
-import Settings, { DefaultSetting } from '../../../src/shared/settings/Settings';
-import { expect } from 'chai';
+import SettingRepository from "../../../src/content/repositories/SettingRepository";
+import SettingClient from "../../../src/content/client/SettingClient";
+import SettingUseCase from "../../../src/content/usecases/SettingUseCase";
+import Settings, {
+  DefaultSetting,
+} from "../../../src/shared/settings/Settings";
+import { expect } from "chai";
 
 class MockSettingRepository implements SettingRepository {
   private current: Settings;
@@ -12,7 +14,7 @@ class MockSettingRepository implements SettingRepository {
   }
 
   set(settings: Settings): void {
-    this.current= settings;
+    this.current = settings;
   }
 
   get(): Settings {
@@ -32,7 +34,7 @@ class MockSettingClient implements SettingClient {
   }
 }
 
-describe('AddonEnabledUseCase', () => {
+describe("AddonEnabledUseCase", () => {
   let repository: MockSettingRepository;
   let client: MockSettingClient;
   let sut: SettingUseCase;
@@ -41,15 +43,15 @@ describe('AddonEnabledUseCase', () => {
     const testSettings = {
       keymaps: {},
       search: {
-        default: 'google',
+        default: "google",
         engines: {
-          google: 'https://google.com/?q={}',
-        }
+          google: "https://google.com/?q={}",
+        },
       },
       properties: {
-        hintchars: 'abcd1234',
+        hintchars: "abcd1234",
         smoothscroll: false,
-        complete: 'sbh',
+        complete: "sbh",
       },
       blacklist: [],
     };
@@ -59,13 +61,13 @@ describe('AddonEnabledUseCase', () => {
     sut = new SettingUseCase(repository, client);
   });
 
-  describe('#reload', () => {
-    it('loads settings and store to repository', async() => {
+  describe("#reload", () => {
+    it("loads settings and store to repository", async () => {
       const settings = await sut.reload();
-      expect(settings.properties.hintchars).to.equal('abcd1234');
+      expect(settings.properties.hintchars).to.equal("abcd1234");
 
       const saved = repository.get();
-      expect(saved.properties.hintchars).to.equal('abcd1234');
+      expect(saved.properties.hintchars).to.equal("abcd1234");
     });
   });
 });