diff --git a/src/Buffer.test.ts b/src/Buffer.test.ts
index ca1437d9..087e2f64 100644
--- a/src/Buffer.test.ts
+++ b/src/Buffer.test.ts
@@ -67,40 +67,40 @@ describe('Buffer', () => {
     describe('wrapped', () => {
       it('should return a range for the first row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(1)).isWrapped = true;
+        buffer.lines.get(1).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(0), { first: 0, last: 1 });
       });
       it('should return a range for a middle row wrapping upwards', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(12)).isWrapped = true;
+        buffer.lines.get(12).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 11, last: 12 });
       });
       it('should return a range for a middle row wrapping downwards', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(13)).isWrapped = true;
+        buffer.lines.get(13).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 12, last: 13 });
       });
       it('should return a range for a middle row wrapping both ways', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(11)).isWrapped = true;
-        (<any> buffer.lines.get(12)).isWrapped = true;
-        (<any> buffer.lines.get(13)).isWrapped = true;
-        (<any> buffer.lines.get(14)).isWrapped = true;
+        buffer.lines.get(11).isWrapped = true;
+        buffer.lines.get(12).isWrapped = true;
+        buffer.lines.get(13).isWrapped = true;
+        buffer.lines.get(14).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 10, last: 14 });
       });
       it('should return a range for the last row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(23)).isWrapped = true;
+        buffer.lines.get(23).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 1), { first: 22, last: 23 });
       });
       it('should return a range for a row that wraps upward to first row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(1)).isWrapped = true;
+        buffer.lines.get(1).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(1), { first: 0, last: 1 });
       });
       it('should return a range for a row that wraps downward to last row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(buffer.lines.length - 1)).isWrapped = true;
+        buffer.lines.get(buffer.lines.length - 1).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 2), { first: 22, last: 23 });
       });
     });
diff --git a/src/Buffer.ts b/src/Buffer.ts
index c34a3786..b71537dc 100644
--- a/src/Buffer.ts
+++ b/src/Buffer.ts
@@ -269,11 +269,11 @@ export class Buffer implements IBuffer {
     let first = y;
     let last = y;
     // Scan upwards for wrapped lines
-    while (first > 0 && (<any>this.lines.get(first)).isWrapped) {
+    while (first > 0 && this.lines.get(first).isWrapped) {
       first--;
     }
     // Scan downwards for wrapped lines
-    while (last + 1 < this.lines.length && (<any>this.lines.get(last + 1)).isWrapped) {
+    while (last + 1 < this.lines.length && this.lines.get(last + 1).isWrapped) {
       last++;
     }
     return { first, last };
diff --git a/src/Linkifier.ts b/src/Linkifier.ts
index a9d8423e..859df661 100644
--- a/src/Linkifier.ts
+++ b/src/Linkifier.ts
@@ -165,7 +165,7 @@ export class Linkifier extends EventEmitter implements ILinkifier {
       return;
     }
 
-    if ((<any>this._terminal.buffer.lines.get(absoluteRowIndex)).isWrapped) {
+    if (this._terminal.buffer.lines.get(absoluteRowIndex).isWrapped) {
       // Only attempt to linkify rows that start in the viewport
       if (rowIndex !== 0) {
         return;
@@ -182,14 +182,14 @@ export class Linkifier extends EventEmitter implements ILinkifier {
           break;
         }
 
-      } while ((<any>line).isWrapped);
+      } while (line.isWrapped);
     }
 
     // Construct full unwrapped line text
     let text = this._terminal.buffer.translateBufferLineToString(absoluteRowIndex, false);
     let currentIndex = absoluteRowIndex + 1;
     while (currentIndex < this._terminal.buffer.lines.length &&
-      (<any>this._terminal.buffer.lines.get(currentIndex)).isWrapped) {
+      this._terminal.buffer.lines.get(currentIndex).isWrapped) {
       text += this._terminal.buffer.translateBufferLineToString(currentIndex++, false);
     }
 
diff --git a/src/SelectionManager.test.ts b/src/SelectionManager.test.ts
index bd9c8cbb..c7374ad5 100644
--- a/src/SelectionManager.test.ts
+++ b/src/SelectionManager.test.ts
@@ -192,7 +192,7 @@ describe('SelectionManager', () => {
     it('should expand upwards or downards for wrapped lines', () => {
       buffer.lines.set(0, stringToRow('                                                                             foo'));
       buffer.lines.set(1, stringToRow('bar                                                                             '));
-      (<any>buffer.lines.get(1)).isWrapped = true;
+      buffer.lines.get(1).isWrapped = true;
       selectionManager.selectWordAt([1, 1]);
       assert.equal(selectionManager.selectionText, 'foobar');
       selectionManager.model.clearSelection();
@@ -206,10 +206,10 @@ describe('SelectionManager', () => {
       buffer.lines.set(2, stringToRow('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'));
       buffer.lines.set(3, stringToRow('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'));
       buffer.lines.set(4, stringToRow('bar                                                                             '));
-      (<any>buffer.lines.get(1)).isWrapped = true;
-      (<any>buffer.lines.get(2)).isWrapped = true;
-      (<any>buffer.lines.get(3)).isWrapped = true;
-      (<any>buffer.lines.get(4)).isWrapped = true;
+      buffer.lines.get(1).isWrapped = true;
+      buffer.lines.get(2).isWrapped = true;
+      buffer.lines.get(3).isWrapped = true;
+      buffer.lines.get(4).isWrapped = true;
       selectionManager.selectWordAt([78, 0]);
       assert.equal(selectionManager.selectionText, expectedText);
       selectionManager.model.clearSelection();
@@ -345,7 +345,7 @@ describe('SelectionManager', () => {
     it('should select the entire wrapped line', () => {
       buffer.lines.set(0, stringToRow('foo'));
       const line2 = stringToRow('bar');
-      (<any>line2).isWrapped = true;
+      line2.isWrapped = true;
       buffer.lines.set(1, line2);
       selectionManager.selectLineAt(0);
       assert.equal(selectionManager.selectionText, 'foobar', 'The selected text is correct');
diff --git a/src/SelectionManager.ts b/src/SelectionManager.ts
index 422dbc14..fcd45f2a 100644
--- a/src/SelectionManager.ts
+++ b/src/SelectionManager.ts
@@ -811,7 +811,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
     if (followWrappedLinesAbove) {
       if (start === 0 && bufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
         const previousBufferLine = this._buffer.lines.get(coords[1] - 1);
-        if (previousBufferLine && (<any>bufferLine).isWrapped && previousBufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+        if (previousBufferLine && bufferLine.isWrapped && previousBufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
           const previousLineWordPosition = this._getWordAt([this._terminal.cols - 1, coords[1] - 1], false, true, false);
           if (previousLineWordPosition) {
             const offset = this._terminal.cols - previousLineWordPosition.start;
@@ -826,7 +826,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
     if (followWrappedLinesBelow) {
       if (start + length === this._terminal.cols && bufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
         const nextBufferLine = this._buffer.lines.get(coords[1] + 1);
-        if (nextBufferLine && (<any>nextBufferLine).isWrapped && nextBufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+        if (nextBufferLine && nextBufferLine.isWrapped && nextBufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
           const nextLineWordPosition = this._getWordAt([0, coords[1] + 1], false, false, true);
           if (nextLineWordPosition) {
             length += nextLineWordPosition.length;
diff --git a/src/addons/winptyCompat/winptyCompat.ts b/src/addons/winptyCompat/winptyCompat.ts
index 25ad7d91..c6b33b27 100644
--- a/src/addons/winptyCompat/winptyCompat.ts
+++ b/src/addons/winptyCompat/winptyCompat.ts
@@ -34,7 +34,7 @@ export function winptyCompatInit(terminal: Terminal): void {
 
     if (lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE) {
       const nextLine = addonTerminal._core.buffer.lines.get(addonTerminal._core.buffer.ybase + addonTerminal._core.buffer.y);
-      (<any>nextLine).isWrapped = true;
+      nextLine.isWrapped = true;
     }
   });
 }
diff --git a/src/handlers/AltClickHandler.ts b/src/handlers/AltClickHandler.ts
index fcafcddb..2932dd5c 100644
--- a/src/handlers/AltClickHandler.ts
+++ b/src/handlers/AltClickHandler.ts
@@ -139,7 +139,7 @@ export class AltClickHandler {
     for (let i = 0; i < Math.abs(startRow - endRow); i++) {
       const direction = this._verticalDirection() === Direction.UP ? -1 : 1;
 
-      if ((<any>this._lines.get(startRow + (direction * i))).isWrapped) {
+      if (this._lines.get(startRow + (direction * i)).isWrapped) {
         wrappedRows++;
       }
     }
@@ -153,12 +153,12 @@ export class AltClickHandler {
    */
   private _wrappedRowsForRow(currentRow: number): number {
     let rowCount = 0;
-    let lineWraps = (<any>this._lines.get(currentRow)).isWrapped;
+    let lineWraps = this._lines.get(currentRow).isWrapped;
 
     while (lineWraps && currentRow >= 0 && currentRow < this._terminal.rows) {
       rowCount++;
       currentRow--;
-      lineWraps = (<any>this._lines.get(currentRow)).isWrapped;
+      lineWraps = this._lines.get(currentRow).isWrapped;
     }
 
     return rowCount;